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

cfclient/ui/tabs/ParamTab.py

@@ -7,7 +7,7 @@
 #  +------+    / /_/ / / /_/ /__/ /  / /_/ / / /_/  __/
 #   ||  ||    /_____/_/\__/\___/_/   \__,_/ /___/\___/
 #
-#  Copyright (C) 2011-2013 Bitcraze AB
+#  Copyright (C) 2011-2023 Bitcraze AB
 #
 #  Crazyflie Nano Quadcopter Client
 #
@@ -31,50 +31,60 @@ to edit them.
 """
 
 import logging
+from threading import Event
 
-from PyQt5 import uic
-from PyQt5.QtCore import Qt, pyqtSignal
-from PyQt5.QtCore import QAbstractItemModel, QModelIndex
-from PyQt5.QtGui import QBrush, QColor
+from PyQt6 import uic, QtCore
+from PyQt6.QtCore import QSortFilterProxyModel, Qt, pyqtSignal
+from PyQt6.QtCore import QAbstractItemModel, QModelIndex, QVariant
+from PyQt6.QtGui import QBrush, QColor
+from PyQt6.QtWidgets import QHeaderView, QFileDialog, QMessageBox
+
+from cflib.crazyflie.param import PersistentParamState
+from cflib.localization import ParamFileManager
 
 import cfclient
-from cfclient.ui.tab import Tab
+from cfclient.ui.tab_toolbox import TabToolbox
+from cfclient.utils.logconfigreader import FILE_REGEX_YAML
 
 __author__ = 'Bitcraze AB'
 __all__ = ['ParamTab']
 
-param_tab_class = uic.loadUiType(
-    cfclient.module_path + "/ui/tabs/paramTab.ui")[0]
+param_tab_class = uic.loadUiType(cfclient.module_path + "/ui/tabs/paramTab.ui")[0]
 
 logger = logging.getLogger(__name__)
 
 
+def round_if_float(value):
+    """If the value is float, we limit to 5 significat numbers"""
+    try:
+        value = float(value)
+        value = f'{value:.5g}'
+    except ValueError:
+        pass
+    return value
+
+
 class ParamChildItem(object):
     """Represents a leaf-node in the tree-view (one parameter)"""
 
-    def __init__(self, parent, name, crazyflie):
+    def __init__(self, parent, name, persistent, crazyflie):
         """Initialize the node"""
         self.parent = parent
         self.name = name
         self.ctype = None
         self.access = None
+        self.persistent = False
         self.value = ""
         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"""
-        self.value = value
+        self.value = round_if_float(value)
         self.is_updating = False
-        self.parent.model.refresh()
-
-    def set_value(self, value):
-        """Send the update value to the Crazyflie. It will automatically be
-        read again after sending and then the updated callback will be
-        called"""
-        complete_name = "%s.%s" % (self.parent.name, self.name)
-        self._cf.param.set_value(complete_name, value)
-        self.is_updating = True
+        self.parent.model.proxy.dataChanged.emit(QModelIndex(), QModelIndex())
 
     def child_count(self):
         """Return the number of children this node has"""
@@ -100,12 +110,23 @@ class ParamGroupItem(object):
 class ParamBlockModel(QAbstractItemModel):
     """Model for handling the parameters in the tree-view"""
 
-    def __init__(self, parent):
+    def __init__(self, parent, mainUI):
         """Create the empty model"""
         super(ParamBlockModel, self).__init__(parent)
         self._nodes = []
-        self._column_headers = ['Name', 'Type', 'Access', 'Value']
+        self._column_headers = ['Name', 'Type', 'Access', 'Persistent', 'Value', 'Stored Value']
         self._red_brush = QBrush(QColor("red"))
+        self._enabled = False
+        self._mainUI = mainUI
+        self.proxy = None
+
+    def set_proxy(self, proxy):
+        self.proxy = proxy
+
+    def set_enabled(self, enabled):
+        if self._enabled != enabled:
+            self._enabled = enabled
+            self.layoutChanged.emit()
 
     def set_toc(self, toc, crazyflie):
         """Populate the model with data from the param TOC"""
