dexcontrol 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

dexcontrol/sensors/imu/zed_imu.py

@@ -11,9 +11,8 @@
 """ZED IMU sensor implementation using Zenoh subscriber."""
 
 import numpy as np
-import zenoh
 
-from dexcontrol.utils.subscribers.imu import IMUSubscriber
+from dexcontrol.comm import create_imu_subscriber
 
 
 class ZedIMUSensor:
@@ -28,23 +27,17 @@ class ZedIMUSensor:
     def __init__(
         self,
         configs,
-        zenoh_session: zenoh.Session,
     ) -> None:
         """Initialize the ZED IMU sensor.
 
         Args:
             configs: Configuration object containing topic, name, and other settings.
-            zenoh_session: Active Zenoh session for communication.
         """
         self._name = configs.name
 
-        # Create the IMU subscriber
-        self._subscriber = IMUSubscriber(
+
+        self._subscriber = create_imu_subscriber(
             topic=configs.topic,
-            zenoh_session=zenoh_session,
-            name=f"{self._name}_subscriber",
-            enable_fps_tracking=configs.enable_fps_tracking,
-            fps_log_interval=configs.fps_log_interval,
         )
 
     def shutdown(self) -> None:
@@ -57,7 +50,8 @@ class ZedIMUSensor:
         Returns:
             True if receiving data, False otherwise.
         """
-        return self._subscriber.is_active()
+        data = self._subscriber.get_latest()
+        return data is not None
 
     def wait_for_active(self, timeout: float = 5.0) -> bool:
         """Wait for the ZED IMU sensor to start receiving data.
@@ -68,92 +62,109 @@ class ZedIMUSensor:
         Returns:
             True if sensor becomes active, False if timeout is reached.
         """
-        return self._subscriber.wait_for_active(timeout)
+        msg = self._subscriber.wait_for_message(timeout)
+        return msg is not None
 
     def get_obs(self, obs_keys: list[str] | None = None) -> dict[str, np.ndarray] | None:
         """Get observation data for the ZED IMU sensor.
 
         Args:
             obs_keys: List of observation keys to retrieve. If None, returns all available data.
-                     Valid keys: ['ang_vel', 'acc', 'quat', 'timestamp']
+                     Valid keys: ['ang_vel', 'acc', 'quat', 'mag', 'timestamp']
 
         Returns:
             Dictionary with observation data including all IMU measurements.
             Keys are mapped as follows:
-            - 'ang_vel': Angular velocity from 'angular_velocity'
-            - 'acc': Linear acceleration from 'acceleration'
-            - 'quat': Orientation quaternion from 'orientation'
+            - 'ang_vel': Angular velocity from 'gyro'
+            - 'acc': Linear acceleration from 'acc'
+            - 'quat': Orientation quaternion from 'quat'
+            - 'mag': Magnetometer from 'mag' (if available)
             - 'timestamp_ns': Timestamp from 'timestamp'
         """
         if obs_keys is None:
             obs_keys = ['ang_vel', 'acc', 'quat']
 
-        data = self._subscriber.get_latest_data()
+        data = self._subscriber.get_latest()
         if data is None:
             return None
 
-        obs_out = {'timestamp_ns': data['timestamp']}
+        obs_out = {}
+
+        # Add timestamp if available
+        if 'timestamp' in data:
+            obs_out['timestamp_ns'] = data['timestamp']
 
         for key in obs_keys:
             if key == 'ang_vel':
-                obs_out[key] = data['angular_velocity']
+                obs_out[key] = data.get('gyro', np.zeros(3))
             elif key == 'acc':
-                obs_out[key] = data['acceleration']
+                obs_out[key] = data.get('acc', np.zeros(3))
             elif key == 'quat':
-                obs_out[key] = data['orientation']
-            else:
-                raise ValueError(f"Invalid observation key: {key}")
+                obs_out[key] = data.get('quat', np.array([1.0, 0.0, 0.0, 0.0]))
+            elif key == 'mag' and 'mag' in data:
+                obs_out[key] = data['mag']
+            elif key == 'timestamp' and 'timestamp' in data:
+                obs_out['timestamp_ns'] = data['timestamp']
 
         return obs_out
 
-    def get_acceleration(self) -> np.ndarray | None:
+    def get_acc(self) -> np.ndarray | None:
         """Get the latest linear acceleration from ZED IMU.
 
         Returns:
             Linear acceleration [x, y, z] in m/s² if available, None otherwise.
         """
-        return self._subscriber.get_acceleration()
+        data = self._subscriber.get_latest()
+        return data.get('acc') if data else None
 
-    def get_angular_velocity(self) -> np.ndarray | None:
+    def get_gyro(self) -> np.ndarray | None:
         """Get the latest angular velocity from ZED IMU.
 
         Returns:
             Angular velocity [x, y, z] in rad/s if available, None otherwise.
         """
-        return self._subscriber.get_angular_velocity()
+        data = self._subscriber.get_latest()
+        return data.get('gyro') if data else None
 
-    def get_orientation(self) -> np.ndarray | None:
+    def get_quat(self) -> np.ndarray | None:
         """Get the latest orientation quaternion from ZED IMU.
 
         Returns:
-            Orientation quaternion [x, y, z, w] if available, None otherwise.
+            Orientation quaternion [w, x, y, z] if available, None otherwise.
+            Note: dexcomm uses [w, x, y, z] quaternion format.
         """
-        return self._subscriber.get_orientation()
+        data = self._subscriber.get_latest()
+        return data.get('quat') if data else None
 
-    def get_magnetometer(self) -> np.ndarray | None:
+    def get_mag(self) -> np.ndarray | None:
         """Get the latest magnetometer reading from ZED IMU.
 
         Returns:
             Magnetic field [x, y, z] in µT if available, None otherwise.
         """
-        return self._subscriber.get_magnetometer()
+        data = self._subscriber.get_latest()
+        if not data or not isinstance(data, dict):
+            return None
+        return data.get('mag', None)
 
-    def has_magnetometer(self) -> bool:
+    def has_mag(self) -> bool:
         """Check if the ZED IMU has magnetometer data available.
 
         Returns:
             True if magnetometer data is available, False otherwise.
         """
-        return self._subscriber.has_magnetometer()
-
-    @property
-    def fps(self) -> float:
-        """Get the current FPS measurement.
-
-        Returns:
-            Current frames per second measurement.
-        """
-        return self._subscriber.fps
+        data = self._subscriber.get_latest()
+        if not data or not isinstance(data, dict):
+            return False
+        return 'mag' in data and data['mag'] is not None
+
+
+    # Backward compatibility aliases
+    get_acceleration = get_acc
+    get_angular_velocity = get_gyro
+    get_orientation = get_quat
+    get_magnetometer = get_mag
+    has_magnetometer = has_mag
 
     @property
     def name(self) -> str:

dexcontrol/sensors/lidar/rplidar.py

@@ -17,9 +17,8 @@ subscriber for scan data.
 from typing import Any
 
 import numpy as np
-import zenoh
 
-from dexcontrol.utils.subscribers.lidar import LidarSubscriber
+from dexcontrol.comm import create_lidar_subscriber
 
 
 class RPLidarSensor:
@@ -32,26 +31,17 @@ class RPLidarSensor:
     def __init__(
         self,
         configs,
-        zenoh_session: zenoh.Session,
     ) -> None:
         """Initialize the LIDAR sensor.
 
         Args:
-            topic: Zenoh topic to subscribe to for LIDAR data.
-            zenoh_session: Active Zenoh session for communication.
-            name: Name for the sensor instance.
-            enable_fps_tracking: Whether to track and log FPS metrics.
-            fps_log_interval: Number of frames between FPS calculations.
+            configs: Configuration for the LIDAR sensor.
         """
         self._name = configs.name
 
         # Create the LIDAR subscriber
-        self._subscriber = LidarSubscriber(
-            topic=configs.topic,
-            zenoh_session=zenoh_session,
-            name=f"{self._name}_subscriber",
-            enable_fps_tracking=configs.enable_fps_tracking,
-            fps_log_interval=configs.fps_log_interval,
+        self._subscriber = create_lidar_subscriber(
+            topic=configs.topic
         )
 
 
@@ -65,7 +55,8 @@ class RPLidarSensor:
         Returns:
             True if receiving data, False otherwise.
         """
-        return self._subscriber.is_active()
+        data = self._subscriber.get_latest()
+        return data is not None
 
     def wait_for_active(self, timeout: float = 5.0) -> bool:
         """Wait for the LIDAR sensor to start receiving data.
@@ -76,7 +67,8 @@ class RPLidarSensor:
         Returns:
             True if sensor becomes active, False if timeout is reached.
         """
-        return self._subscriber.wait_for_active(timeout)
+        msg = self._subscriber.wait_for_message(timeout)
+        return msg is not None
 
     def get_obs(self) -> dict[str, Any] | None:
         """Get the latest LIDAR scan data.
@@ -89,7 +81,8 @@ class RPLidarSensor:
                 - qualities: Array of quality values (0-255) if available, None otherwise
                 - timestamp: Timestamp in nanoseconds (int)
         """
-        return self._subscriber.get_latest_data()
+        data = self._subscriber.get_latest()
+        return data
 
     def get_ranges(self) -> np.ndarray | None:
         """Get the latest range measurements.
@@ -97,7 +90,8 @@ class RPLidarSensor:
         Returns:
             Array of range measurements in meters if available, None otherwise.
         """
-        return self._subscriber.get_ranges()
+        data = self._subscriber.get_latest()
+        return data.ranges if data else None
 
     def get_angles(self) -> np.ndarray | None:
         """Get the latest angle measurements.
@@ -105,7 +99,8 @@ class RPLidarSensor:
         Returns:
             Array of angle measurements in radians if available, None otherwise.
         """
-        return self._subscriber.get_angles()
+        data = self._subscriber.get_latest()
+        return data.angles if data else None
 
     def get_qualities(self) -> np.ndarray | None:
         """Get the latest quality measurements.
@@ -113,7 +108,8 @@ class RPLidarSensor:
         Returns:
             Array of quality values (0-255) if available, None otherwise.
         """
-        return self._subscriber.get_qualities()
+        data = self._subscriber.get_latest()
+        return data.qualities if data else None
 
     def get_point_count(self) -> int:
         """Get the number of points in the latest scan.

dexcontrol/sensors/manager.py

@@ -8,7 +8,7 @@
 # 2. Commercial License
 #    For commercial licensing terms, contact: contact@dexmate.ai
 
-"""Sensor manager for managing robot sensors with Zenoh communication.
+"""Sensor manager for managing robot sensors.
 
 This module provides the Sensors class that manages multiple sensor instances
 based on configuration and provides unified access to them.
@@ -19,7 +19,6 @@ import traceback
 from typing import TYPE_CHECKING, Any
 
 import hydra.utils as hydra_utils
-import zenoh
 from loguru import logger
 from omegaconf import DictConfig, OmegaConf
 
@@ -44,7 +43,6 @@ class Sensors:
 
     Attributes:
         _sensors: List of instantiated sensor objects.
-        _zenoh_session: Active Zenoh session for communication.
     """
 
     if TYPE_CHECKING:
@@ -61,16 +59,13 @@ class Sensors:
         lidar: RPLidarSensor
         ultrasonic: UltrasonicSensor
 
-    def __init__(self, configs: DictConfig | VegaSensorsConfig,
-                 zenoh_session: zenoh.Session) -> None:
+    def __init__(self, configs: DictConfig | VegaSensorsConfig) -> None:
         """Initialize sensors from configuration.
 
         Args:
             configs: Configuration for all sensors (VegaSensorsConfig or DictConfig).
-            zenoh_session: Active Zenoh session for communication.
         """
         self._sensors: list[Any] = []
-        self._zenoh_session = zenoh_session
 
         dict_configs = (OmegaConf.structured(configs) if isinstance(configs, VegaSensorsConfig)
                        else configs)
@@ -108,10 +103,8 @@ class Sensors:
                 'configs': {k: v for k, v in config.items() if k != '_target_'}
             })
 
