dexcontrol 0.2.10__py3-none-any.whl → 0.2.12__py3-none-any.whl

dexcontrol/__init__.py

@@ -32,6 +32,7 @@ from dexcontrol.utils.constants import COMM_CFG_PATH_ENV_VAR
 # Package-level constants
 LIB_PATH: Final[Path] = Path(__file__).resolve().parent
 CFG_PATH: Final[Path] = LIB_PATH / "config"
+MIN_SOC_SOFTWARE_VERSION: int = 233
 
 logger.configure(handlers=[{"sink": RichHandler(markup=True), "format": "{message}"}])
 

dexcontrol/config/core/arm.py

@@ -20,8 +20,8 @@ class ArmConfig:
     wrench_sub_topic: str = "state/wrench/right"
     control_pub_topic: str = "control/arm/right"
     set_mode_query: str = "mode/arm/right"
+    ee_pass_through_pub_topic: str = "control/ee_pass_through/right"
     dof: int = 7
-    default_max_vel: float = 2.0  # do not go over 3.0
     default_control_hz: int = 100
     joint_name: list[str] = field(
         default_factory=lambda: [f"R_arm_j{i + 1}" for i in range(7)]
@@ -29,11 +29,15 @@ class ArmConfig:
     joint_limit: list[list[float]] = field(
         default_factory=lambda: [[-np.pi, np.pi] for _ in range(7)]
     )
+    joint_vel_limit: list[float] = field(
+        default_factory=lambda: [2.4, 2.4, 2.7, 2.7, 2.7, 2.7, 2.7]
+    )
     pose_pool: dict[str, list[float]] = field(
         default_factory=lambda: {
             "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.0, 0.0],
         }
     )

dexcontrol/config/core/hand.py

@@ -31,6 +31,6 @@ class HandConfig:
     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.3468, -1.0946, -1.0844, -1.0154, -1.0118, 1.6],
+            "close": [-0.2668, -1.0946, -1.0844, -1.0154, -1.0118, 1.6],
         }
     )

dexcontrol/config/core/head.py

@@ -21,15 +21,14 @@ class HeadConfig:
         default_factory=lambda: ["head_j1", "head_j2", "head_j3"]
     )
     dof: int = 3
-    # Use the following varaibles if you are using vega-rc2
-    joint_limit_lower: list[float] = field(
-        default_factory=lambda: [-1.2217, -2.7925, -1.396]
+    joint_limit: list[list[float]] = field(
+        default_factory=lambda: [
+            [-1.2217, 1.2217],
+            [-2.7925, 2.7925],
+            [-1.396, 1.396],
+        ]
     )
-    joint_limit_upper: list[float] = field(
-        default_factory=lambda: [1.2217, 2.7925, 1.396]
-    )
-    default_vel: float = 1.57
-    max_vel: float = 2.0
+    joint_vel_limit: list[float] = field(default_factory=lambda: [2.5, 2.5, 2.5])
     pose_pool: dict[str, list[float]] = field(
         default_factory=lambda: {
             "home": [0.0, 0.0, 0.0],

dexcontrol/config/core/misc.py

@@ -13,7 +13,10 @@
 import os
 from dataclasses import dataclass
 
-from dexcontrol.utils.constants import DISABLE_HEARTBEAT_ENV_VAR
+from dexcontrol.utils.constants import (
+    DISABLE_ESTOP_CHECKING_ENV_VAR,
+    DISABLE_HEARTBEAT_ENV_VAR,
+)
 
 
 @dataclass
@@ -27,6 +30,16 @@ class EStopConfig:
     _target_: str = "dexcontrol.core.misc.EStop"
     state_sub_topic: str = "state/estop"
     estop_query_name: str = "system/estop"
+    enabled: bool = True  # Can be disabled via DEXCONTROL_DISABLE_ESTOP_CHECKING=1
+
+    def __post_init__(self):
+        """Check environment variable to disable estop checking."""
+        if os.getenv(DISABLE_ESTOP_CHECKING_ENV_VAR, "0").lower() in (
+            "1",
+            "true",
+            "yes",
+        ):
+            self.enabled = False
 
 
 @dataclass

dexcontrol/config/core/torso.py

@@ -20,10 +20,14 @@ class TorsoConfig:
     joint_name: list[str] = field(
         default_factory=lambda: ["torso_j1", "torso_j2", "torso_j3"]
     )
-    default_vel: float = 0.4  # rad/s, will be used if joint_vel is not provided
-    max_vel: float = 0.6  # max velocity of torso joint, will be used to clip
-    # the joint_vel, Highly recommended to set this value
-    # not higher than 0.6 rad/s
+    joint_limit: list[list[float]] = field(
+        default_factory=lambda: [
+            [0, 1.570],
+            [0, 3.141],
+            [-1.570, 1.570],
+        ]
+    )
+    joint_vel_limit: list[float] = field(default_factory=lambda: [0.6, 0.6, 0.6])
     pose_pool: dict[str, list[float]] = field(
         default_factory=lambda: {
             "home": [0.0, 0.0, 0.0],

dexcontrol/config/sensors/cameras/__init__.py

@@ -8,7 +8,8 @@
 # 2. Commercial License
 #    For commercial licensing terms, contact: contact@dexmate.ai
 
+from .luxonis_camera import LuxonisCameraConfig
 from .rgb_camera import RGBCameraConfig
 from .zed_camera import ZedCameraConfig
 
-__all__ = ["RGBCameraConfig", "ZedCameraConfig"]
+__all__ = ["RGBCameraConfig", "ZedCameraConfig", "LuxonisCameraConfig"]

dexcontrol/config/sensors/cameras/luxonis_camera.py

@@ -0,0 +1,51 @@
+# 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, field
+
+
+@dataclass
+class LuxonisCameraConfig:
+    """Configuration for LuxonisCameraSensor (wrist camera).
+
+    Attributes:
+        _target_: Target sensor class for Hydra instantiation.
+        name: Logical name of the camera.
+        enable: Whether this sensor is enabled.
+        enable_fps_tracking: Enable FPS tracking logs.
+        fps_log_interval: Frames between FPS logs.
+        subscriber_config: Topics for RGB and Depth Zenoh subscribers.
+    """
+
+    _target_: str = "dexcontrol.sensors.camera.luxonis_camera.LuxonisCameraSensor"
+    name: str = "wrist_camera"
+    enable: bool = False
+    enable_fps_tracking: bool = False
+    fps_log_interval: int = 30
+
+    # Note: Resolution is set by the publisher (dexsensor). The publisher now defaults
+    # to 720p to match common Luxonis sensor capabilities (e.g., OV9782 supports 720p/800p).
+    # These subscribers only define topics to consume.
+    subscriber_config: dict = field(
+        default_factory=lambda: {
+            "left_rgb": {
+                "enable": True,
+                "topic": "camera/wrist/left_rgb",
+            },
+            "right_rgb": {
+                "enable": True,
+                "topic": "camera/wrist/right_rgb",
+            },
+            "depth": {
+                "enable": False,
+                "topic": "camera/wrist/depth",
+            },
+        }
+    )

dexcontrol/config/sensors/cameras/rgb_camera.py

@@ -19,7 +19,7 @@ class RGBCameraConfig:
         _target_: The target class to instantiate.
         name: A unique name for the sensor instance.
         enable: Whether the sensor is enabled.
-        use_rtc: If True, uses the high-performance RTCSubscriber. If False,
+        use_rtc: If True, uses the RTCSubscriber. If False,
                  uses the standard RGBCameraSubscriber with a Zenoh topic.
         enable_fps_tracking: If True, tracks and logs the FPS of the stream.
         fps_log_interval: The interval in seconds for logging FPS.

dexcontrol/config/sensors/cameras/zed_camera.py

@@ -19,7 +19,7 @@ class ZedCameraConfig:
         _target_: The target class to instantiate.
         name: A unique name for the sensor instance.
         enable: Whether the sensor is enabled.
-        use_rtc: If True, RGB streams use the high-performance RTCSubscriber.
+        use_rtc: If True, RGB streams use the RTCSubscriber.
                  If False, they use the standard RGBCameraSubscriber. Depth
                  always uses a standard Zenoh subscriber.
         enable_fps_tracking: If True, tracks and logs the FPS of all streams.
@@ -31,7 +31,7 @@ class ZedCameraConfig:
     _target_: str = "dexcontrol.sensors.camera.zed_camera.ZedCameraSensor"
     name: str = "zed_camera"
     enable: bool = False
-    use_rtc: bool = True
+    use_rtc: bool = False
     enable_fps_tracking: bool = False
     fps_log_interval: int = 30
 

dexcontrol/config/sensors/vega_sensors.py

@@ -18,7 +18,7 @@ LiDAR and ultrasonic sensors.
 from collections.abc import Callable
 from dataclasses import dataclass, field
 
-from .cameras import RGBCameraConfig, ZedCameraConfig
+from .cameras import LuxonisCameraConfig, RGBCameraConfig, ZedCameraConfig
 from .imu import ChassisIMUConfig, ZedIMUConfig
 from .lidar import RPLidarConfig
 from .ultrasonic import UltraSonicConfig
@@ -58,6 +58,12 @@ class VegaSensorsConfig:
     """
 
     head_camera: ZedCameraConfig = field(default_factory=ZedCameraConfig)
+    left_wrist_camera: LuxonisCameraConfig = field(
+        default_factory=lambda: LuxonisCameraConfig(name="left_wrist_camera")
+    )
+    right_wrist_camera: LuxonisCameraConfig = field(
+        default_factory=lambda: LuxonisCameraConfig(name="right_wrist_camera")
+    )
     base_left_camera: RGBCameraConfig = field(default_factory=_make_rgb_camera("left"))
     base_right_camera: RGBCameraConfig = field(
         default_factory=_make_rgb_camera("right")
@@ -73,6 +79,8 @@ class VegaSensorsConfig:
 
     def __post_init__(self) -> None:
         self.head_camera.enable = False
+        self.left_wrist_camera.enable = False
+        self.right_wrist_camera.enable = False
         self.base_left_camera.enable = False
         self.base_right_camera.enable = False
         self.base_front_camera.enable = False

dexcontrol/config/vega.py

@@ -52,6 +52,7 @@ class VegaConfig:
                 "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],
             },
         )
@@ -67,6 +68,7 @@ class VegaConfig:
                 "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],
             },
         )
@@ -114,6 +116,7 @@ class VegaConfig:
     reboot_query_name: str = "system/reboot"
     clear_error_query_name: str = "system/clear_error"
     led_query_name: str = "system/led"
+    soc_ntp_query_name: str = "time/soc"
 
     @classmethod
     def register_variant(
@@ -138,11 +141,22 @@ class Vega1Config(VegaConfig):
             control_pub_topic="control/arm/left",
             set_mode_query="mode/arm/left",
             wrench_sub_topic="state/wrench/left",
+            ee_pass_through_pub_topic="control/ee_pass_through/left",
             joint_name=[f"L_arm_j{i + 1}" for i in range(7)],
+            joint_limit=[
+                [-3.071, 3.071],
+                [-0.453, 1.553],
+                [-3.071, 3.071],
+                [-3.071, 0.244],
+                [-3.071, 3.071],
+                [-1.396, 1.396],
+                [-1.378, 1.117],
+            ],
             pose_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],
             },
         )
@@ -153,11 +167,22 @@ class Vega1Config(VegaConfig):
             control_pub_topic="control/arm/right",
             set_mode_query="mode/arm/right",
             wrench_sub_topic="state/wrench/right",
+            ee_pass_through_pub_topic="control/ee_pass_through/right",
             joint_name=[f"R_arm_j{i + 1}" for i in range(7)],
+            joint_limit=[
+                [-3.071, 3.071],
+                [-1.553, 0.453],
+                [-3.071, 3.071],
+                [-3.071, 0.244],
+                [-3.071, 3.071],
+                [-1.396, 1.396],
+                [-1.117, 1.378],
+            ],
             pose_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],
             },
         )
@@ -169,8 +194,11 @@ class Vega1Config(VegaConfig):
     )
     head: HeadConfig = field(
         default_factory=lambda: HeadConfig(
-            joint_limit_lower=[-1.483, -2.792, -1.378],
-            joint_limit_upper=[1.483, 2.792, 1.483],
+            joint_limit=[
+                [-1.483, 1.483],
+                [-2.792, 2.792],
+                [-1.378, 1.378],
+            ],
         )
     )
 

dexcontrol/core/arm.py

@@ -58,6 +58,12 @@ class Arm(RobotJointComponent):
             state_message_type=dexcontrol_msg_pb2.ArmState,
             zenoh_session=zenoh_session,
             joint_name=configs.joint_name,
+            joint_limit=configs.joint_limit
+            if hasattr(configs, "joint_limit")
+            else None,
+            joint_vel_limit=configs.joint_vel_limit
+            if hasattr(configs, "joint_vel_limit")
+            else None,
             pose_pool=configs.pose_pool,
         )
 
@@ -72,14 +78,21 @@ class Arm(RobotJointComponent):
                 configs.wrench_sub_topic, zenoh_session
             )
 
-        self._default_max_vel = configs.default_max_vel
-        self._default_control_hz = configs.default_control_hz
-        if self._default_max_vel > 3.0:
-            logger.warning(
-                f"Max velocity is set to {self._default_max_vel}, which is greater than 3.0. This is not recommended."
+        # Initialize end effector pass through publisher
+        self._ee_pass_through_publisher: Final[zenoh.Publisher] = (
+            zenoh_session.declare_publisher(
+                resolve_key_name(configs.ee_pass_through_pub_topic)
             )
-            self._default_max_vel = 3.0
-            logger.warning("Max velocity is clamped to 3.0")
+        )
+
+        self._default_control_hz = configs.default_control_hz
+        if self._joint_vel_limit is not None:
+            if np.any(self._joint_vel_limit > 2.8):
+                logger.warning(
+                    "Joint velocity limit is greater than 2.8. This is not recommended."
+                )
+                self._joint_vel_limit = np.clip(self._joint_vel_limit, 0, 2.8)
+                logger.warning("Joint velocity limit is clamped to 2.8")
 
     def set_mode(self, mode: Literal["position", "disable"]) -> None:
         """Sets the operating mode of the arm.
@@ -137,6 +150,13 @@ class Arm(RobotJointComponent):
                 immediately. If wait_time is greater than 0, the joint positions will
                 be interpolated between the current position and the target position,
                 and the function will wait for the specified time between each movement.
+
+                **IMPORTANT: When wait_time is 0, you MUST call this function repeatedly
+                in a high-frequency loop (e.g., 100 Hz). DO NOT call it just once!**
+                The function is designed for continuous control when wait_time=0.
+                The highest frequency that the user can call this function is 500 Hz.
+
+
             wait_kwargs: Keyword arguments for the interpolation (only used if
                 wait_time > 0). Supported keys:
                 - control_hz: Control frequency in Hz (default: 100).
@@ -152,6 +172,11 @@ class Arm(RobotJointComponent):
         resolved_joint_pos = (
             self._resolve_relative_joint_cmd(joint_pos) if relative else joint_pos
         )
+        resolved_joint_pos = self._convert_joint_cmd_to_array(resolved_joint_pos)
+        if self._joint_limit is not None:
+            resolved_joint_pos = np.clip(
+                resolved_joint_pos, self._joint_limit[:, 0], self._joint_limit[:, 1]
+            )
 
         if wait_time > 0.0:
             self._execute_trajectory_motion(
@@ -162,16 +187,11 @@ class Arm(RobotJointComponent):
                 exit_on_reach_kwargs,
             )
         else:
-            # Convert to array format
-            if isinstance(resolved_joint_pos, (list, dict)):
-                resolved_joint_pos = self._convert_joint_cmd_to_array(
-                    resolved_joint_pos
-                )
             self._send_position_command(resolved_joint_pos)
 
     def _execute_trajectory_motion(
         self,
-        joint_pos: Float[np.ndarray, " N"] | list[float] | dict[str, float],
+        target_joint_pos: Float[np.ndarray, " N"],
         wait_time: float,
         wait_kwargs: dict[str, float],
         exit_on_reach: bool = False,
@@ -180,7 +200,7 @@ class Arm(RobotJointComponent):
         """Execute trajectory-based motion to target position.
 
         Args:
-            joint_pos: Target joint positions as list, numpy array, or dictionary.
+            target_joint_pos: Target joint positions as numpy array.
             wait_time: Total time for the motion.
             wait_kwargs: Parameters for trajectory generation.
             exit_on_reach: If True, the function will exit when the joint positions are reached.
@@ -188,7 +208,11 @@ class Arm(RobotJointComponent):
         """
         # Set default parameters
         control_hz = wait_kwargs.get("control_hz", self._default_control_hz)
-        max_vel = wait_kwargs.get("max_vel", self._default_max_vel)
+        max_vel = wait_kwargs.get("max_vel")
+        if max_vel is None:
+            max_vel = (
+                self._joint_vel_limit if self._joint_vel_limit is not None else 2.8
+            )
         exit_on_reach_kwargs = exit_on_reach_kwargs or {}
         exit_on_reach_kwargs.setdefault("tolerance", 0.05)
 
@@ -196,19 +220,9 @@ class Arm(RobotJointComponent):
         rate_limiter = RateLimiter(control_hz)
         current_joint_pos = self.get_joint_pos().copy()
 
-        # Convert input to numpy array for trajectory generation
-        if isinstance(joint_pos, (list, dict)):
-            target_pos = (
-                self._convert_dict_to_array(joint_pos)
-                if isinstance(joint_pos, dict)
-                else np.array(joint_pos, dtype=np.float32)
-            )
-        else:
-            target_pos = joint_pos
-
         # Generate trajectory using utility function
         trajectory, _ = generate_linear_trajectory(
-            current_joint_pos, target_pos, max_vel, control_hz
+            current_joint_pos, target_joint_pos, max_vel, control_hz
         )
         # Execute trajectory with time limit
         start_time = time.time()
@@ -220,10 +234,10 @@ class Arm(RobotJointComponent):
 
         # Hold final position for remaining time
         while time.time() - start_time < wait_time:
-            self._send_position_command(target_pos)
+            self._send_position_command(target_joint_pos)
             rate_limiter.sleep()
             if exit_on_reach and self.is_joint_pos_reached(
-                target_pos, **exit_on_reach_kwargs
+                target_joint_pos, **exit_on_reach_kwargs
             ):
                 break
 
@@ -235,6 +249,16 @@ class Arm(RobotJointComponent):
     ) -> None:
         """Controls the arm in joint position mode with a velocity feedforward term.
 
+        Warning:
+            The joint_vel parameter should be well-planned (such as from a trajectory planner).
+            Sending poorly planned or inappropriate joint velocity commands can cause the robot
+            to behave unexpectedly or potentially get damaged. Ensure velocity commands are
+            smooth, within safe limits, and properly coordinated across all joints.
+
+            Additionally, this command MUST be called at high frequency (e.g., 100Hz) to take
+            effect properly. DO NOT call this function just once or at low frequency, as this
+            can lead to unpredictable robot behavior.
+
         Args:
             joint_pos: Joint positions as either:
                 - List of joint values [j1, j2, ..., j7]
@@ -244,6 +268,7 @@ class Arm(RobotJointComponent):
                 - List of joint values [v1, v2, ..., v7]
                 - Numpy array with shape (7,), in radians/sec
                 - Dictionary of joint names and velocity values
+
             relative: If True, the joint positions are relative to the current position.
 
         Raises:
@@ -252,25 +277,15 @@ class Arm(RobotJointComponent):
         resolved_joint_pos = (
             self._resolve_relative_joint_cmd(joint_pos) if relative else joint_pos
         )
-
-        # Convert inputs to numpy arrays
-        if isinstance(resolved_joint_pos, (list, dict)):
-            target_pos = (
-                self._convert_dict_to_array(resolved_joint_pos)
-                if isinstance(resolved_joint_pos, dict)
-                else np.array(resolved_joint_pos, dtype=np.float32)
-            )
-        else:
-            target_pos = resolved_joint_pos
-
-        if isinstance(joint_vel, (list, dict)):
-            target_vel = (
-                self._convert_dict_to_array(joint_vel)
-                if isinstance(joint_vel, dict)
-                else np.array(joint_vel, dtype=np.float32)
+        resolved_joint_pos = self._convert_joint_cmd_to_array(resolved_joint_pos)
+        if self._joint_limit is not None:
+            resolved_joint_pos = np.clip(
+                resolved_joint_pos, self._joint_limit[:, 0], self._joint_limit[:, 1]
             )
-        else:
-            target_vel = joint_vel
+        target_pos = resolved_joint_pos
+        target_vel = self._convert_joint_cmd_to_array(
+            joint_vel, clip_value=self._joint_vel_limit
+        )
 
         control_msg = dexcontrol_msg_pb2.ArmCommand(
             command_type=dexcontrol_msg_pb2.ArmCommand.CommandType.VELOCITY_FEEDFORWARD,
@@ -296,6 +311,16 @@ class Arm(RobotJointComponent):
         if self.wrench_sensor:
             self.wrench_sensor.shutdown()
 
+    def send_ee_pass_through_message(self, message: bytes):
+        """Send an end effector pass through message to the robot arm.
+
+        Args:
+            message: The message to send to the robot arm.
+        """
+        control_msg = dexcontrol_msg_pb2.EndEffectorPassThroughCommand(data=message)
+        control_data = control_msg.SerializeToString()
+        self._ee_pass_through_publisher.put(control_data)
+
 
 class ArmWrenchSensor(RobotComponent):
     """Wrench sensor reader for the robot arm.

dexcontrol/core/component.py

@@ -89,11 +89,11 @@ class RobotComponent:
             Parsed protobuf state message.
 
         Raises:
-            RuntimeError: If no state data is available.
+            None: If no state data is available.
         """
         state = self._subscriber.get_latest_data()
         if state is None:
-            raise RuntimeError("No state data available")
+            logger.error(f"No state data available for {self.__class__.__name__}")
         return state
 
     def wait_for_active(self, timeout: float = 5.0) -> bool:
@@ -133,6 +133,15 @@ class RobotComponent:
         if hasattr(self, "_subscriber") and self._subscriber:
             self._subscriber.shutdown()
 
+    def get_timestamp_ns(self) -> int:
+        """Get the current timestamp (in nanoseconds) of the most recent state update.
+
+        Returns:
+            The current timestamp in nanoseconds when driver updated the state.
+            We convert the time to client clock by adding the server time offset.
+        """
+        return self._get_state().timestamp_ns
+
 
 class RobotJointComponent(RobotComponent):
     """Base class for robot components with both state and control interfaces.
@@ -171,6 +180,8 @@ class RobotJointComponent(RobotComponent):
         state_message_type: type[M],
         zenoh_session: zenoh.Session,
         joint_name: list[str] | None = None,
+        joint_limit: list[list[float]] | None = None,
+        joint_vel_limit: list[float] | None = None,
         pose_pool: Mapping[str, list[float] | np.ndarray] | None = None,
     ) -> None:
         """Initializes RobotJointComponent.
@@ -190,6 +201,13 @@ class RobotJointComponent(RobotComponent):
             resolved_topic
         )
         self._joint_name: list[str] | None = joint_name
+        self._joint_limit: np.ndarray | None = (
+            np.array(joint_limit) if joint_limit else None
+        )
+        self._joint_vel_limit: np.ndarray | None = (
+            np.array(joint_vel_limit) if joint_vel_limit else None
+        )
+
         self._pose_pool: dict[str, np.ndarray] | None = (
             self._convert_pose_pool_to_arrays(pose_pool)
         )
@@ -231,6 +249,18 @@ class RobotJointComponent(RobotComponent):
             raise ValueError("Joint names not available for this component")
         return self._joint_name.copy()
 
+    @property
+    def joint_limit(self) -> np.ndarray | None:
+        """Gets the joint limits of the component."""
+        return self._joint_limit.copy() if self._joint_limit is not None else None
+
+    @property
+    def joint_vel_limit(self) -> np.ndarray | None:
+        """Gets the joint velocity limits of the component."""
+        return (
+            self._joint_vel_limit.copy() if self._joint_vel_limit is not None else None
+        )
+
     def get_predefined_pose(self, pose_name: str) -> np.ndarray:
         """Gets a predefined pose from the pose pool.
 
@@ -466,7 +496,7 @@ class RobotJointComponent(RobotComponent):
     def _convert_joint_cmd_to_array(
         self,
         joint_cmd: Float[np.ndarray, " N"] | list[float] | dict[str, float],
-        clip_value: float | None = None,
+        clip_value: float | np.ndarray | None = None,
     ) -> np.ndarray:
         """Convert joint command to numpy array format.
 
@@ -475,7 +505,9 @@ class RobotJointComponent(RobotComponent):
                 - List of joint values [j1, j2, ..., jN]
                 - Numpy array with shape (N,)
                 - Dictionary mapping joint names to values
-            clip_value: Optional value to clip the output array between [-clip_value, clip_value].
+            clip_value: Optional value to clip the output array. Can be:
+                - float: symmetric clipping between [-clip_value, clip_value]
+                - numpy array: element-wise clipping between [-clip_value, clip_value]
 
         Returns:
             Joint command as numpy array.
@@ -660,6 +692,11 @@ class RobotJointComponent(RobotComponent):
         if isinstance(joint_pos, (list, dict)):
             joint_pos = self._convert_joint_cmd_to_array(joint_pos)
 
+        if self._joint_limit is not None:
+            joint_pos = np.clip(
+                joint_pos, self._joint_limit[:, 0], self._joint_limit[:, 1]
+            )
+
         self._send_position_command(joint_pos)
 
         if wait_time > 0.0: