cfclient 2024.7.1__py3-none-any.whl → 2025.12.1__py3-none-any.whl

cfclient/ui/tabs/FlightTab.py

@@ -7,7 +7,7 @@
 #  +------+    / /_/ / / /_/ /__/ /  / /_/ / / /_/  __/
 #   ||  ||    /_____/_/\__/\___/_/   \__,_/ /___/\___/
 #
-#  Copyright (C) 2011-2023 Bitcraze AB
+#  Copyright (C) 2011-2025 Bitcraze AB
 #
 #  Crazyflie Nano Quadcopter Client
 #
@@ -138,7 +138,7 @@ class FlightTab(TabToolbox, flight_tab_class):
         self._emergency_stop_updated_signal.connect(self.updateEmergencyStop)
         self._helper.inputDeviceReader.emergency_stop_updated.add_callback(
             self._emergency_stop_updated_signal.emit)
-        self._arm_updated_signal.connect(self.updateArm)
+        self._arm_updated_signal.connect(lambda: self.updateArm(from_controller=True))
         self._helper.inputDeviceReader.arm_updated.add_callback(self._arm_updated_signal.emit)
 
         self._helper.inputDeviceReader.heighthold_input_updated.add_callback(
@@ -195,17 +195,6 @@ class FlightTab(TabToolbox, flight_tab_class):
 
         self.uiSetupReady()
 
-        self._led_ring_headlight.clicked.connect(
-            lambda enabled: self._helper.cf.param.set_value("ring.headlightEnable", int(enabled)))
-
-        self._helper.cf.param.add_update_callback(
-            group="ring", name="headlightEnable",
-            cb=(lambda name, checked: self._led_ring_headlight.setChecked(bool(int(checked)))))
-
-        self._ledring_nbr_effects = 0
-
-        self._helper.cf.param.add_update_callback(group="ring", name="effect", cb=self._ring_effect_updated)
-
         self._helper.cf.param.add_update_callback(group="imu_sensors", cb=self._set_available_sensors)
 
         self._helper.cf.param.all_updated.add_callback(self._all_params_updated)
@@ -219,10 +208,7 @@ class FlightTab(TabToolbox, flight_tab_class):
         self.targetCalPitch.setValue(Config().get("trim_pitch"))
         self.targetCalRoll.setValue(Config().get("trim_roll"))
 
-        self._helper.inputDeviceReader.alt1_updated.add_callback(self.alt1_updated)
-        self._helper.inputDeviceReader.alt2_updated.add_callback(self.alt2_updated)
         self._tf_state = 0
-        self._ring_effect = 0
 
         # Connect callbacks for input device limiting of roll/pitch/yaw/thrust
         self._helper.inputDeviceReader.limiting_updated.add_callback(self._limiting_updated.emit)
@@ -446,7 +432,7 @@ class FlightTab(TabToolbox, flight_tab_class):
         # To prevent conflicting commands from the controller and the flight panel
         if JoystickReader().available_devices():
             self.commanderBox.setToolTip(
-                'Cant use both an controller and Command Based Flight'
+                'Cannot use both a controller and Command Based Flight'
             )
             self.commanderBox.setEnabled(False)
             return
@@ -516,16 +502,6 @@ class FlightTab(TabToolbox, flight_tab_class):
         self._enable_estimators(False)
 
         self.logAltHold = None
-        self._led_ring_effect.setEnabled(False)
-        self._led_ring_effect.clear()
-        try:
-            self._led_ring_effect.currentIndexChanged.disconnect(
-                self._ring_effect_changed)
-        except TypeError:
-            # Signal was not connected
-            pass
-        self._led_ring_effect.setCurrentIndex(-1)
-        self._led_ring_headlight.setEnabled(False)
 
         try:
             self._assist_mode_combo.currentIndexChanged.disconnect(
@@ -638,19 +614,16 @@ class FlightTab(TabToolbox, flight_tab_class):
         else:
             self.setMotorLabelsEnabled(True)
 
-    def updateArm(self):
-        if self._is_flying():
+    def updateArm(self, from_controller=False):
+        if self._is_flying() and not from_controller:
             self._helper.cf.loc.send_emergency_stop()
-            # TODO krri disarm?
-        if self._is_crashed():
+        elif self._is_crashed():
             self._helper.cf.platform.send_crash_recovery_request()
-        else:
-            if self._is_armed():
-                self._helper.cf.platform.send_arming_request(False)
-            else:
-                if self._can_arm():
-                    self.armButton.setStyleSheet("background-color: orange")
-                    self._helper.cf.platform.send_arming_request(True)
+        elif self._is_armed():
+            self._helper.cf.platform.send_arming_request(False)
+        elif self._can_arm():
+            self.armButton.setStyleSheet("background-color: orange")
+            self._helper.cf.platform.send_arming_request(True)
 
     def flightmodeChange(self, item):
         Config().set("flightmode", str(self.flightModeCombo.itemText(item)))
@@ -717,81 +690,11 @@ class FlightTab(TabToolbox, flight_tab_class):
         else:
             self._helper.cf.param.set_value("flightmode.althold", int(enabled))
 
-    def alt1_updated(self, state):
-        if state:
-            new_index = (self._ring_effect+1) % (self._ledring_nbr_effects+1)
-            self._helper.cf.param.set_value("ring.effect", str(new_index))
-
-    def alt2_updated(self, state):
-        self._helper.cf.param.set_value("ring.headlightEnable", str(state))
-
     def _all_params_updated(self):
-        self._ring_populate_dropdown()
         self._populate_assisted_mode_dropdown()
         self._update_flight_commander(True)
         self._update_supervisor_and_arming(True)
 
-    def _ring_populate_dropdown(self):
-        try:
-            nbr = int(self._helper.cf.param.values["ring"]["neffect"])
-            current = int(self._helper.cf.param.values["ring"]["effect"])
-        except KeyError:
-            return
-
-        # Used only in alt1_updated function
-        self._ring_effect = current
-        self._ledring_nbr_effects = nbr
-
-        hardcoded_names = {
-            0: "Off",
-            1: "White spinner",
-            2: "Color spinner",
-            3: "Tilt effect",
-            4: "Brightness effect",
-            5: "Color spinner 2",
-            6: "Double spinner",
-            7: "Solid color effect",
-            8: "Factory test",
-            9: "Battery status",
-            10: "Boat lights",
-            11: "Alert",
-            12: "Gravity",
-            13: "LED tab",
-            14: "Color fader",
-            15: "Link quality",
-            16: "Location server status",
-            17: "Sequencer",
-            18: "Lighthouse quality",
-        }
-
-        for i in range(nbr + 1):
-            name = "{}: ".format(i)
-            if i in hardcoded_names:
-                name += hardcoded_names[i]
-            else:
-                name += "N/A"
-            self._led_ring_effect.addItem(name, i)
-
-        self._led_ring_effect.currentIndexChanged.connect(
-            self._ring_effect_changed)
-
-        self._led_ring_effect.setCurrentIndex(current)
-        if int(self._helper.cf.param.values["deck"]["bcLedRing"]) == 1:
-            self._led_ring_effect.setEnabled(True)
-            self._led_ring_headlight.setEnabled(True)
-
-    def _ring_effect_changed(self, index):
-        self._ring_effect = index
-        if index > -1:
-            i = self._led_ring_effect.itemData(index)
-            logger.debug("Changed effect to {}".format(i))
-            if i != int(self._helper.cf.param.values["ring"]["effect"]):
-                self._helper.cf.param.set_value("ring.effect", str(i))
-
-    def _ring_effect_updated(self, name, value):
-        if self._helper.cf.param.is_updated:
-            self._led_ring_effect.setCurrentIndex(int(value))
-
     def _populate_assisted_mode_dropdown(self):
         self._assist_mode_combo.addItem("Altitude hold", 0)
         self._assist_mode_combo.addItem("Position hold", 1)

cfclient/ui/tabs/{LEDTab.py → LEDRingTab.py}

@@ -7,7 +7,7 @@
 #  +------+    / /_/ / / /_/ /__/ /  / /_/ / / /_/  __/
 #   ||  ||    /_____/_/\__/\___/_/   \__,_/ /___/\___/
 #
-#  Copyright (C) 2011-2023 Bitcraze AB
+#  Copyright (C) 2011-2025 Bitcraze AB
 #
 #  Crazyflie Nano Quadcopter Client
 #
@@ -38,28 +38,47 @@ from PyQt6 import QtWidgets
 
 import cfclient
 from cfclient.ui.tab_toolbox import TabToolbox
-from cfclient.utils.ui import UiUtils
 
 from cflib.crazyflie.mem import MemoryElement
 
 __author__ = 'Bitcraze AB'
-__all__ = ['LEDTab']
+__all__ = ['LEDRingTab']
 
 logger = logging.getLogger(__name__)
 
-led_tab_class = uic.loadUiType(cfclient.module_path + "/ui/tabs/ledTab.ui")[0]
+led_ring_tab_class = uic.loadUiType(cfclient.module_path + "/ui/tabs/ledRingTab.ui")[0]
 
 
-class LEDTab(TabToolbox, led_tab_class):
+class LEDRingTab(TabToolbox, led_ring_tab_class):
     """Tab for plotting logging data"""
 
     _connected_signal = pyqtSignal(str)
     _disconnected_signal = pyqtSignal(str)
 
     def __init__(self, helper):
-        super(LEDTab, self).__init__(helper, 'LED')
+        super(LEDRingTab, self).__init__(helper, 'LED Ring')
         self.setupUi(self)
 
+        # LED-ring effect dropdown and headlight checkbox
+        self._ledring_nbr_effects = 0
+
+        # Connect the headlight checkbox
+        self._led_ring_headlight.clicked.connect(
+            lambda enabled: self._helper.cf.param.set_value("ring.headlightEnable", int(enabled)))
+
+        # Update headlight when param changes
+        self._helper.cf.param.add_update_callback(
+            group="ring", name="headlightEnable",
+            cb=lambda name, checked: self._led_ring_headlight.setChecked(bool(int(checked))))
+
+        # Update LED-ring effect when param changes
+        self._helper.cf.param.add_update_callback(
+            group="ring", name="effect",
+            cb=self._ring_effect_updated)
+
+        # Populate dropdown when all params are updated
+        self._helper.cf.param.all_updated.add_callback(self._ring_populate_dropdown)
+
         # Always wrap callbacks from Crazyflie API though QT Signal/Slots
         # to avoid manipulating the UI when rendering it
         self._connected_signal.connect(self._connected)
@@ -108,8 +127,14 @@ class LEDTab(TabToolbox, led_tab_class):
         self._intensity_spin.valueChanged.connect(
             self._intensity_slider.setValue)
 
+        self._helper.inputDeviceReader.alt1_updated.add_callback(self.alt1_updated)
+        self._helper.inputDeviceReader.alt2_updated.add_callback(self.alt2_updated)
+
+        self._led_ring_effect.setEnabled(False)
+        self._led_ring_headlight.setEnabled(False)
+
     def _select(self, nbr):
-        col = QtGui.QColor()  # default to invalid
+        col = QtGui.QColor()
 
         if self._mem:
             led = self._mem.leds[nbr]
@@ -118,10 +143,16 @@ class LEDTab(TabToolbox, led_tab_class):
         col = QtWidgets.QColorDialog.getColor(col)
 
         if col.isValid() and self._mem:
-            logger.info(col.red())
-            self._mem.leds[nbr].set(r=col.red(), g=col.green(), b=col.blue())
-            UiUtils.set_background_color(self.sender(), col.red(), col.green(),
-                                         col.blue())
+            r, g, b = col.red(), col.green(), col.blue()
+            self._mem.leds[nbr].set(r=r, g=g, b=b)
+
+            brightness = 0.299 * r + 0.587 * g + 0.114 * b
+            text_color = "white" if brightness < 128 else "black"
+
+            self.sender().setStyleSheet(
+                f"background-color: rgb({r}, {g}, {b}); color: {text_color};"
+            )
+
             self._write_led_output()
 
     def _intensity_change(self, value):
@@ -149,10 +180,13 @@ class LEDTab(TabToolbox, led_tab_class):
         if self._mem:
             for btn in self._btns:
                 btn.setEnabled(True)
-                btn.setStyleSheet("background-color: black")
+                btn.setStyleSheet("background-color: black; color: white")
                 self._intensity_slider.setEnabled(True)
                 self._intensity_spin.setEnabled(True)
 
+        self._led_ring_effect.setEnabled(True)
+        self._led_ring_headlight.setEnabled(True)
+
     def _disconnected(self, link_uri):
         """Callback for when the Crazyflie has been disconnected"""
         for btn in self._btns:
@@ -161,3 +195,83 @@ class LEDTab(TabToolbox, led_tab_class):
             self._intensity_slider.setEnabled(False)
             self._intensity_spin.setEnabled(False)
             self._intensity_slider.setValue(100)
+
+        self._led_ring_effect.setEnabled(False)
+        self._led_ring_headlight.setEnabled(False)
+
+    def _ring_populate_dropdown(self):
+        try:
+            nbr = int(self._helper.cf.param.values["ring"]["neffect"])
+            current = int(self._helper.cf.param.values["ring"]["effect"])
+        except KeyError:
+            return
+
+        self._ring_effect = current
+        self._ledring_nbr_effects = nbr
+
+        hardcoded_names = {
+            0: "Off",
+            1: "White spinner",
+            2: "Color spinner",
+            3: "Tilt effect",
+            4: "Brightness effect",
+            5: "Color spinner 2",
+            6: "Double spinner",
+            7: "Solid color effect",
+            8: "Factory test",
+            9: "Battery status",
+            10: "Boat lights",
+            11: "Alert",
+            12: "Gravity",
+            13: "LED tab",
+            14: "Color fader",
+            15: "Link quality",
+            16: "Location server status",
+            17: "Sequencer",
+            18: "Lighthouse quality",
+        }
+
+        self._led_ring_effect.clear()
+        for i in range(nbr + 1):
+            name = "{}: ".format(i)
+            name += hardcoded_names.get(i, "N/A")
+            self._led_ring_effect.addItem(name, i)
+
+        self._led_ring_effect.currentIndexChanged.connect(self._ring_effect_changed)
+        self._led_ring_effect.setCurrentIndex(current)
+        self._led_ring_effect.setEnabled(int(self._helper.cf.param.values["deck"]["bcLedRing"]) == 1)
+        self._led_ring_headlight.setEnabled(int(self._helper.cf.param.values["deck"]["bcLedRing"]) == 1)
+
+        try:
+            self._helper.cf.param.set_value("ring.effect", "13")
+            self._led_ring_effect.setCurrentIndex(13)
+            self._ring_effect = 13
+            logger.info("Initialized LED ring to 'LED tab' mode (effect 13).")
+        except Exception as e:
+            logger.warning(f"Could not set LED tab effect on connect: {e}")
+
+    def _ring_effect_changed(self, index):
+        self._ring_effect = index
+        if index > -1:
+            i = self._led_ring_effect.itemData(index)
+            if i != int(self._helper.cf.param.values["ring"]["effect"]):
+                self._helper.cf.param.set_value("ring.effect", str(i))
+
+            if i == 13:
+                self._intensity_slider.setEnabled(True)
+                self._intensity_spin.setEnabled(True)
+            else:
+                self._intensity_slider.setEnabled(False)
+                self._intensity_spin.setEnabled(False)
+
+    def _ring_effect_updated(self, name, value):
+        if self._helper.cf.param.is_updated:
+            self._led_ring_effect.setCurrentIndex(int(value))
+
+    def alt1_updated(self, state):
+        if state:
+            new_index = (self._ring_effect+1) % (self._ledring_nbr_effects+1)
+            self._helper.cf.param.set_value("ring.effect", str(new_index))
+
+    def alt2_updated(self, state):
+        self._helper.cf.param.set_value("ring.headlightEnable", str(state))

cfclient/ui/tabs/LogTab.py

@@ -99,7 +99,7 @@ class LogTab(TabToolbox, param_tab_class):
                         log_groups = cfclient.log_param_doc['logs'][group]
                         log_variable = log_groups['variables'][param]
                         item.setData(4, Qt.ItemDataRole.DisplayRole, log_variable['short_desc'])
-                    except:  # noqa
+                    except (KeyError, TypeError, AttributeError):
                         pass
 
                 groupItem.addChild(item)
@@ -112,5 +112,5 @@ class LogTab(TabToolbox, param_tab_class):
                     label = QtWidgets.QLabel(log_groups['desc'])
                     label.setWordWrap(True)
                     self.logTree.setItemWidget(groupItem, 4, label)
-                except:  # noqa
+                except (KeyError, TypeError, AttributeError):
                     pass

cfclient/ui/tabs/ParamTab.py

@@ -78,6 +78,7 @@ class ParamChildItem(object):
         self._cf = crazyflie
         self.is_updating = True
         self.state = None
+        self.stored_value = ""
 
     def updated(self, name, value):
         """Callback from the param layer when a parameter has been updated"""
@@ -113,7 +114,7 @@ class ParamBlockModel(QAbstractItemModel):
         """Create the empty model"""
         super(ParamBlockModel, self).__init__(parent)
         self._nodes = []
-        self._column_headers = ['Name', 'Type', 'Access', 'Persistent', 'Value']
+        self._column_headers = ['Name', 'Type', 'Access', 'Persistent', 'Value', 'Stored Value']
         self._red_brush = QBrush(QColor("red"))
         self._enabled = False
         self._mainUI = mainUI
@@ -227,12 +228,68 @@ class ParamBlockModel(QAbstractItemModel):
                 return 'Yes' if node.persistent else 'No'
             if index.column() == 4:
                 return node.value
+            if index.column() == 5:
+                return node.stored_value
         elif (role == Qt.ItemDataRole.BackgroundRole and index.column() == 4 and
               node.is_updating):
             return self._red_brush
 
         return None
 
+    def update_stored_value_and_refresh(self, node):
+        """
+        Fetch the persistent stored value for this node, store it in node.stored_value,
+        and refresh the Stored Value column in the view.
+        """
+        if not node.persistent:
+            node.stored_value = ''
+            return
+
+        # Fetch stored value synchronously
+        complete_name = f"{node.parent.name}.{node.name}"
+        from threading import Event
+        wait_event = Event()
+        state_value = None
+
+        def cb(_, state):
+            nonlocal state_value
+            state_value = state
+            wait_event.set()
+
+        self._mainUI.cf.param.persistent_get_state(complete_name, cb)
+        wait_event.wait(timeout=0.2)
+
+        if state_value and state_value.is_stored:
+            node.stored_value = round_if_float(state_value.stored_value)
+        else:
+            node.stored_value = ''
+
+        # Refresh only column 5 (Stored Value)
+        source_row = node.parent.children.index(node)
+        parent_row = self._nodes.index(node.parent)
+        col = 5
+        row_index = self.index(source_row, col, self.createIndex(parent_row, 0, node.parent))
+        proxy_index = self.proxy.mapFromSource(row_index)
+        self.proxy.dataChanged.emit(proxy_index, proxy_index)
+
+    def update_stored_value_from_state(self, node, state: 'PersistentParamState'):
+        """
+        Update the node's stored_value from a PersistentParamState object
+        and refresh the Stored Value column.
+        """
+        if state and state.is_stored:
+            node.stored_value = round_if_float(state.stored_value)
+        else:
+            node.stored_value = ''
+
+        # Refresh only column 5 (Stored Value)
+        source_row = node.parent.children.index(node)
+        parent_row = self._nodes.index(node.parent)
+        col = 5  # Stored Value column
+        row_index = self.index(source_row, col, self.createIndex(parent_row, 0, node.parent))
+        proxy_index = self.proxy.mapFromSource(row_index)
+        self.proxy.dataChanged.emit(proxy_index, proxy_index)
+
     def flags(self, index):
         """Re-implemented function for getting the flags for a certain index"""
         flag = super(ParamBlockModel, self).flags(index)
@@ -336,7 +393,17 @@ class ParamTab(TabToolbox, param_tab_class):
         def success_cb(name, success):
             print(f'store {success}!')
             if success:
-                self.cf.param.persistent_get_state(name, lambda _, state: self._persistent_state_signal.emit(state))
+                # Fetch the persistent state after store
+                def state_cb(_, state):
+                    for group in self._model._nodes:
+                        for node in group.children:
+                            if f"{group.name}.{node.name}" == name:
+                                # Update stored value in model
+                                self._model.update_stored_value_from_state(node, state)
+                                # Update the button text immediately
+                                self._persistent_state_signal.emit(state)
+                                break
+            self.cf.param.persistent_get_state(name, state_cb)
 
         complete = self.paramDetailsLabel.text()
         if self.persistentButton.text() == 'Clear':
@@ -398,7 +465,7 @@ class ParamTab(TabToolbox, param_tab_class):
 
                     self.paramDetailsDescription.setWordWrap(True)
                     self.paramDetailsDescription.setText(desc.replace('\n', ''))
-                except:  # noqa
+                except (KeyError, TypeError, AttributeError):
                     self.paramDetailsDescription.setText('')
 
             complete = f'{group}.{param}'
@@ -417,6 +484,9 @@ class ParamTab(TabToolbox, param_tab_class):
 
             if elem.is_persistent():
                 self.cf.param.persistent_get_state(complete, lambda _, state: self._persistent_state_signal.emit(state))
+                source_index = self.proxyModel.mapToSource(indexes[0])
+                node = source_index.internalPointer()
+                self._model.update_stored_value_and_refresh(node)
 
     def _update_param_io_buttons(self):
         enabled = self._is_connected
@@ -536,7 +606,7 @@ class ParamTab(TabToolbox, param_tab_class):
     def _clear_stored_persistent_params_button_clicked(self):
         dlg = QMessageBox(self)
         dlg.setWindowTitle("Clear Stored Parameters Confirmation")
-        dlg.setText("Are you sure you want to clear your stored persistent parameter?")
+        dlg.setText("Are you sure you want to clear your stored persistent parameters?")
         dlg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         button = dlg.exec()
 
@@ -544,6 +614,22 @@ class ParamTab(TabToolbox, param_tab_class):
             stored_persistent_params = self._get_all_stored_persistent_param_names()
             for complete_name in stored_persistent_params:
                 self._clear_persistent_parameter(complete_name)
+                for group in self._model._nodes:
+                    for node in group.children:
+                        if f"{group.name}.{node.name}" == complete_name:
+                            node.stored_value = ''
+                            # Emit a targeted dataChanged for column 5 only
+                            source_row = group.children.index(node)
+                            parent_row = self._model._nodes.index(group)
+                            col = 5
+
+                            index = self._model.index(
+                                source_row, col,
+                                self._model.index(parent_row, 0, QModelIndex())
+                            )
+                            proxy_index = self._model.proxy.mapFromSource(index)
+                            self._model.proxy.dataChanged.emit(proxy_index, proxy_index)
+                            break
 
     def _connected(self, link_uri):
         self._model.reset()

cfclient/ui/tabs/__init__.py

@@ -34,7 +34,7 @@ from .CrtpSharkToolbox import CrtpSharkToolbox
 # from .ExampleTab import ExampleTab
 from .FlightTab import FlightTab
 # from .GpsTab import GpsTab
-from .LEDTab import LEDTab
+from .LEDRingTab import LEDRingTab
 from .LogBlockTab import LogBlockTab
 from .LogTab import LogTab
 from .ParamTab import ParamTab
@@ -43,6 +43,7 @@ from .locopositioning_tab import LocoPositioningTab
 from .LogClientTab import LogClientTab
 from .lighthouse_tab import LighthouseTab
 from .TuningTab import TuningTab
+from .ColorLEDTab import ColorLEDTab
 
 __author__ = 'Bitcraze AB'
 __all__ = []
@@ -52,7 +53,8 @@ available = [
     # ExampleTab,
     FlightTab,
     # GpsTab,
-    LEDTab,
+    LEDRingTab,
+    ColorLEDTab,
     LogBlockTab,
     LogTab,
     ParamTab,