Add led effect to DCSpy

src/dcspy/aircraft.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
 
+from collections import OrderedDict
 from collections.abc import Sequence
 from itertools import cycle
 from logging import getLogger
 from pathlib import Path
 from pprint import pformat
 from re import search
 from tempfile import gettempdir
+from threading import Timer
 from typing import ClassVar
 
 try:
@@ -17,10 +19,14 @@
 from PIL import Image, ImageDraw, ImageFont
 
 from dcspy import default_yaml, load_yaml
-from dcspy.models import (DEFAULT_FONT_NAME, NO_OF_LCD_SCREENSHOTS, AircraftKwargs, AnyButton, ApacheAllDrawModesKwargs, ApacheEufdMode, BiosValue, LcdButton,
-                          LcdInfo, RequestModel, RequestType)
+from dcspy.models import (DEFAULT_FONT_NAME, NO_OF_LCD_SCREENSHOTS, AircraftKwargs, AnyButton, ApacheAllDrawModesKwargs, ApacheEufdMode, BiosValue, EffectInfo,
+                          LcdButton, LcdInfo, LedEffectType, LedSupport, RequestModel, RequestType)
+from dcspy.sdk.led_sdk import LedSdkManager
 from dcspy.utils import KeyRequest, replace_symbols, substitute_symbols
 
+# todo: to be removed
+RED_PULSE = EffectInfo(type=LedEffectType.PULSE, rgb=(100, 0, 0), duration=0, interval=10)
+YELLOW_PULSE = EffectInfo(type=LedEffectType.PULSE, rgb=(100, 100, 0), duration=0, interval=10)
 LOG = getLogger(__name__)
 
 
@@ -63,6 +69,11 @@ def __init__(self, lcd_type: LcdInfo) -> None:
         self.lcd = lcd_type
         self.cfg = load_yaml(full_path=default_yaml)
         self.bios_data: dict[str, BiosValue] = {}
+        self.led = LedSdkManager(target_dev=LedSupport.LOGI_DEVICETYPE_RGB)  # todo: do we need copy it here?
+        self.led_stack: dict[str, EffectInfo] = OrderedDict()
+        self.led_effect = True
+        self.led_counter = 16
+        self.led_shutdown = Timer(3.2, self.led.logi_led_shutdown)
         if self.bios_name:
             self.key_req = KeyRequest(yaml_path=default_yaml.parent / f'{self.bios_name}.yaml', get_bios_fn=self.get_bios)
             self.bios_data.update(self.key_req.cycle_button_ctrl_name)
@@ -101,6 +112,42 @@ def get_bios(self, selector: str, default: BiosValue = '') -> BiosValue:
         except (KeyError, ValueError):
             return default
 
+    def led_handler(self, selector: str, value: int, effect: EffectInfo) -> None:
+        """
+        Switch on and off LED effect for DCS-BIOS selector.
+
+        :param selector:
+        :param value:
+        :param effect:
+        """
+        self.bios_data[selector] = value
+        if self.led_effect and not self.led_counter:
+            if value:
+                LOG.debug(f'LED on {selector} val: {value} with {effect}')
+                self.led.logi_led_shutdown()
+                self.led_counter = 16
+                LOG.debug(f'Th: {self.led_shutdown}')
+                self.led_shutdown = Timer(3.2, self.led.logi_led_shutdown)
+                self.led_shutdown.start()
+                self.led.start_led_effect(effect=effect)
+                self.led_stack[selector] = effect
+            else:
+                LOG.debug(f'LED off {selector}')
+                self._popitem_and_reply_last_effect(selector)
+        else:
+            self.led_counter -= 1
+        LOG.debug(f'Couter: {value} {self.led_counter}')
+
+    def _popitem_and_reply_last_effect(self, selector: str) -> None:
+        del self.led_stack[selector]
+        if self.led_stack:
+            selector, effect = self.led_stack.popitem()
+            LOG.debug(f'Replay effect for {selector}')
+            value = int(self.bios_data[selector])
+            self.led_handler(selector, value, effect)
+        else:
+            self.led.logi_led_shutdown()
+
     def __repr__(self) -> str:
         return f'{super().__repr__()} with: {pformat(self.__dict__)}'
 

src/dcspy/models.py

@@ -641,13 +641,33 @@ def make_empty(cls) -> GuiPlaneInputRequest:
         return cls(identifier='', request='', widget_iface='')
 
 
