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

cfloader/__init__.py

@@ -32,26 +32,27 @@
 import sys
 
 import cflib.crtp
-from cflib.bootloader import Bootloader
-from cflib.bootloader.boottypes import BootVersion, TargetTypes
+from cflib.bootloader import Bootloader, Target
+from cflib.bootloader.boottypes import BootVersion
 
 
 def main():
     # Initialise the CRTP link driver
-    link = None
     try:
         cflib.crtp.init_drivers()
-        link = cflib.crtp.get_link_driver("radio://")
     except Exception as e:
         print("Error: {}".format(str(e)))
-        if link:
-            link.close()
         sys.exit(-1)
 
     # Set the default parameters
     clink = None
     action = "info"
     boot = "cold"
+    filename = None  # type: Optional[str]
+    targets = None  # type: Optional[List[Target]]
+    bl = None  # type: Optional[Bootloader]
+
+    exit_result = 0
 
     if len(sys.argv) < 2:
         print()
@@ -74,8 +75,6 @@ def main():
         print("                             possible  page in flash and reset "
               "to firmware")
         print("                             mode.")
-        if link:
-            link.close()
         sys.exit(0)
 
     # Analyse the command line parameters
@@ -103,81 +102,65 @@ def main():
     elif sys.argv[0] == "reset":
         action = "reset"
     elif sys.argv[0] == "flash":
-        # print len(sys.argv)
         if len(sys.argv) < 2:
             print("The flash action require a file name.")
-            link.close()
             sys.exit(-1)
         action = "flash"
         filename = sys.argv[1]
-        targetnames = {}
+        targets = []  # Dict[Target]
         for t in sys.argv[2:]:
-            [target, type] = t.split("-")
-            if target in targetnames:
-                targetnames[target] += (type,)
+            if t.startswith("deck-"):
+                [deck, target, type] = t.split("-")
+                targets.append(Target("deck", target, type, [], []))
             else:
-                targetnames[target] = (type,)
+                [target, type] = t.split("-")
+                targets.append(Target("cf2", target, type, [], []))
     else:
         print("Action", sys.argv[0], "unknown!")
-        link.close()
         sys.exit(-1)
 
-    # Currently there's two different targets available
-    targets = ()
-
     try:
         # Initialise the bootloader lib
         bl = Bootloader(clink)
 
-        #########################################
-        # Get the connection with the bootloader
-        #########################################
-        # The connection is done by reseting to the bootloader (default)
-        if boot == "reset":
-            print("Reset to bootloader mode ..."),
+        warm_boot = (boot == "reset")
+        if warm_boot:
+            print("Reset to bootloader mode ...")
             sys.stdout.flush()
-            if bl.start_bootloader(warm_boot=True):
-                print(" done!")
-            else:
-                print("Failed to warmboot")
-                bl.close()
-                sys.exit(-1)
         else:  # The connection is done by a cold boot ...
             print("Restart the Crazyflie you want to bootload in the next"),
             print(" 10 seconds ..."),
 
             sys.stdout.flush()
-            if bl.start_bootloader(warm_boot=False):
-                print(" done!")
-            else:
-                print("Cannot connect the bootloader!")
-                bl.close()
-                sys.exit(-1)
-
-        print("Connected to bootloader on {} (version=0x{:X})".format(
-            BootVersion.to_ver_string(bl.protocol_version),
-            bl.protocol_version))
-
-        if bl.protocol_version == BootVersion.CF2_PROTO_VER:
-            targets += (bl.get_target(TargetTypes.NRF51),)
-        targets += (bl.get_target(TargetTypes.STM32),)
 
         ######################################
         # Doing something (hopefully) useful
         ######################################
 
-        # Print information about the targets
-        for target in targets:
-            print(target)
         if action == "info":
-            None  # Already done ...
+            def print_info(version: int, connected_targets: [Target]):
+                print("Connected to bootloader on {} (version=0x{:X})".format(
+                    BootVersion.to_ver_string(version),
+                    version
+                    )
+                )
+                for target in connected_targets:
+                    print(target)
+
+            # flash_full called with no filename will not flash, just call
+            # our info callback
+            bl.flash_full(None, None, warm_boot, None, print_info)
+        elif action == "flash" and filename:
+            is_target_required = not filename.endswith('.zip')
+            if (is_target_required and not targets):
+                print("The flash action with a non .zip file requires a target")
+                sys.exit(-1)
+            try:
+                bl.flash_full(None, filename, warm_boot, targets)
+            except Exception as e:
+                print("Failed to flash: {}".format(e))
+                exit_result = -1
         elif action == "reset":
-            print
-            print("Reset in firmware mode ...")
-            bl.reset_to_firmware()
-        elif action == "flash":
-            bl.flash(filename, targetnames)
-            print("Reset in firmware mode ...")
             bl.reset_to_firmware()
         else:
             None