@@ -114,9 +135,13 @@ class ParamBlockModel(QAbstractItemModel):
         for group in sorted(toc.keys()):
             new_group = ParamGroupItem(group, self)
             for param in sorted(toc[group].keys()):
-                new_param = ParamChildItem(new_group, param, crazyflie)
-                new_param.ctype = toc[group][param].ctype
-                new_param.access = toc[group][param].get_readable_access()
+                elem = toc[group][param]
+                is_persistent = elem.is_persistent()
+                new_param = ParamChildItem(new_group, param, is_persistent, crazyflie)
+                new_param.ctype = elem.ctype
+                new_param.access = elem.get_readable_access()
+                new_param.persistent = elem.is_persistent()
+
                 crazyflie.param.add_update_callback(
                     group=group, name=param, cb=new_param.updated)
                 new_group.children.append(new_param)
@@ -146,7 +171,7 @@ class ParamBlockModel(QAbstractItemModel):
 
     def headerData(self, section, orientation, role):
         """Re-implemented method to get the headers"""
-        if role == Qt.DisplayRole:
+        if role == Qt.ItemDataRole.DisplayRole:
             return self._column_headers[section]
 
     def rowCount(self, parent):
@@ -173,12 +198,26 @@ class ParamBlockModel(QAbstractItemModel):
 
     def data(self, index, role):
         """Re-implemented method to get the data for a given index and role"""
+
+        if role == Qt.ItemDataRole.BackgroundRole:
+            if index.row() % 2 == 0:
+                return QVariant(self._mainUI.bgColor)
+            else:
+                multiplier = 1.15 if self._mainUI.isDark else 0.95
+                return QVariant(
+                    QColor(
+                        int(self._mainUI.bgColor.red() * multiplier),
+                        int(self._mainUI.bgColor.green() * multiplier),
+                        int(self._mainUI.bgColor.blue() * multiplier)
+                    )
+                )
+
         node = index.internalPointer()
         parent = node.parent
         if not parent:
-            if role == Qt.DisplayRole and index.column() == 0:
+            if role == Qt.ItemDataRole.DisplayRole and index.column() == 0:
                 return node.name
-        elif role == Qt.DisplayRole:
+        elif role == Qt.ItemDataRole.DisplayRole:
             if index.column() == 0:
                 return node.name
             if index.column() == 1:
@@ -186,32 +225,78 @@ class ParamBlockModel(QAbstractItemModel):
             if index.column() == 2:
                 return node.access
             if index.column() == 3:
+                return 'Yes' if node.persistent else 'No'
+            if index.column() == 4:
                 return node.value
-        elif role == Qt.EditRole and index.column() == 3:
-            return node.value
-        elif (role == Qt.BackgroundRole and index.column() == 3 and
+            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 setData(self, index, value, role):
-        """Re-implemented function called when a value has been edited"""
-        node = index.internalPointer()
-        if role == Qt.EditRole:
-            new_val = str(value)
-            # This will not update the value, only trigger a setting and
-            # reading of the parameter from the Crazyflie
-            node.set_value(new_val)
-            return True
-        return False
+    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)
-        node = index.internalPointer()
-        if index.column() == 3 and node.parent and node.access == "RW":
-            flag |= Qt.ItemIsEditable
+
+        if not self._enabled:
+            return Qt.ItemFlag.NoItemFlags
+
         return flag
 
     def reset(self):
@@ -222,7 +307,24 @@ class ParamBlockModel(QAbstractItemModel):
         self.layoutChanged.emit()
 
 