-            sensor = hydra_utils.instantiate(
-                temp_config,
-                zenoh_session=self._zenoh_session,
-            )
+            # Note: zenoh_session no longer needed as DexComm handles sessions
+            sensor = hydra_utils.instantiate(temp_config)
 
             if hasattr(sensor, "start"):
                 sensor.start()

dexcontrol/sensors/ultrasonic.py

@@ -8,21 +8,21 @@
 # 2. Commercial License
 #    For commercial licensing terms, contact: contact@dexmate.ai
 
-"""Ultrasonic sensor implementations using Zenoh subscribers.
+"""Ultrasonic sensor implementations using DexComm subscribers.
 
-This module provides ultrasonic sensor classes that use the generic
-subscriber for distance measurements.
+This module provides ultrasonic sensor classes that use DexComm's
+Raw API for distance measurements.
 """
 
 import numpy as np
-import zenoh
+from dexcomm.serialization import deserialize_protobuf
 
+from dexcontrol.comm import create_subscriber
 from dexcontrol.proto import dexcontrol_msg_pb2
-from dexcontrol.utils.subscribers import ProtobufZenohSubscriber
 
 
 class UltrasonicSensor:
-    """Ultrasonic sensor using Zenoh subscriber.
+    """Ultrasonic sensor using DexComm subscriber.
 
     This sensor provides distance measurements from ultrasonic sensors
     """
@@ -30,24 +30,18 @@ class UltrasonicSensor:
     def __init__(
         self,
         configs,
-        zenoh_session: zenoh.Session,
     ) -> None:
         """Initialize the ultrasonic sensor.
 
         Args:
             configs: Configuration for the ultrasonic sensor.
-            zenoh_session: Active Zenoh session for communication.
         """
         self._name = configs.name
 
-        # Create the generic subscriber with JSON decoder
-        self._subscriber = ProtobufZenohSubscriber(
+        # Create the protobuf subscriber using our clean DexComm integration
+        self._subscriber = create_subscriber(
             topic=configs.topic,
-            zenoh_session=zenoh_session,
-            message_type=dexcontrol_msg_pb2.UltrasonicState,
-            name=f"{self._name}_subscriber",
-            enable_fps_tracking=configs.enable_fps_tracking,
-            fps_log_interval=configs.fps_log_interval,
+            deserializer=lambda data: deserialize_protobuf(data, dexcontrol_msg_pb2.UltrasonicState),
         )
 
 
@@ -61,7 +55,8 @@ class UltrasonicSensor:
         Returns:
             True if receiving data, False otherwise.
         """
-        return self._subscriber.is_active()
+        data = self._subscriber.get_latest()
+        return data is not None
 
     def wait_for_active(self, timeout: float = 5.0) -> bool:
         """Wait for the ultrasonic sensor to start receiving data.
@@ -72,7 +67,8 @@ class UltrasonicSensor:
         Returns:
             True if sensor becomes active, False if timeout is reached.
         """
-        return self._subscriber.wait_for_active(timeout)
+        msg = self._subscriber.wait_for_message(timeout)
+        return msg is not None
 
     def get_obs(self) -> np.ndarray | None:
         """Get observation data for the ultrasonic sensor.
@@ -84,7 +80,7 @@ class UltrasonicSensor:
             Numpy array of distances in meters with shape (4,) in the order:
             [front_left, front_right, back_left, back_right].
         """
-        data = self._subscriber.get_latest_data()
+        data = self._subscriber.get_latest()
         if data is not None:
             obs = [
                 data.front_left,
@@ -96,15 +92,6 @@ class UltrasonicSensor:
 
         return None
 
-    @property
-    def fps(self) -> float:
-        """Get the current FPS measurement.
-
-        Returns:
-            Current frames per second measurement.
-        """
-        return self._subscriber.fps
-
     @property
     def name(self) -> str:
         """Get the sensor name.

dexcontrol/utils/__init__.py

@@ -7,14 +7,3 @@
 #
 # 2. Commercial License
 #    For commercial licensing terms, contact: contact@dexmate.ai
-
-from .subscribers import (
-    BaseZenohSubscriber,
-    DecoderFunction,
-    GenericZenohSubscriber,
-    ProtobufZenohSubscriber,
-    json_decoder,
-    protobuf_decoder,
-    raw_bytes_decoder,
-    string_decoder,
-)

dexcontrol/utils/comm_helper.py

@@ -0,0 +1,111 @@
+# Copyright (C) 2025 Dexmate Inc.
+#
+# This software is dual-licensed:
+#
+# 1. GNU Affero General Public License v3.0 (AGPL-3.0)
+#    See LICENSE-AGPL for details
+#
+# 2. Commercial License
+#    For commercial licensing terms, contact: contact@dexmate.ai
+
+"""Communication helper utilities for DexControl using DexComm.
+
+This module provides simple helper functions for DexControl's communication
+needs using the DexComm library's Raw API.
+"""
+
+import json
+import time
+from pathlib import Path
+from typing import Optional
+
+from dexcomm import ZenohConfig, call_service
+from dexcomm.serialization import deserialize_json
+from loguru import logger
+
+import dexcontrol
+from dexcontrol.utils.os_utils import resolve_key_name
+
+
+def get_robot_config() -> ZenohConfig:
+    """Get DexComm configuration for robot communication.
+
+    This checks for the robot's Zenoh configuration file and creates
+    appropriate DexComm config.
+
+    Returns:
+        ZenohConfig instance configured for the robot.
+    """
+    config_path = dexcontrol.COMM_CFG_PATH
+
+    if config_path and config_path != Path("/tmp/no_config") and config_path.exists():
+        logger.debug(f"Loading config from: {config_path}")
+        return ZenohConfig.from_file(config_path)
+    else:
+        logger.debug("No config file found, using default peer mode")
+        return ZenohConfig.default_peer()
+
+
+def get_zenoh_config_path() -> Optional[Path]:
+    """Get robot config only if not using default SessionManager.
+
+    DexComm's SessionManager will automatically use the config from
+    environment variables if available, so we only need to provide
+    config explicitly if we have a specific robot config file.
+
+    Returns:
+        path to the config file
+    """
+    config_path = dexcontrol.COMM_CFG_PATH
+    return config_path
+
+
+def query_json_service(
+    topic: str,
+    timeout: float = 2.0,
+    max_retries: int = 1,
+    retry_delay: float = 0.5,
+) -> dict | None:
+    """Query for JSON information using DexComm with retry logic.
+
+    Args:
+        topic: Topic to query (will be resolved with robot namespace).
+        timeout: Maximum time to wait for a response in seconds.
+        max_retries: Maximum number of retry attempts.
+        retry_delay: Initial delay between retries (doubles each retry).
+
+    Returns:
+        Dictionary containing the parsed JSON response if successful, None otherwise.
+    """
+    resolved_topic = resolve_key_name(topic)
+    logger.debug(f"Querying topic: {resolved_topic}")
+
+    current_delay = retry_delay
+    for attempt in range(max_retries + 1):
+        try:
+            data = call_service(
+                resolved_topic,
+                timeout=timeout,
+                config=get_zenoh_config_path(),
+                request_serializer=None,
+                response_deserializer=deserialize_json,
+            )
+
+            if data:
+                logger.debug(f"Successfully received JSON data from {resolved_topic}")
+                return data
+
+        except json.JSONDecodeError as e:
+            logger.warning(f"Failed to parse JSON response from {resolved_topic}: {e}")
+        except Exception as e:
+            logger.warning(
+                f"Query failed for {resolved_topic} (attempt {attempt + 1}/{max_retries + 1}): {e}"
+            )
+
+        if attempt < max_retries:
+            logger.debug(f"Retrying in {current_delay:.1f} seconds...")
+            time.sleep(current_delay)
+            current_delay *= 2  # Exponential backoff
+
+    logger.error(f"Failed to query {resolved_topic} after {max_retries + 1} attempts")
+    return None

dexcontrol/utils/constants.py

@@ -16,7 +16,7 @@ from typing import Final
 ROBOT_NAME_ENV_VAR: Final[str] = "ROBOT_NAME"
 
 # Environment variable for communication config path
-COMM_CFG_PATH_ENV_VAR: Final[str] = "DEXMATE_COMM_CFG_PATH"
+COMM_CFG_PATH_ENV_VAR: Final[str] = "ZENOH_CONFIG"
 
 # Environment variable to disable heartbeat monitoring
 DISABLE_HEARTBEAT_ENV_VAR: Final[str] = "DEXCONTROL_DISABLE_HEARTBEAT"

dexcontrol/utils/os_utils.py

@@ -137,28 +137,14 @@ def validate_server_version(version_info: dict[str, Any]) -> None:
         return
 
     # Check each component's software version
-    components_below_min = []
-    for component_name, component_info in server_info.items():
-        if isinstance(component_info, dict):
-            software_version = component_info.get("software_version")
-            if software_version is not None:
-                try:
-                    # Convert to int if it's a string
-                    software_version_int = int(software_version)
-                    if software_version_int < dexcontrol.MIN_SOC_SOFTWARE_VERSION:
-                        components_below_min.append(
-                            (component_name, software_version_int)
-                        )
-                except (ValueError, TypeError) as e:
-                    logger.debug(
-                        f"Could not parse software version for {component_name}: {e}"
-                    )
-
-    # If any components are below minimum version, show warning
-    if components_below_min:
-        show_server_version_warning(
-            components_below_min, dexcontrol.MIN_SOC_SOFTWARE_VERSION
-        )
+    soc_info = server_info.get("soc", {})
+    software_version = soc_info.get("software_version", {})
+    if software_version is not None:
+        software_version_int = int(software_version)
+        if software_version_int < dexcontrol.MIN_SOC_SOFTWARE_VERSION:
+            show_server_version_warning(
+                [("soc", software_version_int)], dexcontrol.MIN_SOC_SOFTWARE_VERSION
+            )
 
 
 def show_server_version_warning(

{dexcontrol-0.3.0.dist-info → dexcontrol-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dexcontrol
-Version: 0.3.0
+Version: 0.3.2
 Summary: A Python library of Sensing and Control for Dexmate's Robot
 Project-URL: Repository, https://github.com/dexmate-ai/dexcontrol
 Author-email: Dexmate <contact@dexmate.ai>
@@ -202,6 +202,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 Requires-Python: <3.14,>=3.10
 Requires-Dist: aiortc
+Requires-Dist: dexcomm>=0.1.2
 Requires-Dist: eclipse-zenoh>=1.2.0
 Requires-Dist: hydra-core==1.3.2
 Requires-Dist: jaxtyping>=0.2.38