emcek / dcspy / 443

pending completion

Build # 443

Build Type

Pull #17

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/emcek/dcspy/commit/<a class=hub.com/emcek/dcspy/commit/4ac5280bdf52c3cbcbec6c461f44c2696b358d64">4ac5280bd<a href="https://github.com/emcek/dcspy/commit/4ac5280bdf52c3cbcbec6c461f44c2696b358d64">">Merge </a><a class="double-link" href="https://github.com/emcek/dcspy/commit/<a class="double-link" href="https://github.com/emcek/dcspy/commit/73caacdb56e5a256f9eb23b8f6268dd61ce080fd">73caacdb5</a>">73caacdb5</a><a href="https://github.com/emcek/dcspy/commit/4ac5280bdf52c3cbcbec6c461f44c2696b358d64"> into 1f6518793">1f6518793</a>

Pull Request Pull Request #17: add G19 handling

Run Details

87 of 87 new or added lines in 6 files covered. (100.0%)

414 of 599 relevant lines covered (69.12%)

0.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

52.5

/dcspy/logitech.py

from functools import partial
from importlib import import_module
from logging import getLogger
from math import log2
from socket import socket
from typing import List, Tuple

from PIL import Image, ImageDraw

from dcspy import LcdColor, LcdMono, SUPPORTED_CRAFTS, FONT_11, SEND_ADDR, lcd_sdk
from dcspy.aircrafts import Aircraft
from dcspy.dcsbios import ProtocolParser

LOG = getLogger(__name__)


class LogitechKeyboard:
    def __init__(self, parser_hook: ProtocolParser, **kwargs) -> None:
        """
        General keyboard with LCD form Logitech.

        It can be easily extended for any of:
        - Mono LCD: G13, G15 (v1 and v2) and G510
        - RGB LCD: G19

        However it define bunch of functionally to be used be child class:
        - DCS-BIOS callback for currently used aircraft in DCS
        - auto-detecting aircraft and load its handling class
        - send button request to DCS-BIOS

        Child class needs redefine:
        - buttons with supported buttons as tuple of int
        - pass lcd_type argument as LcdSize NamedTuple to super constructor

        :param parser_hook: BSC-BIOS parser
        :type parser_hook: ProtocolParser
        """
        getattr(import_module('dcspy.dcsbios'), 'StringBuffer')(parser_hook, 0x0000, 16, partial(self.detecting_plane))
        self.parser = parser_hook
        self.plane_name = ''
        self.plane_detected = False
        self.already_pressed = False
        self.buttons: Tuple[int, ...] = (0,)
        self._display: List[str] = list()
        self.lcd = kwargs.get('lcd_type', LcdMono)
        lcd_sdk.logi_lcd_init('DCS World', self.lcd.type)
        self.plane = Aircraft(self.lcd)

    @property
    def display(self) -> List[str]:
        """
        Get latest set text at LCD.

        :return: list of strings with data, row by row
        :rtype: List[str]
        """
        return self._display

    @display.setter
    def display(self, message: List[str]) -> None:
        """
        Display message at LCD.

        For G13/G15/G510 takes first 4 or less elements of list and display as 4 rows.
        For G19 takes first 8 or less elements of list and display as 8 rows.

        :param message: List of strings to display, row by row.
        :type message: List[str]
        """
        img = Image.new('1', (self.lcd.width, self.lcd.height), 0)
        draw = ImageDraw.Draw(img)
        self._display = message
        for line_no, line in enumerate(message):
            draw.text((0, 10 * line_no), line, 255, FONT_11)
        lcd_sdk.update_display(img)

    def detecting_plane(self, value: str) -> None:
        """
        Try detect airplane base on value received from DCS-BIOS.

        :param value: data from DCS-BIOS
        :type value: str
        """
        value = value.replace('-', '').replace('_', '')
        if self.plane_name != value:
            self.plane_name = value
            if self.plane_name in SUPPORTED_CRAFTS:
                self.plane_name = value
                LOG.info(f'Detected Aircraft: {value}')
                self.display = ['Detected aircraft:', self.plane_name]
                self.plane_detected = True
            else:
                LOG.warning(f'Not supported aircraft: {value}')
                self.display = ['Detected aircraft:', self.plane_name, 'Not supported yet!']

    def load_new_plane(self) -> None:
        """
        Dynamic load of new detected aircraft.

        Setup callbacks for detected plane inside DCS-BIOS parser.
        """
        self.plane_detected = False
        self.plane = getattr(import_module('dcspy.aircrafts'), self.plane_name)(self.lcd)
        LOG.debug(f'Dynamic load of: {self.plane_name} as {SUPPORTED_CRAFTS[self.plane_name]}')
        for field_name, proto_data in self.plane.bios_data.items():
            buffer = getattr(import_module('dcspy.dcsbios'), proto_data['class'])
            buffer(parser=self.parser, callback=partial(self.plane.set_bios, field_name), **proto_data['args'])

    def check_buttons(self) -> int:
        """
        Check if button was pressed and return its number.

        For G13/G15/G510: 1-4
        For G19 9-15: LEFT = 9, RIGHT = 10, OK = 11, CANCEL = 12, UP = 13, DOWN = 14, MENU = 15

        :return: number of pressed button
        :rtype: int
        """
        for btn in self.buttons:
            if lcd_sdk.logi_lcd_is_button_pressed(btn):
                if not self.already_pressed:
                    self.already_pressed = True
                    return int(log2(btn)) + 1
                return 0
        self.already_pressed = False
        return 0

    def button_handle(self, sock: socket) -> None:
        """
        Button handler.

        * detect if button was pressed
        * fetch BSD-BIOS request form plane
        * sent it action to DCS-BIOS via. network socket

        :param sock: network socket
        :type sock: socket
        """
        button = self.check_buttons()
        if button:
            sock.sendto(bytes(self.plane.button_request(button), 'utf-8'), SEND_ADDR)

    def clear(self, true_clear=False):
        """
        Clear LCD.

        :param true_clear:
        """
        LOG.debug(f'Clear LCD type: {self.lcd.type}')
        lcd_sdk.clear_display(true_clear)

    def __str__(self):
        return f'{self.__class__.__name__}: {self.lcd.width}x{self.lcd.height}'

    def __repr__(self):
        return f'{super().__repr__()} with: {self.__dict__}'


