reachy-mini 1.2.5rc1__py3-none-any.whl → 1.2.11__py3-none-any.whl

reachy_mini/reachy_mini.py

@@ -9,8 +9,9 @@ It also includes methods for multimedia interactions like playing sounds and loo
 import asyncio
 import json
 import logging
+import platform
 import time
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Literal, Optional, Union, cast
 
 import cv2
 import numpy as np
@@ -18,7 +19,7 @@ import numpy.typing as npt
 from asgiref.sync import async_to_sync
 from scipy.spatial.transform import Rotation as R
 
-from reachy_mini.daemon.utils import daemon_check
+from reachy_mini.daemon.utils import daemon_check, is_local_camera_available
 from reachy_mini.io.protocol import GotoTaskRequest
 from reachy_mini.io.zenoh_client import ZenohClient
 from reachy_mini.media.media_manager import MediaBackend, MediaManager
@@ -49,12 +50,17 @@ SLEEP_HEAD_POSE = np.array(
     ]
 )
 
+ConnectionMode = Literal["auto", "localhost_only", "network"]
+
 
 class ReachyMini:
     """Reachy Mini class for controlling a simulated or real Reachy Mini robot.
 
     Args:
-        localhost_only (bool): If True, will only connect to localhost daemons, defaults to True.
+        connection_mode: Select how to connect to the daemon. Use
+            `"localhost_only"` to restrict connections to daemons running on
+            localhost, `"network"` to scout for daemons on the LAN, or `"auto"`
+            (default) to try localhost first then fall back to the network.
         spawn_daemon (bool): If True, will spawn a daemon to control the robot, defaults to False.
         use_sim (bool): If True and spawn_daemon is True, will spawn a simulated robot, defaults to True.
 
@@ -63,25 +69,33 @@ class ReachyMini:
     def __init__(
         self,
         robot_name: str = "reachy_mini",
-        localhost_only: bool = True,
+        connection_mode: ConnectionMode = "auto",
         spawn_daemon: bool = False,
         use_sim: bool = False,
         timeout: float = 5.0,
         automatic_body_yaw: bool = True,
         log_level: str = "INFO",
         media_backend: str = "default",
+        localhost_only: Optional[bool] = None,
     ) -> None:
         """Initialize the Reachy Mini robot.
 
         Args:
             robot_name (str): Name of the robot, defaults to "reachy_mini".
-            localhost_only (bool): If True, will only connect to localhost daemons, defaults to True.
+            connection_mode: `"auto"` (default), `"localhost_only"` or `"network"`.
+                `"auto"` will first try daemons on localhost and fall back to
+                network discovery if no local daemon responds.
+            localhost_only (Optional[bool]): Deprecated alias for the connection
+                mode. Set `False` to search for network daemons. Will be removed
+                in a future release.
             spawn_daemon (bool): If True, will spawn a daemon to control the robot, defaults to False.
             use_sim (bool): If True and spawn_daemon is True, will spawn a simulated robot, defaults to True.
             timeout (float): Timeout for the client connection, defaults to 5.0 seconds.
             automatic_body_yaw (bool): If True, the body yaw will be used to compute the IK and FK. Default is False.
             log_level (str): Logging level, defaults to "INFO".
-            media_backend (str): Media backend to use, either "default" (OpenCV), "gstreamer" or "webrtc", defaults to "default".
+            media_backend (str): Use "no_media" to disable media entirely. Any other value
+                triggers auto-detection: Lite uses OpenCV, Wireless uses GStreamer (local)
+                or WebRTC (remote) based on environment.
 
         It will try to connect to the daemon, and if it fails, it will raise an exception.
 
@@ -90,8 +104,12 @@ class ReachyMini:
         self.logger.setLevel(log_level)
         self.robot_name = robot_name
         daemon_check(spawn_daemon, use_sim)
-        self.client = ZenohClient(robot_name, localhost_only)
-        self.client.wait_for_connection(timeout=timeout)
+        normalized_mode = self._normalize_connection_mode(
+            connection_mode, localhost_only
+        )
+        self.client, self.connection_mode = self._initialize_client(
+            normalized_mode, timeout
+        )
         self.set_automatic_body_yaw(automatic_body_yaw)
         self._last_head_pose: Optional[npt.NDArray[np.float64]] = None
         self.is_recording = False
@@ -131,40 +149,97 @@ class ReachyMini:
         """Expose the MediaManager instance used by ReachyMini."""
         return self.media_manager
 
+    @property
+    def imu(self) -> Dict[str, List[float] | float] | None:
+        """Get the current IMU data from the backend.
+
+        Returns:
+            dict with the following keys, or None if IMU is not available (Lite version)
+            or no data received yet:
+            - 'accelerometer': [x, y, z] in m/s^2
+            - 'gyroscope': [x, y, z] in rad/s
+            - 'quaternion': [w, x, y, z] orientation quaternion
+            - 'temperature': float in °C
+
+        Note:
+            - Data is cached from the last Zenoh update at 50Hz
+            - Quaternion is in [w, x, y, z] format
+
+        Example:
+            >>> imu_data = reachy.imu
+            >>> if imu_data is not None:
+            >>>     accel_x, accel_y, accel_z = imu_data['accelerometer']
+            >>>     gyro_x, gyro_y, gyro_z = imu_data['gyroscope']
+            >>>     quat_w, quat_x, quat_y, quat_z = imu_data['quaternion']
+            >>>     temp = imu_data['temperature']
+
+        """
+        return self.client.get_current_imu_data()
+
     def _configure_mediamanager(
         self, media_backend: str, log_level: str
     ) -> MediaManager:
-        mbackend = MediaBackend.DEFAULT
         daemon_status = self.client.get_status()
+        is_wireless = daemon_status.get("wireless_version", False)
 
-        # If wireless, force webrtc unless no_media is selected
-        if media_backend != "no_media" and daemon_status.get(
-            "wireless_version"
-        ):
-            mbackend = MediaBackend.WEBRTC
+        # If no_media is requested, skip all media initialization
+        if media_backend.lower() == "no_media":
+            self.logger.info("No media backend requested.")
+            mbackend = MediaBackend.NO_MEDIA
         else:
-            match media_backend.lower():
-                case "webrtc":
-                    if not daemon_status.get("wireless_version"):
+            if is_wireless:
+                if is_local_camera_available():
+                    # Local client on CM4: use GStreamer to read from unix socket
+                    # This avoids WebRTC encode/decode overhead
+                    if "no_video" in media_backend.lower():
+                        mbackend = MediaBackend.GSTREAMER_NO_VIDEO
+                        self.logger.info(
+                            "Auto-detected: Wireless + local camera socket. "
+                            "Using GStreamer audio-only backend (no WebRTC overhead)."
+                        )
+                    else:
+                        mbackend = MediaBackend.GSTREAMER
+                        self.logger.info(
+                            "Auto-detected: Wireless + local camera socket. "
+                            "Using GStreamer backend (no WebRTC overhead)."
+                        )
+                else:
+                    # Remote client: use WebRTC for streaming
+                    self.logger.info(
+                        "Auto-detected: Wireless + remote client. "
+                        "Using WebRTC backend for streaming."
+                    )
+                    mbackend = MediaBackend.WEBRTC
+            else:
+                # Lite version: use specified backend if compatible
+                try:
+                    mbackend = MediaBackend(media_backend.lower())
+                    if mbackend == MediaBackend.WEBRTC:
                         self.logger.warning(
-                            "Non-wireless version detected, daemon should use the flag '--wireless-version'. Reverting to default"
+                            f"Incompatible media backend on Lite: {media_backend}, using default backend."
                         )
                         mbackend = MediaBackend.DEFAULT
+                    # TODO : Remove when wheel is released !
+                    elif "gstreamer" in media_backend.lower() and (
+                        platform.system() == "Darwin" or platform.system() == "Windows"
+                    ):
+                        self.logger.warning(
+                            f"Unsupported media backend on Lite for {platform.system()}: {media_backend}, using default backend."
+                        )
+                        mbackend = (
+                            MediaBackend.DEFAULT_NO_VIDEO
+                            if "no_video" in media_backend.lower()
+                            else MediaBackend.DEFAULT
+                        )
                     else:
-                        self.logger.info("WebRTC backend configured successfully.")
-                        mbackend = MediaBackend.WEBRTC
-                case "gstreamer":
-                    mbackend = MediaBackend.GSTREAMER
-                case "default":
-                    mbackend = MediaBackend.DEFAULT
-                case "no_media":
-                    mbackend = MediaBackend.NO_MEDIA
-                case "default_no_video":
-                    mbackend = MediaBackend.DEFAULT_NO_VIDEO
-                case _:
-                    raise ValueError(
-                        f"Invalid media_backend '{media_backend}'. Supported values are 'default', 'gstreamer', 'no_media', 'default_no_video', and 'webrtc'."
+                        self.logger.info(
+                            f"Auto-detected: Lite. Using {mbackend} backend."
+                        )
+                except ValueError:
+                    self.logger.warning(
+                        f"Invalid media backend on Lite: {media_backend}, using default backend."
                     )
+                    mbackend = MediaBackend.DEFAULT
 
         return MediaManager(
             use_sim=self.client.get_status()["simulation_enabled"],
@@ -173,6 +248,78 @@ class ReachyMini:
             signalling_host=self.client.get_status()["wlan_ip"],
         )
 
+    def _normalize_connection_mode(
+        self,
+        connection_mode: ConnectionMode,
+        legacy_localhost_only: Optional[bool],
+    ) -> ConnectionMode:
+        """Normalize connection mode input, optionally honoring the legacy alias."""
+        normalized = connection_mode.lower()
+        if normalized not in {"auto", "localhost_only", "network"}:
+            raise ValueError(
+                "Invalid connection_mode. Use 'auto', 'localhost_only', or 'network'."
+            )
+        resolved = cast(ConnectionMode, normalized)
+
+        if legacy_localhost_only is None:
+            return resolved
+
+        self.logger.warning(
+            "The 'localhost_only' argument is deprecated and will be removed in a "
+            "future release. Please switch to connection_mode."
+        )
+
+        if resolved != "auto":
+            self.logger.warning(
+                "Both connection_mode=%s and localhost_only=%s were provided. "
+                "connection_mode takes precedence.",
+                resolved,
+                legacy_localhost_only,
+            )
+            return resolved
+
+        return "localhost_only" if legacy_localhost_only else "network"
+
+    def _initialize_client(
+        self, requested_mode: ConnectionMode, timeout: float
+    ) -> tuple[ZenohClient, ConnectionMode]:
+        """Create a client according to the requested mode, adding auto fallback."""
+        requested_mode = cast(ConnectionMode, requested_mode.lower())
+        if requested_mode == "auto":
+            try:
+                client = self._connect_single(localhost_only=True, timeout=timeout)
+                selected: ConnectionMode = "localhost_only"
+            except Exception as err:
+                self.logger.info(
+                    "Auto connection: localhost attempt failed (%s). "
+                    "Trying network discovery.",
+                    err,
+                )
+                client = self._connect_single(localhost_only=False, timeout=timeout)
+                selected = "network"
+            self.logger.info("Connection mode selected: %s", selected)
+            return client, selected
+
+        if requested_mode == "localhost_only":
+            client = self._connect_single(localhost_only=True, timeout=timeout)
+            selected = "localhost_only"
+        else:
+            client = self._connect_single(localhost_only=False, timeout=timeout)
+            selected = "network"
+
+        self.logger.info("Connection mode selected: %s", selected)
+        return client, selected
+
+    def _connect_single(self, localhost_only: bool, timeout: float) -> ZenohClient:
+        """Connect once with the requested tunneling mode and guard cleanup."""
+        client = ZenohClient(self.robot_name, localhost_only)
+        try:
+            client.wait_for_connection(timeout=timeout)
+        except Exception:
+            client.disconnect()
+            raise
+        return client
+
     def set_target(
         self,
         head: Optional[npt.NDArray[np.float64]] = None,  # 4x4 pose matrix
@@ -268,12 +415,16 @@ class ReachyMini:
             )
 
         req = GotoTaskRequest(
-            head=np.array(head, dtype=np.float64).flatten().tolist()
-            if head is not None
-            else None,
-            antennas=np.array(antennas, dtype=np.float64).flatten().tolist()
-            if antennas is not None
-            else None,
+            head=(
+                np.array(head, dtype=np.float64).flatten().tolist()
+                if head is not None
+                else None
+            ),
+            antennas=(
+                np.array(antennas, dtype=np.float64).flatten().tolist()
+                if antennas is not None
+                else None
+            ),
             duration=duration,
             method=method,
             body_yaw=body_yaw,
@@ -606,9 +757,10 @@ class ReachyMini:
         cmd = {}
 
         if pose is not None:
-            assert pose.shape == (4, 4), (
-                f"Head pose should be a 4x4 matrix, got {pose.shape}."
-            )
+            assert pose.shape == (
+                4,
+                4,
+            ), f"Head pose should be a 4x4 matrix, got {pose.shape}."
             cmd["head_pose"] = pose.tolist()
         else:
             raise ValueError("Pose must be provided as a 4x4 matrix.")
@@ -667,6 +819,8 @@ class ReachyMini:
 
         Args:
             ids (List[str] | None): List of motor names to enable. If None, all motors will be enabled.
+                Valid names match `src/reachy_mini/assets/config/hardware_config.yaml`:
+                `body_rotation`, `stewart_1` … `stewart_6`, `right_antenna`, `left_antenna`.
 
         """
         self._set_torque(True, ids=ids)
@@ -676,6 +830,8 @@ class ReachyMini:
 
         Args:
             ids (List[str] | None): List of motor names to disable. If None, all motors will be disabled.
+                Valid names match `src/reachy_mini/assets/config/hardware_config.yaml`:
+                `body_rotation`, `stewart_1` … `stewart_6`, `right_antenna`, `left_antenna`.
 
         """
         self._set_torque(False, ids=ids)

reachy_mini/tools/reflash_motors.py

@@ -97,7 +97,7 @@ def reflash_motors(
             )
         except RuntimeError as e:
             console.print(
-                f"❌ Configuration check failed for motor '{motor_name}': {e}",
+                f"[FAIL] Configuration check failed for motor '{motor_name}': {e}",
                 style="red",
             )
             return

reachy_mini/tools/scan_motors.py

@@ -0,0 +1,86 @@
+"""Scan a serial bus to find which motor IDs respond at common baudrates."""
+
+import os
+import time
+from typing import List
+
+import serial.tools.list_ports
+from rustypot import Xl330PyController
+
+SERIAL_TIMEOUT = 0.01
+COMMANDS_BITS_LENGTH = {
+    "Ping": (10 + 14) * 10,
+    "Read": (14 + 15) * 10,
+    "Write": (16 + 11) * 10,
+}
+XL_BAUDRATE_CONV_TABLE = {
+    9600: 0,
+    57600: 1,
+    115200: 2,
+    1000000: 3,
+    2000000: 4,
+    3000000: 5,
+    4000000: 6,
+}
+
+def find_serial_port(
+    wireless_version: bool = False,
+    vid: str = "1a86",
+    pid: str = "55d3",
+    pi_uart: str = "/dev/ttyAMA3",
+) -> list[str]:
+    """Replicate from the daemon.utils.find_serial_port function."""
+    # If it's a wireless version, we should use the Raspberry Pi UART
+    if wireless_version:
+        return [pi_uart] if os.path.exists(pi_uart) else []
+
+    # If it's a lite version, we should find it using the VID and PID
+    ports = serial.tools.list_ports.comports()
+
+    vid = vid.upper()
+    pid = pid.upper()
+
+    return [p.device for p in ports if f"USB VID:PID={vid}:{pid}" in p.hwid]
+
+def scan(port: str, baudrate: int) -> List[int]:
+    """Scan the bus at the given baudrate and return detected IDs."""
+    found_motors: list[int] = []
+    try:
+        controller = Xl330PyController(port, baudrate, float(SERIAL_TIMEOUT) + float(COMMANDS_BITS_LENGTH["Ping"]) / baudrate)
+        for motor_id in range(255):
+            try:
+                if controller.ping(motor_id):
+                    found_motors.append(motor_id)
+            except Exception:
+                pass 
+    except Exception as e:
+        print(f"Error while scanning port {port} at baudrate {baudrate}: {e}")
+    finally:
+        # CRITICAL: Close the controller to release the serial port
+        if controller is not None:
+            try:
+                del controller
+            except Exception:
+                pass
+        # Small delay to ensure port is fully released
+        time.sleep(SERIAL_TIMEOUT)
+    return found_motors
+
+def main() -> None:
+    """Iterate through baudrates and print the IDs found at each."""
+    try:
+        port = find_serial_port()[0]
+    except IndexError:
+        print("No serial port found. Please check your USB connection and permissions.")
+        return
+    for baudrate in XL_BAUDRATE_CONV_TABLE.keys():
+        print(f"Trying baudrate: {baudrate}")
+        found_motors = scan(port, baudrate)
+        if found_motors:
+            print(f"Found motors at baudrate {baudrate}: {found_motors}")
+        else:
+            print(f"No motors found at baudrate {baudrate}")
+
+
+if __name__ == "__main__":
+    main()

reachy_mini/tools/setup_motor.py

@@ -32,6 +32,24 @@ XL_BAUDRATE_CONV_TABLE = {
     4000000: 6,
 }
 
+id2name = {
+    10: "body_rotation",
+    11: "stewart_1",
+    12: "stewart_2",
+    13: "stewart_3",
+    14: "stewart_4",
+    15: "stewart_5",
+    16: "stewart_6",
+    17: "right_antenna",
+    18: "left_antenna",
+}
+
+# (TX + RX) * (1 start + 8 data + 1 stop) 
+COMMANDS_BITS_LENGTH = {
+    "Ping": (10 + 14) * 10,
+    "Read": (14 + 15) * 10,
+    "Write": (16 + 11) * 10,
+}   
 
 def setup_motor(
     motor_config: MotorConfig,
@@ -47,9 +65,9 @@ def setup_motor(
         from_baudrate,
     ):
         raise RuntimeError(
-            f"No motor found on port {serial_port}. "
-            f"Make sure the motor is in factory settings (ID {from_id} and baudrate {from_baudrate}) and connected to the specified port."
+            f"No motor found on port {serial_port}. Make sure Reachy Mini is powered !"
         )
+        # f"Make sure the motor {id2name.get(from_id, from_id)} is in factory settings (ID {from_id} and baudrate {from_baudrate}) and connected to the specified port."
 
     # Make sure the torque is disabled to be able to write EEPROM
     disable_torque(serial_port, from_id, from_baudrate)
@@ -132,19 +150,19 @@ def lookup_for_motor(
             end="",
             flush=True,
         )
-    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Ping"]) / baudrate)
     ret = c.ping(id)
     if not silent:
-        print(f"{'✅' if ret else '❌'}")
+        print(f"{'[OK]' if ret else '[FAIL]'}")
     return ret
 
 
 def disable_torque(serial_port: str, id: int, baudrate: int) -> None:
     """Disable the torque of the motor with the given ID on the specified serial port."""
     print(f"Disabling torque for motor with ID {id}...", end="", flush=True)
-    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Write"]) / baudrate)
     c.write_torque_enable(id, False)
-    print("✅")
+    print("[OK]")
 
 
 def change_baudrate(
@@ -152,25 +170,25 @@ def change_baudrate(
 ) -> None:
     """Change the baudrate of the motor with the given ID on the specified serial port."""
     print(f"Changing baudrate to {target_baudrate}...", end="", flush=True)
-    c = Xl330PyController(serial_port, baudrate=base_baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=base_baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Write"]) / base_baudrate)
     c.write_baud_rate(id, XL_BAUDRATE_CONV_TABLE[target_baudrate])
-    print("✅")
+    print("[OK]")
 
 
 def change_id(serial_port: str, current_id: int, new_id: int, baudrate: int) -> None:
     """Change the ID of the motor with the given current ID on the specified serial port."""
     print(f"Changing ID from {current_id} to {new_id}...", end="", flush=True)
-    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Write"]) / baudrate)
     c.write_id(current_id, new_id)
-    print("✅")
+    print("[OK]")
 
 
 def change_offset(serial_port: str, id: int, offset: int, baudrate: int) -> None:
     """Change the offset of the motor with the given ID on the specified serial port."""
     print(f"Changing offset for motor with ID {id} to {offset}...", end="", flush=True)
-    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Write"]) / baudrate)
     c.write_homing_offset(id, offset)
-    print("✅")
+    print("[OK]")
 
 
 def change_operating_mode(
@@ -182,9 +200,9 @@ def change_operating_mode(
         end="",
         flush=True,
     )
-    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Write"]) / baudrate)
     c.write_operating_mode(id, operating_mode)
-    print("✅")
+    print("[OK]")
 
 
 def change_angle_limits(
@@ -200,10 +218,10 @@ def change_angle_limits(
         end="",
         flush=True,
     )
-    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Write"]) / baudrate)
     c.write_raw_min_position_limit(id, angle_limit_min)
     c.write_raw_max_position_limit(id, angle_limit_max)
-    print("✅")
+    print("[OK]")
 
 
 def change_shutdown_error(
@@ -215,9 +233,9 @@ def change_shutdown_error(
         end="",
         flush=True,
     )
-    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Write"]) / baudrate)
     c.write_shutdown(id, shutdown_error)
-    print("✅")
+    print("[OK]")
 
 
 def change_return_delay_time(
@@ -229,14 +247,14 @@ def change_return_delay_time(
         end="",
         flush=True,
     )
-    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Write"]) / baudrate)
     c.write_return_delay_time(id, return_delay_time)
-    print("✅")
+    print("[OK]")
 
 
 def light_led_up(serial_port: str, id: int, baudrate: int) -> None:
     """Light the LED of the motor with the given ID on the specified serial port."""
-    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Write"]) / baudrate)
 
     trials = 0
 
@@ -251,7 +269,7 @@ def light_led_up(serial_port: str, id: int, baudrate: int) -> None:
 
 def light_led_down(serial_port: str, id: int, baudrate: int) -> None:
     """Light the LED of the motor with the given ID on the specified serial port."""
-    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Write"]) / baudrate)
     trials = 0
 
     while trials < 3:
@@ -267,14 +285,14 @@ def check_configuration(
     motor_config: MotorConfig, serial_port: str, baudrate: int
 ) -> None:
     """Check the configuration of the motor with the given ID on the specified serial port."""
-    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT)
+    c = Xl330PyController(serial_port, baudrate=baudrate, timeout=SERIAL_TIMEOUT + float(COMMANDS_BITS_LENGTH["Read"]) / baudrate)
 
     print("Checking configuration...")
 
     # Check if there is a motor with the desired ID
     if not c.ping(motor_config.id):
         raise RuntimeError(f"No motor with ID {motor_config.id} found, cannot proceed")
-    print(f"Found motor with ID {motor_config.id} ✅.")
+    print(f"Found motor with ID {motor_config.id} [OK].")
 
     # Read return delay time
     return_delay = c.read_return_delay_time(motor_config.id)[0]
@@ -282,7 +300,7 @@ def check_configuration(
         raise RuntimeError(
             f"Return delay time is {return_delay}, expected {motor_config.return_delay_time}"
         )
-    print(f"Return delay time is correct: {return_delay} ✅.")
+    print(f"Return delay time is correct: {return_delay} [OK].")
 
     # Read operating mode
     operating_mode = c.read_operating_mode(motor_config.id)[0]
@@ -290,7 +308,7 @@ def check_configuration(
         raise RuntimeError(
             f"Operating mode is {operating_mode}, expected {motor_config.operating_mode}"
         )
-    print(f"Operating mode is correct: {operating_mode} ✅.")
+    print(f"Operating mode is correct: {operating_mode} [OK].")
 
     # Read angle limits
     angle_limit_min = c.read_raw_min_position_limit(motor_config.id)[0]
@@ -304,14 +322,14 @@ def check_configuration(
             f"Angle limit max is {angle_limit_max}, expected {motor_config.angle_limit_max}"
         )
     print(
-        f"Angle limits are correct: [{motor_config.angle_limit_min}, {motor_config.angle_limit_max}] ✅."
+        f"Angle limits are correct: [{motor_config.angle_limit_min}, {motor_config.angle_limit_max}] [OK]."
     )
 
     # Read homing offset
     offset = c.read_homing_offset(motor_config.id)[0]
     if offset != motor_config.offset:
         raise RuntimeError(f"Homing offset is {offset}, expected {motor_config.offset}")
-    print(f"Homing offset is correct: {offset} ✅.")
+    print(f"Homing offset is correct: {offset} [OK].")
 
     # Read shutdown
     shutdown = c.read_shutdown(motor_config.id)[0]
@@ -319,9 +337,9 @@ def check_configuration(
         raise RuntimeError(
             f"Shutdown is {shutdown}, expected {motor_config.shutdown_error}"
         )
-    print(f"Shutdown error is correct: {shutdown} ✅.")
+    print(f"Shutdown error is correct: {shutdown} [OK].")
 
-    print("Configuration is correct ✅!")
+    print("Configuration is correct [OK]!")
 
 
 def run(args: argparse.Namespace) -> None:
@@ -356,7 +374,7 @@ def run(args: argparse.Namespace) -> None:
                 baudrate=config.serial.baudrate,
             )
         except RuntimeError as e:
-            print(f"❌ Configuration check failed for motor '{motor_name}': {e}")
+            print(f"[FAIL] Configuration check failed for motor '{motor_name}': {e}")
             return
 
         light_led_up(

reachy_mini/utils/interpolation.py

@@ -19,7 +19,7 @@ def minimum_jerk(
     final_velocity: Optional[npt.NDArray[np.float64]] = None,
     final_acceleration: Optional[npt.NDArray[np.float64]] = None,
 ) -> InterpolationFunc:
-    """Compute the mimimum jerk interpolation function from starting position to goal position."""
+    """Compute the minimum jerk interpolation function from starting position to goal position."""
     if starting_velocity is None:
         starting_velocity = np.zeros(starting_position.shape)
     if starting_acceleration is None: