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

dexcontrol/__init__.py

@@ -30,8 +30,10 @@ from dexcontrol.robot import Robot
 from dexcontrol.utils.constants import COMM_CFG_PATH_ENV_VAR
 
 # Package-level constants
+__version__: str = "0.3.0"  # Current library version
 LIB_PATH: Final[Path] = Path(__file__).resolve().parent
 CFG_PATH: Final[Path] = LIB_PATH / "config"
+MIN_SOC_SOFTWARE_VERSION: int = 286
 
 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/chassis.py

@@ -14,14 +14,19 @@ from dataclasses import dataclass, field
 @dataclass
 class ChassisConfig:
     _target_: str = "dexcontrol.core.chassis.Chassis"
-    control_pub_topic: str = "control/chassis"
-    state_sub_topic: str = "state/chassis"
+    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"
     dof: int = 2
     center_to_wheel_axis_dist: float = (
         0.219  # the distance between base center and wheel axis in m
     )
     wheels_dist: float = 0.45  # the distance between two wheels in m (0.41 for vega-rc2, 0.45 for vega-1)
-    joint_name: list[str] = field(
-        default_factory=lambda: ["L_wheel_j1", "L_wheel_j2", "R_wheel_j1", "R_wheel_j2"]
+    steer_joint_name: list[str] = field(
+        default_factory=lambda: ["L_wheel_j1", "R_wheel_j1"]
+    )
+    drive_joint_name: list[str] = field(
+        default_factory=lambda: ["L_wheel_j2", "R_wheel_j2"]
     )
     max_vel: float = 0.8

dexcontrol/config/core/hand.py

@@ -16,6 +16,7 @@ class HandConfig:
     _target_: str = "dexcontrol.core.hand.HandF5D6"
     state_sub_topic: str = "state/hand/right"
     control_pub_topic: str = "control/hand/right"
+    touch_sensor_sub_topic: str = "state/hand/right/touch"  # Only for V2 hand
     dof: int = 6
     joint_name: list[str] = field(
         default_factory=lambda: [
@@ -31,6 +32,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],
             },
         )
@@ -75,6 +77,7 @@ class VegaConfig:
         default_factory=lambda: HandConfig(
             state_sub_topic="state/hand/left",
             control_pub_topic="control/hand/left",
+            touch_sensor_sub_topic="state/hand/left/touch",
             joint_name=[
                 "L_th_j1",
                 "L_ff_j1",
@@ -89,6 +92,7 @@ class VegaConfig:
         default_factory=lambda: HandConfig(
             state_sub_topic="state/hand/right",
             control_pub_topic="control/hand/right",
+            touch_sensor_sub_topic="state/hand/right/touch",
             joint_name=[
                 "R_th_j1",
                 "R_ff_j1",
@@ -109,11 +113,13 @@ class VegaConfig:
     heartbeat: HeartbeatConfig = field(default_factory=HeartbeatConfig)
 
     # Queries
-    version_info_name: str = "info/version"
+    version_info_name: str = "info/versions"  # Updated to use JSON interface
     status_info_name: str = "info/status"
+    hand_info_query_name: str = "info/hand_type"
     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 +144,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 +170,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 +197,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

@@ -55,9 +55,15 @@ class Arm(RobotJointComponent):
         super().__init__(
             state_sub_topic=configs.state_sub_topic,
             control_pub_topic=configs.control_pub_topic,
-            state_message_type=dexcontrol_msg_pb2.ArmState,
+            state_message_type=dexcontrol_msg_pb2.MotorStateWithCurrent,
             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,18 +78,28 @@ 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.
 
+        .. deprecated::
+            Use set_modes() instead for setting arm modes.
+
         Args:
             mode: Operating mode for the arm. Must be either "position" or "disable".
                 "position": Enable position control
@@ -92,17 +108,35 @@ class Arm(RobotJointComponent):
         Raises:
             ValueError: If an invalid mode is specified.
         """
+        logger.warning("arm.set_mode() is deprecated, use set_modes() instead")
+        self.set_modes([mode] * 7)
+
+    def set_modes(self, modes: list[Literal["position", "disable", "release"]]) -> None:
+        """Sets the operating modes of the arm.
+
+        Args:
+            modes: List of operating modes for the arm. Each mode must be either "position", "disable", or "current".
+
+        Raises:
+            ValueError: If any mode in the list is invalid.
+        """
         mode_map = {
             "position": dexcontrol_query_pb2.SetArmMode.Mode.POSITION,
             "disable": dexcontrol_query_pb2.SetArmMode.Mode.DISABLE,
+            "release": dexcontrol_query_pb2.SetArmMode.Mode.CURRENT,
         }
 
-        if mode not in mode_map:
-            raise ValueError(
-                f"Invalid mode: {mode}. Must be one of {list(mode_map.keys())}"
-            )
+        for mode in modes:
+            if mode not in mode_map:
+                raise ValueError(
+                    f"Invalid mode: {mode}. Must be one of {list(mode_map.keys())}"
+                )
 
-        query_msg = dexcontrol_query_pb2.SetArmMode(mode=mode_map[mode])
+        if len(modes) != 7:
+            raise ValueError("Arm modes length must match arm DoF (7).")
+
+        converted_modes = [mode_map[mode] for mode in modes]
+        query_msg = dexcontrol_query_pb2.SetArmMode(modes=converted_modes)
         self.mode_querier.get(payload=query_msg.SerializeToString())
 
     def _send_position_command(self, joint_pos: np.ndarray) -> None:
@@ -111,8 +145,8 @@ class Arm(RobotJointComponent):
         Args:
             joint_pos: Joint positions as numpy array.
         """
-        control_msg = dexcontrol_msg_pb2.ArmCommand()
-        control_msg.joint_pos.extend(joint_pos.tolist())
+        control_msg = dexcontrol_msg_pb2.MotorPosVelCurrentCommand()
+        control_msg.pos.extend(joint_pos.tolist())
         self._publish_control(control_msg)
 
     def set_joint_pos(
@@ -137,6 +171,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 +193,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 +208,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 +221,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 +229,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 +241,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 +255,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 +270,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 +289,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,30 +298,19 @@ 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)
+        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_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)
-            )
-        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,
-            joint_pos=list(target_pos),
-            joint_vel=list(target_vel),
+        control_msg = dexcontrol_msg_pb2.MotorPosVelCurrentCommand(
+            pos=list(target_pos),
+            vel=list(target_vel),
         )
         self._publish_control(control_msg)
 
@@ -296,6 +331,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.