@@ -186,6 +169,7 @@ def main():
 
         traceback.print_exc(file=sys.stdout)
         print(e)
+        exit_result = -1
 
     finally:
         #########################
@@ -193,3 +177,5 @@ def main():
         #########################
         if bl:
             bl.close()
+
+    sys.exit(exit_result)

cfzmq/__init__.py

@@ -53,15 +53,15 @@ if os.name == 'posix':
 os.environ["SDL_VIDEODRIVER"] = "dummy"
 
 # Main command socket for control (ping/pong)
-ZMQ_SRV_PORT = 2000
+ZMQ_SRV_PORT = 0
 # Log data socket (publish)
-ZMQ_LOG_PORT = 2001
+ZMQ_LOG_PORT = 1
 # Param value updated (publish)
-ZMQ_PARAM_PORT = 2002
+ZMQ_PARAM_PORT = 2
 # Async event for connection, like connection lost (publish)
-ZMQ_CONN_PORT = 2003
+ZMQ_CONN_PORT = 3
 # Control set-poins for Crazyflie (pull)
-ZMQ_CTRL_PORT = 2004
+ZMQ_CTRL_PORT = 4
 
 # Timeout before giving up when verifying param write
 PARAM_TIMEOUT = 2
@@ -317,9 +317,9 @@ class _CtrlThread(Thread):
 class ZMQServer():
     """Crazyflie ZMQ server"""
 
-    def __init__(self, base_url):
+    def __init__(self, base_url, base_port):
         """Start threads and bind ports"""
-        cflib.crtp.init_drivers(enable_debug_driver=True)
+        cflib.crtp.init_drivers()
         self._cf = Crazyflie(ro_cache=None,
                              rw_cache=cfclient.config_path + "/cache")
 
@@ -328,11 +328,16 @@ class ZMQServer():
         self._base_url = base_url
         self._context = zmq.Context()
 
-        cmd_srv = self._bind_zmq_socket(zmq.REP, "cmd", ZMQ_SRV_PORT)
-        log_srv = self._bind_zmq_socket(zmq.PUB, "log", ZMQ_LOG_PORT)
-        param_srv = self._bind_zmq_socket(zmq.PUB, "param", ZMQ_PARAM_PORT)
-        ctrl_srv = self._bind_zmq_socket(zmq.PULL, "ctrl", ZMQ_CTRL_PORT)
-        conn_srv = self._bind_zmq_socket(zmq.PUB, "conn", ZMQ_CONN_PORT)
+        cmd_srv = self._bind_zmq_socket(zmq.REP, "cmd",
+                                        base_port + ZMQ_SRV_PORT)
+        log_srv = self._bind_zmq_socket(zmq.PUB, "log",
+                                        base_port + ZMQ_LOG_PORT)
+        param_srv = self._bind_zmq_socket(zmq.PUB, "param",
+                                          base_port + ZMQ_PARAM_PORT)
+        ctrl_srv = self._bind_zmq_socket(zmq.PULL, "ctrl",
+                                         base_port + ZMQ_CTRL_PORT)
+        conn_srv = self._bind_zmq_socket(zmq.PUB, "conn",
+                                         base_port + ZMQ_CONN_PORT)
 
         self._scan_thread = _SrvThread(cmd_srv, log_srv, param_srv, conn_srv,
                                        self._cf)
@@ -360,14 +365,17 @@ def main():
                         help="URL where ZMQ will accept connections")
     parser.add_argument("-d", "--debug", action="store_true", dest="debug",
                         help="Enable debug output")
-    (args, unused) = parser.parse_known_args()
+    parser.add_argument("-p", "--port", action="store", dest="port", type=int,
+                        default=2000,
+                        help="Base port to used for ZMQ sockets")
+    (args, _) = parser.parse_known_args()
 
     if args.debug:
         logging.basicConfig(level=logging.DEBUG)
     else:
         logging.basicConfig(level=logging.INFO)
 
-    ZMQServer(args.url)
+    ZMQServer(args.url, args.port)
 
     # CRTL-C to exit
 

cfclient/ui/dialogs/cf1config.py

@@ -1,265 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-#     ||          ____  _ __
-#  +------+      / __ )(_) /_______________ _____  ___
-#  | 0xBC |     / __  / / __/ ___/ ___/ __ `/_  / / _ \
-#  +------+    / /_/ / / /_/ /__/ /  / /_/ / / /_/  __/
-#   ||  ||    /_____/_/\__/\___/_/   \__,_/ /___/\___/
-#
-#  Copyright (C) 2011-2013 Bitcraze AB
-#
-#  Crazyflie Nano Quadcopter Client
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-
-#  You should have received a copy of the GNU General Public License along with
-#  this program; if not, write to the Free Software Foundation, Inc.,
-#  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-"""
-The bootloader dialog is used to update the Crazyflie firmware and to
-read/write the configuration block in the Crazyflie flash.
-"""
-
-import struct
-from cflib.bootloader import Bootloader
-
-import logging
-
-from PyQt5 import QtWidgets, uic
-from PyQt5.QtCore import pyqtSlot, pyqtSignal, QThread
-
-import cfclient
-from cfclient.utils.config import Config
-from functools import reduce
-
-__author__ = 'Bitcraze AB'
-__all__ = ['Cf1ConfigDialog']
-
-logger = logging.getLogger(__name__)
-
-service_dialog_class = uic.loadUiType(cfclient.module_path +
-                                      "/ui/dialogs/cf1config.ui")[0]
-
-
-class UIState:
-    DISCONNECTED = 0
-    CONNECTING = 5
-    CONNECT_FAILED = 1
-    COLD_CONNECT = 2
-    FLASHING = 3
-    RESET = 4
-
-
-class Cf1ConfigDialog(QtWidgets.QWidget, service_dialog_class):
-    """Tab for update the Crazyflie firmware and for reading/writing the config
-    block in flash"""
-
-    def __init__(self, helper, *args):
-        super(Cf1ConfigDialog, self).__init__(*args)
-        self.setupUi(self)
-
-        self.tabName = "CF1 Config"
-        self.menuName = "CF1 Config"
-
-        # self.tabWidget = tabWidget
-        self.helper = helper
-
-        # self.cf = crazyflie
-        self.clt = CrazyloadThread()
-
-        # Connecting GUI signals (a pity to do that manually...)
-        self.coldBootButton.clicked.connect(self.initiateColdboot)
-        self.resetButton.clicked.connect(self.resetCopter)
-        self.saveConfigblock.clicked.connect(self.writeConfig)
-        self._cancel_bootloading.clicked.connect(self.close)
-
-        self.clt.statusChanged.connect(self.statusUpdate)
-        self.clt.connectingSignal.connect(
-            lambda: self.setUiState(UIState.CONNECTING))
-        self.clt.connectedSignal.connect(
-            lambda: self.setUiState(UIState.COLD_CONNECT))
-        self.clt.failed_signal.connect(lambda m: self._ui_connection_fail(m))
-        self.clt.disconnectedSignal.connect(
-            lambda: self.setUiState(UIState.DISCONNECTED))
-        self.clt.updateConfigSignal.connect(self.updateConfig)
-
-        self.clt.start()
-
-    def _ui_connection_fail(self, message):
-        self.setStatusLabel(message)
-        self.coldBootButton.setEnabled(True)
-
-    def setUiState(self, state):
-        if (state == UIState.DISCONNECTED):
-            self.resetButton.setEnabled(False)
-            self.setStatusLabel("Not connected")
-            self.coldBootButton.setEnabled(True)
-            self.progressBar.setTextVisible(False)
-            self.progressBar.setValue(0)
-            self.statusLabel.setText('Status: <b>IDLE</b>')
-            self.saveConfigblock.setEnabled(False)
-        elif (state == UIState.CONNECTING):
-            self.resetButton.setEnabled(False)
-            self.setStatusLabel("Trying to connect cold bootloader, restart "
-                                "the Crazyflie to connect")
-            self.coldBootButton.setEnabled(False)
-        elif (state == UIState.CONNECT_FAILED):
-            self.setStatusLabel("Connecting to bootloader failed")
-            self.coldBootButton.setEnabled(True)
-        elif (state == UIState.COLD_CONNECT):
-            self.resetButton.setEnabled(True)
-            self.saveConfigblock.setEnabled(True)
-            self.setStatusLabel("Connected to bootloader")
-            self.coldBootButton.setEnabled(False)
-        elif (state == UIState.RESET):
-            self.setStatusLabel("Resetting to firmware, disconnected")
-            self.resetButton.setEnabled(False)
-            self.coldBootButton.setEnabled(False)
-            self.rollTrim.setValue(0)
-            self.pitchTrim.setValue(0)
-            self.radioChannel.setValue(0)
-            self.radioSpeed.setCurrentIndex(0)
-
-    def setStatusLabel(self, text):
-        self.connectionStatus.setText("Status: <b>%s</b>" % text)
-
-    def connected(self):
-        self.setUiState(UIState.COLD_CONNECT)
-
-    def connectionFailed(self):
-        self.setUiState(UIState.CONNECT_FAILED)
-
-    def resetCopter(self):
-        self.clt.resetCopterSignal.emit()
-        self.setUiState(UIState.RESET)
-
-    def updateConfig(self, channel, speed, rollTrim, pitchTrim):
-        self.rollTrim.setValue(rollTrim)
-        self.pitchTrim.setValue(pitchTrim)
-        self.radioChannel.setValue(channel)
-        self.radioSpeed.setCurrentIndex(speed)
-
-    def closeEvent(self, event):
-        self.setUiState(UIState.RESET)
-        self.clt.resetCopterSignal.emit()
-
-    @pyqtSlot(str, int)
-    def statusUpdate(self, status, progress):
-        logger.debug("Status: [%s] | %d", status, progress)
-        self.statusLabel.setText('Status: <b>' + status + '</b>')
-        if progress >= 0 and progress < 100:
-            self.progressBar.setTextVisible(True)
-            self.progressBar.setValue(progress)
-        else:
-            self.progressBar.setTextVisible(False)
-            self.progressBar.setValue(100)
-        if progress >= 100:
-            self.resetButton.setEnabled(True)
-
-    def initiateColdboot(self):
-        self.clt.initiateColdBootSignal.emit("radio://0/100")
-
-    def writeConfig(self):
-        pitchTrim = self.pitchTrim.value()
-        rollTrim = self.rollTrim.value()
-        channel = self.radioChannel.value()
-        speed = self.radioSpeed.currentIndex()
-
-        self.clt.writeConfigSignal.emit(channel, speed, rollTrim, pitchTrim)
-
-
-# No run method specified here as the default run implementation is running the
-# event loop which is what we want
-class CrazyloadThread(QThread):
-    # Input signals declaration (not sure it should be used like that...)
-    initiateColdBootSignal = pyqtSignal(str)
-    resetCopterSignal = pyqtSignal()
-    writeConfigSignal = pyqtSignal(int, int, float, float)
-    # Output signals declaration
-    statusChanged = pyqtSignal(str, int)
-    connectedSignal = pyqtSignal()
-    connectingSignal = pyqtSignal()
-    failed_signal = pyqtSignal(str)
-    disconnectedSignal = pyqtSignal()
-    updateConfigSignal = pyqtSignal(int, int, float, float)
-
-    def __init__(self):
-        super(CrazyloadThread, self).__init__()
-
-        # Make sure that the signals are handled by this thread event loop
-        self.moveToThread(self)
-        self._bl = Bootloader()
-        self._bl.progress_cb = self.statusChanged.emit
-
-        self.writeConfigSignal.connect(self.writeConfigAction)
-        self.initiateColdBootSignal.connect(self.initiateColdBoot)
-        self.resetCopterSignal.connect(self.resetCopter)
-
-    def __del__(self):
-        self.quit()
-        self.wait()
-
-    def initiateColdBoot(self, linkURI):
-        self.connectingSignal.emit()
-
-        try:
-            success = self._bl.start_bootloader(warm_boot=False)
-            if not success:
-                self.failed_signal.emit("Could not connect to bootloader")
-            else:
-                self.connectedSignal.emit()
-                self.readConfigAction()
-        except Exception as e:
-            self.failed_signal.emit("{}".format(e))
-
-    def checksum256(self, st):
-        return reduce(lambda x, y: x + y, list(st)) % 256
-
-    def writeConfigAction(self, channel, speed, rollTrim, pitchTrim):
-        data = (0x00, channel, speed, pitchTrim, rollTrim)
-        image = struct.pack("<BBBff", *data)
-        # Adding some magic:
-        image = bytearray("0xBC".encode('ISO-8859-1')) + image
-        image += struct.pack("B", 256 - self.checksum256(image))
-
-        self._bl.write_cf1_config(image)
-
-    def readConfigAction(self):
-        self.statusChanged.emit("Reading config block...", 0)
-        data = self._bl.read_cf1_config()
-        if (data is not None):
-            if data[0:4] == bytearray("0xBC".encode('ISO-8859-1')):
-                # Skip 0xBC and version at the beginning
-                [channel,
-                 speed,
-                 pitchTrim,
-                 rollTrim] = struct.unpack("<BBff", data[5:15])
-                self.statusChanged.emit("Reading config block...done!", 100)
-            else:
-                channel = Config().get("default_cf_channel")
-                speed = Config().get("default_cf_speed")
-                pitchTrim = Config().get("default_cf_trim")
-                rollTrim = Config().get("default_cf_trim")
-                self.statusChanged.emit(
-                    "Could not find config block, showing defaults", 100)
-            self.updateConfigSignal.emit(channel, speed, rollTrim, pitchTrim)
-        else:
-            self.statusChanged.emit("Reading config block failed!", 0)
-
-    def resetCopter(self):
-        try:
-            self._bl.reset_to_firmware()
-        except Exception:
-            pass
-        self._bl.close()
-        self.disconnectedSignal.emit()