-class ParamTab(Tab, param_tab_class):
+class ParamTreeFilterProxy(QSortFilterProxyModel):
+    """
+    Implement a filtering proxy model that show all children if the group matches.
+    """
+    def __init__(self, paramTree):
+        super(ParamTreeFilterProxy, self).__init__(paramTree)
+
+    def filterAcceptsRow(self, source_row: int, source_parent: QModelIndex) -> bool:
+        '''
+        When a group match the filter, make sure all children matches as well.
+        '''
+        if not source_parent.isValid():
+            return super().filterAcceptsRow(source_row, source_parent)
+
+        return super().filterAcceptsRow(source_parent.row(), source_parent.parent())
+
+
+class ParamTab(TabToolbox, param_tab_class):
     """
     Show all the parameters in the TOC and give the user the ability to edit
     them
@@ -231,16 +333,16 @@ class ParamTab(Tab, param_tab_class):
     _connected_signal = pyqtSignal(str)
     _disconnected_signal = pyqtSignal(str)
 
-    def __init__(self, tabWidget, helper, *args):
+    _set_param_value_signal = pyqtSignal()
+    _persistent_state_signal = pyqtSignal(PersistentParamState)
+    _param_default_signal = pyqtSignal(object)
+    _reset_param_signal = pyqtSignal(str)
+
+    def __init__(self, helper):
         """Create the parameter tab"""
-        super(ParamTab, self).__init__(*args)
+        super(ParamTab, self).__init__(helper, 'Parameters')
         self.setupUi(self)
 
-        self.tabName = "Parameters"
-        self.menuName = "Parameters"
-
-        self.helper = helper
-        self.tabWidget = tabWidget
         self.cf = helper.cf
 
         self.cf.connected.add_callback(self._connected_signal.emit)
@@ -248,14 +350,298 @@ class ParamTab(Tab, param_tab_class):
         self.cf.disconnected.add_callback(self._disconnected_signal.emit)
         self._disconnected_signal.connect(self._disconnected)
 
-        self._model = ParamBlockModel(None)
-        self.paramTree.setModel(self._model)
+        self._model = ParamBlockModel(None, self._helper.mainUI)
+        self._persistent_state_signal.connect(self._persistent_state_cb)
+        self._set_param_value_signal.connect(self._set_param_value)
+        self.setParamButton.clicked.connect(self._set_param_value_signal.emit)
+        self.currentValue.returnPressed.connect(self._set_param_value_signal.emit)
+        self._param_default_signal.connect(self._param_default_cb)
+
+        self._reset_param_signal.connect(lambda text: self.currentValue.setText(text))
+        self.resetDefaultButton.clicked.connect(lambda: self._reset_param_signal.emit(self.defaultValue.text()))
+        self.persistentButton.clicked.connect(self._persistent_button_cb)
+
+        self.proxyModel = ParamTreeFilterProxy(self.paramTree)
+        self.proxyModel.setSourceModel(self._model)
+        self.proxyModel.setRecursiveFilteringEnabled(True)
+        self._model.set_proxy(self.proxyModel)
+
+        @QtCore.pyqtSlot(str)
+        def onFilterChanged(text):
+            self.proxyModel.setFilterRegExp(text)
+
+        self.filterBox.textChanged.connect(onFilterChanged)
+
+        self.paramTree.setModel(self.proxyModel)
+        self.paramTree.header().setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
+        self.paramTree.selectionModel().selectionChanged.connect(self._paramChanged)
+
+        self._load_param_button.clicked.connect(self._load_param_button_clicked)
+        self._dump_param_button.clicked.connect(self._dump_param_button_clicked)
+        self._clear_param_button.clicked.connect(self._clear_stored_persistent_params_button_clicked)
+
+        self._is_connected = False
+        self._update_param_io_buttons()
+
+    def _param_default_cb(self, default_value):
+        if default_value is not None:
+            self.defaultValue.setText(str(default_value))
+        else:
+            self.defaultValue.setText('-')
+
+    def _persistent_button_cb(self, _):
+        def success_cb(name, success):
+            print(f'store {success}!')
+            if success:
+                # 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':
+            self.cf.param.persistent_clear(complete, success_cb)
+        else:
+            self.cf.param.persistent_store(complete, success_cb)
+
+    def _persistent_state_cb(self, state):
+        print(f'persistent callback! state: {state}')
+        self.persistentFrame.setVisible(True)
+
+        if state.is_stored:
+            self.storedValue.setText(str(state.stored_value))
+        else:
+            self.storedValue.setText('Not stored')
+
+        self.persistentButton.setText('Clear' if state.is_stored else 'Store')
+
+    def _set_param_value(self):
+        name = self.paramDetailsLabel.text()
+        value = self.currentValue.text()
+        try:
+            self.cf.param.set_value(name, value)
+            self.currentValue.setStyleSheet('')
+        except Exception:
+            self.currentValue.setStyleSheet('border: 1px solid red')
+
+    def _paramChanged(self):
+
+        group = None
+        param = None
+        indexes = self.paramTree.selectionModel().selectedIndexes()
+        if len(indexes) > 0:
+            selectedIndex = indexes[0]
+            if selectedIndex.parent().isValid():
+                group = selectedIndex.parent().data()
+                param = selectedIndex.data()
+            else:
+                group = selectedIndex.data()
+
+        # Made visible in _persistent_state_cb()
+        self.persistentFrame.setVisible(False)
+
+        are_details_visible = param is not None
+        self.valueFrame.setVisible(are_details_visible)
+        self.paramDetailsLabel.setVisible(are_details_visible)
+        self.paramDetailsDescription.setVisible(are_details_visible)
+
+        if param:
+            self.paramDetailsLabel.setText(f'{group}.{param}' if param is not None else group)
+            if cfclient.log_param_doc is not None:
+                try:
+                    desc = str()
+                    group_doc = cfclient.log_param_doc['params'][group]
+                    if param is None:
+                        desc = group_doc['desc']
+                    else:
+                        desc = group_doc['variables'][param]['short_desc']
+
+                    self.paramDetailsDescription.setWordWrap(True)
+                    self.paramDetailsDescription.setText(desc.replace('\n', ''))
+                except (KeyError, TypeError, AttributeError):
+                    self.paramDetailsDescription.setText('')
+
+            complete = f'{group}.{param}'
+            elem = self.cf.param.toc.get_element_by_complete_name(complete)
+            value = round_if_float(self.cf.param.get_value(complete))
+            self.currentValue.setText(value)
+            self.currentValue.setStyleSheet('')
+            self.currentValue.setCursorPosition(0)
+            self.defaultValue.setText('-')
+            self.cf.param.get_default_value(complete, lambda _, value: self._param_default_signal.emit(value))
+
+            writable = elem.get_readable_access() == 'RW'
+            self.currentValue.setEnabled(writable)
+            self.setParamButton.setEnabled(writable)
+            self.resetDefaultButton.setEnabled(writable)
+
+            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
+        self._load_param_button.setEnabled(enabled)
+        self._dump_param_button.setEnabled(enabled)
+        self._clear_param_button.setEnabled(enabled)
+
+    def _load_param_button_clicked(self):
+        names = QFileDialog.getOpenFileName(self, 'Open file', cfclient.config_path, FILE_REGEX_YAML)
+
+        if names[0] == '':
+            return
+        filename = names[0]
+        parameters = ParamFileManager.read(filename)
+
+        def _is_persistent_stored_callback(complete_name, success):
+            if not success:
+                print(f'Persistent params: failed to store {complete_name}!')
+                QMessageBox.about(self, 'Warning', f'Failed to persistently store {complete_name}!')
+            else:
+                print(f'Persistent params: stored {complete_name}!')
+
+        _set_param_names = []
+        for param, state in parameters.items():
+            if state.is_stored:
+                try:
+                    self.cf.param.set_value(param, state.stored_value)
+                    _set_param_names.append(param)
+                except Exception:
+                    print(f'Failed to set {param}!')
+                    QMessageBox.about(self, 'Warning', f'Failed to set {param}!')
+                print(f'Set {param}!')
+                self.cf.param.persistent_store(param, _is_persistent_stored_callback)
+
+        self._update_param_io_buttons()
+        dlg = QMessageBox(self)
+        dlg.setWindowTitle("Info")
+        _parameters_and_values = [f"{_param_name}:{parameters[_param_name].stored_value}"
+                                  for _param_name in _set_param_names]
+        dlg.setText('Loaded persistent parameters from file:\n' + "\n".join(_parameters_and_values))
+        dlg.setIcon(QMessageBox.Icon.NoIcon)
+        dlg.exec()
+
+    def _get_persistent_state(self, complete_param_name):
+        wait_for_callback_event = Event()
+        state_value = None
+
+        def state_callback(complete_name, value):
+            nonlocal state_value
+            state_value = value
+            wait_for_callback_event.set()
+
+        self.cf.param.persistent_get_state(complete_param_name, state_callback)
+        wait_for_callback_event.wait()
+        return state_value
+
+    def _get_all_persistent_param_names(self):
+        persistent_params = []
+        for group_name, params in self.cf.param.toc.toc.items():
+            for param_name, element in params.items():
+                if element.is_persistent():
+                    complete_name = group_name + '.' + param_name
+                    persistent_params.append(complete_name)
+
+        return persistent_params
+
+    def _get_all_stored_persistent_param_names(self):
+        persistent_params = self._get_all_persistent_param_names()
+        stored_params = []
+        for complete_name in persistent_params:
+            state = self._get_persistent_state(complete_name)
+            if state.is_stored:
+                stored_params.append(complete_name)
+        return stored_params
+
+    def _get_all_stored_persistent_params(self):
+        persistent_params = self._get_all_persistent_param_names()
+        stored_params = {}
+        for complete_name in persistent_params:
+            state = self._get_persistent_state(complete_name)
+            if state.is_stored:
+                stored_params[complete_name] = state
+        return stored_params
+
+    def _dump_param_button_clicked(self):
+        stored_persistent_params = self._get_all_stored_persistent_params()
+        names = QFileDialog.getSaveFileName(self, 'Save file', cfclient.config_path, FILE_REGEX_YAML)
+        if names[0] == '':
+            return
+        if not names[0].endswith(".yaml"):
+            filename = names[0] + ".yaml"
+        else:
+            filename = names[0]
+
+        ParamFileManager.write(filename, stored_persistent_params)
+        dlg = QMessageBox(self)
+        dlg.setWindowTitle('Info')
+        _parameters_and_values = [f"{_param_name}: {stored_persistent_params[_param_name].stored_value}"
+                                  for _param_name in stored_persistent_params.keys()]
+        dlg.setText('Dumped persistent parameters to file:\n' + "\n".join(_parameters_and_values))
+        dlg.setIcon(QMessageBox.Icon.NoIcon)
+        dlg.exec()
+
+    def _clear_persistent_parameter(self, complete_param_name):
+        wait_for_callback_event = Event()
+
+        def is_stored_cleared(complete_name, success):
+            if success:
+                print(f'Persistent params: cleared {complete_name}!')
+            else:
+                print(f'Persistent params: failed to clear {complete_name}!')
+            wait_for_callback_event.set()
+
+        self.cf.param.persistent_clear(complete_param_name, callback=is_stored_cleared)
+        wait_for_callback_event.wait()
+
+    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 parameters?")
+        dlg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+        button = dlg.exec()
+
+        if button == QMessageBox.StandardButton.Yes:
+            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.set_toc(self.cf.param.toc.toc, self.helper.cf)
-        self.paramTree.expandAll()
+        self._model.reset()
+        self._model.set_toc(self.cf.param.toc.toc, self._helper.cf)
+        self._model.set_enabled(True)
+        self._helper.cf.param.request_update_of_all_params()
+        self._is_connected = True
+        self._update_param_io_buttons()
 
     def _disconnected(self, link_uri):
-        self._model.beginResetModel()
+        self._is_connected = False
+        self._update_param_io_buttons()
         self._model.reset()
-        self._model.endResetModel()
+        self._paramChanged()
+        self._model.set_enabled(False)