class KeyboardMono(LogitechKeyboard):
    def __init__(self, parser_hook: ProtocolParser) -> None:
        """
        Logitech keyboard with mono LCD.

        Support for: G510, G13, G15 (v1 and v2)

        :param parser_hook: BSC-BIOS parser
        :type parser_hook: ProtocolParser
        """
        super().__init__(parser_hook, lcd_type=LcdMono)
        self.buttons = (lcd_sdk.MONO_BUTTON_0, lcd_sdk.MONO_BUTTON_1, lcd_sdk.MONO_BUTTON_2, lcd_sdk.MONO_BUTTON_3)


class KeyboardColor(LogitechKeyboard):
    def __init__(self, parser_hook: ProtocolParser) -> None:
        """
        Logitech keyboard with color LCD.

        Support for: G19

        :param parser_hook: BSC-BIOS parser
        :type parser_hook: ProtocolParser
        """
        super().__init__(parser_hook, lcd_type=LcdColor)
        self.buttons = (lcd_sdk.COLOR_BUTTON_LEFT, lcd_sdk.COLOR_BUTTON_RIGHT, lcd_sdk.COLOR_BUTTON_OK,
                        lcd_sdk.COLOR_BUTTON_CANCEL, lcd_sdk.COLOR_BUTTON_UP, lcd_sdk.COLOR_BUTTON_DOWN,
                        lcd_sdk.COLOR_BUTTON_MENU)

