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

reachy_mini/daemon/daemon.py

@@ -30,6 +30,7 @@ from reachy_mini.io import (
 from reachy_mini.media.media_manager import MediaManager
 from reachy_mini.tools.reflash_motors import reflash_motors
 
+from .backend.mockup_sim import MockupSimBackend, MockupSimBackendStatus
 from .backend.mujoco import MujocoBackend, MujocoBackendStatus
 from .backend.robot import RobotBackend, RobotBackendStatus
 
@@ -57,7 +58,7 @@ class Daemon:
         self.wireless_version = wireless_version
         self.desktop_app_daemon = desktop_app_daemon
 
-        self.backend: "RobotBackend | MujocoBackend | None" = None
+        self.backend: "RobotBackend | MujocoBackend | MockupSimBackend | None" = None
         # Get package version
         try:
             package_version = version("reachy_mini")
@@ -72,6 +73,7 @@ class Daemon:
             wireless_version=wireless_version,
             desktop_app_daemon=desktop_app_daemon,
             simulation_enabled=None,
+            mockup_sim_enabled=None,
             backend_status=None,
             error=None,
             wlan_ip=None,
@@ -91,9 +93,18 @@ class Daemon:
                 self.logger.error(f"Failed to initialize WebRTC: {e}")
                 self._webrtc = None
 
+    def __del__(self) -> None:
+        """Destructor to ensure proper cleanup."""
+        self.logger.debug("Cleaning up Daemon resources...")
+        if self._webrtc is not None:
+            self._webrtc.stop()
+            self._webrtc.__del__()
+            self._webrtc = None
+
     async def start(
         self,
         sim: bool = False,
+        mockup_sim: bool = False,
         serialport: str = "auto",
         scene: str = "empty",
         localhost_only: bool = True,
@@ -110,6 +121,7 @@ class Daemon:
 
         Args:
             sim (bool): If True, run in simulation mode using Mujoco. Defaults to False.
+            mockup_sim (bool): If True, run in lightweight simulation mode (no MuJoCo). Defaults to False.
             serialport (str): Serial port for real motors. Defaults to "auto", which will try to find the port automatically.
             scene (str): Name of the scene to load in simulation mode ("empty" or "minimal"). Defaults to "empty".
             localhost_only (bool): If True, restrict the server to localhost only clients. Defaults to True.
@@ -131,16 +143,20 @@ class Daemon:
             return self._status.state
 
         self.logger.info(
-            f"Daemon start parameters: sim={sim}, serialport={serialport}, scene={scene}, localhost_only={localhost_only}, wake_up_on_start={wake_up_on_start}, check_collision={check_collision}, kinematics_engine={kinematics_engine}, headless={headless}, hardware_config_filepath={hardware_config_filepath}"
+            f"Daemon start parameters: sim={sim}, mockup_sim={mockup_sim}, serialport={serialport}, scene={scene}, localhost_only={localhost_only}, wake_up_on_start={wake_up_on_start}, check_collision={check_collision}, kinematics_engine={kinematics_engine}, headless={headless}, hardware_config_filepath={hardware_config_filepath}"
         )
 
+        # mockup-sim behaves exactly like a real robot for apps (they open webcam directly)
+        # Only MuJoCo (--sim) sets simulation_enabled=True (streams video via UDP)
         self._status.simulation_enabled = sim
+        self._status.mockup_sim_enabled = mockup_sim
 
         if not localhost_only:
             self._status.wlan_ip = get_ip_address()
 
         self._start_params = {
             "sim": sim,
+            "mockup_sim": mockup_sim,
             "serialport": serialport,
             "headless": headless,
             "websocket_uri": websocket_uri,
@@ -157,6 +173,7 @@ class Daemon:
             self.backend = self._setup_backend(
                 wireless_version=self.wireless_version,
                 sim=sim,
+                mockup_sim=mockup_sim,
                 serialport=serialport,
                 scene=scene,
                 check_collision=check_collision,
@@ -348,12 +365,13 @@ class Daemon:
             self._status.state = DaemonState.STOPPING
             self.backend.is_shutting_down = True
             self._thread_event_publish_status.set()
-            self.zenoh_server.stop()
+
             if self.websocket_server is not None:
                 self.websocket_server.stop()
 
             if self._webrtc:
-                self._webrtc.stop()
+                # We use pause() instead of stop() to keep the signalling server running and the producer registered, allowing proper restart.
+                self._webrtc.pause()
 
             if goto_sleep_on_stop:
                 try:
@@ -378,6 +396,9 @@ class Daemon:
             self.backend.close()
             self.backend.ready.clear()
 
+            # zenoh server must be closed after backend finishes to publish all data
+            self.zenoh_server.stop()
+
             if self._status.state != DaemonState.ERROR:
                 self.logger.info("Daemon stopped successfully.")
                 self._status.state = DaemonState.STOPPED
@@ -400,6 +421,7 @@ class Daemon:
     async def restart(
         self,
         sim: Optional[bool] = None,
+        mockup_sim: Optional[bool] = None,
         serialport: Optional[str] = None,
         scene: Optional[str] = None,
         headless: Optional[bool] = None,
@@ -414,6 +436,7 @@ class Daemon:
 
         Args:
             sim (bool): If True, run in simulation mode using Mujoco. Defaults to None (uses the previous value).
+            mockup_sim (bool): If True, run in lightweight simulation mode (no MuJoCo). Defaults to None (uses the previous value).
             serialport (str): Serial port for real motors. Defaults to None (uses the previous value).
             scene (str): Name of the scene to load in simulation mode ("empty" or "minimal"). Defaults to None (uses the previous value).
             headless (bool): If True, run Mujoco in headless mode (no GUI). Defaults to None (uses the previous value).
@@ -442,6 +465,9 @@ class Daemon:
             )
             params: dict[str, Any] = {
                 "sim": sim if sim is not None else self._start_params["sim"],
+                "mockup_sim": mockup_sim
+                if mockup_sim is not None
+                else self._start_params["mockup_sim"],
                 "serialport": serialport
                 if serialport is not None
                 else self._start_params["serialport"],
@@ -501,6 +527,7 @@ class Daemon:
     async def run4ever(
         self,
         sim: bool = False,
+        mockup_sim: bool = False,
         serialport: str = "auto",
         scene: str = "empty",
         localhost_only: bool = True,
@@ -519,6 +546,7 @@ class Daemon:
 
         Args:
             sim (bool): If True, run in simulation mode using Mujoco. Defaults to False.
+            mockup_sim (bool): If True, run in lightweight simulation mode (no MuJoCo). Defaults to False.
             serialport (str): Serial port for real motors. Defaults to "auto", which will try to find the port automatically.
             scene (str): Name of the scene to load in simulation mode ("empty" or "minimal"). Defaults to "empty".
             localhost_only (bool): If True, restrict the server to localhost only clients. Defaults to True.
@@ -534,6 +562,7 @@ class Daemon:
         """
         await self.start(
             sim=sim,
+            mockup_sim=mockup_sim,
             serialport=serialport,
             scene=scene,
             localhost_only=localhost_only,
@@ -569,6 +598,7 @@ class Daemon:
         self,
         wireless_version: bool,
         sim: bool,
+        mockup_sim: bool,
         serialport: str,
         scene: str,
         check_collision: bool,
@@ -578,8 +608,14 @@ class Daemon:
         websocket_uri: Optional[str],
         hardware_config_filepath: str | None = None,
         reflash_motors_on_start: bool = True,
-    ) -> "RobotBackend | MujocoBackend":
-        if sim:
+    ) -> "RobotBackend | MujocoBackend | MockupSimBackend":
+        if mockup_sim:
+            return MockupSimBackend(
+                check_collision=check_collision,
+                kinematics_engine=kinematics_engine,
+                use_audio=use_audio,
+            )
+        elif sim:
             return MujocoBackend(
                 scene=scene,
                 check_collision=check_collision,
@@ -645,7 +681,10 @@ class DaemonStatus:
     wireless_version: bool
     desktop_app_daemon: bool
     simulation_enabled: Optional[bool]
-    backend_status: Optional[RobotBackendStatus | MujocoBackendStatus]
+    mockup_sim_enabled: Optional[bool]
+    backend_status: Optional[
+        RobotBackendStatus | MujocoBackendStatus | MockupSimBackendStatus
+    ]
     error: Optional[str] = None
     wlan_ip: Optional[str] = None
     version: Optional[str] = None

reachy_mini/daemon/utils.py

@@ -1,7 +1,6 @@
 """Utilities for managing the Reachy Mini daemon."""
 
 import os
-import socket
 import struct
 import subprocess
 import time
@@ -11,6 +10,46 @@ from typing import Any, List
 import psutil
 import serial.tools.list_ports
 
+# Path to the unix socket created by WebRTC daemon for local camera access
+CAMERA_SOCKET_PATH = "/tmp/reachymini_camera_socket"
+
+
+def is_localhost(ip: str | None) -> bool:
+    """Check if an IP address corresponds to localhost.
+
+    Args:
+        ip: The IP address to check. Can be None.
+
+    Returns:
+        True if the IP is a localhost address, False otherwise.
+
+    """
+    if ip is None:
+        return False
+
+    localhost_addresses = {
+        "127.0.0.1",
+        "::1",
+        "localhost",
+        "0.0.0.0",
+    }
+    return ip in localhost_addresses or ip.startswith("127.")
+
+
+def is_local_camera_available() -> bool:
+    """Check if local camera access is available via the unix socket.
+
+    On wireless Reachy Mini, the WebRTC daemon exposes raw camera frames
+    via a unix socket at /tmp/reachymini_camera_socket. Local clients
+    (running on the CM4) can access this socket directly without going
+    through WebRTC encoding/decoding, which saves CPU and reduces latency.
+
+    Returns:
+        True if the local camera socket exists and is accessible.
+
+    """
+    return os.path.exists(CAMERA_SOCKET_PATH)
+
 
 def daemon_check(spawn_daemon: bool, use_sim: bool) -> None:
     """Check if the Reachy Mini daemon is running and spawn it if necessary."""
@@ -88,20 +127,37 @@ def find_serial_port(
 
 
 def get_ip_address(ifname: str = "wlan0") -> str | None:
-    """Get the IP address of a specific network interface (Linux Only)."""
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    try:
-        import fcntl
-
-        return socket.inet_ntoa(
-            fcntl.ioctl(
-                s.fileno(),
-                0x8915,  # SIOCGIFADDR
-                struct.pack("256s", ifname[:15].encode("utf-8")),
-            )[20:24]
-        )
-    except OSError:
-        print(f"Could not get IP address for interface {ifname}.")
+    """Get the IP address of a specific network interface (Linux and Windows)."""
+    import platform
+    import socket
+
+    if platform.system() == "Linux":
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            import fcntl
+
+            return socket.inet_ntoa(
+                fcntl.ioctl(
+                    s.fileno(),
+                    0x8915,  # SIOCGIFADDR
+                    struct.pack("256s", ifname[:15].encode("utf-8")),
+                )[20:24]
+            )
+        except OSError:
+            print(f"Could not get IP address for interface {ifname}.")
+            return None
+    elif platform.system() == "Windows":
+        import psutil
+
+        addrs = psutil.net_if_addrs()
+        if ifname in addrs:
+            for snic in addrs[ifname]:
+                if snic.family == socket.AF_INET:
+                    return str(snic.address)
+        print(f"Could not get IP address for interface {ifname} on Windows.")
+        return None
+    else:
+        print(f"Platform {platform.system()} not supported for get_ip_address.")
         return None
 
 

reachy_mini/io/zenoh_client.py

@@ -59,6 +59,7 @@ class ZenohClient(AbstractClient):
         self.joint_position_received = threading.Event()
         self.head_pose_received = threading.Event()
         self.status_received = threading.Event()
+        self.imu_data_received = threading.Event()
 
         self.session = zenoh.open(c)
         self.cmd_pub = self.session.declare_publisher(f"{self.prefix}/command")
@@ -83,6 +84,11 @@ class ZenohClient(AbstractClient):
             self._handle_status,
         )
 
+        self.imu_sub = self.session.declare_subscriber(
+            f"{self.prefix}/imu_data",
+            self._handle_imu_data,
+        )
+
         self._last_head_joint_positions = None
         self._last_antennas_joint_positions = None
         self._last_head_pose: Optional[npt.NDArray[np.float64]] = None
@@ -92,6 +98,7 @@ class ZenohClient(AbstractClient):
         self._recorded_data_ready = threading.Event()
         self._is_alive = False
         self._last_status: Dict[str, Any] = {}  # contains a DaemonStatus
+        self._last_imu_data: Optional[Dict[str, List[float] | float]] = None
 
         self.tasks: dict[UUID, TaskState] = {}
         self.task_request_pub = self.session.declare_publisher(f"{self.prefix}/task")
@@ -178,6 +185,13 @@ class ZenohClient(AbstractClient):
             self._last_status = status
             self.status_received.set()
 
+    def _handle_imu_data(self, sample: zenoh.Sample) -> None:
+        """Handle incoming IMU data."""
+        if sample.payload:
+            imu_data = json.loads(sample.payload.to_string())
+            self._last_imu_data = imu_data
+            self.imu_data_received.set()
+
     def get_current_joints(self) -> tuple[list[float], list[float]]:
         """Get the current joint positions."""
         assert (
@@ -214,6 +228,18 @@ class ZenohClient(AbstractClient):
         self.status_received.clear()  # ready for next run
         return self._last_status
 
+    def get_current_imu_data(self) -> Optional[Dict[str, List[float] | float]]:
+        """Get the current IMU data.
+
+        Returns:
+            dict with 'accelerometer', 'gyroscope', 'quaternion', and 'temperature' keys,
+            or None if no data has been received yet or IMU is not available.
+
+        """
+        if self._last_imu_data is None:
+            return None
+        return self._last_imu_data.copy()
+
     def _handle_head_pose(self, sample: zenoh.Sample) -> None:
         """Handle incoming head pose."""
         if sample.payload:

reachy_mini/io/zenoh_server.py

@@ -72,13 +72,11 @@ class ZenohServer(AbstractServer):
                         },
                         # Allow standard discovery
                         "scouting": {
-                            "multicast": { "enabled": True },
-                            "gossip": { "enabled": True },
+                            "multicast": {"enabled": True},
+                            "gossip": {"enabled": True},
                         },
                         # No forced connect target; router will accept incoming sessions
-                        "connect": {
-                            "endpoints": []
-                        }
+                        "connect": {"endpoints": []},
                     }
                 )
             )
@@ -96,6 +94,10 @@ class ZenohServer(AbstractServer):
         self.pub_pose = self.session.declare_publisher(f"{self.prefix}/head_pose")
         self.backend.set_pose_publisher(self.pub_pose)
 
+        # Declare IMU data publisher
+        self.pub_imu = self.session.declare_publisher(f"{self.prefix}/imu_data")
+        self.backend.set_imu_publisher(self.pub_imu)
+
         self.task_req_sub = self.session.declare_subscriber(
             f"{self.prefix}/task",
             self._handle_task_request,
@@ -118,7 +120,9 @@ class ZenohServer(AbstractServer):
         data = sample.payload.to_string()
         command = json.loads(data)
         with self._lock:
-            block_targets = self.backend.is_move_running  # Prevent concurrent target updates from different clients
+            block_targets = (
+                self.backend.is_move_running
+            )  # Prevent concurrent target updates from different clients
 
             def _maybe_ignore(field: str) -> bool:
                 """Return True if the command should be ignored while a move runs."""

reachy_mini/kinematics/nn_kinematics.py

@@ -13,13 +13,13 @@ class NNKinematics:
     """Neural Network based FK/IK. Fitted from PlacoKinematics data."""
 
     def __init__(self, models_root_path: str):
-        """Intialize."""
+        """Initialize."""
         self.fk_model_path = f"{models_root_path}/fknetwork.onnx"
         self.ik_model_path = f"{models_root_path}/iknetwork.onnx"
         self.fk_infer = OnnxInfer(self.fk_model_path)
         self.ik_infer = OnnxInfer(self.ik_model_path)
 
-        self.automatic_body_yaw = False  # No used, kept for canaompatibility
+        self.automatic_body_yaw = False  # Not used, kept for compatibility
 
     def ik(
         self,

reachy_mini/kinematics/placo_kinematics.py

@@ -70,7 +70,7 @@ class PlacoKinematics:
         # we could go to soft limits to avoid over-constraining the IK
         # but the current implementation works robustly with hard limits
         # so we keep the hard limits for now
-        constrant_type = "hard"  # "hard" or "soft"
+        constraint_type = "hard"  # "hard" or "soft"
 
         # IK closing tasks
         ik_closing_tasks = []
@@ -78,7 +78,7 @@ class PlacoKinematics:
             ik_closing_task = self.ik_solver.add_relative_position_task(
                 f"closing_{i}_1", f"closing_{i}_2", np.zeros(3)
             )
-            ik_closing_task.configure(f"closing_{i}", constrant_type, 1.0)
+            ik_closing_task.configure(f"closing_{i}", constraint_type, 1.0)
             ik_closing_tasks.append(ik_closing_task)
 
         # FK closing tasks
@@ -87,7 +87,7 @@ class PlacoKinematics:
             fk_closing_task = self.fk_solver.add_relative_position_task(
                 f"closing_{i}_1", f"closing_{i}_2", np.zeros(3)
             )
-            fk_closing_task.configure(f"closing_{i}", constrant_type, 1.0)
+            fk_closing_task.configure(f"closing_{i}", constraint_type, 1.0)
             fk_closing_tasks.append(fk_closing_task)
 
         # Add the constraint between the rotated torso and the head
@@ -227,9 +227,9 @@ class PlacoKinematics:
         self.robot_ik.set_joint_limits("yaw_body", -2.8, 2.8)
 
         # initial state
-        self._inital_q = self.robot.state.q.copy()
-        self._inital_qd = np.zeros_like(self.robot.state.qd)
-        self._inital_qdd = np.zeros_like(self.robot.state.qdd)
+        self._initial_q = self.robot.state.q.copy()
+        self._initial_qd = np.zeros_like(self.robot.state.qd)
+        self._initial_qdd = np.zeros_like(self.robot.state.qdd)
 
         # initial FK to set the head pose
         for _ in range(10):
@@ -237,11 +237,11 @@ class PlacoKinematics:
             self.robot_ik.update_kinematics()
 
         # last good q to revert to in case of collision
-        self._inital_q = self.robot_ik.state.q.copy()
+        self._initial_q = self.robot_ik.state.q.copy()
         self._last_good_q = self.robot_ik.state.q.copy()
 
         # update the robot state to the initial state
-        self._update_state_to_initial(self.robot)  # revert to the inital state
+        self._update_state_to_initial(self.robot)  # revert to the initial state
         self.robot.update_kinematics()
 
         if self.check_collision:
@@ -262,9 +262,9 @@ class PlacoKinematics:
             robot (placo.RobotWrapper): The robot wrapper instance to update.
 
         """
-        robot.state.q = self._inital_q
-        robot.state.qd = self._inital_qd
-        robot.state.qdd = self._inital_qdd
+        robot.state.q = self._initial_q
+        robot.state.qd = self._initial_qd
+        robot.state.qdd = self._initial_qdd
 
     def _pose_distance(
         self, pose1: npt.NDArray[np.float64], pose2: npt.NDArray[np.float64]
@@ -374,7 +374,7 @@ class PlacoKinematics:
             self._logger.debug("IK: Poses too far, starting from initial configuration")
 
         done = True
-        # do the inital ik
+        # do the initial ik
         for i in range(no_iterations):
             try:
                 self.ik_solver.solve(True)  # False to not update the kinematics
@@ -398,7 +398,7 @@ class PlacoKinematics:
             self.robot_ik.update_kinematics()
 
             no_iterations += 2  # add a few more iterations
-            # do the inital ik with 10 iterations
+            # do the initial ik with 10 iterations
             for i in range(no_iterations):
                 try:
                     self.ik_solver.solve(True)  # False to not update the kinematics
@@ -455,7 +455,7 @@ class PlacoKinematics:
         )
 
         done = True
-        # do the inital ik with 2 iterations
+        # do the initial ik with 2 iterations
         for i in range(no_iterations):
             try:
                 self.fk_solver.solve(True)  # False to not update the kinematics
@@ -476,7 +476,7 @@ class PlacoKinematics:
             self.robot.update_kinematics()
 
             no_iterations += 2  # add a few more iterations
-            # do the inital ik with 10 iterations
+            # do the initial ik with 10 iterations
             for i in range(no_iterations):
                 try:
                     self.fk_solver.solve(True)  # False to not update the kinematics

reachy_mini/media/__init__.py

@@ -1 +1,55 @@
-"""Media module."""
+"""Media module for Reachy Mini robot.
+
+This module provides comprehensive audio and video capabilities for the Reachy Mini robot,
+supporting multiple backends and offering a unified interface for media operations.
+
+The media module includes:
+- Camera capture and video streaming
+- Microphone input and audio recording
+- Speaker output and sound playback
+- Direction of Arrival (DoA) estimation with ReSpeaker microphone array
+- Multiple backend support (OpenCV, GStreamer, SoundDevice, WebRTC)
+- Camera calibration and intrinsic parameter access
+- Cross-platform compatibility
+
+Key Components:
+- MediaManager: Unified interface for managing audio and video devices
+- CameraBase: Abstract base class for camera implementations
+- AudioBase: Abstract base class for audio implementations
+- Multiple backend implementations for different use cases
+
+Example usage:
+    >>> from reachy_mini.media.media_manager import MediaManager, MediaBackend
+    >>>
+    >>> # Create media manager with default backend
+    >>> media = MediaManager(backend=MediaBackend.DEFAULT)
+    >>>
+    >>> # Capture video frames
+    >>> frame = media.get_frame()
+    >>> if frame is not None:
+    ...     cv2.imshow("Camera", frame)
+    ...     cv2.waitKey(1)
+    >>>
+    >>> # Record audio
+    >>> media.start_recording()
+    >>> samples = media.get_audio_sample()
+    >>>
+    >>> # Play sound
+    >>> media.play_sound("/path/to/sound.wav")
+    >>>
+    >>> # Clean up
+    >>> media.close()
+
+Available backends:
+- MediaBackend.DEFAULT: OpenCV + SoundDevice (cross-platform default)
+- MediaBackend.GSTREAMER: GStreamer-based media (advanced features)
+- MediaBackend.WEBRTC: WebRTC for real-time communication
+- MediaBackend.NO_MEDIA: No media devices (headless operation)
+
+For more information on specific components, see:
+- media_manager.py: Media management and backend selection
+- camera_base.py: Camera interface definition
+- audio_base.py: Audio interface definition
+- camera_opencv.py: OpenCV camera implementation
+- audio_sounddevice.py: SoundDevice audio implementation
+"""