dexcontrol 0.2.7__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,18 +20,24 @@ 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_control_hz: int = 100
     joint_name: list[str] = field(
         default_factory=lambda: [f"R_arm_j{i + 1}" for i in range(7)]
     )
     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

@@ -28,20 +28,9 @@ class HandConfig:
         ]
     )
 
-    # Not to modify the following varaibles unless you change a different hand
-    control_joint_names: list[str] = field(
-        default_factory=lambda: ["th_j1", "ff_j1", "mf_j1", "rf_j1", "lf_j1", "th_j0"]
-    )
-    joint_pos_open: list[float] = field(
-        default_factory=lambda: [0.1834, 0.2891, 0.2801, 0.284, 0.2811, -0.0158]
-    )
-    joint_pos_close: list[float] = field(
-        default_factory=lambda: [
-            -0.3468,
-            -1.0946,
-            -1.0844,
-            -1.0154,
-            -1.0118,
-            1.6,
-        ]
+    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.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

@@ -15,7 +15,7 @@ communication and the ArmWrenchSensor class for reading wrench sensor data.
 """
 
 import time
-from typing import Final, Literal
+from typing import Any, Final, Literal
 
 import numpy as np
 import zenoh
@@ -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,6 +78,22 @@ class Arm(RobotJointComponent):
                 configs.wrench_sub_topic, zenoh_session
             )
 
+        # 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_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.
 
@@ -112,6 +134,8 @@ class Arm(RobotJointComponent):
         relative: bool = False,
         wait_time: float = 0.0,
         wait_kwargs: dict[str, float] | None = None,
+        exit_on_reach: bool = False,
+        exit_on_reach_kwargs: dict[str, Any] | None = None,
     ) -> None:
         """Controls the arm in joint position mode.
 
@@ -126,11 +150,19 @@ 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).
                 - max_vel: Maximum velocity in rad/s (default: 0.5).
-
+            exit_on_reach: If True, the function will exit when the joint positions are reached.
+            exit_on_reach_kwargs: Optional parameters for exit when the joint positions are reached.
         Raises:
             ValueError: If joint_pos dictionary contains invalid joint names.
         """
@@ -140,53 +172,58 @@ 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(resolved_joint_pos, wait_time, wait_kwargs)
+            self._execute_trajectory_motion(
+                resolved_joint_pos,
+                wait_time,
+                wait_kwargs,
+                exit_on_reach,
+                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,
+        exit_on_reach_kwargs: dict[str, Any] | None = None,
     ) -> None:
         """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.
+            exit_on_reach_kwargs: Optional parameters for exit when the joint positions are reached.
         """
         # Set default parameters
-        control_hz = wait_kwargs.get("control_hz", 100)
-        max_vel = wait_kwargs.get("max_vel", 0.5)
+        control_hz = wait_kwargs.get("control_hz", self._default_control_hz)
+        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)
 
         # Create rate limiter and get current position
         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()
         for pos in trajectory:
@@ -197,8 +234,12 @@ 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_joint_pos, **exit_on_reach_kwargs
+            ):
+                break
 
     def set_joint_pos_vel(
         self,
@@ -208,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]
@@ -217,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:
@@ -225,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,
@@ -269,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.