1	from functools import partial	1✔
2	from importlib import import_module	1✔
3	from logging import getLogger	1✔
4	from math import log2	1✔
5	from socket import socket	1✔
6	from typing import List, Tuple	1✔
7
8	from PIL import Image, ImageDraw	1✔
9
10	from dcspy import LcdColor, LcdMono, SUPPORTED_CRAFTS, FONT_11, SEND_ADDR, lcd_sdk	1✔
11	from dcspy.aircrafts import Aircraft	1✔
12	from dcspy.dcsbios import ProtocolParser	1✔
13
14	LOG = getLogger(__name__)	1✔
15
16
17	class LogitechKeyboard:	1✔
18	def __init__(self, parser_hook: ProtocolParser, **kwargs) -> None:	1✔
19	"""
20	General keyboard with LCD form Logitech.
21
22	It can be easily extended for any of:
23	- Mono LCD: G13, G15 (v1 and v2) and G510
24	- RGB LCD: G19
25
26	However it define bunch of functionally to be used be child class:
27	- DCS-BIOS callback for currently used aircraft in DCS
28	- auto-detecting aircraft and load its handling class
29	- send button request to DCS-BIOS
30
31	Child class needs redefine:
32	- buttons with supported buttons as tuple of int
33	- pass lcd_type argument as LcdSize NamedTuple to super constructor
34
35	:param parser_hook: BSC-BIOS parser
36	:type parser_hook: ProtocolParser
37	"""
38	getattr(import_module('dcspy.dcsbios'), 'StringBuffer')(parser_hook, 0x0000, 16, partial(self.detecting_plane))	1✔
39	self.parser = parser_hook	1✔
40	self.plane_name = ''	1✔
41	self.plane_detected = False	1✔
42	self.already_pressed = False	1✔
43	self.buttons: Tuple[int, ...] = (0,)	1✔
44	self._display: List[str] = list()	1✔
45	self.lcd = kwargs.get('lcd_type', LcdMono)	1✔
46	lcd_sdk.logi_lcd_init('DCS World', self.lcd.type)	1✔
47	self.plane = Aircraft(self.lcd)	1✔
48
49	@property	1✔
50	def display(self) -> List[str]:	1✔
51	"""
52	Get latest set text at LCD.
53
54	:return: list of strings with data, row by row
55	:rtype: List[str]
56	"""
57	return self._display	×
58
59	@display.setter	1✔
60	def display(self, message: List[str]) -> None:	1✔
61	"""
62	Display message at LCD.
63
64	For G13/G15/G510 takes first 4 or less elements of list and display as 4 rows.
65	For G19 takes first 8 or less elements of list and display as 8 rows.
66
67	:param message: List of strings to display, row by row.
68	:type message: List[str]
69	"""
70	img = Image.new('1', (self.lcd.width, self.lcd.height), 0)	×
71	draw = ImageDraw.Draw(img)	×
72	self._display = message	×
73	for line_no, line in enumerate(message):	×
74	draw.text((0, 10 * line_no), line, 255, FONT_11)	×
75	lcd_sdk.update_display(img)	×
76
77	def detecting_plane(self, value: str) -> None:	1✔
78	"""
79	Try detect airplane base on value received from DCS-BIOS.
80
81	:param value: data from DCS-BIOS
82	:type value: str
83	"""
84	value = value.replace('-', '').replace('_', '')	×
85	if self.plane_name != value:	×
86	self.plane_name = value	×
87	if self.plane_name in SUPPORTED_CRAFTS:	×
88	self.plane_name = value	×
89	LOG.info(f'Detected Aircraft: {value}')	×
90	self.display = ['Detected aircraft:', self.plane_name]	×
91	self.plane_detected = True	×
92	else:
93	LOG.warning(f'Not supported aircraft: {value}')	×
94	self.display = ['Detected aircraft:', self.plane_name, 'Not supported yet!']	×
95
96	def load_new_plane(self) -> None:	1✔
97	"""
98	Dynamic load of new detected aircraft.
99
100	Setup callbacks for detected plane inside DCS-BIOS parser.
101	"""
102	self.plane_detected = False	×
103	self.plane = getattr(import_module('dcspy.aircrafts'), self.plane_name)(self.lcd)	×
104	LOG.debug(f'Dynamic load of: {self.plane_name} as {SUPPORTED_CRAFTS[self.plane_name]}')	×
105	for field_name, proto_data in self.plane.bios_data.items():	×
106	buffer = getattr(import_module('dcspy.dcsbios'), proto_data['class'])	×
107	buffer(parser=self.parser, callback=partial(self.plane.set_bios, field_name), **proto_data['args'])	×
108
109	def check_buttons(self) -> int:	1✔
110	"""
111	Check if button was pressed and return its number.
112
113	For G13/G15/G510: 1-4
114	For G19 9-15: LEFT = 9, RIGHT = 10, OK = 11, CANCEL = 12, UP = 13, DOWN = 14, MENU = 15
115
116	:return: number of pressed button
117	:rtype: int
118	"""
119	for btn in self.buttons:	×
120	if lcd_sdk.logi_lcd_is_button_pressed(btn):	×
121	if not self.already_pressed:	×
122	self.already_pressed = True	×
123	return int(log2(btn)) + 1	×
124	return 0	×
125	self.already_pressed = False	×
126	return 0	×
127
128	def button_handle(self, sock: socket) -> None:	1✔
129	"""
130	Button handler.
131
132	* detect if button was pressed
133	* fetch BSD-BIOS request form plane
134	* sent it action to DCS-BIOS via. network socket
135
136	:param sock: network socket
137	:type sock: socket
138	"""
139	button = self.check_buttons()	×
140	if button:	×
141	sock.sendto(bytes(self.plane.button_request(button), 'utf-8'), SEND_ADDR)	×
142
143	def clear(self, true_clear=False):	1✔
144	"""
145	Clear LCD.
146
147	:param true_clear:
148	"""
149	LOG.debug(f'Clear LCD type: {self.lcd.type}')	×
150	lcd_sdk.clear_display(true_clear)	×
151
152	def __str__(self):	1✔
153	return f'{self.__class__.__name__}: {self.lcd.width}x{self.lcd.height}'	×
154
155	def __repr__(self):	1✔
156	return f'{super().__repr__()} with: {self.__dict__}'	×
157
158
159	class KeyboardMono(LogitechKeyboard):	1✔
160	def __init__(self, parser_hook: ProtocolParser) -> None:	1✔
161	"""
162	Logitech keyboard with mono LCD.
163
164	Support for: G510, G13, G15 (v1 and v2)
165
166	:param parser_hook: BSC-BIOS parser
167	:type parser_hook: ProtocolParser
168	"""
169	super().__init__(parser_hook, lcd_type=LcdMono)	1✔
170	self.buttons = (lcd_sdk.MONO_BUTTON_0, lcd_sdk.MONO_BUTTON_1, lcd_sdk.MONO_BUTTON_2, lcd_sdk.MONO_BUTTON_3)	1✔
171
172
173	class KeyboardColor(LogitechKeyboard):	1✔
174	def __init__(self, parser_hook: ProtocolParser) -> None:	1✔
175	"""
176	Logitech keyboard with color LCD.
177
178	Support for: G19
179
180	:param parser_hook: BSC-BIOS parser
181	:type parser_hook: ProtocolParser
182	"""
183	super().__init__(parser_hook, lcd_type=LcdColor)	1✔
184	self.buttons = (lcd_sdk.COLOR_BUTTON_LEFT, lcd_sdk.COLOR_BUTTON_RIGHT, lcd_sdk.COLOR_BUTTON_OK,	1✔
185	lcd_sdk.COLOR_BUTTON_CANCEL, lcd_sdk.COLOR_BUTTON_UP, lcd_sdk.COLOR_BUTTON_DOWN,
186	lcd_sdk.COLOR_BUTTON_MENU)

emcek / dcspy / 443

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous