dexbot-utils 0.4.0__py3-none-any.whl

dexbot_utils/configs/components/sensors/ultrasonic/ultrasonic.py

@@ -0,0 +1,20 @@
+# 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
+
+from dataclasses import dataclass
+
+from ...base import BaseComponentConfig
+
+
+@dataclass
+class UltraSonicConfig(BaseComponentConfig):
+    enabled: bool = False
+    topic: str = "state/ultrasonic"
+    name: str = "ultrasonic"

dexbot_utils/configs/components/vega_1/__init__.py

@@ -0,0 +1,30 @@
+"""Vega-specific component configuration dataclasses.
+
+This module contains Vega robot family specific component configurations.
+"""
+
+from .arm import Vega1ArmConfig
+from .chassis import Vega1ChassisConfig
+from .hand import (
+    DexDGripperConfig,
+    DexSGripperConfig,
+    F5D6HandV1Config,
+    F5D6HandV2Config,
+)
+from .head import Vega1HeadConfig
+from .misc import BatteryConfig, EStopConfig, HeartbeatConfig
+from .torso import Vega1TorsoConfig
+
+__all__ = [
+    "Vega1ArmConfig",
+    "Vega1ChassisConfig",
+    "F5D6HandV1Config",
+    "F5D6HandV2Config",
+    "DexSGripperConfig",
+    "DexDGripperConfig",
+    "Vega1HeadConfig",
+    "Vega1TorsoConfig",
+    "BatteryConfig",
+    "EStopConfig",
+    "HeartbeatConfig",
+]

dexbot_utils/configs/components/vega_1/arm.py

@@ -0,0 +1,81 @@
+"""Arm component configuration."""
+
+from dataclasses import dataclass
+
+from ..base import BaseJointComponentConfig
+
+
+@dataclass
+class Vega1ArmConfig(BaseJointComponentConfig):
+    """Configuration for Vega robot arm component.
+
+    Attributes:
+        side: Arm side ("left" or "right")
+        pv_mode: Position-velocity control mode flag
+        default_control_hz: Default control frequency in Hz
+        joints: Property returning list of joint names for the arm
+        pose_pool: Property returning dictionary of predefined arm poses
+        state_sub_topic: Property returning topic for arm state feedback
+        wrench_sub_topic: Property returning topic for wrench feedback
+        wrist_button_sub_topic: Property returning topic for wrist button state
+        control_pub_topic: Property returning topic for arm control commands
+        set_mode_query: Property returning service name for setting arm control mode
+        ee_pass_through_pub_topic: Property returning topic for end-effector pass-through
+    """
+
+    side: str = "left"
+    pv_mode: bool = False
+    default_control_hz: int = 100
+    enable_ee_pass_through: bool = False
+
+    @property
+    def joints(self) -> list[str]:
+        joint_prefix = "L" if self.side == "left" else "R"
+        joint_suffixes = [
+            "arm_j1",
+            "arm_j2",
+            "arm_j3",
+            "arm_j4",
+            "arm_j5",
+            "arm_j6",
+            "arm_j7",
+        ]
+        return [f"{joint_prefix}_{suffix}" for suffix in joint_suffixes]
+
+    @property
+    def pose_pool(self) -> dict[str, list[float]]:
+        pool = {
+            "folded": [1.57079, 0.0, 0, -3.1, 0, 0, -0.69813],
+            "folded_closed_hand": [1.57079, 0.0, 0, -3.1, 0, 0, -0.9],
+            "L_shape": [0.064, 0.3, 0.0, -1.556, 1.271, 0.0, 0.0],
+            "lift_up": [0.064, 0.3, 0.0, -2.756, 1.271, 0.0, 0.0],
+            "zero": [-1.57079, 0.0, 0, 0.0, 0, 0, 0.0],
+        }
+        if self.side == "right":
+            for k, v in pool.items():
+                pool[k] = [-v[0], -v[1], -v[2], v[3], -v[4], -v[5], -v[6]]
+        return pool
+
+    @property
+    def state_sub_topic(self) -> str:
+        return f"state/arm/{self.side}"
+
+    @property
+    def wrench_sub_topic(self) -> str:
+        return f"state/wrench/{self.side}"
+
+    @property
+    def wrist_button_sub_topic(self) -> str:
+        return f"state/wrist_button/{self.side}"
+
+    @property
+    def control_pub_topic(self) -> str:
+        return f"control/arm/{self.side}"
+
+    @property
+    def set_mode_query(self) -> str:
+        return f"mode/arm/{self.side}"
+
+    @property
+    def ee_pass_through_pub_topic(self) -> str:
+        return f"control/ee_pass_through/{self.side}"

dexbot_utils/configs/components/vega_1/chassis.py

@@ -0,0 +1,47 @@
+"""Chassis component configuration."""
+
+from dataclasses import dataclass, field
+
+from ..base import BaseJointComponentConfig
+
+
+@dataclass
+class Vega1ChassisConfig(BaseJointComponentConfig):
+    """Configuration for Vega robot chassis/mobile base component.
+
+    Attributes:
+        pv_mode: Position-velocity control mode flag
+        max_linear_vel: Maximum linear velocity (m/s)
+        max_steering_angle: Maximum steering angle (rad)
+        center_to_wheel_axis_dist: Distance from base center to wheel axis (m)
+        wheels_dist: Distance between two wheels (m)
+        steer_joints: List of steering joint names
+        drive_joints: List of drive joint names
+        steer_control_pub_topic: Topic for steering control commands
+        steer_state_sub_topic: Topic for steering state feedback
+        drive_control_pub_topic: Topic for drive control commands
+        drive_state_sub_topic: Topic for drive state feedback
+        joints: Property returning all chassis joints (steer + drive)
+    """
+
+    pv_mode: bool = False
+    max_linear_vel: float = 0.8
+    max_steering_angle: float = 2.35
+    center_to_wheel_axis_dist: float = 0.219
+    wheels_dist: float = 0.45
+    steer_joints: list[str] = field(
+        default_factory=lambda: ["L_wheel_j1", "R_wheel_j1"]
+    )
+    drive_joints: list[str] = field(
+        default_factory=lambda: ["L_wheel_j2", "R_wheel_j2"]
+    )
+
+    steer_control_pub_topic: str = "control/chassis/steer"
+    steer_state_sub_topic: str = "state/chassis/steer"
+    drive_control_pub_topic: str = "control/chassis/drive"
+    drive_state_sub_topic: str = "state/chassis/drive"
+
+    @property
+    def joints(self) -> list[str]:
+        """Return all chassis joints (steer + drive)."""
+        return self.steer_joints + self.drive_joints

dexbot_utils/configs/components/vega_1/hand.py

@@ -0,0 +1,113 @@
+"""Hand component configuration."""
+
+from dataclasses import dataclass, field
+
+from ..base import BaseJointComponentConfig
+
+
+@dataclass
+class F5D6HandV1Config(BaseJointComponentConfig):
+    """Configuration for F5D6 V1 hand component.
+
+    Attributes:
+        pv_mode: Position-velocity control mode flag
+        side: Hand side ("left" or "right")
+        pose_pool: Dictionary of predefined hand poses with joint positions
+        state_sub_topic: Property returning topic for hand state feedback
+        control_pub_topic: Property returning topic for hand control commands
+        joints: Property returning list of joint names for the hand
+    """
+
+    pv_mode: bool = False
+    side: str = "left"
+    pose_pool: dict[str, list[float]] = field(
+        default_factory=lambda: {
+            "open": [0.1834, 0.2891, 0.2801, 0.284, 0.2811, -0.0158],
+            "close": [-0.1, -1.0946, -1.0844, -1.0154, -1.0118, 0.84],
+        }
+    )
+
+    @property
+    def state_sub_topic(self) -> str:
+        return f"state/hand/{self.side}"
+
+    @property
+    def control_pub_topic(self) -> str:
+        return f"control/hand/{self.side}"
+
+    @property
+    def joints(self) -> list[str]:
+        joint_prefix = "L" if self.side == "left" else "R"
+        joint_suffixes = [
+            "th_j1",
+            "ff_j1",
+            "mf_j1",
+            "rf_j1",
+            "lf_j1",
+            "th_j0",
+        ]
+        return [f"{joint_prefix}_{suffix}" for suffix in joint_suffixes]
+
+
+@dataclass
+class F5D6HandV2Config(F5D6HandV1Config):
+    """Configuration for F5D6 V2 hand component with touch sensors.
+
+    Inherits all attributes from F5D6HandV1Config and adds touch sensor support.
+
+    Attributes:
+        touch_sensor_sub_topic: Property returning topic for touch sensor feedback
+    """
+
+    @property
+    def touch_sensor_sub_topic(self) -> str:
+        # Only for V2 hand
+        return f"state/hand/{self.side}/touch"
+
+
+@dataclass
+class DexSGripperConfig(BaseJointComponentConfig):
+    """Configuration for DexS single gripper component.
+
+    Attributes:
+        pv_mode: Position-velocity control mode flag
+        side: Gripper side ("left" or "right")
+        pose_pool: Dictionary of predefined gripper poses with joint positions
+        state_sub_topic: Property returning topic for gripper state feedback
+        control_pub_topic: Property returning topic for gripper control commands
+        joints: Property returning list of joint names for the gripper
+    """
+
+    pv_mode: bool = False
+    side: str = "left"
+    pose_pool: dict[str, list[float]] = field(
+        default_factory=lambda: {
+            "open": [0.7854],
+            "close": [0.0],
+        }
+    )
+
+    # TODO: when gripper auto detection is available, we should use the hand namespace instead of gripper namespace
+    @property
+    def state_sub_topic(self) -> str:
+        return f"state/gripper/{self.side}"
+
+    @property
+    def control_pub_topic(self) -> str:
+        return f"control/gripper/{self.side}"
+
+    @property
+    def joints(self) -> list[str]:
+        joint_prefix = "L" if self.side == "left" else "R"
+        return [f"{joint_prefix}_gripper_j1"]
+
+
+@dataclass
+class DexDGripperConfig(DexSGripperConfig):
+    """Configuration for DexD double gripper component.
+
+    Inherits all attributes and behavior from DexSGripperConfig.
+    Double and single grippers currently share the same interface.
+    """
+
+    pass

dexbot_utils/configs/components/vega_1/head.py

@@ -0,0 +1,32 @@
+"""Head component configuration."""
+
+from dataclasses import dataclass, field
+
+from ..base import BaseJointComponentConfig
+
+
+@dataclass
+class Vega1HeadConfig(BaseJointComponentConfig):
+    """Configuration for Vega robot head component.
+
+    Attributes:
+        pv_mode: Position-velocity control mode flag
+        joints: List of joint names for the head
+        state_sub_topic: Topic for head state feedback
+        control_pub_topic: Topic for head control commands
+        set_mode_query: Service name for setting head control mode
+        pose_pool: Dictionary of predefined head poses with joint positions
+    """
+
+    pv_mode: bool = True
+    joints: list[str] = field(default_factory=lambda: ["head_j1", "head_j2", "head_j3"])
+
+    state_sub_topic: str = "state/head"
+    control_pub_topic: str = "control/head"
+    set_mode_query: str = "mode/head"
+    pose_pool: dict[str, list[float]] = field(
+        default_factory=lambda: {
+            "home": [0.0, 0.0, 0.0],
+            "tucked": [0.0, 0.0, -1.37],
+        }
+    )

dexbot_utils/configs/components/vega_1/misc.py

@@ -0,0 +1,46 @@
+"""Miscellaneous component configurations (battery, estop, heartbeat)."""
+
+from dataclasses import dataclass
+
+from ..base import BaseComponentConfig
+
+
+@dataclass
+class BatteryConfig(BaseComponentConfig):
+    """Configuration for battery management system.
+
+    Attributes:
+        state_sub_topic: Topic for battery state feedback
+    """
+
+    state_sub_topic: str = "state/bms"
+
+
+@dataclass
+class EStopConfig(BaseComponentConfig):
+    """Configuration for emergency stop component.
+
+    Can be disabled via DEXCONTROL_DISABLE_ESTOP_CHECKING=1 environment variable.
+
+    Attributes:
+        state_sub_topic: Topic for emergency stop state feedback
+        estop_query_name: Service name for emergency stop queries
+    """
+
+    state_sub_topic: str = "state/estop"
+    estop_query_name: str = "system/estop"
+
+
+@dataclass
+class HeartbeatConfig(BaseComponentConfig):
+    """Configuration for system heartbeat monitoring.
+
+    Can be disabled via DEXCONTROL_DISABLE_HEARTBEAT=1 environment variable.
+
+    Attributes:
+        heartbeat_topic: Topic for heartbeat messages
+        timeout_seconds: Heartbeat timeout threshold in seconds
+    """
+
+    heartbeat_topic: str = "heartbeat"
+    timeout_seconds: float = 1.0

dexbot_utils/configs/components/vega_1/torso.py

@@ -0,0 +1,41 @@
+"""Torso component configuration."""
+
+from dataclasses import dataclass, field
+
+from ..base import BaseJointComponentConfig
+
+
+@dataclass
+class Vega1TorsoConfig(BaseJointComponentConfig):
+    """Configuration for Vega robot torso component.
+
+    Attributes:
+        pv_mode: Position-velocity control mode flag
+        joints: List of joint names for the torso
+        state_sub_topic: Topic for torso state feedback
+        control_pub_topic: Topic for torso control commands
+        pose_pool: Dictionary of predefined torso poses with joint positions
+    """
+
+    pv_mode: bool = True
+    joints: list[str] = field(
+        default_factory=lambda: ["torso_j1", "torso_j2", "torso_j3"]
+    )
+    state_sub_topic: str = "state/torso"
+    control_pub_topic: str = "control/torso"
+
+    pose_pool: dict[str, list[float]] = field(
+        default_factory=lambda: {
+            "home": [0.0, 0.0, 0.0],
+            "folded": [0.0, 0.0, -1.5708],
+            "crouch20_low": [0.0, 0.0, -0.35],
+            "crouch20_medium": [0.52, 1.05, 0.18],
+            "crouch20_high": [0.78, 1.57, 0.44],
+            "crouch45_low": [0.0, 0.0, -0.79],
+            "crouch45_medium": [0.52, 1.05, -0.26],
+            "crouch45_high": [0.78, 1.57, 0],
+            "crouch90_low": [0.0, 0.0, -1.57],
+            "crouch90_medium": [0.52, 1.05, -1.04],
+            "crouch90_high": [0.78, 1.57, -0.78],
+        }
+    )

dexbot_utils/configs/registry.py

@@ -0,0 +1,112 @@
+"""Configuration registry for robot variants."""
+
+from typing import Callable, ClassVar, TypeVar
+
+from .robots.base import BaseRobotConfig
+
+T = TypeVar("T", bound=BaseRobotConfig)
+
+
+def register_variant(variant: str) -> Callable[[type[T]], type[T]]:
+    """Decorator to register a robot configuration variant.
+
+    Use this decorator on robot config dataclasses to auto-register them.
+
+    Args:
+        variant: Variant name (e.g., "vega_1", "vega_1u", "vega_1p")
+
+    Returns:
+        Decorator function
+
+    Example:
+        @register_variant("vega_1")
+        @dataclass
+        class Vega1Config(BaseRobotConfig):
+            robot_model: str = "vega_1"
+            ...
+    """
+
+    def decorator(config_class: type[T]) -> type[T]:
+        ConfigRegistry.register(variant, config_class)
+        return config_class
+
+    return decorator
+
+
+class ConfigRegistry:
+    """Registry for robot configuration variants.
+
+    Provides a central registry for managing robot configuration classes
+    and factory methods for retrieving configurations.
+    """
+
+    _registry: ClassVar[dict[str, type[BaseRobotConfig]]] = {}
+
+    @classmethod
+    def register(cls, variant: str, config_class: type[BaseRobotConfig]) -> None:
+        """Register a robot configuration variant.
+
+        Args:
+            variant: Variant name (e.g., "vega_1", "vega_1u")
+            config_class: Configuration dataclass for the variant
+        """
+        cls._registry[variant] = config_class
+
+    @classmethod
+    def get(cls, variant: str) -> BaseRobotConfig:
+        """Get a robot configuration instance.
+
+        Args:
+            variant: Variant name
+
+        Returns:
+            Configuration instance for the variant
+
+        Raises:
+            ValueError: If variant is not registered
+        """
+        if variant not in cls._registry:
+            raise ValueError(
+                f"Unknown robot variant: '{variant}'. "
+                f"Available variants: {list(cls._registry.keys())}"
+            )
+
+        config_class = cls._registry[variant]
+        return config_class()
+
+    @classmethod
+    def list_variants(cls) -> list[str]:
+        """List all registered robot variants.
+
+        Returns:
+            List of variant names
+        """
+        return list(cls._registry.keys())
+
+
+def get_robot_config(variant: str) -> BaseRobotConfig:
+    """Get robot configuration for a specific variant.
+
+    Convenience function that delegates to ConfigRegistry.get().
+
+    Args:
+        variant: Robot variant name (e.g., "vega_1")
+
+    Returns:
+        Configuration instance
+
+    Raises:
+        ValueError: If variant is not registered
+    """
+    return ConfigRegistry.get(variant)
+
+
+def get_available_variants() -> list[str]:
+    """Get list of available robot variants.
+
+    Convenience function that delegates to ConfigRegistry.list_variants().
+
+    Returns:
+        List of registered variant names
+    """
+    return ConfigRegistry.list_variants()

dexbot_utils/configs/robots/base.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, field
+
+from ..components.base import BaseComponentConfig
+
+
+@dataclass
+class BaseRobotConfig:
+    """Base configuration for a robot.
+
+    Attributes:
+        robot_model: Robot model name (e.g., "vega_1", "vega_1u")
+        abbr: Robot abbreviation (e.g., "vg")
+        urdf_path: Path to URDF file (relative or absolute)
+        components: Dictionary of component configurations
+        querables: Dictionary of queryable service names
+    """
+
+    robot_model: str = ""
+    abbr: str = ""
+    urdf_path: str = ""
+
+    components: dict[str, BaseComponentConfig] = field(default_factory=dict)
+    sensors: dict[str, BaseComponentConfig] = field(default_factory=dict)
+    querables: dict[str, str] = field(default_factory=dict)

dexbot_utils/configs/robots/vega_1.py

@@ -0,0 +1,127 @@
+"""Vega-1 robot configurations."""
+
+from dataclasses import dataclass, field
+
+from dexmate_urdf import robots
+
+from ..components.sensors.cameras import ZedXCameraConfig, ZedXOneCameraConfig
+from ..components.sensors.imu import ChassisIMUConfig, ZedIMUConfig
+from ..components.sensors.lidar import Lidar3DConfig
+from ..components.sensors.ultrasonic import UltraSonicConfig
+from ..components.vega_1 import (
+    BatteryConfig,
+    DexDGripperConfig,
+    EStopConfig,
+    F5D6HandV2Config,
+    HeartbeatConfig,
+    Vega1ArmConfig,
+    Vega1ChassisConfig,
+    Vega1HeadConfig,
+    Vega1TorsoConfig,
+)
+from ..registry import register_variant
+from .base import BaseComponentConfig, BaseRobotConfig
+
+
+@register_variant("vega_1")
+@dataclass
+class Vega1Config(BaseRobotConfig):
+    """Configuration for Vega-1 robot base (no hands)."""
+
+    robot_model: str = "vega_1"
+    abbr: str = "vg"
+    urdf_path: str = str(robots.humanoid.vega_1.vega_1.urdf)
+
+    components: dict[str, BaseComponentConfig] = field(
+        default_factory=lambda: {
+            "left_arm": Vega1ArmConfig(side="left"),
+            "right_arm": Vega1ArmConfig(side="right"),
+            "torso": Vega1TorsoConfig(),
+            "chassis": Vega1ChassisConfig(),
+            "head": Vega1HeadConfig(),
+            "battery": BatteryConfig(),
+            "estop": EStopConfig(),
+            "heartbeat": HeartbeatConfig(),
+        }
+    )
+
+    sensors: dict[str, BaseComponentConfig] = field(
+        default_factory=lambda: {
+            "head_camera": ZedXCameraConfig(name="head_camera"),
+            "chassis_imu": ChassisIMUConfig(name="chassis_imu"),
+            "head_imu": ZedIMUConfig(name="head_imu"),
+            "front_lidar_3d": Lidar3DConfig(name="lidar_3d_front"),
+            "ultrasonic": UltraSonicConfig(name="ultrasonic"),
+        }
+    )
+
+    querables: dict[str, str] = field(
+        default_factory=lambda: {
+            # Querables
+            "version_info": "info/versions",
+            "status_info": "info/status",
+            "hand_info": "info/hand_type",
+            "reboot": "system/reboot",
+            "clear_error": "system/clear_error",
+            "soc_ntp": "time/soc",
+            "chassis_led": "system/led",
+        }
+    )
+
+
+@register_variant("vega_1_f5d6")
+@dataclass
+class Vega1F5D6Config(Vega1Config):
+    """Configuration for Vega-1 robot with F5D6 hands."""
+
+    urdf_path: str = str(robots.humanoid.vega_1.vega_1_f5d6.urdf)
+
+    components: dict[str, BaseComponentConfig] = field(
+        default_factory=lambda: {
+            "left_arm": Vega1ArmConfig(side="left"),
+            "right_arm": Vega1ArmConfig(side="right"),
+            "torso": Vega1TorsoConfig(),
+            "chassis": Vega1ChassisConfig(),
+            "head": Vega1HeadConfig(),
+            "left_hand": F5D6HandV2Config(side="left"),
+            "right_hand": F5D6HandV2Config(side="right"),
+            "battery": BatteryConfig(),
+            "estop": EStopConfig(),
+            "heartbeat": HeartbeatConfig(),
+        }
+    )
+
+
+@register_variant("vega_1_gripper")
+@dataclass
+class Vega1DGripperConfig(Vega1Config):
+    """Configuration for Vega-1 robot with D-gripper hands and wrist cameras."""
+
+    urdf_path: str = str(robots.humanoid.vega_1.vega_1_gripper.urdf)
+
+    components: dict[str, BaseComponentConfig] = field(
+        default_factory=lambda: {
+            "left_arm": Vega1ArmConfig(side="left"),
+            "right_arm": Vega1ArmConfig(side="right"),
+            "torso": Vega1TorsoConfig(),
+            "chassis": Vega1ChassisConfig(),
+            "head": Vega1HeadConfig(),
+            "left_hand": DexDGripperConfig(side="left"),
+            "right_hand": DexDGripperConfig(side="right"),
+            "battery": BatteryConfig(),
+            "estop": EStopConfig(),
+            "heartbeat": HeartbeatConfig(),
+        }
+    )
+
+    sensors: dict[str, BaseComponentConfig] = field(
+        default_factory=lambda: {
+            "head_camera": ZedXCameraConfig(name="head_camera"),
+            "chassis_imu": ChassisIMUConfig(name="chassis_imu"),
+            "head_imu": ZedIMUConfig(name="head_imu"),
+            "front_lidar_3d": Lidar3DConfig(name="lidar_3d_front"),
+            "ultrasonic": UltraSonicConfig(name="ultrasonic"),
+            "left_wrist_camera": ZedXOneCameraConfig(side="left"),
+            "right_wrist_camera": ZedXOneCameraConfig(side="right"),
+        }
+    )