-class LedConstants(Enum):
-    """LED constants."""
-    LOGI_LED_DURATION_INFINITE = 0
+class LedSupport(Enum):
+    """LED supported types."""
+    LOGI_DEVICETYPE_NONE = 0
     LOGI_DEVICETYPE_MONOCHROME = 1
     LOGI_DEVICETYPE_RGB = 2
     LOGI_DEVICETYPE_ALL = 3  # LOGI_DEVICETYPE_MONOCHROME | LOGI_DEVICETYPE_RGB
 
+    def __str__(self) -> str:
+        return self.name.split('_')[-1]
+
+
+class LedEffectType(Enum):
+    """LED effect type."""
+    FLASH = 'flash'
+    PULSE = 'pulse'
+    NONE = 'none'
+
+    def __str__(self) -> str:
+        return self.value
+
+# todo: rename it
+class EffectInfo(BaseModel):
+    type: LedEffectType
+    rgb: tuple[int, int, int]  # todo: think of conversion 0-255 -> 0-100% where to do it?
+    duration: int
+    interval: int
+
 
 class LcdButton(Enum):
     """LCD Buttons."""
@@ -870,6 +890,8 @@ class LogitechDeviceModel(BaseModel):
     btn_m_range: tuple[int, int] = (0, 0)
     lcd_keys: Sequence[LcdButton] = ()
     lcd_info: LcdInfo = NoneLcd
+    led_type: LedSupport = LedSupport.LOGI_DEVICETYPE_NONE
+    comments: str = ''
 
     def get_key_at(self, row: int, col: int) -> AnyButton | None:
         """
@@ -919,17 +941,15 @@ def cols(self) -> int:
         return max([self.no_g_modes, mouse_btn_exist, lcd_btn_exists])
 
     def __str__(self) -> str:
-        result = []
-        if self.lcd_info.type.value:
-            result.append(f'{self.lcd_info}')
-        if self.lcd_keys:
-            lcd_buttons = ', '.join([str(lcd_btn) for lcd_btn in self.lcd_keys])
-            result.append(f'LCD Buttons: {lcd_buttons}')
-        if self.no_g_modes and self.no_g_keys:
-            result.append(f'G-Keys: {self.no_g_keys} in {self.no_g_modes} modes')
-        if self.btn_m_range[0] and self.btn_m_range[1]:
-            result.append(f'Mouse Buttons: {self.btn_m_range[0]} to {self.btn_m_range[1]}')
-        return '\n'.join(result)
+        details = [
+            str(self.lcd_info) if self.lcd_info.type.value else None,
+            f"LCD Buttons: {', '.join(map(str, self.lcd_keys))}" if self.lcd_keys else None,
+            f"G-Keys: {self.no_g_keys} in {self.no_g_modes} modes" if self.no_g_modes and self.no_g_keys else None,
+            f"Mouse Buttons: {self.btn_m_range[0]} to {self.btn_m_range[1]}" if all(self.btn_m_range) else None,
+            f"LED support: {self.led_type}" if self.led_type.value else None,  # todo: test this
+            f"Comments: {self.comments}" if self.comments else None,  # todo: test this
+        ]
+        return '\n'.join(filter(None, details))
 
     @property
     def g_keys(self) -> Sequence[Gkey]:
@@ -960,23 +980,37 @@ def lcd_name(self) -> str:
 
 
 G19 = LogitechDeviceModel(klass='G19', no_g_modes=3, no_g_keys=12, lcd_info=LcdColor,
-                          lcd_keys=(LcdButton.LEFT, LcdButton.RIGHT, LcdButton.OK, LcdButton.CANCEL, LcdButton.UP, LcdButton.DOWN, LcdButton.MENU))
+                          lcd_keys=(LcdButton.LEFT, LcdButton.RIGHT, LcdButton.OK, LcdButton.CANCEL, LcdButton.UP, LcdButton.DOWN, LcdButton.MENU),
+                          led_type=LedSupport.LOGI_DEVICETYPE_RGB)
 G13 = LogitechDeviceModel(klass='G13', no_g_modes=3, no_g_keys=29, lcd_info=LcdMono,
-                          lcd_keys=(LcdButton.ONE, LcdButton.TWO, LcdButton.THREE, LcdButton.FOUR))
+                          lcd_keys=(LcdButton.ONE, LcdButton.TWO, LcdButton.THREE, LcdButton.FOUR),
+                          led_type=LedSupport.LOGI_DEVICETYPE_RGB)
 G15v1 = LogitechDeviceModel(klass='G15v1', no_g_modes=3, no_g_keys=18, lcd_info=LcdMono,
-                            lcd_keys=(LcdButton.ONE, LcdButton.TWO, LcdButton.THREE, LcdButton.FOUR))
+                            lcd_keys=(LcdButton.ONE, LcdButton.TWO, LcdButton.THREE, LcdButton.FOUR),
+                            led_type=LedSupport.LOGI_DEVICETYPE_MONOCHROME,
+                            comments='Highest RGB given is <33%, the color will be off, if >33% and <66%, the '
+                                     'brightness will be low, and when >66%, the brightness will be high')  # todo: make nicer descriptions
 G15v2 = LogitechDeviceModel(klass='G15v2', no_g_modes=3, no_g_keys=6, lcd_info=LcdMono,
-                            lcd_keys=(LcdButton.ONE, LcdButton.TWO, LcdButton.THREE, LcdButton.FOUR))
+                            lcd_keys=(LcdButton.ONE, LcdButton.TWO, LcdButton.THREE, LcdButton.FOUR),
+                            led_type=LedSupport.LOGI_DEVICETYPE_MONOCHROME,
+                            comments='Highest RGB given is <33%, the color will be off, if >33% and <66%, the '
+                                     'brightness will be low, and when >66%, the brightness will be high')
 G510 = LogitechDeviceModel(klass='G510', no_g_modes=3, no_g_keys=18, lcd_info=LcdMono,
-                           lcd_keys=(LcdButton.ONE, LcdButton.TWO, LcdButton.THREE, LcdButton.FOUR))
+                           lcd_keys=(LcdButton.ONE, LcdButton.TWO, LcdButton.THREE, LcdButton.FOUR),
+                           led_type=LedSupport.LOGI_DEVICETYPE_RGB)
 LCD_KEYBOARDS_DEV = [G19, G510, G15v1, G15v2, G13]
 
-G910 = LogitechDeviceModel(klass='G910', no_g_modes=3, no_g_keys=9)
-G710 = LogitechDeviceModel(klass='G710', no_g_modes=3, no_g_keys=6)
-G110 = LogitechDeviceModel(klass='G110', no_g_modes=3, no_g_keys=12)
+G910 = LogitechDeviceModel(klass='G910', no_g_modes=3, no_g_keys=9, led_type=LedSupport.LOGI_DEVICETYPE_RGB)
+G710 = LogitechDeviceModel(klass='G710', no_g_modes=3, no_g_keys=6, led_type=LedSupport.LOGI_DEVICETYPE_MONOCHROME,
+                           comments='Highest value for R, G or B defines brightness')
+G110 = LogitechDeviceModel(klass='G110', no_g_modes=3, no_g_keys=12, led_type=LedSupport.LOGI_DEVICETYPE_RGB,
+                           comments='green it will be ignored')
 G103 = LogitechDeviceModel(klass='G103', no_g_modes=3, no_g_keys=6)
-G105 = LogitechDeviceModel(klass='G105', no_g_modes=3, no_g_keys=6)
-G11 = LogitechDeviceModel(klass='G11', no_g_modes=3, no_g_keys=18)
+G105 = LogitechDeviceModel(klass='G105', no_g_modes=3, no_g_keys=6, led_type=LedSupport.LOGI_DEVICETYPE_MONOCHROME,
+                           comments='Highest value for R, G or B defines brightness')
+G11 = LogitechDeviceModel(klass='G11', no_g_modes=3, no_g_keys=18, led_type=LedSupport.LOGI_DEVICETYPE_MONOCHROME,
+                          comments='Highest RGB given is <33%, the color will be off, if >33% and <66%, the brightness '
+                                   'will be low, and when >66%, the brightness will be high')
 KEYBOARDS_DEV = [G910, G710, G110, G103, G105, G11]
 
 G35 = LogitechDeviceModel(klass='G35', no_g_modes=1, no_g_keys=3)
@@ -985,8 +1019,9 @@ def lcd_name(self) -> str:
 G933 = LogitechDeviceModel(klass='G933', no_g_modes=1, no_g_keys=3)
 HEADPHONES_DEV = [G35, G633, G930, G933]
 
-G600 = LogitechDeviceModel(klass='G600', btn_m_range=(6, 20))
-G300 = LogitechDeviceModel(klass='G300', btn_m_range=(6, 9))
+G600 = LogitechDeviceModel(klass='G600', btn_m_range=(6, 20), led_type=LedSupport.LOGI_DEVICETYPE_RGB)
+G300 = LogitechDeviceModel(klass='G300', btn_m_range=(6, 9), led_type=LedSupport.LOGI_DEVICETYPE_RGB,
+                           comments='When calling the LED, if <50%, the color will be off, and when >50%, the color will be on')
 G400 = LogitechDeviceModel(klass='G400', btn_m_range=(6, 8))
 G700 = LogitechDeviceModel(klass='G700', btn_m_range=(1, 13))
 G9 = LogitechDeviceModel(klass='G9', btn_m_range=(4, 8))

src/dcspy/qt_gui.py

@@ -26,14 +26,15 @@
 from PySide6.QtGui import (QAction, QActionGroup, QColor, QColorConstants, QFont, QGuiApplication, QIcon, QPixmap, QShowEvent, QStandardItemModel, QStyleHints,
                            QTextCharFormat)
 from PySide6.QtUiTools import QUiLoader
-from PySide6.QtWidgets import (QApplication, QButtonGroup, QCheckBox, QComboBox, QCompleter, QDialog, QDockWidget, QFileDialog, QGroupBox, QLabel, QLineEdit,
-                               QListView, QMainWindow, QMenu, QMessageBox, QProgressBar, QPushButton, QRadioButton, QSlider, QSpinBox, QStatusBar,
-                               QSystemTrayIcon, QTableWidget, QTabWidget, QTextBrowser, QTextEdit, QToolBar, QToolBox, QWidget)
+from PySide6.QtWidgets import (QApplication, QButtonGroup, QCheckBox, QComboBox, QCompleter, QDialog, QDockWidget, QDoubleSpinBox, QFileDialog, QGroupBox,
+                               QLabel, QLineEdit, QListView, QMainWindow, QMenu, QMessageBox, QProgressBar, QPushButton, QRadioButton, QSlider, QSpinBox,
+                               QStatusBar, QSystemTrayIcon, QTableWidget, QTabWidget, QTextBrowser, QTextEdit, QToolBar, QToolBox, QWidget)
 
 from dcspy import default_yaml, qtgui_rc
 from dcspy.models import (ALL_DEV, BIOS_REPO_NAME, CTRL_LIST_SEPARATOR, DCSPY_REPO_NAME, AnyButton, ControlDepiction, ControlKeyData, DcspyConfigYaml,
-                          FontsConfig, Gkey, GuiPlaneInputRequest, GuiTab, LcdButton, LcdMono, LcdType, LogitechDeviceModel, MouseButton, MsgBoxTypes, Release,
-                          RequestType, SystemData, __version__)
+                          EffectInfo, FontsConfig, Gkey, GuiPlaneInputRequest, GuiTab, LcdButton, LcdMono, LcdType, LedEffectType, LedSupport,
+                          LogitechDeviceModel, MouseButton, MsgBoxTypes, Release, RequestType, SystemData, __version__)
+from dcspy.sdk.led_sdk import LedSdkManager
 from dcspy.starter import DCSpyStarter
 from dcspy.utils import (CloneProgress, check_bios_ver, check_dcs_bios_entry, check_dcs_ver, check_github_repo, check_ver_at_github, collect_debug_data,
                          count_files, defaults_cfg, detect_system_color_mode, download_file, generate_bios_jsons_with_lupa, get_all_git_refs,
@@ -61,6 +62,7 @@ def __init__(self, cli_args=Namespace(), cfg_dict: DcspyConfigYaml | None = None
         """
         super().__init__()
         UiLoader().load_ui(':/ui/ui/qtdcs.ui', self)
+        self.led = LedSdkManager(name='DCSpy', target_dev=LedSupport.LOGI_DEVICETYPE_RGB)  # todo: where to keep it for simulation purpose
         self._find_children()
         self.config = cfg_dict
         if not cfg_dict:
@@ -92,12 +94,14 @@ def __init__(self, cli_args=Namespace(), cfg_dict: DcspyConfigYaml | None = None
         self.dw_device.setFloating(True)
         self.bg_rb_input_iface = QButtonGroup(self)
         self.bg_rb_device = QButtonGroup(self)
+        self.led_effect = EffectInfo(type=LedEffectType.NONE, rgb=(0,0,0), duration=0, interval=0)
         self._init_tray()
         self._init_combo_plane()
         self._init_menu_bar()
         self.apply_configuration(cfg=self.config)
         self._init_settings()
         self._init_devices()
+        self._init_led()
         self._init_autosave()
         self._trigger_refresh_data()
 
@@ -236,6 +240,39 @@ def _init_menu_bar(self) -> None:
         color_mode.addAction(self.a_mode_system)
         color_mode.triggered.connect(self._switch_color_mode)
 
+    def _init_led(self) -> None:
+        """Initialize LED related stuff."""
+        self.combo_effect_type.addItems([LedEffectType.PULSE.name, LedEffectType.FLASH.name])
+
+        self.pb_stop_sim.clicked.connect(self._stop_led)
+        self.pb_start_sim.clicked.connect(self._start_led)
+        self.sp_interval.valueChanged.connect(self._set_led_effect)
+        self.sp_duration.valueChanged.connect(self._set_led_effect)
+        self.sp_sleep.valueChanged.connect(self._set_led_effect)
+        self.sp_r.valueChanged.connect(self._set_led_effect)
+        self.sp_g.valueChanged.connect(self._set_led_effect)
+        self.sp_b.valueChanged.connect(self._set_led_effect)
+        self.combo_effect_type.currentIndexChanged.connect(self._set_led_effect)
+
+
+    def _set_led_effect(self) -> None:
+        """Set LED effect."""
+        # todo: how to save it in a config file
+        self.led_effect = EffectInfo(type=getattr(LedEffectType, self.combo_effect_type.currentText()),
+                                     rgb=(int(self.sp_r.value()), int(self.sp_g.value()), int(self.sp_b.value())),
+                                     duration=self.sp_duration.value(), interval=self.sp_interval.value())
+
+    def _start_led(self):
+        self.led.logi_led_init()
+        self.led.logi_led_set_target_device(LedSupport.LOGI_DEVICETYPE_RGB)  # todo: take from device
+        LOG.debug(f'Start LED effect: {self.led_effect}')
+        self.led.start_led_effect(effect=self.led_effect)
+
+    def _stop_led(self):
+        self.led.logi_led_stop_effects()
+        LOG.debug('Stopped LED effect')
+        self.led.logi_led_shutdown()
+
     def _init_autosave(self) -> None:
         """Initialize of autosave."""
         widget_dict = {
@@ -458,6 +495,7 @@ def _load_table_gkeys(self) -> None:
     def _generate_table(self) -> None:
         """Generate a table of combo boxes with completer functionality."""
         ctrl_list_without_sep = [item for item in self.ctrl_list if item and CTRL_LIST_SEPARATOR not in item]
+        self.combo_ctrl.addItems(self.ctrl_list)  # todo: move to better place
         for row in range(0, self.device.rows.total):
             for col in range(0, self.device.cols):
                 self._make_combo_with_completer_at(row, col, ctrl_list_without_sep)
@@ -1744,6 +1782,18 @@ def _find_children(self) -> None:
         self.pb_bios_check: QPushButton = self.findChild(QPushButton, 'pb_bios_check')  # type: ignore[assignment]
         self.pb_bios_repair: QPushButton = self.findChild(QPushButton, 'pb_bios_repair')  # type: ignore[assignment]
 
+        # todo: move to correct places, change widgets types
+        self.pb_stop_sim: QPushButton = self.findChild(QPushButton, 'pb_stop_sim')  # type: ignore[assignment]
+        self.pb_start_sim: QPushButton = self.findChild(QPushButton, 'pb_start_sim')  # type: ignore[assignment]
+        self.combo_ctrl: QComboBox = self.findChild(QComboBox, 'combo_ctrl')  # type: ignore[assignment]
+        self.combo_effect_type: QComboBox = self.findChild(QComboBox, 'combo_effect_type')  # type: ignore[assignment]
+        self.sp_interval: QSpinBox = self.findChild(QSpinBox, 'sp_interval')  # type: ignore[assignment]
+        self.sp_duration: QSpinBox = self.findChild(QSpinBox, 'sp_duration')  # type: ignore[assignment]
+        self.sp_sleep: QDoubleSpinBox = self.findChild(QDoubleSpinBox, 'sp_sleep')  # type: ignore[assignment]
+        self.sp_r: QSpinBox = self.findChild(QSpinBox, 'sp_r')  # type: ignore[assignment]
+        self.sp_g: QSpinBox = self.findChild(QSpinBox, 'sp_g')  # type: ignore[assignment]
+        self.sp_b: QSpinBox = self.findChild(QSpinBox, 'sp_b')  # type: ignore[assignment]
+
         self.cb_autostart: QCheckBox = self.findChild(QCheckBox, 'cb_autostart')  # type: ignore[assignment]
         self.cb_show_gui: QCheckBox = self.findChild(QCheckBox, 'cb_show_gui')  # type: ignore[assignment]
         self.cb_check_ver: QCheckBox = self.findChild(QCheckBox, 'cb_check_ver')  # type: ignore[assignment]