faster canbus

.github/workflows/release.yml

@@ -83,11 +83,11 @@ jobs:
           fi
 
       - name: Remove Tags with Git dependencies
-        # TODO(Steven): Temporary patch to remove pi from PyPi 0.4.0 release due to its reliance on git dependencies.
+        # TODO(Steven): Temporary patch to remove libero and pi from PyPi 0.4.0 release due to its reliance on git dependencies.
         run: |
           echo "::info:: Checking for Git dependencies to remove from pyproject.toml..."
-          grep -E '@ git\+https|lerobot\[pi\]' pyproject.toml | sed 's/^/::warning:: Removing line: /' || true
-          sed -E -i '/@ git\+https|lerobot\[pi\]/d' pyproject.toml
+          grep -E '@ git\+https|lerobot\[pi\]|lerobot\[libero\]' pyproject.toml | sed 's/^/::warning:: Removing line: /' || true
+          sed -E -i '/@ git\+https|lerobot\[pi\]|lerobot\[libero\]/d' pyproject.toml
           echo "::info:: Git dependencies removed. Proceeding with build."
 
       - name: Install build dependencies

.github/workflows/unbound_deps_tests.yml

@@ -70,7 +70,7 @@ jobs:
           echo "Dependencies unbound:" && cat pyproject.toml
 
       - name: Install lerobot with all extras
-        run: uv sync --all-extras --no-extra groot # TODO(Steven): Make flash-attn optional
+        run: uv sync --all-extras
 
       - name: Run pytest (all extras)
         run: uv run pytest tests -vv

README.md

@@ -186,7 +186,7 @@ For a full list of optional dependencies, see:
 https://pypi.org/project/lerobot/
 
 > [!NOTE]
-> For lerobot 0.4.0, if you want to install pi tags, you will have to do: `pip install "lerobot[pi]@git+https://github.com/huggingface/lerobot.git"`.
+> For lerobot 0.4.0, if you want to install libero or pi tags, you will have to do: `pip install "lerobot[pi,libero]@git+https://github.com/huggingface/lerobot.git"`.
 >
 > This will be solved in the next patch release
 

docs/source/_toctree.yml

@@ -41,8 +41,6 @@
     title: NVIDIA GR00T N1.5
   title: "Policies"
 - sections:
-  - local: envhub
-    title: Environments from the Hub
   - local: il_sim
     title: Imitation Learning in Sim
   - local: libero

docs/source/envhub.mdx

@@ -1,424 +0,0 @@
-# Loading Environments from the Hub
-
-The **EnvHub** feature allows you to load simulation environments directly from the Hugging Face Hub with a single line of code. This unlocks a powerful new model for collaboration: instead of environments being locked away inside monolithic libraries, anyone can publish custom environments and share them with the community.
-
-## Overview
-
-With EnvHub, you can:
-
-- Load environments from the Hub instantly
-- Share your custom simulation tasks with the community
-- Version control your environments using Git
-- Distribute complex physics simulations without packaging hassles
-
-## Quick Start
-
-Loading an environment from the Hub is as simple as:
-
-```python
-from lerobot.envs.factory import make_env
-
-# Load a hub environment (requires explicit consent to run remote code)
-env = make_env("lerobot/cartpole-env", trust_remote_code=True)
-```
-
-<Tip warning={true}>
-  **Security Notice**: Loading environments from the Hub executes Python code
-  from third-party repositories. Only use `trust_remote_code=True` with
-  repositories you trust. We strongly recommend pinning to a specific commit
-  hash for reproducibility and security.
-</Tip>
-
-## What is EnvHub?
-
-EnvHub is a framework that allows researchers and developers to:
-
-1. **Publish environments** to the Hugging Face Hub as Git repositories
-2. **Load environments** dynamically without installing them as packages
-3. **Version and track** environment changes using Git semantics
-4. **Discover** new simulation tasks shared by the community
-
-This design means you can go from discovering an interesting environment on the Hub to running experiments in seconds, without worrying about dependency conflicts or complex installation procedures.
-
-## Repository Structure
-
-To make your environment loadable from the Hub, your repository must contain at minimum:
-
-### Required Files
-
-**`env.py`** (or custom Python file)
-
-- Must expose a `make_env(n_envs: int, use_async_envs: bool)` function
-- This function should return one of:
-  - A `gym.vector.VectorEnv` (most common)
-  - A single `gym.Env` (will be automatically wrapped)
-  - A dict mapping `{suite_name: {task_id: VectorEnv}}` (for multi-task benchmarks)
-
-### Optional Files
-
-**`requirements.txt`**
-
-- List any additional dependencies your environment needs
-- Users will need to install these manually before loading your environment
-
-**`README.md`**
-
-- Document your environment: what task it implements, observation/action spaces, rewards, etc.
-- Include usage examples and any special setup instructions
-
-**`.gitignore`**
-
-- Exclude unnecessary files from your repository
-
-### Example Repository Structure
-
-```
-my-environment-repo/
-├── env.py                 # Main environment definition (required)
-├── requirements.txt       # Dependencies (optional)
-├── README.md             # Documentation (recommended)
-├── assets/               # Images, videos, etc. (optional)
-│   └── demo.gif
-└── configs/              # Config files if needed (optional)
-    └── task_config.yaml
-```
-
-## Creating Your Environment Repository
-
-### Step 1: Define Your Environment
-
-Create an `env.py` file with a `make_env` function:
-
-```python
-# env.py
-import gymnasium as gym
-
-def make_env(n_envs: int = 1, use_async_envs: bool = False):
-    """
-    Create vectorized environments for your custom task.
-
-    Args:
-        n_envs: Number of parallel environments
-        use_async_envs: Whether to use AsyncVectorEnv or SyncVectorEnv
-
-    Returns:
-        gym.vector.VectorEnv or dict mapping suite names to vectorized envs
-    """
-    def _make_single_env():
-        # Create your custom environment
-        return gym.make("CartPole-v1")
-
-    # Choose vector environment type
-    env_cls = gym.vector.AsyncVectorEnv if use_async_envs else gym.vector.SyncVectorEnv
-
-    # Create vectorized environment
-    vec_env = env_cls([_make_single_env for _ in range(n_envs)])
-
-    return vec_env
-```
-
-### Step 2: Test Locally
-
-Before uploading, test your environment locally:
-
-```python
-from lerobot.envs.utils import _load_module_from_path, _call_make_env, _normalize_hub_result
-
-# Load your module
-module = _load_module_from_path("./env.py")
-
-# Test the make_env function
-result = _call_make_env(module, n_envs=2, use_async_envs=False)
-normalized = _normalize_hub_result(result)
-
-# Verify it works
-suite_name = next(iter(normalized))
-env = normalized[suite_name][0]
-obs, info = env.reset()
-print(f"Observation shape: {obs.shape if hasattr(obs, 'shape') else type(obs)}")
-env.close()
-```
-
-### Step 3: Upload to the Hub
-
-Upload your repository to Hugging Face:
-
-```bash
-# Install huggingface_hub if needed
-pip install huggingface_hub
-
-# Login to Hugging Face
-huggingface-cli login
-
-# Create a new repository
-huggingface-cli repo create my-custom-env --type space --org my-org
-
-# Initialize git and push
-git init
-git add .
-git commit -m "Initial environment implementation"
-git remote add origin https://huggingface.co/my-org/my-custom-env
-git push -u origin main
-```
-
-Alternatively, use the `huggingface_hub` Python API:
-
-```python
-from huggingface_hub import HfApi
-
-api = HfApi()
-
-# Create repository
-api.create_repo("my-custom-env", repo_type="space")
-
-# Upload files
-api.upload_folder(
-    folder_path="./my-env-folder",
-    repo_id="username/my-custom-env",
-    repo_type="space",
-)
-```
-
-## Loading Environments from the Hub
-
-### Basic Usage
-
-```python
-from lerobot.envs.factory import make_env
-
-# Load from the hub
-envs_dict = make_env(
-    "username/my-custom-env",
-    n_envs=4,
-    trust_remote_code=True
-)
-
-# Access the environment
-suite_name = next(iter(envs_dict))
-env = envs_dict[suite_name][0]
-
-# Use it like any gym environment
-obs, info = env.reset()
-action = env.action_space.sample()
-obs, reward, terminated, truncated, info = env.step(action)
-```
-
-### Advanced: Pinning to Specific Versions
-
-For reproducibility and security, pin to a specific Git revision:
-
-```python
-# Pin to a specific branch
-env = make_env("username/my-env@main", trust_remote_code=True)
-
-# Pin to a specific commit (recommended for papers/experiments)
-env = make_env("username/my-env@abc123def456", trust_remote_code=True)
-
-# Pin to a tag
-env = make_env("username/my-env@v1.0.0", trust_remote_code=True)
-```
-
-### Custom File Paths
-
-If your environment definition is not in `env.py`:
-
-```python
-# Load from a custom file
-env = make_env("username/my-env:custom_env.py", trust_remote_code=True)
-
-# Combine with version pinning
-env = make_env("username/my-env@v1.0:envs/task_a.py", trust_remote_code=True)
-```
-
-### Async Environments
-
-For better performance with multiple environments:
-
-```python
-envs_dict = make_env(
-    "username/my-env",
-    n_envs=8,
-    use_async_envs=True,  # Use AsyncVectorEnv for parallel execution
-    trust_remote_code=True
-)
-```
-
-## URL Format Reference
-
-The hub URL format supports several patterns:
-
-| Pattern              | Description                    | Example                                |
-| -------------------- | ------------------------------ | -------------------------------------- |
-| `user/repo`          | Load `env.py` from main branch | `make_env("lerobot/pusht-env")`        |
-| `user/repo@revision` | Load from specific revision    | `make_env("lerobot/pusht-env@main")`   |
-| `user/repo:path`     | Load custom file               | `make_env("lerobot/envs:pusht.py")`    |
-| `user/repo@rev:path` | Revision + custom file         | `make_env("lerobot/envs@v1:pusht.py")` |
-
-## Multi-Task Environments
-
-For benchmarks with multiple tasks (like LIBERO), return a nested dictionary:
-
-```python
-def make_env(n_envs: int = 1, use_async_envs: bool = False):
-    env_cls = gym.vector.AsyncVectorEnv if use_async_envs else gym.vector.SyncVectorEnv
-
-    # Return dict: {suite_name: {task_id: VectorEnv}}
-    return {
-        "suite_1": {
-            0: env_cls([lambda: gym.make("Task1-v0") for _ in range(n_envs)]),
-            1: env_cls([lambda: gym.make("Task2-v0") for _ in range(n_envs)]),
-        },
-        "suite_2": {
-            0: env_cls([lambda: gym.make("Task3-v0") for _ in range(n_envs)]),
-        }
-    }
-```
-
-## Security Considerations
-
-<Tip warning={true}>
-  **Important**: The `trust_remote_code=True` flag is required to execute
-  environment code from the Hub. This is by design for security.
-</Tip>
-
-When loading environments from the Hub:
-
-1. **Review the code first**: Visit the repository and inspect `env.py` before loading
-2. **Pin to commits**: Use specific commit hashes for reproducibility
-3. **Check dependencies**: Review `requirements.txt` for suspicious packages
-4. **Use trusted sources**: Prefer official organizations or well-known researchers
-5. **Sandbox if needed**: Run untrusted code in isolated environments (containers, VMs)
-
-Example of safe usage:
-
-```python
-# ❌ BAD: Loading without inspection
-env = make_env("random-user/untrusted-env", trust_remote_code=True)
-
-# ✅ GOOD: Review code, then pin to specific commit
-# 1. Visit https://huggingface.co/trusted-org/verified-env
-# 2. Review the env.py file
-# 3. Copy the commit hash
-env = make_env("trusted-org/verified-env@a1b2c3d4", trust_remote_code=True)
-```
-
-## Example: CartPole from the Hub
-
-Here's a complete example using the reference CartPole environment:
-
-```python
-from lerobot.envs.factory import make_env
-import numpy as np
-
-# Load the environment
-envs_dict = make_env("lerobot/cartpole-env", n_envs=4, trust_remote_code=True)
-
-# Get the vectorized environment
-suite_name = next(iter(envs_dict))
-env = envs_dict[suite_name][0]
-
-# Run a simple episode
-obs, info = env.reset()
-done = np.zeros(env.num_envs, dtype=bool)
-total_reward = np.zeros(env.num_envs)
-
-while not done.all():
-    # Random policy
-    action = env.action_space.sample()
-    obs, reward, terminated, truncated, info = env.step(action)
-    total_reward += reward
-    done = terminated | truncated
-
-print(f"Average reward: {total_reward.mean():.2f}")
-env.close()
-```
-
-## Benefits of EnvHub
-
-### For Environment Authors
-
-- **Easy distribution**: No PyPI packaging required
-- **Version control**: Use Git for environment versioning
-- **Rapid iteration**: Push updates instantly
-- **Documentation**: Hub README renders beautifully
-- **Community**: Reach LeRobot users directly
-
-### For Researchers
-
-- **Quick experiments**: Load any environment in one line
-- **Reproducibility**: Pin to specific commits
-- **Discovery**: Browse environments on the Hub
-- **No conflicts**: No need to install conflicting packages
-
-### For the Community
-
-- **Growing ecosystem**: More diverse simulation tasks
-- **Standardization**: Common `make_env` API
-- **Collaboration**: Fork and improve existing environments
-- **Accessibility**: Lower barrier to sharing research
-
-## Troubleshooting
-
-### "Refusing to execute remote code"
-
-You must explicitly pass `trust_remote_code=True`:
-
-```python
-env = make_env("user/repo", trust_remote_code=True)
-```
-
-### "Module X not found"
-
-The hub environment has dependencies you need to install:
-
-```bash
-# Check the repo's requirements.txt and install dependencies
-pip install gymnasium numpy
-```
-
-### "make_env not found in module"
-
-Your `env.py` must expose a `make_env` function:
-
-```python
-def make_env(n_envs: int, use_async_envs: bool):
-    # Your implementation
-    pass
-```
-
-### Environment returns wrong type
-
-The `make_env` function must return:
-
-- A `gym.vector.VectorEnv`, or
-- A single `gym.Env`, or
-- A dict `{suite_name: {task_id: VectorEnv}}`
-
-## Best Practices
-
-1. **Document your environment**: Include observation/action space descriptions, reward structure, and termination conditions in your README
-2. **Add requirements.txt**: List all dependencies with versions
-3. **Test thoroughly**: Verify your environment works locally before pushing
-4. **Use semantic versioning**: Tag releases with version numbers
-5. **Add examples**: Include usage examples in your README
-6. **Keep it simple**: Minimize dependencies when possible
-7. **License your work**: Add a LICENSE file to clarify usage terms
-
-## Future Directions
-
-The EnvHub ecosystem enables exciting possibilities:
-
-- **GPU-accelerated physics**: Share Isaac Gym or Brax environments
-- **Photorealistic rendering**: Distribute environments with advanced graphics
-- **Multi-agent scenarios**: Complex interaction tasks
-- **Real-world simulators**: Digital twins of physical setups
-- **Procedural generation**: Infinite task variations
-- **Domain randomization**: Pre-configured DR pipelines
-
-As more researchers and developers contribute, the diversity and quality of available environments will grow, benefiting the entire robotics learning community.
-
-## See Also
-
-- [Hugging Face Hub Documentation](https://huggingface.co/docs/hub/en/index)
-- [Gymnasium Documentation](https://gymnasium.farama.org/index.html)
-- [Example Hub Environment](https://huggingface.co/lerobot/cartpole-env)

docs/source/groot.mdx

@@ -40,7 +40,7 @@ python -c "import flash_attn; print(f'Flash Attention {flash_attn.__version__} i
 3. Install LeRobot by running:
 
 ```bash
-pip install lerobot[groot]
+pip install lerobot[groot] # consider also installing libero,dev and test tags
 ```
 
 ## Usage
@@ -83,9 +83,6 @@ accelerate launch \
 
 ### Libero Benchmark Results
 
-> [!NOTE]
-> Follow our instructions for Libero usage: [Libero](./libero)
-
 GR00T has demonstrated strong performance on the Libero benchmark suite. To compare and test its LeRobot implementation, we finetuned the GR00T N1.5 model for 30k steps on the Libero dataset and compared the results to the GR00T reference results.
 
 | Benchmark          | LeRobot Implementation | GR00T Reference |

docs/source/installation.mdx

@@ -82,7 +82,7 @@ For a full list of optional dependencies, see:
 https://pypi.org/project/lerobot/
 
 > [!NOTE]
-> For lerobot 0.4.0, if you want to install pi, you will have to do: `pip install "lerobot[pi]@git+https://github.com/huggingface/lerobot.git"`
+> For lerobot 0.4.0, if you want to install libero or pi, you will have to do: `pip install "lerobot[pi,libero]@git+https://github.com/huggingface/lerobot.git"`
 
 ### Troubleshooting
 

docs/source/openarms.mdx

@@ -0,0 +1,328 @@
+# OpenArms Robot
+
+OpenArms is a 7 DOF robotic arm with a gripper, designed by [Enactic, Inc.](https://www.enactic.com/) It uses Damiao motors controlled via CAN bus communication and MIT control mode for smooth, precise motion.
+
+## Hardware Overview
+
+- **7 DOF per arm** (14 DOF total for dual arm setup)
+- **1 gripper per arm** (2 grippers total)
+- **Damiao motors** with 4 different types:
+  - **DM8009** (DM-J8009P-2EC) for shoulders (J1, J2) - high torque
+  - **DM4340** for shoulder rotation and elbow (J3, J4)
+  - **DM4310** (DM-J4310-2EC V1.1) for wrist (J5, J6, J7) and gripper (J8)
+- **24V power supply** required
+- **CAN interface device**:
+  - **Linux**: Any SocketCAN-compatible adapter
+  - **macOS**: CANable, PEAK PCAN-USB, or Kvaser USBcan
+- Proper CAN wiring (CANH, CANL, 120Ω termination)
+
+
+## Motor Configuration
+
+Each arm has the following motor configuration based on the [OpenArm setup guide](https://docs.openarm.dev/software/setup/):
+
+| Joint | Motor | Motor Type | Sender CAN ID | Receiver ID | Description |
+|-------|-------|------------|---------------|-------------|-------------|
+| J1 | joint_1 | DM8009 | 0x01 | 0x11 | Shoulder pan |
+| J2 | joint_2 | DM8009 | 0x02 | 0x12 | Shoulder lift |
+| J3 | joint_3 | DM4340 | 0x03 | 0x13 | Shoulder rotation |
+| J4 | joint_4 | DM4340 | 0x04 | 0x14 | Elbow flex |
+| J5 | joint_5 | DM4310 | 0x05 | 0x15 | Wrist roll |
+| J6 | joint_6 | DM4310 | 0x06 | 0x16 | Wrist pitch |
+| J7 | joint_7 | DM4310 | 0x07 | 0x17 | Wrist rotation |
+| J8 | gripper | DM4310 | 0x08 | 0x18 | Gripper |
+
+For dual arm setups, the left arm uses IDs 0x09-0x10 for joints 1-8 with the same motor types.
+
+## Quick Start 
+
+```bash
+# Install system dependencies
+sudo apt install can-utils iproute2
+
+# Install LeRobot with OpenArms support
+pip install -e ".[openarms]"
+```
+
+## Setup Guide
+
+### Step 1: Motor ID Configuration
+
+**IMPORTANT**: Before using the robot, motors must be configured with the correct CAN IDs.
+
+Refer to the [OpenArm Motor ID Configuration Guide](https://docs.openarm.dev/software/setup/motor-id) for detailed instructions using the Damiao Debugging Tools on Windows.
+
+Key points:
+- Each motor needs a unique **Sender CAN ID** (0x01-0x08)
+- Each motor needs a unique **Receiver/Master ID** (0x11-0x18)
+- Use the Damiao Debugging Tools to set these IDs
+
+### Step 2: Setup CAN Interface
+
+Configure your CAN interface as described in the [OpenArm CAN Setup Guide](https://docs.openarm.dev/software/setup/can-setup):
+
+#### Linux (SocketCAN)
+
+```bash
+# Find your CAN interface
+ip link show
+
+# Configure can0, 1, 2, 3
+sudo ip link set can0 down
+sudo ip link set can0 type can bitrate 1000000
+sudo ip link set can0 up
+
+sudo ip link set can1 down
+sudo ip link set can1 type can bitrate 1000000
+sudo ip link set can1 up
+
+sudo ip link set can2 down
+sudo ip link set can2 type can bitrate 1000000
+sudo ip link set can2 up
+
+sudo ip link set can3 down
+sudo ip link set can3 type can bitrate 1000000
+sudo ip link set can3 up
+
+# Verify configuration
+ip link show can0
+```
+
+or run:
+
+`examples/openarms/setup_can.sh`
+
+### Testing canbus and motor connection
+
+Please run this script to check if all motors can be found and to find your can-fd speed: `python examples/openarms/debug_can_communication.py`
+
+## Usage
+
+### Basic Setup
+
+
+```python
+from lerobot.robots.openarms import OpenArmsFollower
+from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
+
+# Configure for dual arm setup
+config = OpenArmsFollowerConfig(
+    port="can0",
+    can_interface="socketcan",  # Or "auto" for auto-detection
+    id="openarms_dual",
+    is_dual_arm=True,
+)
+
+robot = OpenArmsFollower(config)
+robot.connect()
+```
+
+### Calibration
+
+On first use, you'll need to calibrate the robot:
+
+```python
+robot.calibrate()
+```
+
+The calibration process will:
+1. Disable torque on all motors
+2. Ask you to position arms in **hanging position with grippers closed**
+3. Set this as the zero position
+4. Ask you to move each joint through its full range
+5. Record min/max positions for each joint
+6. Save calibration to file
+
+### Reading Observations
+
+The robot provides comprehensive state information:
+
+```python
+observation = robot.get_observation()
+
+# Observation includes for each motor:
+# - {motor_name}.pos: Position in degrees
+# - {motor_name}.vel: Velocity in degrees/second  
+# - {motor_name}.torque: Motor torque
+# - {camera_name}: Camera images (if configured)
+
+print(f"Right arm joint 1 position: {observation['right_joint_1.pos']:.1f}°")
+print(f"Right arm joint 1 velocity: {observation['right_joint_1.vel']:.1f}°/s")
+print(f"Right arm joint 1 torque: {observation['right_joint_1.torque']:.3f} N·m")
+```
+
+### Sending Actions
+
+```python
+# Send target positions (in degrees)
+action = {
+    "right_joint_1.pos": 45.0,
+    "right_joint_2.pos": -30.0,
+    # ... all joints
+    "right_gripper.pos": 45.0,  # Half-closed
+}
+
+actual_action = robot.send_action(action)
+```
+
+### Gripper Control
+
+```python
+# Open gripper
+robot.open_gripper(arm="right")
+
+# Close gripper  
+robot.close_gripper(arm="right")
+```
+
+## Safety Features
+
+### 1. Maximum Relative Target
+
+Limits how far a joint can move in a single command to prevent sudden movements:
+
+```python
+config = OpenArmsFollowerConfig(
+    port="can0",
+    # Limit all joints to 10 degrees per command
+    max_relative_target=10.0,
+    
+    # Or set per-motor limits
+    max_relative_target={
+        "right_joint_1": 15.0,  # Slower moving joint
+        "right_joint_2": 10.0,
+        "right_gripper": 5.0,   # Very slow gripper
+    }
+)
+```
+
+**How it works**: If current position is 50° and you command 80°, with `max_relative_target=10.0`, the robot will only move to 60° in that step.
+
+### 2. Torque Limits
+
+Control maximum torque output, especially important for grippers and teleoperation:
+
+```python
+config = OpenArmsFollowerConfig(
+    port="can0",
+    # Gripper torque limit (fraction of motor's max torque)
+    gripper_torque_limit=0.5,  # 50% of max torque
+)
+```
+
+Lower torque limits prevent damage when gripping delicate objects.
+
+### 3. MIT Control Gains
+
+Control responsiveness and stability via PID-like gains:
+
+```python
+config = OpenArmsFollowerConfig(
+    port="can0",
+    position_kp=10.0,  # Position gain (higher = more responsive)
+    position_kd=0.5,   # Velocity damping (higher = more damped)
+)
+```
+
+**Guidelines**:
+- **For following (robot)**: Higher gains for responsiveness
+  - `position_kp=10.0`, `position_kd=0.5`
+- **For teleoperation (leader)**: Lower gains or disable torque for manual movement
+  - `manual_control=True` (torque disabled)
+
+### 4. Velocity Limits
+
+Velocity limits are enforced by the Damiao motors based on motor type. For DM4310:
+- Max velocity: 30 rad/s ≈ 1718°/s
+
+The motors will automatically limit velocity to safe values.
+
+## Teleoperation
+
+### Leader Arm Setup
+
+The leader arm is moved manually (torque disabled) to generate commands:
+
+```python
+from lerobot.teleoperators.openarms import OpenArmsLeader
+from lerobot.teleoperators.openarms.config_openarms_leader import OpenArmsLeaderConfig
+
+config = OpenArmsLeaderConfig(
+    port="can1",  # Separate CAN interface for leader
+    id="openarms_leader",
+    manual_control=True,  # Torque disabled for manual movement
+    is_dual_arm=True,
+)
+
+leader = OpenArmsLeader(config)
+leader.connect()
+
+# Read current position as action
+action = leader.get_action()
+# action contains positions for all joints in degrees
+```
+
+### Safety Considerations for Teleoperation
+
+1. **Use separate CAN interfaces** for leader and follower to avoid conflicts
+2. **Enable max_relative_target** on follower to smooth abrupt movements
+3. **Lower torque limits** on follower to prevent damage from tracking errors
+4. **Test with one arm** before enabling dual arm teleoperation
+5. **Have emergency stop** ready (power switch or CAN disable)
+
+```python
+# Recommended follower config for teleoperation
+follower_config = OpenArmsFollowerConfig(
+    port="can0",
+    max_relative_target=5.0,  # Small steps for smooth following
+    gripper_torque_limit=0.3, # Low torque for safety
+    position_kp=5.0,  # Lower gains for gentler following
+    position_kd=0.3,
+)
+```
+
+## Troubleshooting
+
+### Motor Shaking/Unstable
+
+- **Lower control gains**: Reduce `position_kp` and `position_kd`
+- **Check calibration**: Re-run calibration procedure
+- **Verify power**: Insufficient current can cause instability
+- **Check mechanical**: Loose connections, binding, or damaged components
+
+### CAN Bus Errors
+
+```bash
+# Check for errors
+ip -s link show can0
+
+# Reset CAN interface
+sudo ip link set can0 down
+sudo ip link set can0 up
+```
+
+### Control Mode
+
+OpenArms uses **MIT control mode** which allows simultaneous control of:
+- Position (degrees)
+- Velocity (degrees/second)
+- Torque (N·m)
+- Position gain (Kp)
+- Velocity damping (Kd)
+
+### Communication
+
+- **Protocol**: CAN 2.0 at 1 Mbps (or CAN-FD at 5 Mbps)
+- **Frame format**: Standard 11-bit IDs
+- **Update rate**: Typically 50-100 Hz depending on motor count
+- **Latency**: ~10-20ms per motor command
+
+## References
+
+- [OpenArm Official Documentation](https://docs.openarm.dev/)
+- [OpenArm Setup Guide](https://docs.openarm.dev/software/setup/)
+- [Motor ID Configuration](https://docs.openarm.dev/software/setup/motor-id)
+- [CAN Interface Setup](https://docs.openarm.dev/software/setup/can-setup)
+- [Motor Communication Test](https://docs.openarm.dev/software/setup/configure-test)
+- [Damiao Motor Documentation](https://wiki.seeedstudio.com/damiao_series/)
+- [Enactic GitHub](https://github.com/enactic/openarm_can)

docs/source/pi0.mdx

@@ -28,11 +28,6 @@ As described by Physical Intelligence, while AI has achieved remarkable success
    pip install -e ".[pi]"
    ```
 
-   > [!NOTE]
-   > For lerobot 0.4.0, if you want to install pi tag, you will have to do: `pip install "lerobot[pi]@git+https://github.com/huggingface/lerobot.git"`.
-   >
-   > This will be solved in the next patch release
-
 ## Training Data and Capabilities
 
 π₀ is trained on the largest robot interaction dataset to date, combining three key data sources:

docs/source/pi05.mdx

@@ -36,11 +36,6 @@ This diverse training mixture creates a "curriculum" that enables generalization
    pip install -e ".[pi]"
    ```
 
-   > [!NOTE]
-   > For lerobot 0.4.0, if you want to install pi tag, you will have to do: `pip install "lerobot[pi]@git+https://github.com/huggingface/lerobot.git"`.
-   >
-   > This will be solved in the next patch release
-
 ## Usage
 
 To use π₀.₅ in your LeRobot configuration, specify the policy type as:

examples/openarms/debug_can_communication.py

@@ -0,0 +1,416 @@
+#!/usr/bin/env python3
+"""
+Comprehensive debug script for OpenArms CAN FD communication.
+Tests all 4 CAN interfaces with CAN FD support.
+"""
+
+import can
+import time
+import sys
+import subprocess
+
+def check_can_interface(port):
+    """Check if CAN interface is UP and configured."""
+    try:
+        result = subprocess.run(['ip', 'link', 'show', port], 
+                              capture_output=True, text=True)
+        if result.returncode != 0:
+            return False, "Interface not found", None
+        
+        output = result.stdout
+        if 'UP' not in output:
+            return False, "Interface is DOWN", None
+        
+        # Check if CAN FD is enabled
+        is_fd = 'fd on' in output.lower() or 'canfd' in output.lower()
+        
+        return True, "Interface is UP", is_fd
+    except FileNotFoundError:
+        return None, "Cannot check (ip command not found)", None
+
+
+def test_motor_on_interface(bus, motor_id, timeout=2.0, use_fd=False):
+    """
+    Test a single motor and return all responses.
+    
+    Returns:
+        list of (arbitration_id, data) tuples for all responses received
+    """
+    # Send enable command
+    enable_msg = can.Message(
+        arbitration_id=motor_id,
+        data=[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC],
+        is_extended_id=False,
+        is_fd=use_fd
+    )
+    
+    try:
+        bus.send(enable_msg)
+    except Exception as e:
+        return None, f"Send error: {e}"
+    
+    # Listen for responses
+    responses = []
+    start_time = time.time()
+    
+    while time.time() - start_time < timeout:
+        msg = bus.recv(timeout=0.1)
+        if msg:
+            responses.append((msg.arbitration_id, msg.data, msg.is_fd if hasattr(msg, 'is_fd') else False))
+    
+    # Send disable command
+    disable_msg = can.Message(
+        arbitration_id=motor_id,
+        data=[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD],
+        is_extended_id=False,
+        is_fd=use_fd
+    )
+    try:
+        bus.send(disable_msg)
+    except:
+        pass
+    
+    return responses, None
+
+
+def test_interface(port, interface_type="socketcan", use_can_fd=True):
+    """Test all 8 motors on a single CAN interface."""
+    
+    results = {
+        'interface': port,
+        'status': None,
+        'is_fd': use_can_fd,
+        'motors': {}
+    }
+    
+    # Check interface status
+    status_ok, status_msg, interface_has_fd = check_can_interface(port)
+    
+    if interface_has_fd is not None:
+        results['interface_fd_enabled'] = interface_has_fd
+        if use_can_fd and not interface_has_fd:
+            status_msg += " (CAN FD NOT enabled on interface!)"
+        elif interface_has_fd:
+            status_msg += " (CAN FD enabled)"
+    
+    results['status'] = status_msg
+    
+    if status_ok is False:
+        return results
+    
+    # Try to connect
+    try:
+        if use_can_fd:
+            print(f"  Connecting to {port} with CAN FD (1 Mbps / 5 Mbps)...")
+            bus = can.interface.Bus(
+                channel=port,
+                interface=interface_type,
+                bitrate=1000000,
+                data_bitrate=5000000,
+                fd=True
+            )
+        else:
+            print(f"  Connecting to {port} with CAN 2.0 (1 Mbps)...")
+            bus = can.interface.Bus(
+                channel=port,
+                interface=interface_type,
+                bitrate=1000000
+            )
+    except Exception as e:
+        results['status'] = f"Connection failed: {e}"
+        return results
+    
+    try:
+        # Clear any pending messages
+        while bus.recv(timeout=0.01):
+            pass
+        
+        # Test each motor (0x01 to 0x08)
+        for motor_id in range(0x01, 0x09):
+            responses, error = test_motor_on_interface(bus, motor_id, timeout=1.0, use_fd=use_can_fd)
+            
+            if error:
+                results['motors'][motor_id] = {'error': error}
+            elif responses:
+                results['motors'][motor_id] = {
+                    'found': True,
+                    'responses': responses
+                }
+            else:
+                results['motors'][motor_id] = {
+                    'found': False,
+                    'responses': []
+                }
+            
+            time.sleep(0.05)  # Small delay between motors
+        
+    finally:
+        bus.shutdown()
+    
+    return results
+
+
+def print_results(all_results):
+    """Print formatted results for all interfaces."""
+    
+    print("SUMMARY - Motors Found on Each Interface")
+    
+    motor_names = {
+        0x01: "joint_1 (Shoulder pan)",
+        0x02: "joint_2 (Shoulder lift)",
+        0x03: "joint_3 (Shoulder rotation)",
+        0x04: "joint_4 (Elbow flex)",
+        0x05: "joint_5 (Wrist roll)",
+        0x06: "joint_6 (Wrist pitch)",
+        0x07: "joint_7 (Wrist rotation)",
+        0x08: "gripper",
+    }
+    
+    total_found = 0
+    
+    for result in all_results:
+        interface = result['interface']
+        status = result['status']
+        
+        print(f"{interface}: {status}")
+        if result.get('is_fd'):
+            print(f"  Mode: CAN FD")
+        else:
+            print(f"  Mode: CAN 2.0")
+        
+        if 'Connection failed' in status or 'DOWN' in status:
+            print(f"  ⚠ Cannot test {interface}")
+            continue
+        
+        motors_found = 0
+        
+        for motor_id in range(0x01, 0x09):
+            motor_data = result['motors'].get(motor_id, {})
+            motor_name = motor_names.get(motor_id, "Unknown")
+            
+            if motor_data.get('error'):
+                print(f"  Motor 0x{motor_id:02X} ({motor_name}): ✗ {motor_data['error']}")
+            elif motor_data.get('found'):
+                motors_found += 1
+                total_found += 1
+                responses = motor_data['responses']
+                print(f"  Motor 0x{motor_id:02X} ({motor_name}): ✓ FOUND")
+                
+                for resp_id, data, is_fd in responses:
+                    data_hex = data.hex()
+                    fd_flag = " [FD]" if is_fd else " [2.0]"
+                    print(f"    → Response from 0x{resp_id:02X}{fd_flag}: {data_hex}")
+            else:
+                print(f"  Motor 0x{motor_id:02X} ({motor_name}): ✗ No response")
+        
+        print(f"\n  Summary: {motors_found}/8 motors found on {interface}")
+    
+    # Overall summary
+    print("OVERALL SUMMARY")
+    print(f"Total motors found across all interfaces: {total_found}")
+    
+    # Analyze configuration
+    print("DIAGNOSIS")
+    
+    for result in all_results:
+        interface = result['interface']
+        motors_found = sum(1 for m in result['motors'].values() if m.get('found'))
+        
+        if motors_found == 0:
+            print(f"\n⚠ {interface}: NO MOTORS FOUND")
+            print("  Possible issues:")
+            print("    1. CAN FD mode mismatch (interface vs motor configuration)")
+            print("    2. Missing 120Ω termination resistors at BOTH cable ends")
+            print("    3. Motor timeout parameter set incorrectly (should NOT be 0)")
+            print("    4. CANH/CANL wiring issue")
+            print("    5. Cable too long (>40m for CAN FD at 5Mbps)")
+            
+            # Check FD mismatch
+            if result.get('is_fd') and not result.get('interface_fd_enabled'):
+                print("    ⚠️ CRITICAL: Trying CAN FD but interface NOT configured for FD!")
+                print(f"       Fix: sudo ip link set {interface} type can bitrate 1000000 dbitrate 5000000 fd on")
+                
+        elif motors_found < 8:
+            print(f"\n⚠ {interface}: Only {motors_found}/8 motors responding")
+            print("  Check power and connections for missing motors")
+        else:
+            print(f"\n✓ {interface}: All 8 motors responding correctly!")
+    
+    # Check for unexpected response IDs
+    print("RESPONSE ID ANALYSIS")
+    
+    for result in all_results:
+        interface = result['interface']
+        unexpected = []
+        
+        for motor_id, motor_data in result['motors'].items():
+            if motor_data.get('found'):
+                expected_id = motor_id + 0x10
+                actual_ids = [resp[0] for resp in motor_data['responses']]
+                
+                if expected_id not in actual_ids:
+                    unexpected.append((motor_id, actual_ids))
+        
+        if unexpected:
+            print(f"\n⚠ {interface}: Unexpected response IDs detected")
+            for motor_id, actual_ids in unexpected:
+                expected_id = motor_id + 0x10
+                print(f"  Motor 0x{motor_id:02X}: Expected 0x{expected_id:02X}, "
+                      f"got {[f'0x{id:02X}' for id in actual_ids]}")
+            print("  → Motor Master IDs need reconfiguration")
+        else:
+            motors_found = sum(1 for m in result['motors'].values() if m.get('found'))
+            if motors_found > 0:
+                print(f"\n✓ {interface}: All responding motors use correct IDs")
+
+
+def test_communication_speed(interface, motor_id, num_iterations=100):
+    """
+    Test communication speed with a motor.
+    
+    Returns:
+        tuple: (hz, avg_latency_ms) or (None, None) if test failed
+    """
+    try:
+        # Connect to interface
+        bus = can.interface.Bus(
+            channel=interface,
+            interface="socketcan",
+            bitrate=1000000,
+            data_bitrate=5000000,
+            fd=True
+        )
+        
+        # Send refresh commands and measure round-trip time
+        latencies = []
+        successful = 0
+        
+        for _ in range(num_iterations):
+            start = time.perf_counter()
+            
+            # Send enable command (lightweight operation)
+            enable_msg = can.Message(
+                arbitration_id=motor_id,
+                data=[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC],
+                is_extended_id=False,
+                is_fd=True
+            )
+            bus.send(enable_msg)
+            
+            # Wait for response
+            msg = bus.recv(timeout=0.1)
+            
+            if msg:
+                latency = (time.perf_counter() - start) * 1000  # Convert to ms
+                latencies.append(latency)
+                successful += 1
+        
+        bus.shutdown()
+        
+        if successful > 0:
+            avg_latency = sum(latencies) / len(latencies)
+            hz = 1000.0 / avg_latency if avg_latency > 0 else 0
+            return hz, avg_latency
+        
+        return None, None
+        
+    except Exception as e:
+        print(f"    Speed test error: {e}")
+        return None, None
+
+
+def main():
+    """Main function to test all CAN interfaces with CAN FD."""
+    
+    print("\nThis will test all 4 CAN interfaces (can0-can3) with CAN FD")
+    print("Testing motors 0x01-0x08 on each interface")
+    print()
+    print("Make sure:")
+    print("  ✓ Motors are powered (24V)")
+    print("  ✓ CAN interfaces configured with FD mode:")
+    print("    ./examples/openarms/setup_can.sh")
+    print("  ✓ Motor 'timeout' parameter NOT set to 0 (use Damiao tools)")
+    print("  ✓ CAN wiring includes 120Ω termination at BOTH ends")
+    print()
+    
+    input("Press ENTER to start testing...")
+    
+    # Test all 4 interfaces with CAN FD
+    all_results = []
+    
+    for i in range(4):
+        interface = f"can{i}"
+        print(f"Testing {interface}...")
+        
+        result = test_interface(interface, use_can_fd=True)
+        all_results.append(result)
+        
+        # Quick status
+        if 'Connection failed' in result['status'] or 'DOWN' in result['status']:
+            print(f"  ⚠ {interface}: {result['status']}")
+        else:
+            motors_found = sum(1 for m in result['motors'].values() if m.get('found'))
+            print(f"  {interface}: {motors_found}/8 motors found")
+        
+        time.sleep(0.2)
+    
+    # Print detailed results
+    print_results(all_results)
+    
+    print("Testing Complete!")
+    
+    all_found = sum(sum(1 for m in r['motors'].values() if m.get('found')) for r in all_results)
+    
+    if all_found == 0:
+        print("\n⚠️ CRITICAL: No motors found on any interface!")
+        print("\nTop issues to check:")
+        print("  1. Motor 'timeout' parameter (use Damiao tools to set > 0)")
+        print("  2. CAN FD not enabled (run ./examples/openarms/setup_can.sh)")
+        print("  3. Missing termination resistors")
+        print("\nTry:")
+        print("  a) Check motor parameters with Damiao Debugging Tools")
+        print("  b) Verify CAN FD is enabled: ip -d link show can0 | grep fd")
+        print("  c) Run setup script: ./examples/openarms/setup_can.sh")
+    else:
+        # Run speed test on interfaces with motors
+        print("COMMUNICATION SPEED TEST")
+        print("\nTesting maximum communication frequency...")
+        
+        for result in all_results:
+            interface = result['interface']
+            
+            # Find first responding motor
+            responding_motor = None
+            for motor_id, motor_data in result['motors'].items():
+                if motor_data.get('found'):
+                    responding_motor = motor_id
+                    break
+            
+            if responding_motor:
+                print(f"\n{interface}: Testing with motor 0x{responding_motor:02X}...")
+                hz, latency = test_communication_speed(interface, responding_motor, num_iterations=100)
+                
+                if hz:
+                    print(f"  ✓ Max frequency: {hz:.1f} Hz")
+                    print(f"  ✓ Avg latency: {latency:.2f} ms")
+                    print(f"  ✓ Commands per second: ~{int(hz)}")
+                else:
+                    print(f"  ✗ Speed test failed")
+            else:
+                print(f"\n{interface}: No motors found, skipping speed test")
+
+        print()
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n\nTesting interrupted by user.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\nUnexpected error: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+

examples/openarms/setup_can.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# Setup all OpenArms CAN interfaces with CAN FD
+
+set -e
+
+echo "=========================================="
+echo "OpenArms CAN FD Interface Setup"
+echo "=========================================="
+echo ""
+echo "Mode: CAN FD"
+echo "  - Nominal bitrate: 1 Mbps"
+echo "  - Data bitrate: 5 Mbps"
+echo ""
+echo "Configuring interfaces can0, can1, can2, can3..."
+echo ""
+
+# Configure each CAN interface with CAN FD
+for i in 0 1 2 3; do
+    interface="can$i"
+    
+    # Check if interface exists
+    if ! ip link show "$interface" &> /dev/null; then
+        echo "⚠ $interface: Not found, skipping"
+        continue
+    fi
+    
+    # Bring down interface
+    sudo ip link set "$interface" down 2>/dev/null
+    
+    # Configure CAN FD mode
+    sudo ip link set "$interface" type can \
+        bitrate 1000000 \
+        dbitrate 5000000 \
+        fd on
+    
+    # Bring up interface
+    sudo ip link set "$interface" up
+    
+    # Verify configuration
+    if ip link show "$interface" | grep -q "UP"; then
+        echo "✓ $interface: Configured and UP"
+    else
+        echo "✗ $interface: Failed to bring UP"
+    fi
+done
+
+echo ""
+echo "=========================================="
+echo "Verification"
+echo "=========================================="
+echo ""
+
+# Show detailed status for each interface
+for i in 0 1 2 3; do
+    interface="can$i"
+    if ip link show "$interface" &> /dev/null; then
+        echo "$interface:"
+        # Show key parameters
+        ip -d link show "$interface" | grep -E "can|state|bitrate|dbitrate" | head -3
+        echo ""
+    fi
+done
+
+echo "=========================================="
+echo "Setup Complete!"
+echo "=========================================="
+echo ""
+echo "All interfaces configured for CAN FD mode"
+echo ""
+echo "Next steps:"
+echo "  1. Test motors: python debug_can_communication.py"
+echo "  2. Run teleoperation: python examples/openarms/teleop.py"
+echo ""

examples/openarms/teleop.py

@@ -0,0 +1,148 @@
+"""
+OpenArms Teleoperation Example - Full Dual Arms
+
+This script demonstrates teleoperation of OpenArms follower robot using an OpenArms leader arm.
+It first calibrates both devices, then enters a teleoperation loop for both arms.
+"""
+
+import time
+
+from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
+from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
+from lerobot.teleoperators.openarms.openarms_leader import OpenArmsLeader
+from lerobot.teleoperators.openarms.config_openarms_leader import OpenArmsLeaderConfig
+
+
+follower_config = OpenArmsFollowerConfig(
+    port_left="can0",   # CAN interface for follower left arm
+    port_right="can1",  # CAN interface for follower right arm
+    can_interface="socketcan",  # Linux SocketCAN
+    id="openarms_follower",
+    disable_torque_on_disconnect=True,
+    max_relative_target=5.0,  # Safety limit
+)
+
+
+leader_config = OpenArmsLeaderConfig(
+    port_left="can2",   # CAN interface for leader left arm
+    port_right="can3",  # CAN interface for leader right arm
+    can_interface="socketcan",  # Linux SocketCAN
+    id="openarms_leader",
+    manual_control=True,  # Enable manual control (torque disabled)
+)
+
+print("=" * 60)
+print("OpenArms Teleoperation - Full Dual Arms")
+print("=" * 60)
+
+# Initialize devices
+print("\n[1/4] Initializing devices...")
+follower = OpenArmsFollower(follower_config)
+leader = OpenArmsLeader(leader_config)
+
+# Connect and calibrate follower
+print("\n[2/4] Connecting and calibrating follower robot...")
+print("Note: If you have existing calibration, just press ENTER to use it.")
+follower.connect(calibrate=True)
+
+# Connect and calibrate leader
+print("\n[3/4] Connecting and calibrating leader arm...")
+print("Note: The leader arm will have torque disabled for manual control.")
+leader.connect(calibrate=True)
+
+# Wait for user to be ready
+print("\n[4/4] Ready for teleoperation!")
+print("\nBoth arms will be controlled (16 motors total):")
+print("  RIGHT ARM: joints 1-7 + gripper")
+print("  LEFT ARM: joints 1-7 + gripper")
+
+print("\nPress ENTER to start teleoperation...")
+input()
+
+print("\nTeleoperation started! Move both leader arms.")
+print("Press Ctrl+C to stop.\n")
+
+# All joints for both arms (16 motors total)
+all_joints = [
+    # Right arm
+    "right_joint_1",
+    "right_joint_2",
+    "right_joint_3",
+    "right_joint_4",
+    "right_joint_5",
+    "right_joint_6",
+    "right_joint_7",
+    "right_gripper",
+    # Left arm
+    "left_joint_1",
+    "left_joint_2",
+    "left_joint_3",
+    "left_joint_4",
+    "left_joint_5",
+    "left_joint_6",
+    "left_joint_7",
+    "left_gripper",
+]
+
+# Performance monitoring
+loop_times = []
+start_time = time.perf_counter()
+last_print_time = start_time
+
+try:
+    while True:
+        loop_start = time.perf_counter()
+        
+        # Get action from leader
+        leader_action = leader.get_action()
+        
+        # Filter to only position data for all joints (both arms)
+        joint_action = {}
+        for joint in all_joints:
+            pos_key = f"{joint}.pos"
+            if pos_key in leader_action:
+                joint_action[pos_key] = leader_action[pos_key]
+        
+        # Send action to follower (both arms)
+        if joint_action:
+            follower.send_action(joint_action)
+        
+        # Measure loop time
+        loop_end = time.perf_counter()
+        loop_time = loop_end - loop_start
+        loop_times.append(loop_time)
+        
+        # Print stats every 2 seconds
+        if loop_end - last_print_time >= 2.0:
+            if loop_times:
+                avg_time = sum(loop_times) / len(loop_times)
+                current_hz = 1.0 / avg_time if avg_time > 0 else 0
+                min_time = min(loop_times)
+                max_time = max(loop_times)
+                max_hz = 1.0 / min_time if min_time > 0 else 0
+                min_hz = 1.0 / max_time if max_time > 0 else 0
+                
+                print(f"[Hz Stats] Avg: {current_hz:.1f} Hz | "
+                      f"Range: {min_hz:.1f}-{max_hz:.1f} Hz | "
+                      f"Avg loop time: {avg_time*1000:.1f} ms")
+                
+                # Reset for next measurement window
+                loop_times = []
+                last_print_time = loop_end
+            
+except KeyboardInterrupt:
+    print("\n\nStopping teleoperation...")
+finally:
+    # Disconnect devices
+    print("Disconnecting devices...")
+    try:
+        follower.disconnect()
+    except Exception as e:
+        print(f"Error disconnecting follower: {e}")
+    
+    try:
+        leader.disconnect()
+    except Exception as e:
+        print(f"Error disconnecting leader: {e}")
+    
+    print("Done!")

pyproject.toml

@@ -102,8 +102,10 @@ grpcio-dep = ["grpcio==1.73.1", "protobuf==6.31.0"] # TODO: Bumb dependency (com
 # Motors
 feetech = ["feetech-servo-sdk>=1.0.0,<2.0.0"]
 dynamixel = ["dynamixel-sdk>=3.7.31,<3.9.0"]
+damiao = ["python-can>=4.2.0,<5.0.0"]
 
 # Robots
+openarms = ["lerobot[damiao]"]
 gamepad = ["lerobot[pygame-dep]", "hidapi>=0.14.0,<0.15.0"]
 hopejr = ["lerobot[feetech]", "lerobot[pygame-dep]"]
 lekiwi = ["lerobot[feetech]", "pyzmq>=26.2.1,<28.0.0"]
@@ -142,12 +144,13 @@ video_benchmark = ["scikit-image>=0.23.2,<0.26.0", "pandas>=2.2.2,<2.4.0"]
 # Simulation
 aloha = ["gym-aloha>=0.1.2,<0.2.0"]
 pusht = ["gym-pusht>=0.1.5,<0.2.0", "pymunk>=6.6.0,<7.0.0"] # TODO: Fix pymunk version in gym-pusht instead
-libero = ["lerobot[transformers-dep]", "hf-libero>=0.1.3,<0.2.0"]
+libero = ["lerobot[transformers-dep]", "libero @ git+https://github.com/huggingface/lerobot-libero.git@main#egg=libero"]
 metaworld = ["metaworld==3.0.0"]
 
 # All
 all = [
     "lerobot[dynamixel]",
+    "lerobot[openarms]",
     "lerobot[gamepad]",
     "lerobot[hopejr]",
     "lerobot[lekiwi]",

src/lerobot/datasets/dataset_tools.py

@@ -39,7 +39,6 @@ from lerobot.datasets.aggregate import aggregate_datasets
 from lerobot.datasets.compute_stats import aggregate_stats
 from lerobot.datasets.lerobot_dataset import LeRobotDataset, LeRobotDatasetMetadata
 from lerobot.datasets.utils import (
-    DATA_DIR,
     DEFAULT_CHUNK_SIZE,
     DEFAULT_DATA_FILE_SIZE_IN_MB,
     DEFAULT_DATA_PATH,
@@ -963,23 +962,28 @@ def _copy_data_with_feature_changes(
     remove_features: list[str] | None = None,
 ) -> None:
     """Copy data while adding or removing features."""
-    data_dir = dataset.root / DATA_DIR
-    parquet_files = sorted(data_dir.glob("*/*.parquet"))
+    if dataset.meta.episodes is None:
+        dataset.meta.episodes = load_episodes(dataset.meta.root)
 
-    if not parquet_files:
-        raise ValueError(f"No parquet files found in {data_dir}")
+    # Map file paths to episode indices to extract chunk/file indices
+    file_to_episodes: dict[Path, set[int]] = {}
+    for ep_idx in range(dataset.meta.total_episodes):
+        file_path = dataset.meta.get_data_file_path(ep_idx)
+        if file_path not in file_to_episodes:
+            file_to_episodes[file_path] = set()
+        file_to_episodes[file_path].add(ep_idx)
 
     frame_idx = 0
 
-    for src_path in tqdm(parquet_files, desc="Processing data files"):
-        df = pd.read_parquet(src_path).reset_index(drop=True)
+    for src_path in tqdm(sorted(file_to_episodes.keys()), desc="Processing data files"):
+        df = pd.read_parquet(dataset.root / src_path).reset_index(drop=True)
 
-        relative_path = src_path.relative_to(dataset.root)
-        chunk_dir = relative_path.parts[1]
-        file_name = relative_path.parts[2]
-
-        chunk_idx = int(chunk_dir.split("-")[1])
-        file_idx = int(file_name.split("-")[1].split(".")[0])
+        # Get chunk_idx and file_idx from the source file's first episode
+        episodes_in_file = file_to_episodes[src_path]
+        first_ep_idx = min(episodes_in_file)
+        src_ep = dataset.meta.episodes[first_ep_idx]
+        chunk_idx = src_ep["data/chunk_index"]
+        file_idx = src_ep["data/file_index"]
 
         if remove_features:
             df = df.drop(columns=remove_features, errors="ignore")
@@ -1005,7 +1009,7 @@ def _copy_data_with_feature_changes(
                         df[feature_name] = feature_slice
             frame_idx = end_idx
 
-        # Write using the same chunk/file structure as source
+        # Write using the preserved chunk_idx and file_idx from source
         dst_path = new_meta.root / DEFAULT_DATA_PATH.format(chunk_index=chunk_idx, file_index=file_idx)
         dst_path.parent.mkdir(parents=True, exist_ok=True)
 

src/lerobot/datasets/lerobot_dataset.py

@@ -430,7 +430,9 @@ class LeRobotDatasetMetadata:
         video_keys = [video_key] if video_key is not None else self.video_keys
         for key in video_keys:
             if not self.features[key].get("info", None):
-                video_path = self.root / self.video_path.format(video_key=key, chunk_index=0, file_index=0)
+                video_path = self.root / self.video_path.format(
+                    video_key=video_key, chunk_index=0, file_index=0
+                )
                 self.info["features"][key]["info"] = get_video_info(video_path)
 
     def update_chunk_settings(
@@ -940,26 +942,11 @@ class LeRobotDataset(torch.utils.data.Dataset):
         return query_timestamps
 
     def _query_hf_dataset(self, query_indices: dict[str, list[int]]) -> dict:
-        """
-        Query dataset for indices across keys, skipping video keys.
-
-        Tries column-first [key][indices] for speed, falls back to row-first.
-
-        Args:
-            query_indices: Dict mapping keys to index lists to retrieve
-
-        Returns:
-            Dict with stacked tensors of queried data (video keys excluded)
-        """
-        result: dict = {}
-        for key, q_idx in query_indices.items():
-            if key in self.meta.video_keys:
-                continue
-            try:
-                result[key] = torch.stack(self.hf_dataset[key][q_idx])
-            except (KeyError, TypeError, IndexError):
-                result[key] = torch.stack(self.hf_dataset[q_idx][key])
-        return result
+        return {
+            key: torch.stack(self.hf_dataset[q_idx][key])
+            for key, q_idx in query_indices.items()
+            if key not in self.meta.video_keys
+        }
 
     def _query_videos(self, query_timestamps: dict[str, list[float]], ep_idx: int) -> dict[str, torch.Tensor]:
         """Note: When using data workers (e.g. DataLoader with num_workers>0), do not call this function

src/lerobot/envs/factory.py

@@ -19,7 +19,6 @@ import gymnasium as gym
 from gymnasium.envs.registration import registry as gym_registry
 
 from lerobot.envs.configs import AlohaEnv, EnvConfig, LiberoEnv, PushtEnv
-from lerobot.envs.utils import _call_make_env, _download_hub_file, _import_hub_module, _normalize_hub_result
 
 
 def make_env_config(env_type: str, **kwargs) -> EnvConfig:
@@ -34,24 +33,15 @@ def make_env_config(env_type: str, **kwargs) -> EnvConfig:
 
 
 def make_env(
-    cfg: EnvConfig | str,
-    n_envs: int = 1,
-    use_async_envs: bool = False,
-    hub_cache_dir: str | None = None,
-    trust_remote_code: bool = False,
+    cfg: EnvConfig, n_envs: int = 1, use_async_envs: bool = False
 ) -> dict[str, dict[int, gym.vector.VectorEnv]]:
-    """Makes a gym vector environment according to the config or Hub reference.
+    """Makes a gym vector environment according to the config.
 
     Args:
-        cfg (EnvConfig | str): Either an `EnvConfig` object describing the environment to build locally,
-            or a Hugging Face Hub repository identifier (e.g. `"username/repo"`). In the latter case,
-            the repo must include a Python file (usually `env.py`).
+        cfg (EnvConfig): the config of the environment to instantiate.
         n_envs (int, optional): The number of parallelized env to return. Defaults to 1.
         use_async_envs (bool, optional): Whether to return an AsyncVectorEnv or a SyncVectorEnv. Defaults to
             False.
-        hub_cache_dir (str | None): Optional cache path for downloaded hub files.
-        trust_remote_code (bool): **Explicit consent** to execute remote code from the Hub.
-            Default False — must be set to True to import/exec hub `env.py`.
 
     Raises:
         ValueError: if n_envs < 1
@@ -64,21 +54,6 @@ def make_env(
             - For single-task environments: a single suite entry (cfg.type) with task_id=0.
 
     """
-    # if user passed a hub id string (e.g., "username/repo", "username/repo@main:env.py")
-    # simplified: only support hub-provided `make_env`
-    if isinstance(cfg, str):
-        # _download_hub_file will raise the same RuntimeError if trust_remote_code is False
-        repo_id, file_path, local_file, revision = _download_hub_file(cfg, trust_remote_code, hub_cache_dir)
-
-        # import and surface clear import errors
-        module = _import_hub_module(local_file, repo_id)
-
-        # call the hub-provided make_env
-        raw_result = _call_make_env(module, n_envs=n_envs, use_async_envs=use_async_envs)
-
-        # normalize the return into {suite: {task_id: vec_env}}
-        return _normalize_hub_result(raw_result)
-
     if n_envs < 1:
         raise ValueError("`n_envs` must be at least 1")
 

src/lerobot/envs/utils.py

@@ -13,8 +13,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import importlib.util
-import os
 import warnings
 from collections.abc import Mapping, Sequence
 from functools import singledispatch
@@ -24,7 +22,6 @@ import einops
 import gymnasium as gym
 import numpy as np
 import torch
-from huggingface_hub import hf_hub_download, snapshot_download
 from torch import Tensor
 
 from lerobot.configs.types import FeatureType, PolicyFeature
@@ -198,132 +195,3 @@ def _(envs: Sequence) -> None:
 @close_envs.register
 def _(env: gym.Env) -> None:
     _close_single_env(env)
-
-
-# helper to safely load a python file as a module
-def _load_module_from_path(path: str, module_name: str | None = None):
-    module_name = module_name or f"hub_env_{os.path.basename(path).replace('.', '_')}"
-    spec = importlib.util.spec_from_file_location(module_name, path)
-    if spec is None:
-        raise ImportError(f"Could not load module spec for {module_name} from {path}")
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)  # type: ignore
-    return module
-
-
-# helper to parse hub string (supports "user/repo", "user/repo@rev", optional path)
-# examples:
-#   "user/repo" -> will look for env.py at repo root
-#   "user/repo@main:envs/my_env.py" -> explicit revision and path
-def _parse_hub_url(hub_uri: str):
-    # very small parser: [repo_id][@revision][:path]
-    # repo_id is required (user/repo or org/repo)
-    revision = None
-    file_path = "env.py"
-    if "@" in hub_uri:
-        repo_and_rev, *rest = hub_uri.split(":", 1)
-        repo_id, rev = repo_and_rev.split("@", 1)
-        revision = rev
-        if rest:
-            file_path = rest[0]
-    else:
-        repo_id, *rest = hub_uri.split(":", 1)
-        if rest:
-            file_path = rest[0]
-    return repo_id, revision, file_path
-
-
-def _download_hub_file(
-    cfg_str: str,
-    trust_remote_code: bool,
-    hub_cache_dir: str | None,
-) -> tuple[str, str, str, str]:
-    """
-    Parse `cfg_str` (hub URL), enforce `trust_remote_code`, and return
-    (repo_id, file_path, local_file, revision).
-    """
-    if not trust_remote_code:
-        raise RuntimeError(
-            f"Refusing to execute remote code from the Hub for '{cfg_str}'. "
-            "Executing hub env modules runs arbitrary Python code from third-party repositories. "
-            "If you trust this repo and understand the risks, call `make_env(..., trust_remote_code=True)` "
-            "and prefer pinning to a specific revision: 'user/repo@<commit-hash>:env.py'."
-        )
-
-    repo_id, revision, file_path = _parse_hub_url(cfg_str)
-
-    try:
-        local_file = hf_hub_download(
-            repo_id=repo_id, filename=file_path, revision=revision, cache_dir=hub_cache_dir
-        )
-    except Exception as e:
-        # fallback to snapshot download
-        snapshot_dir = snapshot_download(repo_id=repo_id, revision=revision, cache_dir=hub_cache_dir)
-        local_file = os.path.join(snapshot_dir, file_path)
-        if not os.path.exists(local_file):
-            raise FileNotFoundError(
-                f"Could not find {file_path} in repository {repo_id}@{revision or 'main'}"
-            ) from e
-
-    return repo_id, file_path, local_file, revision
-
-
-def _import_hub_module(local_file: str, repo_id: str) -> Any:
-    """
-    Import the downloaded file as a module and surface helpful import error messages.
-    """
-    module_name = f"hub_env_{repo_id.replace('/', '_')}"
-    try:
-        module = _load_module_from_path(local_file, module_name=module_name)
-    except ModuleNotFoundError as e:
-        missing = getattr(e, "name", None) or str(e)
-        raise ModuleNotFoundError(
-            f"Hub env '{repo_id}:{os.path.basename(local_file)}' failed to import because the dependency "
-            f"'{missing}' is not installed locally.\n\n"
-        ) from e
-    except ImportError as e:
-        raise ImportError(
-            f"Failed to load hub env module '{repo_id}:{os.path.basename(local_file)}'. Import error: {e}\n\n"
-        ) from e
-    return module
-
-
-def _call_make_env(module: Any, n_envs: int, use_async_envs: bool) -> Any:
-    """
-    Ensure module exposes make_env and call it.
-    """
-    if not hasattr(module, "make_env"):
-        raise AttributeError(
-            f"The hub module {getattr(module, '__name__', 'hub_module')} must expose `make_env(n_envs=int, use_async_envs=bool)`."
-        )
-    entry_fn = module.make_env
-    return entry_fn(n_envs=n_envs, use_async_envs=use_async_envs)
-
-
-def _normalize_hub_result(result: Any) -> dict[str, dict[int, gym.vector.VectorEnv]]:
-    """
-    Normalize possible return types from hub `make_env` into the mapping:
-      { suite_name: { task_id: vector_env } }
-    Accepts:
-      - dict (assumed already correct)
-      - gym.vector.VectorEnv
-      - gym.Env (will be wrapped into SyncVectorEnv)
-    """
-    if isinstance(result, dict):
-        return result
-
-    # VectorEnv: use its spec.id if available
-    if isinstance(result, gym.vector.VectorEnv):
-        suite_name = getattr(result, "spec", None) and getattr(result.spec, "id", None) or "hub_env"
-        return {suite_name: {0: result}}
-
-    # Single Env: wrap into SyncVectorEnv
-    if isinstance(result, gym.Env):
-        vec = gym.vector.SyncVectorEnv([lambda: result])
-        suite_name = getattr(result, "spec", None) and getattr(result.spec, "id", None) or "hub_env"
-        return {suite_name: {0: vec}}
-
-    raise ValueError(
-        "Hub `make_env` must return either a mapping {suite: {task_id: vec_env}}, "
-        "a gym.vector.VectorEnv, or a single gym.Env."
-    )

src/lerobot/motors/__init__.py

@@ -14,4 +14,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .motors_bus import Motor, MotorCalibration, MotorNormMode, MotorsBus
+from .motors_bus import (
+    Motor,
+    MotorCalibration,
+    MotorNormMode,
+    MotorsBus,  # Backward compatibility (alias for SerialMotorsBus)
+    MotorsBusBase,
+    SerialMotorsBus,
+)

src/lerobot/motors/damiao/__init__.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .damiao import DamiaoMotorsBus
+from .tables import *

src/lerobot/motors/damiao/damiao.py

@@ -0,0 +1,787 @@
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# TODO(pepijn): add license of: https://github.com/cmjang/DM_Control_Python?tab=MIT-1-ov-file#readme
+
+import logging
+import time
+from contextlib import contextmanager
+from copy import deepcopy
+from functools import cached_property
+from typing import Dict, List, Optional, Tuple, Union
+
+import can
+import numpy as np
+
+from lerobot.motors import Motor, MotorCalibration, MotorNormMode, MotorsBusBase
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
+from lerobot.utils.utils import enter_pressed, move_cursor_up
+
+from .tables import (
+    AVAILABLE_BAUDRATES,
+    CAN_CMD_DISABLE,
+    CAN_CMD_ENABLE,
+    CAN_CMD_REFRESH,
+    CAN_CMD_SET_ZERO,
+    CAN_PARAM_ID,
+    DEFAULT_BAUDRATE,
+    DEFAULT_TIMEOUT_MS,
+    MODEL_RESOLUTION,
+    MOTOR_LIMIT_PARAMS,
+    NORMALIZED_DATA,
+    MotorType,
+)
+
+logger = logging.getLogger(__name__)
+
+NameOrID = Union[str, int]
+Value = Union[int, float]
+
+
+class DamiaoMotorsBus(MotorsBusBase):
+    """
+    The Damiao implementation for a MotorsBus using CAN bus communication.
+    
+    This class uses python-can for CAN bus communication with Damiao motors.
+    For more info, see:
+    - python-can documentation: https://python-can.readthedocs.io/en/stable/
+    - Seedstudio documentation: https://wiki.seeedstudio.com/damiao_series/
+    - DM_Control_Python repo: https://github.com/cmjang/DM_Control_Python
+    """
+
+    # CAN-specific settings
+    available_baudrates = deepcopy(AVAILABLE_BAUDRATES)
+    default_baudrate = DEFAULT_BAUDRATE
+    default_timeout = DEFAULT_TIMEOUT_MS
+    
+    # Motor configuration
+    model_resolution_table = deepcopy(MODEL_RESOLUTION)
+    normalized_data = deepcopy(NORMALIZED_DATA)
+
+    def __init__(
+        self,
+        port: str,
+        motors: dict[str, Motor],
+        calibration: dict[str, MotorCalibration] | None = None,
+        can_interface: str = "auto",
+        use_can_fd: bool = True,
+        bitrate: int = 1000000,
+        data_bitrate: int | None = 5000000,
+    ):
+        """
+        Initialize the Damiao motors bus.
+
+        Args:
+            port: CAN interface name (e.g., "can0" for Linux, "/dev/cu.usbmodem*" for macOS)
+            motors: Dictionary mapping motor names to Motor objects
+            calibration: Optional calibration data
+            can_interface: CAN interface type - "auto" (default), "socketcan" (Linux), or "slcan" (macOS/serial)
+            use_can_fd: Whether to use CAN FD mode (default: True for OpenArms)
+            bitrate: Nominal bitrate in bps (default: 1000000 = 1 Mbps)
+            data_bitrate: Data bitrate for CAN FD in bps (default: 5000000 = 5 Mbps), ignored if use_can_fd is False
+        """
+        super().__init__(port, motors, calibration)
+        self.port = port
+        self.can_interface = can_interface
+        self.use_can_fd = use_can_fd
+        self.bitrate = bitrate
+        self.data_bitrate = data_bitrate
+        self.canbus = None
+        self._is_connected = False
+        
+        # Map motor names to CAN IDs
+        self._motor_can_ids = {}
+        self._recv_id_to_motor = {}
+        
+        # Store motor types and recv IDs
+        self._motor_types = {}
+        for name, motor in self.motors.items():
+            if hasattr(motor, "motor_type"):
+                self._motor_types[name] = motor.motor_type
+            else:
+                # Default to DM4310 if not specified
+                self._motor_types[name] = MotorType.DM4310
+            
+            # Map recv_id to motor name for filtering responses
+            if hasattr(motor, "recv_id"):
+                self._recv_id_to_motor[motor.recv_id] = name
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if the CAN bus is connected."""
+        return self._is_connected and self.canbus is not None
+
+    def connect(self, handshake: bool = True) -> None:
+        """
+        Open the CAN bus and initialize communication.
+
+        Args:
+            handshake: If True, ping all motors to verify they're present
+        """
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(
+                f"{self.__class__.__name__}('{self.port}') is already connected."
+            )
+
+        try:
+            # Auto-detect interface type based on port name
+            if self.can_interface == "auto":
+                if self.port.startswith("/dev/"):
+                    # Serial device (macOS/Windows)
+                    self.can_interface = "slcan"
+                    logger.info(f"Auto-detected slcan interface for port {self.port}")
+                else:
+                    # Network interface (Linux)
+                    self.can_interface = "socketcan"
+                    logger.info(f"Auto-detected socketcan interface for port {self.port}")
+            
+            # Connect to CAN bus
+            if self.can_interface == "socketcan":
+                # Linux SocketCAN with CAN FD support
+                if self.use_can_fd and self.data_bitrate is not None:
+                    self.canbus = can.interface.Bus(
+                        channel=self.port,
+                        interface="socketcan",
+                        bitrate=self.bitrate,
+                        data_bitrate=self.data_bitrate,
+                        fd=True
+                    )
+                    logger.info(f"Connected to {self.port} with CAN FD (bitrate={self.bitrate}, data_bitrate={self.data_bitrate})")
+                else:
+                    self.canbus = can.interface.Bus(
+                        channel=self.port,
+                        interface="socketcan",
+                        bitrate=self.bitrate
+                    )
+                    logger.info(f"Connected to {self.port} with CAN 2.0 (bitrate={self.bitrate})")
+            elif self.can_interface == "slcan":
+                # Serial Line CAN (macOS, Windows, or USB adapters)
+                # Note: SLCAN typically doesn't support CAN FD
+                self.canbus = can.interface.Bus(
+                    channel=self.port,
+                    interface="slcan",
+                    bitrate=self.bitrate
+                )
+                logger.info(f"Connected to {self.port} with SLCAN (bitrate={self.bitrate})")
+            else:
+                # Generic interface (vector, pcan, etc.)
+                if self.use_can_fd and self.data_bitrate is not None:
+                    self.canbus = can.interface.Bus(
+                        channel=self.port,
+                        interface=self.can_interface,
+                        bitrate=self.bitrate,
+                        data_bitrate=self.data_bitrate,
+                        fd=True
+                    )
+                else:
+                    self.canbus = can.interface.Bus(
+                        channel=self.port,
+                        interface=self.can_interface,
+                        bitrate=self.bitrate
+                    )
+            
+            self._is_connected = True
+            
+            if handshake:
+                self._handshake()
+                
+            logger.debug(f"{self.__class__.__name__} connected via {self.can_interface}.")
+        except Exception as e:
+            self._is_connected = False
+            raise ConnectionError(f"Failed to connect to CAN bus: {e}")
+
+    def _handshake(self) -> None:
+        """Verify all motors are present by refreshing their status."""
+        for motor_name in self.motors:
+            self._refresh_motor(motor_name)
+            time.sleep(0.01)  # Small delay between motors
+
+    def disconnect(self, disable_torque: bool = True) -> None:
+        """
+        Close the CAN bus connection.
+
+        Args:
+            disable_torque: If True, disable torque on all motors before disconnecting
+        """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(
+                f"{self.__class__.__name__}('{self.port}') is not connected."
+            )
+
+        if disable_torque:
+            try:
+                self.disable_torque()
+            except Exception as e:
+                logger.warning(f"Failed to disable torque during disconnect: {e}")
+
+        if self.canbus:
+            self.canbus.shutdown()
+            self.canbus = None
+        self._is_connected = False
+        logger.debug(f"{self.__class__.__name__} disconnected.")
+
+    def configure_motors(self) -> None:
+        """Configure all motors with default settings."""
+        # Damiao motors don't require much configuration in MIT mode
+        # Just ensure they're enabled
+        for motor in self.motors:
+            self._enable_motor(motor)
+            time.sleep(0.01)
+
+    def _enable_motor(self, motor: NameOrID) -> None:
+        """Enable a single motor."""
+        motor_id = self._get_motor_id(motor)
+        recv_id = self._get_motor_recv_id(motor)
+        data = [0xFF] * 7 + [CAN_CMD_ENABLE]
+        msg = can.Message(arbitration_id=motor_id, data=data, is_extended_id=False)
+        self.canbus.send(msg)
+        self._recv_motor_response(expected_recv_id=recv_id)
+
+    def _disable_motor(self, motor: NameOrID) -> None:
+        """Disable a single motor."""
+        motor_id = self._get_motor_id(motor)
+        recv_id = self._get_motor_recv_id(motor)
+        data = [0xFF] * 7 + [CAN_CMD_DISABLE]
+        msg = can.Message(arbitration_id=motor_id, data=data, is_extended_id=False)
+        self.canbus.send(msg)
+        self._recv_motor_response(expected_recv_id=recv_id)
+
+    def enable_torque(self, motors: str | list[str] | None = None, num_retry: int = 0) -> None:
+        """Enable torque on selected motors."""
+        motors = self._get_motors_list(motors)
+        for motor in motors:
+            for _ in range(num_retry + 1):
+                try:
+                    self._enable_motor(motor)
+                    break
+                except Exception as e:
+                    if _ == num_retry:
+                        raise e
+                    time.sleep(0.01)
+
+    def disable_torque(self, motors: str | list[str] | None = None, num_retry: int = 0) -> None:
+        """Disable torque on selected motors."""
+        motors = self._get_motors_list(motors)
+        for motor in motors:
+            for _ in range(num_retry + 1):
+                try:
+                    self._disable_motor(motor)
+                    break
+                except Exception as e:
+                    if _ == num_retry:
+                        raise e
+                    time.sleep(0.01)
+
+    @contextmanager
+    def torque_disabled(self, motors: str | list[str] | None = None):
+        """
+        Context manager that guarantees torque is re-enabled.
+        
+        This helper is useful to temporarily disable torque when configuring motors.
+        
+        Examples:
+            >>> with bus.torque_disabled():
+            ...     # Safe operations here with torque disabled
+            ...     pass
+        """
+        self.disable_torque(motors)
+        try:
+            yield
+        finally:
+            self.enable_torque(motors)
+
+    def set_zero_position(self, motors: str | list[str] | None = None) -> None:
+        """Set current position as zero for selected motors."""
+        motors = self._get_motors_list(motors)
+        for motor in motors:
+            motor_id = self._get_motor_id(motor)
+            recv_id = self._get_motor_recv_id(motor)
+            data = [0xFF] * 7 + [CAN_CMD_SET_ZERO]
+            msg = can.Message(arbitration_id=motor_id, data=data, is_extended_id=False)
+            self.canbus.send(msg)
+            self._recv_motor_response(expected_recv_id=recv_id)
+            time.sleep(0.01)
+
+    def _refresh_motor(self, motor: NameOrID) -> Optional[can.Message]:
+        """Refresh motor status and return the response."""
+        motor_id = self._get_motor_id(motor)
+        recv_id = self._get_motor_recv_id(motor)
+        data = [motor_id & 0xFF, (motor_id >> 8) & 0xFF, CAN_CMD_REFRESH, 0, 0, 0, 0, 0]
+        msg = can.Message(arbitration_id=CAN_PARAM_ID, data=data, is_extended_id=False)
+        self.canbus.send(msg)
+        return self._recv_motor_response(expected_recv_id=recv_id)
+
+    def _recv_motor_response(self, expected_recv_id: Optional[int] = None, timeout: float = 0.001) -> Optional[can.Message]:
+        """
+        Receive a response from a motor.
+        
+        Args:
+            expected_recv_id: If provided, only return messages from this CAN ID
+            timeout: Timeout in seconds (default: 1ms for high-speed operation)
+        
+        Returns:
+            CAN message if received, None otherwise
+        """
+        try:
+            start_time = time.time()
+            messages_seen = []
+            while time.time() - start_time < timeout:
+                msg = self.canbus.recv(timeout=0.0001)  # 100us timeout for fast polling
+                if msg:
+                    messages_seen.append(f"0x{msg.arbitration_id:02X}")
+                    # If no filter specified, return any message
+                    if expected_recv_id is None:
+                        return msg
+                    # Otherwise, only return if it matches the expected recv_id
+                    if msg.arbitration_id == expected_recv_id:
+                        return msg
+                    else:
+                        logger.debug(f"Ignoring message from CAN ID 0x{msg.arbitration_id:02X}, expected 0x{expected_recv_id:02X}")
+            
+            # Only log warnings if we're in debug mode to reduce overhead
+            if logger.isEnabledFor(logging.DEBUG):
+                if messages_seen:
+                    logger.debug(f"Received {len(messages_seen)} message(s) from IDs {set(messages_seen)}, but expected 0x{expected_recv_id:02X}")
+                else:
+                    logger.debug(f"No CAN messages received (expected from 0x{expected_recv_id:02X})")
+        except Exception as e:
+            logger.debug(f"Failed to receive CAN message: {e}")
+        return None
+    
+    def _recv_all_responses(self, expected_recv_ids: list[int], timeout: float = 0.002) -> dict[int, can.Message]:
+        """
+        Efficiently receive responses from multiple motors at once.
+        Uses the OpenArms pattern: collect all available messages within timeout.
+        
+        Args:
+            expected_recv_ids: List of CAN IDs we expect responses from
+            timeout: Total timeout in seconds (default: 2ms)
+        
+        Returns:
+            Dictionary mapping recv_id to CAN message
+        """
+        responses = {}
+        expected_set = set(expected_recv_ids)
+        start_time = time.time()
+        
+        try:
+            while len(responses) < len(expected_recv_ids) and (time.time() - start_time) < timeout:
+                msg = self.canbus.recv(timeout=0.0001)  # 100us poll timeout
+                if msg and msg.arbitration_id in expected_set:
+                    responses[msg.arbitration_id] = msg
+                    if len(responses) == len(expected_recv_ids):
+                        break  # Got all responses, exit early
+        except Exception as e:
+            logger.debug(f"Error receiving responses: {e}")
+        
+        return responses
+
+    def _mit_control(
+        self,
+        motor: NameOrID,
+        kp: float,
+        kd: float,
+        position_degrees: float,
+        velocity_deg_per_sec: float,
+        torque: float,
+    ) -> None:
+        """
+        Send MIT control command to a motor.
+
+        Args:
+            motor: Motor name or ID
+            kp: Position gain
+            kd: Velocity gain
+            position_degrees: Target position (degrees)
+            velocity_deg_per_sec: Target velocity (degrees/s)
+            torque: Target torque (N·m)
+        """
+        motor_id = self._get_motor_id(motor)
+        motor_name = self._get_motor_name(motor)
+        motor_type = self._motor_types.get(motor_name, MotorType.DM4310)
+        
+        # Convert degrees to radians for motor control
+        position_rad = np.radians(position_degrees)
+        velocity_rad_per_sec = np.radians(velocity_deg_per_sec)
+        
+        # Get motor limits
+        pmax, vmax, tmax = MOTOR_LIMIT_PARAMS[motor_type]
+        
+        # Encode parameters
+        kp_uint = self._float_to_uint(kp, 0, 500, 12)
+        kd_uint = self._float_to_uint(kd, 0, 5, 12)
+        q_uint = self._float_to_uint(position_rad, -pmax, pmax, 16)
+        dq_uint = self._float_to_uint(velocity_rad_per_sec, -vmax, vmax, 12)
+        tau_uint = self._float_to_uint(torque, -tmax, tmax, 12)
+        
+        # Pack data
+        data = [0] * 8
+        data[0] = (q_uint >> 8) & 0xFF
+        data[1] = q_uint & 0xFF
+        data[2] = dq_uint >> 4
+        data[3] = ((dq_uint & 0xF) << 4) | ((kp_uint >> 8) & 0xF)
+        data[4] = kp_uint & 0xFF
+        data[5] = kd_uint >> 4
+        data[6] = ((kd_uint & 0xF) << 4) | ((tau_uint >> 8) & 0xF)
+        data[7] = tau_uint & 0xFF
+        
+        msg = can.Message(arbitration_id=motor_id, data=data, is_extended_id=False)
+        self.canbus.send(msg)
+        recv_id = self._get_motor_recv_id(motor)
+        self._recv_motor_response(expected_recv_id=recv_id)
+
+    def _float_to_uint(self, x: float, x_min: float, x_max: float, bits: int) -> int:
+        """Convert float to unsigned integer for CAN transmission."""
+        x = max(x_min, min(x_max, x))  # Clamp to range
+        span = x_max - x_min
+        data_norm = (x - x_min) / span
+        return int(data_norm * ((1 << bits) - 1))
+
+    def _uint_to_float(self, x: int, x_min: float, x_max: float, bits: int) -> float:
+        """Convert unsigned integer from CAN to float."""
+        span = x_max - x_min
+        data_norm = float(x) / ((1 << bits) - 1)
+        return data_norm * span + x_min
+
+    def _decode_motor_state(self, data: bytes, motor_type: MotorType) -> Tuple[float, float, float, int, int]:
+        """
+        Decode motor state from CAN data.
+
+        Returns:
+            Tuple of (position_degrees, velocity_deg_per_sec, torque, temp_mos, temp_rotor)
+        """
+        if len(data) < 8:
+            raise ValueError("Invalid motor state data")
+        
+        # Extract encoded values
+        q_uint = (data[1] << 8) | data[2]
+        dq_uint = (data[3] << 4) | (data[4] >> 4)
+        tau_uint = ((data[4] & 0x0F) << 8) | data[5]
+        t_mos = data[6]
+        t_rotor = data[7]
+        
+        # Get motor limits
+        pmax, vmax, tmax = MOTOR_LIMIT_PARAMS[motor_type]
+        
+        # Decode to physical values (radians)
+        position_rad = self._uint_to_float(q_uint, -pmax, pmax, 16)
+        velocity_rad_per_sec = self._uint_to_float(dq_uint, -vmax, vmax, 12)
+        torque = self._uint_to_float(tau_uint, -tmax, tmax, 12)
+        
+        # Convert to degrees
+        position_degrees = np.degrees(position_rad)
+        velocity_deg_per_sec = np.degrees(velocity_rad_per_sec)
+        
+        return position_degrees, velocity_deg_per_sec, torque, t_mos, t_rotor
+
+    def read(
+        self,
+        data_name: str,
+        motor: str,
+        *,
+        normalize: bool = True,
+        num_retry: int = 0,
+    ) -> Value:
+        """Read a value from a single motor. Positions are always in degrees."""
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+        
+        # Refresh motor to get latest state
+        msg = self._refresh_motor(motor)
+        if msg is None:
+            motor_id = self._get_motor_id(motor)
+            recv_id = self._get_motor_recv_id(motor)
+            raise ConnectionError(
+                f"No response from motor '{motor}' (send ID: 0x{motor_id:02X}, recv ID: 0x{recv_id:02X}). "
+                f"Check that: 1) Motor is powered (24V), 2) CAN wiring is correct, "
+                f"3) Motor IDs are configured correctly using Damiao Debugging Tools"
+            )
+        
+        motor_type = self._motor_types.get(motor, MotorType.DM4310)
+        position_degrees, velocity_deg_per_sec, torque, t_mos, t_rotor = self._decode_motor_state(msg.data, motor_type)
+        
+        # Return requested data (already in degrees for position/velocity)
+        if data_name == "Present_Position":
+            value = position_degrees
+        elif data_name == "Present_Velocity":
+            value = velocity_deg_per_sec
+        elif data_name == "Present_Torque":
+            value = torque
+        elif data_name == "Temperature_MOS":
+            value = t_mos
+        elif data_name == "Temperature_Rotor":
+            value = t_rotor
+        else:
+            raise ValueError(f"Unknown data_name: {data_name}")
+        
+        # For Damiao, positions are always in degrees, no normalization needed
+        # We keep the normalize parameter for compatibility but don't use it
+        return value
+
+    def write(
+        self,
+        data_name: str,
+        motor: str,
+        value: Value,
+        *,
+        normalize: bool = True,
+        num_retry: int = 0,
+    ) -> None:
+        """Write a value to a single motor. Positions are always in degrees."""
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+        
+        # Value is expected to be in degrees for positions
+        if data_name == "Goal_Position":
+            # Use MIT control with position in degrees
+            self._mit_control(motor, 10.0, 0.5, value, 0, 0)
+        else:
+            raise ValueError(f"Writing {data_name} not supported in MIT mode")
+
+    def sync_read(
+        self,
+        data_name: str,
+        motors: str | list[str] | None = None,
+        *,
+        normalize: bool = True,
+        num_retry: int = 0,
+    ) -> Dict[str, Value]:
+        """
+        Read the same value from multiple motors simultaneously.
+        Uses batched operations: sends all refresh commands, then collects all responses.
+        This is MUCH faster than sequential reads (OpenArms pattern).
+        """
+        motors = self._get_motors_list(motors)
+        result = {}
+
+        # Step 1: Send refresh commands to ALL motors first (no waiting)
+        for motor in motors:
+            motor_id = self._get_motor_id(motor)
+            data = [motor_id & 0xFF, (motor_id >> 8) & 0xFF, CAN_CMD_REFRESH, 0, 0, 0, 0, 0]
+            msg = can.Message(arbitration_id=CAN_PARAM_ID, data=data, is_extended_id=False)
+            self.canbus.send(msg)
+        
+        # Step 2: Collect all responses at once (batch receive)
+        expected_recv_ids = [self._get_motor_recv_id(motor) for motor in motors]
+        responses = self._recv_all_responses(expected_recv_ids, timeout=0.003)  # 3ms total timeout
+        
+        # Step 3: Parse responses
+        for motor in motors:
+            try:
+                recv_id = self._get_motor_recv_id(motor)
+                msg = responses.get(recv_id)
+                
+                if msg is None:
+                    logger.warning(f"No response from motor '{motor}' (recv ID: 0x{recv_id:02X})")
+                    result[motor] = 0.0
+                    continue
+                
+                motor_type = self._motor_types.get(motor, MotorType.DM4310)
+                position_degrees, velocity_deg_per_sec, torque, t_mos, t_rotor = self._decode_motor_state(msg.data, motor_type)
+                
+                # Return requested data
+                if data_name == "Present_Position":
+                    value = position_degrees
+                elif data_name == "Present_Velocity":
+                    value = velocity_deg_per_sec
+                elif data_name == "Present_Torque":
+                    value = torque
+                elif data_name == "Temperature_MOS":
+                    value = t_mos
+                elif data_name == "Temperature_Rotor":
+                    value = t_rotor
+                else:
+                    raise ValueError(f"Unknown data_name: {data_name}")
+                
+                result[motor] = value
+                
+            except Exception as e:
+                logger.warning(f"Failed to read {data_name} from {motor}: {e}")
+                result[motor] = 0.0
+        
+        return result
+
+    def sync_write(
+        self,
+        data_name: str,
+        values: Dict[str, Value],
+        *,
+        normalize: bool = True,
+        num_retry: int = 0,
+    ) -> None:
+        """
+        Write different values to multiple motors simultaneously. Positions are always in degrees.
+        Uses batched operations: sends all commands first, then collects responses (OpenArms pattern).
+        """
+        if data_name == "Goal_Position":
+            # Step 1: Send all MIT control commands first (no waiting)
+            for motor, value_degrees in values.items():
+                motor_id = self._get_motor_id(motor)
+                motor_name = self._get_motor_name(motor)
+                motor_type = self._motor_types.get(motor_name, MotorType.DM4310)
+                
+                # Convert degrees to radians
+                position_rad = np.radians(value_degrees)
+                
+                # Default gains for position control
+                kp, kd = 10.0, 0.5
+                
+                # Get motor limits and encode parameters
+                pmax, vmax, tmax = MOTOR_LIMIT_PARAMS[motor_type]
+                kp_uint = self._float_to_uint(kp, 0, 500, 12)
+                kd_uint = self._float_to_uint(kd, 0, 5, 12)
+                q_uint = self._float_to_uint(position_rad, -pmax, pmax, 16)
+                dq_uint = self._float_to_uint(0, -vmax, vmax, 12)
+                tau_uint = self._float_to_uint(0, -tmax, tmax, 12)
+                
+                # Pack data
+                data = [0] * 8
+                data[0] = (q_uint >> 8) & 0xFF
+                data[1] = q_uint & 0xFF
+                data[2] = dq_uint >> 4
+                data[3] = ((dq_uint & 0xF) << 4) | ((kp_uint >> 8) & 0xF)
+                data[4] = kp_uint & 0xFF
+                data[5] = kd_uint >> 4
+                data[6] = ((kd_uint & 0xF) << 4) | ((tau_uint >> 8) & 0xF)
+                data[7] = tau_uint & 0xFF
+                
+                msg = can.Message(arbitration_id=motor_id, data=data, is_extended_id=False)
+                self.canbus.send(msg)
+            
+            # Step 2: Collect all responses at once
+            expected_recv_ids = [self._get_motor_recv_id(motor) for motor in values.keys()]
+            self._recv_all_responses(expected_recv_ids, timeout=0.002)  # 2ms timeout
+        else:
+            # Fall back to individual writes for other data types
+            for motor, value in values.items():
+                self.write(data_name, motor, value, normalize=normalize, num_retry=num_retry)
+
+    def read_calibration(self) -> dict[str, MotorCalibration]:
+        """Read calibration data from motors."""
+        # Damiao motors don't store calibration internally
+        # Return existing calibration or empty dict
+        return self.calibration if self.calibration else {}
+
+    def write_calibration(self, calibration_dict: dict[str, MotorCalibration], cache: bool = True) -> None:
+        """Write calibration data to motors."""
+        # Damiao motors don't store calibration internally
+        # Just cache it in memory
+        if cache:
+            self.calibration = calibration_dict
+
+    def record_ranges_of_motion(
+        self, motors: NameOrID | list[NameOrID] | None = None, display_values: bool = True
+    ) -> tuple[dict[NameOrID, Value], dict[NameOrID, Value]]:
+        """
+        Interactively record the min/max values of each motor in degrees.
+
+        Move the joints by hand (with torque disabled) while the method streams live positions.
+        Press Enter to finish.
+        """
+        if motors is None:
+            motors = list(self.motors.keys())
+        elif isinstance(motors, (str, int)):
+            motors = [motors]
+
+        # Disable torque for manual movement
+        self.disable_torque(motors)
+        time.sleep(0.1)
+
+        # Get initial positions (already in degrees)
+        start_positions = self.sync_read("Present_Position", motors, normalize=False)
+        mins = start_positions.copy()
+        maxes = start_positions.copy()
+
+        print("\nMove joints through their full range of motion. Press ENTER when done.")
+        user_pressed_enter = False
+        
+        while not user_pressed_enter:
+            positions = self.sync_read("Present_Position", motors, normalize=False)
+            
+            for motor in motors:
+                if motor in positions:
+                    mins[motor] = min(positions[motor], mins.get(motor, positions[motor]))
+                    maxes[motor] = max(positions[motor], maxes.get(motor, positions[motor]))
+
+            if display_values:
+                print("\n" + "=" * 50)
+                print(f"{'MOTOR':<20} | {'MIN (deg)':>12} | {'POS (deg)':>12} | {'MAX (deg)':>12}")
+                print("-" * 50)
+                for motor in motors:
+                    if motor in positions:
+                        print(f"{motor:<20} | {mins[motor]:>12.1f} | {positions[motor]:>12.1f} | {maxes[motor]:>12.1f}")
+
+            if enter_pressed():
+                user_pressed_enter = True
+
+            if display_values and not user_pressed_enter:
+                # Move cursor up to overwrite the previous output
+                move_cursor_up(len(motors) + 4)
+
+            time.sleep(0.05)
+
+        # Re-enable torque
+        self.enable_torque(motors)
+        
+        # Validate ranges
+        for motor in motors:
+            if motor in mins and motor in maxes:
+                if abs(maxes[motor] - mins[motor]) < 5.0:  # At least 5 degrees of range
+                    raise ValueError(f"Motor {motor} has insufficient range of motion (< 5 degrees)")
+
+        return mins, maxes
+
+    def _get_motors_list(self, motors: str | list[str] | None) -> list[str]:
+        """Convert motor specification to list of motor names."""
+        if motors is None:
+            return list(self.motors.keys())
+        elif isinstance(motors, str):
+            return [motors]
+        elif isinstance(motors, list):
+            return motors
+        else:
+            raise TypeError(f"Invalid motors type: {type(motors)}")
+
+    def _get_motor_id(self, motor: NameOrID) -> int:
+        """Get CAN ID for a motor."""
+        if isinstance(motor, str):
+            if motor in self.motors:
+                return self.motors[motor].id
+            else:
+                raise ValueError(f"Unknown motor: {motor}")
+        else:
+            return motor
+
+    def _get_motor_name(self, motor: NameOrID) -> str:
+        """Get motor name from name or ID."""
+        if isinstance(motor, str):
+            return motor
+        else:
+            for name, m in self.motors.items():
+                if m.id == motor:
+                    return name
+            raise ValueError(f"Unknown motor ID: {motor}")
+    
+    def _get_motor_recv_id(self, motor: NameOrID) -> Optional[int]:
+        """Get motor recv_id from name or ID."""
+        motor_name = self._get_motor_name(motor)
+        motor_obj = self.motors.get(motor_name)
+        if motor_obj and hasattr(motor_obj, "recv_id"):
+            return motor_obj.recv_id
+        return None
+
+    @cached_property
+    def is_calibrated(self) -> bool:
+        """Check if motors are calibrated."""
+        return bool(self.calibration)

src/lerobot/motors/damiao/seed_damiao.py

@@ -0,0 +1,833 @@
+## This is a derivative of the following software.
+## https://github.com/cmjang/DM_Control_Python/blob/main/DM_CAN.py
+
+import can
+from time import sleep, time
+import numpy as np
+from enum import IntEnum
+from struct import unpack
+from struct import pack
+
+class Motor:
+    def __init__(self, MotorType, SlaveID, MasterID):
+        """
+        define Motor object 定义电机对象
+        :param MotorType: Motor type 电机类型
+        :param SlaveID: CANID 电机ID
+        :param MasterID: MasterID 主机ID 建议不要设为0
+        """
+        self.Pd = float(0)
+        self.Vd = float(0)
+        self.goal_position = float(0)
+        self.goal_tau = float(0)
+        self.state_q = float(0)
+        self.state_dq = float(0)
+        self.state_tau = float(0)
+        self.state_tmos = int(0)
+        self.state_trotor = int(0)
+        self.SlaveID = SlaveID
+        self.MasterID = MasterID
+        self.MotorType = MotorType
+        self.isEnable = False
+        self.NowControlMode = Control_Type.MIT
+        self.temp_param_dict = {}
+
+    def recv_data(self, q: float, dq: float, tau: float, tmos: int, trotor: int):
+        self.state_q = q
+        self.state_dq = dq
+        self.state_tau = tau
+        self.state_tmos = tmos
+        self.state_trotor = trotor
+
+    def getPosition(self):
+        """
+        get the position of the motor 获取电机位置
+        :return: the position of the motor 电机位置
+        """
+        return self.state_q
+
+    def getVelocity(self):
+        """
+        get the velocity of the motor 获取电机速度
+        :return: the velocity of the motor 电机速度
+        """
+        return self.state_dq
+
+    def getTorque(self):
+        """
+        get the torque of the motor 获取电机力矩
+        :return: the torque of the motor 电机力矩
+        """
+        return self.state_tau
+
+    def getParam(self, RID):
+        """
+        get the parameter of the motor 获取电机内部的参数，需要提前读取
+        :param RID: DM_variable 电机参数
+        :return: the parameter of the motor 电机参数
+        """
+        if RID in self.temp_param_dict:
+            return self.temp_param_dict[RID]
+        else:
+            return None
+
+
+class MotorControl:
+    #send_data_frame = np.array(
+    #    [0x55, 0xAA, 0x1e, 0x03, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0, 0, 0, 0, 0x00, 0x08, 0x00,
+    #     0x00, 0, 0, 0, 0, 0, 0, 0, 0, 0x00], np.uint8)
+    #                4310           4310_48        4340           4340_48
+    Limit_Param = [[12.5, 30, 10], [12.5, 50, 10], [12.5, 8, 28], [12.5, 10, 28],
+                   # 6006           8006           8009            10010L         10010
+                   [12.5, 45, 20], [12.5, 45, 40], [12.5, 45, 54], [12.5, 25, 200], [12.5, 20, 200],
+                   # H3510            DMG62150      DMH6220
+                   [12.5 , 280 , 1],[12.5 , 45 , 10],[12.5 , 45 , 10]]
+
+    def __init__(self, channel: str, bitrate: int = 1000000):
+        """
+        define MotorControl object 定义电机控制对象
+        :param serial_device: serial object 串口对象
+        """
+        #self.serial_ = serial_device
+        self.motors_map = dict()
+        self.data_save = bytes()  # save data
+        #if self.serial_.is_open:  # open the serial port
+        #    print("Serial port is open")
+        #    serial_device.close()
+        #self.serial_.open()
+        self.canbus = can.interface.Bus(channel=channel, interface='socketcan', bitrate=bitrate)
+
+        #print("can is open")
+        
+
+    def controlMIT(self, DM_Motor, kp: float, kd: float, q: float, dq: float, tau: float):
+        """
+        MIT Control Mode Function 达妙电机MIT控制模式函数
+        :param DM_Motor: Motor object 电机对象
+        :param kp: kp
+        :param kd:  kd
+        :param q:  position  期望位置
+        :param dq:  velocity  期望速度
+        :param tau: torque  期望力矩
+        :return: None
+        """
+        if DM_Motor.SlaveID not in self.motors_map:
+            print("controlMIT ERROR : Motor ID not found")
+            return
+        kp_uint = float_to_uint(kp, 0, 500, 12)
+        kd_uint = float_to_uint(kd, 0, 5, 12)
+        MotorType = DM_Motor.MotorType
+        Q_MAX = self.Limit_Param[MotorType][0]
+        DQ_MAX = self.Limit_Param[MotorType][1]
+        TAU_MAX = self.Limit_Param[MotorType][2]
+        q_uint = float_to_uint(q, -Q_MAX, Q_MAX, 16)
+        dq_uint = float_to_uint(dq, -DQ_MAX, DQ_MAX, 12)
+        tau_uint = float_to_uint(tau, -TAU_MAX, TAU_MAX, 12)
+        data_buf = np.array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
+        data_buf[0] = (q_uint >> 8) & 0xff
+        data_buf[1] = q_uint & 0xff
+        data_buf[2] = dq_uint >> 4
+        data_buf[3] = ((dq_uint & 0xf) << 4) | ((kp_uint >> 8) & 0xf)
+        data_buf[4] = kp_uint & 0xff
+        data_buf[5] = kd_uint >> 4
+        data_buf[6] = ((kd_uint & 0xf) << 4) | ((tau_uint >> 8) & 0xf)
+        data_buf[7] = tau_uint & 0xff
+        self.__send_data(DM_Motor.SlaveID, data_buf)
+        self.recv()  # receive the data from serial port
+
+    def control_delay(self, DM_Motor, kp: float, kd: float, q: float, dq: float, tau: float, delay: float):
+        """
+        MIT Control Mode Function with delay 达妙电机MIT控制模式函数带延迟
+        :param DM_Motor: Motor object 电机对象
+        :param kp: kp
+        :param kd: kd
+        :param q:  position  期望位置
+        :param dq:  velocity  期望速度
+        :param tau: torque  期望力矩
+        :param delay: delay time 延迟时间 单位秒
+        """
+        self.controlMIT(DM_Motor, kp, kd, q, dq, tau)
+        sleep(delay)
+
+    def control_Pos_Vel(self, Motor, P_desired: float, V_desired: float):
+        """
+        control the motor in position and velocity control mode 电机位置速度控制模式
+        :param Motor: Motor object 电机对象
+        :param P_desired: desired position 期望位置
+        :param V_desired: desired velocity 期望速度
+        :return: None
+        """
+        if Motor.SlaveID not in self.motors_map:
+            print("Control Pos_Vel Error : Motor ID not found")
+            return
+        motorid = 0x100 + Motor.SlaveID
+        data_buf = np.array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
+        P_desired_uint8s = float_to_uint8s(P_desired)
+        V_desired_uint8s = float_to_uint8s(V_desired)
+        data_buf[0:4] = P_desired_uint8s
+        data_buf[4:8] = V_desired_uint8s
+        self.__send_data(motorid, data_buf)
+        self.recv()  # receive the data from serial port
+
+    def control_Vel(self, Motor, Vel_desired):
+        """
+        control the motor in velocity control mode 电机速度控制模式
+        :param Motor: Motor object 电机对象
+        :param Vel_desired: desired velocity 期望速度
+        """
+        if Motor.SlaveID not in self.motors_map:
+            print("control_VEL ERROR : Motor ID not found")
+            return
+        motorid = 0x200 + Motor.SlaveID
+        data_buf = np.array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
+        Vel_desired_uint8s = float_to_uint8s(Vel_desired)
+        data_buf[0:4] = Vel_desired_uint8s
+        self.__send_data(motorid, data_buf)
+        self.recv()  # receive the data from serial port
+
+    def control_pos_force(self, Motor, Pos_des: float, Vel_des, i_des):
+        """
+        control the motor in EMIT control mode 电机力位混合模式
+        :param Pos_des: desired position rad  期望位置 单位为rad
+        :param Vel_des: desired velocity rad/s  期望速度 为放大100倍
+        :param i_des: desired current rang 0-10000 期望电流标幺值放大10000倍
+        电流标幺值：实际电流值除以最大电流值，最大电流见上电打印
+        """
+        if Motor.SlaveID not in self.motors_map:
+            print("control_pos_vel ERROR : Motor ID not found")
+            return
+        motorid = 0x300 + Motor.SlaveID
+        data_buf = np.array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
+        Pos_desired_uint8s = float_to_uint8s(Pos_des)
+        data_buf[0:4] = Pos_desired_uint8s
+        Vel_uint = np.uint16(Vel_des)
+        ides_uint = np.uint16(i_des)
+        data_buf[4] = Vel_uint & 0xff
+        data_buf[5] = Vel_uint >> 8
+        data_buf[6] = ides_uint & 0xff
+        data_buf[7] = ides_uint >> 8
+        self.__send_data(motorid, data_buf)
+        self.recv()  # receive the data from serial port
+
+    def enable(self, Motor):
+        """
+        enable motor 使能电机
+        最好在上电后几秒后再使能电机
+        :param Motor: Motor object 电机对象
+        """
+        self.__control_cmd(Motor, np.uint8(0xFC))
+        sleep(0.1)
+        self.recv()  # receive the data from serial port
+
+    def enable_old(self, Motor ,ControlMode):
+        """
+        enable motor old firmware 使能电机旧版本固件，这个是为了旧版本电机固件的兼容性
+        可恶的旧版本固件使能需要加上偏移量
+        最好在上电后几秒后再使能电机
+        :param Motor: Motor object 电机对象
+        """
+        data_buf = np.array([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc], np.uint8)
+        enable_id = ((int(ControlMode)-1) << 2) + Motor.SlaveID
+        self.__send_data(enable_id, data_buf)
+        sleep(0.1)
+        self.recv()  # receive the data from serial port
+
+    def disable(self, Motor):
+        """
+        disable motor 失能电机
+        :param Motor: Motor object 电机对象
+        """
+        self.__control_cmd(Motor, np.uint8(0xFD))
+        sleep(0.1)
+        self.recv()  # receive the data from serial port
+
+    def set_zero_position(self, Motor):
+        """
+        set the zero position of the motor 设置电机0位
+        :param Motor: Motor object 电机对象
+        """
+        self.__control_cmd(Motor, np.uint8(0xFE))
+        sleep(0.1)
+        self.recv()  # receive the data from serial port
+
+    def recv(self):
+        # 把上次没有解析完的剩下的也放进来
+        # data_recv = b''.join([self.data_save, self.serial_.read_all()])
+        #data_recv = b''.join([self.data_save, self.canbus.recv()])
+
+
+        # packets = self.__extract_packets(data_recv)
+        # for packet in packets:
+        #     data = packet[7:15]
+        #     CANID = (packet[6] << 24) | (packet[5] << 16) | (packet[4] << 8) | packet[3]
+        #     CMD = packet[1]
+        #     self.__process_packet(data, CANID, CMD)
+        
+        data_recv = self.canbus.recv(0.1)
+
+        if data_recv is not None:
+            # data = data_recv.data
+            # err = data[0] >> 12
+            # id = data[0] & 0x7f
+            # pos = (data[1] << 8) + data[2]
+            # vel = (data[3] << 4) + (data[4] >> 4)
+            # tau = ((data[4] & 0x0f) << 8) + data[5]
+            # t_mos = data[6]
+            # t_rotor = data[7]
+            # print(hex(id), err, id, pos, vel, tau, goal_tau, t_mos, t_rotor)
+            # CANID = data_recv.arbitration_id
+            CANID = data_recv.data[0]
+            # CMD = data_recv.data[3]
+            CMD = 0x11                  # 飯田：修正の必要あり
+            self.__process_packet(data_recv.data, CANID, CMD)
+
+            # 飯田：Debug print
+            # print(hex(CANID),hex(CMD))
+            # print(hex(data_recv.data[0]),hex(data_recv.data[1]),hex(data_recv.data[2]),hex(data_recv.data[3]),hex(data_recv.data[4]),hex(data_recv.data[5]),hex(data_recv.data[6]),hex(data_recv.data[7]))
+            #return data
+
+    def recv_set_param_data(self):
+        #data_recv = self.serial_.read_all()
+
+        # packets = self.__extract_packets(data_recv)
+        # for packet in packets:
+        #     data = packet[7:15]
+        #     CANID = (packet[6] << 24) | (packet[5] << 16) | (packet[4] << 8) | packet[3]
+        #     CMD = packet[1]
+        #     self.__process_set_param_packet(data, CANID, CMD)
+        
+        data_recv = self.canbus.recv(0.1)
+
+
+        if data_recv is not None:
+            data = data_recv.data
+            CANID = data_recv.arbitration_id
+            # CANID = data_recv.data[0]
+            # CMD = data_recv.data[3]  
+            CMD = 0x11                  # 飯田：修正の必要あり
+            self.__process_packet(data, CANID, CMD)
+
+
+            # 飯田：Debug print
+            print(hex(CANID),hex(CMD))
+            print(hex(data_recv.data[0]),hex(data_recv.data[1]),hex(data_recv.data[2]),hex(data_recv.data[3]),hex(data_recv.data[4]),hex(data_recv.data[5]),hex(data_recv.data[6]),hex(data_recv.data[7]))
+
+    def __process_packet(self, data, CANID, CMD):
+        if CMD == 0x11:
+            if CANID != 0x00:
+                if CANID in self.motors_map:
+                    q_uint = np.uint16((np.uint16(data[1]) << 8) | data[2])
+                    dq_uint = np.uint16((np.uint16(data[3]) << 4) | (data[4] >> 4))
+                    tau_uint = np.uint16(((data[4] & 0xf) << 8) | data[5])
+                    t_mos = data[6]
+                    t_rotor = data[7]
+                    MotorType_recv = self.motors_map[CANID].MotorType
+                    Q_MAX = self.Limit_Param[MotorType_recv][0]
+                    DQ_MAX = self.Limit_Param[MotorType_recv][1]
+                    TAU_MAX = self.Limit_Param[MotorType_recv][2]
+                    recv_q = uint_to_float(q_uint, -Q_MAX, Q_MAX, 16)
+                    recv_dq = uint_to_float(dq_uint, -DQ_MAX, DQ_MAX, 12)
+                    recv_tau = uint_to_float(tau_uint, -TAU_MAX, TAU_MAX, 12)
+                    self.motors_map[CANID].recv_data(recv_q, recv_dq, recv_tau, t_mos, t_rotor)
+            else:
+                MasterID=data[0] & 0x0f
+                if MasterID in self.motors_map:
+                    q_uint = np.uint16((np.uint16(data[1]) << 8) | data[2])
+                    dq_uint = np.uint16((np.uint16(data[3]) << 4) | (data[4] >> 4))
+                    tau_uint = np.uint16(((data[4] & 0xf) << 8) | data[5])
+                    t_mos = data[6]
+                    t_rotor = data[7]
+                    MotorType_recv = self.motors_map[MasterID].MotorType
+                    Q_MAX = self.Limit_Param[MotorType_recv][0]
+                    DQ_MAX = self.Limit_Param[MotorType_recv][1]
+                    TAU_MAX = self.Limit_Param[MotorType_recv][2]
+                    recv_q = uint_to_float(q_uint, -Q_MAX, Q_MAX, 16)
+                    recv_dq = uint_to_float(dq_uint, -DQ_MAX, DQ_MAX, 12)
+                    recv_tau = uint_to_float(tau_uint, -TAU_MAX, TAU_MAX, 12)
+                    self.motors_map[MasterID].recv_data(recv_q, recv_dq, recv_tau, t_mos, t_rotor)
+
+
+    def __process_set_param_packet(self, data, CANID, CMD):
+        if CMD == 0x11 and (data[2] == 0x33 or data[2] == 0x55):
+            masterid=CANID
+            slaveId = ((data[1] << 8) | data[0])
+            if CANID==0x00:  #防止有人把MasterID设为0稳一手
+                masterid=slaveId
+
+            if masterid not in self.motors_map:
+                if slaveId not in self.motors_map:
+                    return
+                else:
+                    masterid=slaveId
+
+            RID = data[3]
+            # 读取参数得到的数据
+            if is_in_ranges(RID):
+                #uint32类型
+                num = uint8s_to_uint32(data[4], data[5], data[6], data[7])
+                self.motors_map[masterid].temp_param_dict[RID] = num
+
+            else:
+                #float类型
+                num = uint8s_to_float(data[4], data[5], data[6], data[7])
+                self.motors_map[masterid].temp_param_dict[RID] = num
+
+
+    def addMotor(self, Motor):
+        """
+        add motor to the motor control object 添加电机到电机控制对象
+        :param Motor: Motor object 电机对象
+        """
+        self.motors_map[Motor.SlaveID] = Motor
+        if Motor.MasterID != 0:
+            self.motors_map[Motor.MasterID] = Motor
+        return True
+
+    def __control_cmd(self, Motor, cmd: np.uint8):     # 飯田：コマンドは通ります
+        data_buf = np.array([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, cmd], np.uint8)
+        self.__send_data(Motor.SlaveID, data_buf)
+
+    def __send_data(self, motor_id, data):
+        """
+        send data to the motor 发送数据到电机
+        :param motor_id:
+        :param data:
+        :return:
+        """
+        #self.send_data_frame[13] = motor_id & 0xff
+        #self.send_data_frame[14] = (motor_id >> 8)& 0xff  #id high 8 bits
+        #self.send_data_frame[21:29] = data
+        #self.serial_.write(bytes(self.send_data_frame.T))
+
+        msg =can.Message(is_extended_id=False,arbitration_id=motor_id,data=data,is_remote_frame = False)
+        self.canbus.send(msg)
+
+    def __read_RID_param(self, Motor, RID):             # 飯田：修正の必要あり?
+        can_id_l = Motor.SlaveID & 0xff #id low 8 bits
+        can_id_h = (Motor.SlaveID >> 8)& 0xff  #id high 8 bits
+        data_buf = np.array([np.uint8(can_id_l), np.uint8(can_id_h), 0x33, np.uint8(RID), 0x00, 0x00, 0x00, 0x00], np.uint8)
+        self.__send_data(0x7FF, data_buf)
+        
+
+
+    def __write_motor_param(self, Motor, RID, data):             # 飯田：修正の必要あり?
+        can_id_l = Motor.SlaveID & 0xff #id low 8 bits
+        can_id_h = (Motor.SlaveID >> 8)& 0xff  #id high 8 bits
+        data_buf = np.array([np.uint8(can_id_l), np.uint8(can_id_h), 0x55, np.uint8(RID), 0x00, 0x00, 0x00, 0x00], np.uint8)
+        if not is_in_ranges(RID):
+            # data is float
+            data_buf[4:8] = float_to_uint8s(data)
+        else:
+            # data is int
+            data_buf[4:8] = data_to_uint8s(int(data))
+        self.__send_data(0x7FF, data_buf)
+
+    def switchControlMode(self, Motor, ControlMode):
+        """
+        switch the control mode of the motor 切换电机控制模式
+        :param Motor: Motor object 电机对象
+        :param ControlMode: Control_Type 电机控制模式 example:MIT:Control_Type.MIT MIT模式
+        """
+        max_retries = 20
+        retry_interval = 0.1  #retry times
+        RID = 10
+        self.__write_motor_param(Motor, RID, np.uint8(ControlMode))
+        for _ in range(max_retries):
+            sleep(retry_interval)
+            self.recv_set_param_data()
+            if Motor.SlaveID in self.motors_map:
+                if RID in self.motors_map[Motor.SlaveID].temp_param_dict:
+                    if abs(self.motors_map[Motor.SlaveID].temp_param_dict[RID] - ControlMode) < 0.1:
+                        return True
+                    else:
+                        return False
+        return False
+
+    def save_motor_param(self, Motor):
+        """
+        save the all parameter  to flash 保存所有电机参数
+        :param Motor: Motor object 电机对象
+        :return:
+        """
+        can_id_l = Motor.SlaveID & 0xff #id low 8 bits
+        can_id_h = (Motor.SlaveID >> 8)& 0xff  #id high 8 bits
+        data_buf = np.array([np.uint8(can_id_l), np.uint8(can_id_h), 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
+        self.disable(Motor)  # before save disable the motor
+        self.__send_data(0x7FF, data_buf)
+        sleep(0.001)
+
+    def change_limit_param(self, Motor_Type, PMAX, VMAX, TMAX):
+        """
+        change the PMAX VMAX TMAX of the motor 改变电机的PMAX VMAX TMAX
+        :param Motor_Type:
+        :param PMAX: 电机的PMAX
+        :param VMAX: 电机的VMAX
+        :param TMAX: 电机的TMAX
+        :return:
+        """
+        self.Limit_Param[Motor_Type][0] = PMAX
+        self.Limit_Param[Motor_Type][1] = VMAX
+        self.Limit_Param[Motor_Type][2] = TMAX
+
+    def refresh_motor_status(self,Motor):
+        """
+        get the motor status 获得电机状态
+        """
+        can_id_l = Motor.SlaveID & 0xff #id low 8 bits
+        can_id_h = (Motor.SlaveID >> 8) & 0xff  #id high 8 bits
+        data_buf = np.array([np.uint8(can_id_l), np.uint8(can_id_h), 0xCC, 0x00, 0x00, 0x00, 0x00, 0x00], np.uint8)
+        self.__send_data(0x7FF, data_buf)
+        self.recv()  # receive the data from serial port
+
+    def change_motor_param(self, Motor, RID, data):
+        """
+        change the RID of the motor 改变电机的参数
+        :param Motor: Motor object 电机对象
+        :param RID: DM_variable 电机参数
+        :param data: 电机参数的值
+        :return: True or False ,True means success, False means fail
+        """
+        max_retries = 20
+        retry_interval = 0.05  #retry times
+
+        self.__write_motor_param(Motor, RID, data)
+        for _ in range(max_retries):
+            self.recv_set_param_data()
+            if Motor.SlaveID in self.motors_map and RID in self.motors_map[Motor.SlaveID].temp_param_dict:
+                if abs(self.motors_map[Motor.SlaveID].temp_param_dict[RID] - data) < 0.1:
+                    return True
+                else:
+                    return False
+            sleep(retry_interval)
+        return False
+
+    def read_motor_param(self, Motor, RID):
+        """
+        read only the RID of the motor 读取电机的内部信息例如 版本号等
+        :param Motor: Motor object 电机对象
+        :param RID: DM_variable 电机参数
+        :return: 电机参数的值
+        """
+        max_retries = 5
+        retry_interval = 0.05  #retry times
+        self.__read_RID_param(Motor, RID)
+        for _ in range(max_retries):
+            sleep(retry_interval)
+            self.recv_set_param_data()
+            if Motor.SlaveID in self.motors_map:
+                if RID in self.motors_map[Motor.SlaveID].temp_param_dict:
+                    return self.motors_map[Motor.SlaveID].temp_param_dict[RID]
+        return None
+
+    # -------------------------------------------------
+    # Extract packets from the serial data
+    def __extract_packets(self, data):          
+        frames = []
+        header = 0xAA
+        tail = 0x55
+        frame_length = 16
+        i = 0
+        remainder_pos = 0
+
+        while i <= len(data) - frame_length:
+            if data[i] == header and data[i + frame_length - 1] == tail:
+                frame = data[i:i + frame_length]
+                frames.append(frame)
+                i += frame_length
+                remainder_pos = i
+            else:
+                i += 1
+        self.data_save = data[remainder_pos:]
+        return frames
+
+
+def LIMIT_MIN_MAX(x, min, max):
+    if x <= min:
+        x = min
+    elif x > max:
+        x = max
+
+
+def float_to_uint(x: float, x_min: float, x_max: float, bits):
+    LIMIT_MIN_MAX(x, x_min, x_max)
+    span = x_max - x_min
+    data_norm = (x - x_min) / span
+    return np.uint16(data_norm * ((1 << bits) - 1))
+
+
+def uint_to_float(x: np.uint16, min: float, max: float, bits):
+    span = max - min
+    data_norm = float(x) / ((1 << bits) - 1)
+    temp = data_norm * span + min
+    return np.float32(temp)
+
+
+def float_to_uint8s(value):
+    # Pack the float into 4 bytes
+    packed = pack('f', value)
+    # Unpack the bytes into four uint8 values
+    return unpack('4B', packed)
+
+
+def data_to_uint8s(value):
+    # Check if the value is within the range of uint32
+    if isinstance(value, int) and (0 <= value <= 0xFFFFFFFF):
+        # Pack the uint32 into 4 bytes
+        packed = pack('I', value)
+    else:
+        raise ValueError("Value must be an integer within the range of uint32")
+
+    # Unpack the bytes into four uint8 values
+    return unpack('4B', packed)
+
+
+def is_in_ranges(number):
+    """
+    check if the number is in the range of uint32
+    :param number:
+    :return:
+    """
+    if (7 <= number <= 10) or (13 <= number <= 16) or (35 <= number <= 36):
+        return True
+    return False
+
+
+def uint8s_to_uint32(byte1, byte2, byte3, byte4):
+    # Pack the four uint8 values into a single uint32 value in little-endian order
+    packed = pack('<4B', byte1, byte2, byte3, byte4)
+    # Unpack the packed bytes into a uint32 value
+    return unpack('<I', packed)[0]
+
+
+def uint8s_to_float(byte1, byte2, byte3, byte4):
+    # Pack the four uint8 values into a single float value in little-endian order
+    packed = pack('<4B', byte1, byte2, byte3, byte4)
+    # Unpack the packed bytes into a float value
+    return unpack('<f', packed)[0]
+
+
+def print_hex(data):
+    hex_values = [f'{byte:02X}' for byte in data]
+    print(' '.join(hex_values))
+
+
+def get_enum_by_index(index, enum_class):
+    try:
+        return enum_class(index)
+    except ValueError:
+        return None
+
+
+class DM_Motor_Type(IntEnum):
+    DM4310 = 0
+    DM4310_48V = 1
+    DM4340 = 2
+    DM4340_48V = 3
+    DM6006 = 4
+    DM8006 = 5
+    DM8009 = 6
+    DM10010L = 7
+    DM10010 = 8
+    DMH3510 = 9
+    DMH6215 = 10
+    DMG6220 = 11
+
+
+class DM_variable(IntEnum):
+    UV_Value = 0
+    KT_Value = 1
+    OT_Value = 2
+    OC_Value = 3
+    ACC = 4
+    DEC = 5
+    MAX_SPD = 6
+    MST_ID = 7
+    ESC_ID = 8
+    TIMEOUT = 9
+    CTRL_MODE = 10
+    Damp = 11
+    Inertia = 12
+    hw_ver = 13
+    sw_ver = 14
+    SN = 15
+    NPP = 16
+    Rs = 17
+    LS = 18
+    Flux = 19
+    Gr = 20
+    PMAX = 21
+    VMAX = 22
+    TMAX = 23
+    I_BW = 24
+    KP_ASR = 25
+    KI_ASR = 26
+    KP_APR = 27
+    KI_APR = 28
+    OV_Value = 29
+    GREF = 30
+    Deta = 31
+    V_BW = 32
+    IQ_c1 = 33
+    VL_c1 = 34
+    can_br = 35
+    sub_ver = 36
+    u_off = 50
+    v_off = 51
+    k1 = 52
+    k2 = 53
+    m_off = 54
+    dir = 55
+    p_m = 80
+    xout = 81
+
+
+class Control_Type(IntEnum):
+    MIT = 1
+    POS_VEL = 2
+    VEL = 3
+    Torque_Pos = 4
+
+class DamiaoPort:
+    def __init__(self, device, types, can_ids, master_ids, motor_with_torque, control_mode=Control_Type.MIT):
+        self.device = device
+        self.types = types
+        self.can_ids = can_ids
+        self.master_ids = master_ids
+        self.control = MotorControl(self.device, bitrate=4000000)
+        self.motors = [Motor(type, can_id, master_id) for type, can_id, master_id in zip(types, can_ids, master_ids)]
+        self.stat_data = []
+        self.stat_time = []
+        for motor in self.motors:
+            self.control.addMotor(motor)
+            self.control.enable(motor)
+
+    def get_present_status(self):
+        self.stat_time.append(time())
+        stat = [[
+            motor.goal_position,
+            motor.goal_tau,
+            motor.getPosition(),
+            motor.getVelocity(),
+            motor.getTorque(),
+            motor.state_tmos,
+            motor.state_trotor,
+        ] for motor in self.motors]
+        self.stat_data.append(stat)
+
+        return stat
+
+    def save_status(self, filename):
+        np.savez(filename, np.array(self.stat_time), np.array(self.stat_data))
+
+    def disable(self):
+        for motor in self.motors:
+            self.control.disable(motor)
+
+    def shutdown(self):
+        for motor in self.motors:
+            self.control.controlMIT(motor, 0, 0, 0, 0, 0)
+        self.control.canbus.shutdown()
+
+    def set_zero_position(self):
+        for motor in self.motors:
+            self.control.disable(motor)
+        sleep(1)
+        for motor in self.motors:
+            self.control.set_zero_position(motor)
+        sleep(1)
+        for motor in self.motors:
+            self.control.enable(motor)
+        return 0
+
+    async def move_towards(self, goal_positions, kps, kds):
+        for motor, goal_position, kp, kd in zip(self.motors, goal_positions, kps, kds):
+            delta = goal_position - motor.getPosition()
+            v = motor.getVelocity()
+            tau = kp * delta - kd * v
+            motor.goal_position = goal_position
+            motor.goal_tau = tau
+            self.control.controlMIT(motor, 0, 0, 0, 0, tau)
+            await asyncio.sleep(0.00003)
+
+    def move_regressor_sync(self, regs, search_range, search_step, goal_positions, kps, kds):
+        TORQUE_SCALER=30
+        if len(self.stat_data) == 0:
+            return self.move_towards_sync(goal_positions, kps, kds)
+        for motor, reg, goal_position, kp, kd, stat in zip(
+                self.motors, regs, goal_positions, kps, kds, self.stat_data[-1]):
+            pos = motor.getPosition()
+            vel = motor.getVelocity()
+            delta = goal_position - pos
+            goal_tau = kp * delta - kd * vel
+            _goal_pos, _goal_tau, _pos, _vel, _tau = stat
+            x = np.array([[_pos, _vel, _tau, _goal_pos, _goal_tau],
+                          [pos, vel, motor.getTorque(), goal_position, goal_tau]])
+            x /= np.array([[np.pi, 10, TORQUE_SCALER, np.pi, TORQUE_SCALER]])
+            xs = []
+            for tau in np.linspace(goal_tau/TORQUE_SCALER - search_range,
+                                   goal_tau/TORQUE_SCALER + search_range,
+                                   num=search_step):
+                x_ = x.copy()
+                x_[0,4] = tau
+                xs.append(x_.flatten())
+            h = reg.predict(xs)
+            diff = h - goal_position
+            tau = TORQUE_SCALER * xs[np.argmin(diff ** 2)][4]
+            goal_tau = tau
+            motor.goal_position = goal_position
+            motor.goal_tau = goal_tau
+            self.control.controlMIT(motor, 0, 0, 0, 0, goal_tau)
+            sleep(0.00003)
+
+    def move_towards_sync(self, goal_positions, kps, kds):
+        for motor, goal_position, kp, kd in zip(self.motors, goal_positions, kps, kds):
+            delta = goal_position - motor.getPosition()
+            v = motor.getVelocity()
+            tau = kp * delta - kd * v
+            motor.goal_position = goal_position
+            motor.goal_tau = tau
+            self.control.controlMIT(motor, 0, 0, 0, 0, tau)
+            # sleep(0.00003)
+
+    def set_goal_torque_sync(self, goal_taus):
+        for motor, goal_tau in zip(self.motors, goal_taus):
+            motor.goal_position = 0
+            motor.goal_tau = goal_tau
+            self.control.controlMIT(motor, 0, 0, 0, 0, motor.goal_tau)
+            sleep(0.00003)
+
+    def move_torque_sync(self, taus):
+        for motor,tau in zip(self.motors, taus):
+            motor.goal_position = 0
+            motor.goal_tau = tau
+            self.control.controlMIT(motor, 0, 0, 0, 0, motor.goal_tau)
+            sleep(0.00003)
+
+    def keep_torque_sync(self):
+        for motor in self.motors:
+            self.control.controlMIT(motor, 0, 0, 0, 0, motor.goal_tau)
+            sleep(0.00003)
+
+    async def set_goal_positions(self, goal_positions, kps):
+        for motor, goal_position, kp in zip(self.motors, goal_positions, kps):
+            motor.goal_position = goal_position
+            motor.goal_tau = 0
+            self.control.controlMIT(motor, kp, 1.2, goal_position, 0, 0)
+            await asyncio.sleep(0.00003)
+
+    def set_goal_positions_sync(self, goal_positions, kps, kds):
+        for motor, goal_position, kp, kd in zip(self.motors, goal_positions, kps, kds):
+            motor.goal_position = goal_position
+            motor.goal_tau = 0
+            self.control.controlMIT(motor, kp, kd, goal_position, 0, 0)
+            sleep(0.00003)
+
+    def set_goal_posvel(self, goal_positions):
+        for motor, goal_position in zip(self.motors, goal_positions):
+            motor.goal_position = goal_position
+            motor.goal_tau = 0
+            self.control.control_pos_force(motor, goal_position, 1, 1)
+
+    def controlMIT(self, motor, kp, kd, q, dq, tau):
+        self.control.controlMIT(self.motors[motor], kp, kd, q, dq, tau)
+

src/lerobot/motors/damiao/tables.py

@@ -0,0 +1,209 @@
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Configuration tables for Damiao motors."""
+
+from enum import IntEnum
+from typing import Dict, List, Tuple
+
+# Motor type definitions
+class MotorType(IntEnum):
+    DM3507 = 0
+    DM4310 = 1
+    DM4310_48V = 2
+    DM4340 = 3
+    DM4340_48V = 4
+    DM6006 = 5
+    DM8006 = 6
+    DM8009 = 7
+    DM10010L = 8
+    DM10010 = 9
+    DMH3510 = 10
+    DMH6215 = 11
+    DMG6220 = 12
+
+# Control modes
+class ControlMode(IntEnum):
+    MIT = 1
+    POS_VEL = 2
+    VEL = 3
+    TORQUE_POS = 4
+
+# Motor variable IDs (RID)
+class MotorVariable(IntEnum):
+    UV_VALUE = 0
+    KT_VALUE = 1
+    OT_VALUE = 2
+    OC_VALUE = 3
+    ACC = 4
+    DEC = 5
+    MAX_SPD = 6
+    MST_ID = 7
+    ESC_ID = 8
+    TIMEOUT = 9
+    CTRL_MODE = 10
+    DAMP = 11
+    INERTIA = 12
+    HW_VER = 13
+    SW_VER = 14
+    SN = 15
+    NPP = 16
+    RS = 17
+    LS = 18
+    FLUX = 19
+    GR = 20
+    PMAX = 21
+    VMAX = 22
+    TMAX = 23
+    I_BW = 24
+    KP_ASR = 25
+    KI_ASR = 26
+    KP_APR = 27
+    KI_APR = 28
+    OV_VALUE = 29
+    GREF = 30
+    DETA = 31
+    V_BW = 32
+    IQ_C1 = 33
+    VL_C1 = 34
+    CAN_BR = 35
+    SUB_VER = 36
+    U_OFF = 50
+    V_OFF = 51
+    K1 = 52
+    K2 = 53
+    M_OFF = 54
+    DIR = 55
+    P_M = 80
+    XOUT = 81
+
+# Motor limit parameters [PMAX, VMAX, TMAX] 
+# PMAX: Maximum position (rad)
+# VMAX: Maximum velocity (rad/s)
+# TMAX: Maximum torque (N·m)
+MOTOR_LIMIT_PARAMS = {
+    MotorType.DM3507: (12.5, 30, 10),
+    MotorType.DM4310: (12.5, 30, 10),
+    MotorType.DM4310_48V: (12.5, 50, 10),
+    MotorType.DM4340: (12.5, 8, 28),
+    MotorType.DM4340_48V: (12.5, 10, 28),
+    MotorType.DM6006: (12.5, 45, 20),
+    MotorType.DM8006: (12.5, 45, 40),
+    MotorType.DM8009: (12.5, 45, 54),
+    MotorType.DM10010L: (12.5, 25, 200),
+    MotorType.DM10010: (12.5, 20, 200),
+    MotorType.DMH3510: (12.5, 280, 1),
+    MotorType.DMH6215: (12.5, 45, 10),
+    MotorType.DMG6220: (12.5, 45, 10),
+}
+
+# Motor model names
+MODEL_NAMES = {
+    MotorType.DM3507: "dm3507",
+    MotorType.DM4310: "dm4310",
+    MotorType.DM4310_48V: "dm4310_48v",
+    MotorType.DM4340: "dm4340",
+    MotorType.DM4340_48V: "dm4340_48v",
+    MotorType.DM6006: "dm6006",
+    MotorType.DM8006: "dm8006",
+    MotorType.DM8009: "dm8009",
+    MotorType.DM10010L: "dm10010l",
+    MotorType.DM10010: "dm10010",
+    MotorType.DMH3510: "dmh3510",
+    MotorType.DMH6215: "dmh6215",
+    MotorType.DMG6220: "dmg6220",
+}
+
+# Motor resolution table (encoder counts per revolution)
+MODEL_RESOLUTION = {
+    "dm3507": 65536,
+    "dm4310": 65536,
+    "dm4310_48v": 65536,
+    "dm4340": 65536,
+    "dm4340_48v": 65536,
+    "dm6006": 65536,
+    "dm8006": 65536,
+    "dm8009": 65536,
+    "dm10010l": 65536,
+    "dm10010": 65536,
+    "dmh3510": 65536,
+    "dmh6215": 65536,
+    "dmg6220": 65536,
+}
+
+# CAN baudrates supported by Damiao motors
+AVAILABLE_BAUDRATES = [
+    125000,   # 0: 125 kbps
+    200000,   # 1: 200 kbps
+    250000,   # 2: 250 kbps
+    500000,   # 3: 500 kbps
+    1000000,  # 4: 1 mbps (default for OpenArms)
+    2000000,  # 5: 2 mbps
+    2500000,  # 6: 2.5 mbps
+    3200000,  # 7: 3.2 mbps
+    4000000,  # 8: 4 mbps
+    5000000,  # 9: 5 mbps
+]
+DEFAULT_BAUDRATE = 1000000  # 1 Mbps is standard for OpenArms
+
+# Default timeout in milliseconds
+DEFAULT_TIMEOUT_MS = 1000
+
+# Data that should be normalized
+NORMALIZED_DATA = ["Present_Position", "Goal_Position"]
+
+# OpenArms specific configurations
+# Based on: https://docs.openarm.dev/software/setup/configure-test
+# OpenArms has 7 DOF per arm (14 total for dual arm)
+OPENARMS_ARM_MOTOR_IDS = {
+    "joint_1": {"send": 0x01, "recv": 0x11},  # J1 - Shoulder pan
+    "joint_2": {"send": 0x02, "recv": 0x12},  # J2 - Shoulder lift
+    "joint_3": {"send": 0x03, "recv": 0x13},  # J3 - Elbow flex
+    "joint_4": {"send": 0x04, "recv": 0x14},  # J4 - Wrist flex
+    "joint_5": {"send": 0x05, "recv": 0x15},  # J5 - Wrist roll
+    "joint_6": {"send": 0x06, "recv": 0x16},  # J6 - Wrist pitch
+    "joint_7": {"send": 0x07, "recv": 0x17},  # J7 - Wrist rotation
+}
+
+OPENARMS_GRIPPER_MOTOR_IDS = {
+    "gripper": {"send": 0x08, "recv": 0x18},  # J8 - Gripper
+}
+
+# Default motor types for OpenArms
+OPENARMS_DEFAULT_MOTOR_TYPES = {
+    "joint_1": MotorType.DM8009,   # Shoulder pan - high torque
+    "joint_2": MotorType.DM8009,   # Shoulder lift - high torque
+    "joint_3": MotorType.DM4340,   # Shoulder rotation
+    "joint_4": MotorType.DM4340,   # Elbow flex
+    "joint_5": MotorType.DM4310,   # Wrist roll
+    "joint_6": MotorType.DM4310,   # Wrist pitch
+    "joint_7": MotorType.DM4310,   # Wrist rotation
+    "gripper": MotorType.DM4310,   # Gripper
+}
+
+# MIT control parameter ranges
+MIT_KP_RANGE = (0.0, 500.0)
+MIT_KD_RANGE = (0.0, 5.0)
+
+# CAN frame command IDs
+CAN_CMD_ENABLE = 0xFC
+CAN_CMD_DISABLE = 0xFD
+CAN_CMD_SET_ZERO = 0xFE
+CAN_CMD_REFRESH = 0xCC
+CAN_CMD_QUERY_PARAM = 0x33
+CAN_CMD_WRITE_PARAM = 0x55
+CAN_CMD_SAVE_PARAM = 0xAA
+
+# CAN ID for parameter operations
+CAN_PARAM_ID = 0x7FF

src/lerobot/motors/dynamixel/dynamixel.py

@@ -24,7 +24,7 @@ from enum import Enum
 
 from lerobot.motors.encoding_utils import decode_twos_complement, encode_twos_complement
 
-from ..motors_bus import Motor, MotorCalibration, MotorsBus, NameOrID, Value, get_address
+from ..motors_bus import Motor, MotorCalibration, NameOrID, SerialMotorsBus, Value, get_address
 from .tables import (
     AVAILABLE_BAUDRATES,
     MODEL_BAUDRATE_TABLE,
@@ -100,7 +100,7 @@ def _split_into_byte_chunks(value: int, length: int) -> list[int]:
     return data
 
 
-class DynamixelMotorsBus(MotorsBus):
+class DynamixelMotorsBus(SerialMotorsBus):
     """
     The Dynamixel implementation for a MotorsBus. It relies on the python dynamixel sdk to communicate with
     the motors. For more info, see the Dynamixel SDK Documentation:

src/lerobot/motors/feetech/feetech.py

@@ -19,7 +19,7 @@ from pprint import pformat
 
 from lerobot.motors.encoding_utils import decode_sign_magnitude, encode_sign_magnitude
 
-from ..motors_bus import Motor, MotorCalibration, MotorsBus, NameOrID, Value, get_address
+from ..motors_bus import Motor, MotorCalibration, NameOrID, SerialMotorsBus, Value, get_address
 from .tables import (
     FIRMWARE_MAJOR_VERSION,
     FIRMWARE_MINOR_VERSION,
@@ -96,7 +96,7 @@ def patch_setPacketTimeout(self, packet_length):  # noqa: N802
     self.packet_timeout = (self.tx_time_per_byte * packet_length) + (self.tx_time_per_byte * 3.0) + 50
 
 
-class FeetechMotorsBus(MotorsBus):
+class FeetechMotorsBus(SerialMotorsBus):
     """
     The FeetechMotorsBus class allows to efficiently read and write to the attached motors. It relies on the
     python feetech sdk to communicate with the motors, which is itself based on the dynamixel sdk.

src/lerobot/motors/motors_bus.py

@@ -19,6 +19,8 @@
 # TODO(aliberts): Add block noqa when feature below is available
 # https://github.com/astral-sh/ruff/issues/3711
 
+from __future__ import annotations
+
 import abc
 import logging
 from contextlib import contextmanager
@@ -41,6 +43,92 @@ Value: TypeAlias = int | float
 logger = logging.getLogger(__name__)
 
 
+class MotorsBusBase(abc.ABC):
+    """
+    Base class for all motor bus implementations.
+    
+    This is a minimal interface that all motor buses must implement, regardless of their
+    communication protocol (serial, CAN, etc.).
+    """
+
+    def __init__(
+        self,
+        port: str,
+        motors: dict[str, Motor],
+        calibration: dict[str, MotorCalibration] | None = None,
+    ):
+        self.port = port
+        self.motors = motors
+        self.calibration = calibration if calibration else {}
+
+    @abc.abstractmethod
+    def connect(self, handshake: bool = True) -> None:
+        """Establish connection to the motors."""
+        pass
+
+    @abc.abstractmethod
+    def disconnect(self, disable_torque: bool = True) -> None:
+        """Disconnect from the motors."""
+        pass
+
+    @property
+    @abc.abstractmethod
+    def is_connected(self) -> bool:
+        """Check if connected to the motors."""
+        pass
+
+    @abc.abstractmethod
+    def read(self, data_name: str, motor: str, *, normalize: bool = True, num_retry: int = 0) -> Value:
+        """Read a value from a single motor."""
+        pass
+
+    @abc.abstractmethod
+    def write(
+        self, data_name: str, motor: str, value: Value, *, normalize: bool = True, num_retry: int = 0
+    ) -> None:
+        """Write a value to a single motor."""
+        pass
+
+    @abc.abstractmethod
+    def sync_read(
+        self, data_name: str, motors: str | list[str] | None = None, *, normalize: bool = True
+    ) -> dict[str, Value]:
+        """Read a value from multiple motors."""
+        pass
+
+    @abc.abstractmethod
+    def sync_write(
+        self,
+        data_name: str,
+        values: Value | dict[str, Value],
+        motors: str | list[str] | None = None,
+        *,
+        normalize: bool = True,
+    ) -> None:
+        """Write values to multiple motors."""
+        pass
+
+    @abc.abstractmethod
+    def enable_torque(self, motors: str | list[str] | None = None, num_retry: int = 0) -> None:
+        """Enable torque on selected motors."""
+        pass
+
+    @abc.abstractmethod
+    def disable_torque(self, motors: int | str | list[str] | None = None, num_retry: int = 0) -> None:
+        """Disable torque on selected motors."""
+        pass
+
+    @abc.abstractmethod
+    def read_calibration(self) -> dict[str, MotorCalibration]:
+        """Read calibration parameters from the motors."""
+        pass
+
+    @abc.abstractmethod
+    def write_calibration(self, calibration_dict: dict[str, MotorCalibration], cache: bool = True) -> None:
+        """Write calibration parameters to the motors."""
+        pass
+
+
 def get_ctrl_table(model_ctrl_table: dict[str, dict], model: str) -> dict[str, tuple[int, int]]:
     ctrl_table = model_ctrl_table.get(model)
     if ctrl_table is None:
@@ -203,15 +291,15 @@ class GroupSyncWrite(Protocol):
     def txPacket(self): ...
 
 
-class MotorsBus(abc.ABC):
+class SerialMotorsBus(MotorsBusBase):
     """
-    A MotorsBus allows to efficiently read and write to the attached motors.
+    A SerialMotorsBus allows to efficiently read and write to motors connected via serial communication.
     It represents several motors daisy-chained together and connected through a serial port.
-    There are currently two implementations of this abstract class:
+    There are currently two implementations of this class:
         - DynamixelMotorsBus
         - FeetechMotorsBus
 
-    Note: This class may evolve in the future should we add support for other types of bus.
+    This class is specifically for serial-based motor protocols (Dynamixel, Feetech, etc.).
 
     A MotorsBus subclass instance requires a port (e.g. `FeetechMotorsBus(port="/dev/tty.usbmodem575E0031751"`)).
     To find the port, you can run our utility script:
@@ -1212,3 +1300,7 @@ class MotorsBus(abc.ABC):
         for id_, value in ids_values.items():
             data = self._serialize_data(value, length)
             self.sync_writer.addParam(id_, data)
+
+
+# Backward compatibility alias
+MotorsBus = SerialMotorsBus

src/lerobot/policies/factory.py

@@ -38,7 +38,6 @@ from lerobot.policies.sac.configuration_sac import SACConfig
 from lerobot.policies.sac.reward_model.configuration_classifier import RewardClassifierConfig
 from lerobot.policies.smolvla.configuration_smolvla import SmolVLAConfig
 from lerobot.policies.tdmpc.configuration_tdmpc import TDMPCConfig
-from lerobot.policies.utils import validate_visual_features_consistency
 from lerobot.policies.vqbet.configuration_vqbet import VQBeTConfig
 from lerobot.processor import PolicyAction, PolicyProcessorPipeline
 from lerobot.processor.converters import (
@@ -421,7 +420,20 @@ def make_policy(
     # policy = torch.compile(policy, mode="reduce-overhead")
 
     if not rename_map:
-        validate_visual_features_consistency(cfg, features)
-        # TODO: (jadechoghari) - add a check_state(cfg, features) and check_action(cfg, features)
-
+        expected_features = set(cfg.input_features.keys()) | set(cfg.output_features.keys())
+        provided_features = set(features.keys())
+        if expected_features and provided_features != expected_features:
+            missing = expected_features - provided_features
+            extra = provided_features - expected_features
+            # TODO (jadechoghari): provide a dynamic rename map suggestion to the user.
+            raise ValueError(
+                f"Feature mismatch between dataset/environment and policy config.\n"
+                f"- Missing features: {sorted(missing) if missing else 'None'}\n"
+                f"- Extra features: {sorted(extra) if extra else 'None'}\n\n"
+                f"Please ensure your dataset and policy use consistent feature names.\n"
+                f"If your dataset uses different observation keys (e.g., cameras named differently), "
+                f"use the `--rename_map` argument, for example:\n"
+                f'  --rename_map=\'{{"observation.images.left": "observation.images.camera1", '
+                f'"observation.images.top": "observation.images.camera2"}}\''
+            )
     return policy

src/lerobot/policies/utils.py

@@ -22,8 +22,6 @@ import numpy as np
 import torch
 from torch import nn
 
-from lerobot.configs.policies import PreTrainedConfig
-from lerobot.configs.types import FeatureType, PolicyFeature
 from lerobot.datasets.utils import build_dataset_frame
 from lerobot.processor import PolicyAction, RobotAction, RobotObservation
 from lerobot.utils.constants import ACTION, OBS_STR
@@ -200,42 +198,3 @@ def make_robot_action(action_tensor: PolicyAction, ds_features: dict[str, dict])
         f"{name}": float(action_tensor[i]) for i, name in enumerate(action_names)
     }
     return act_processed_policy
-
-
-def raise_feature_mismatch_error(
-    provided_features: set[str],
-    expected_features: set[str],
-) -> None:
-    """
-    Raises a standardized ValueError for feature mismatches between dataset/environment and policy config.
-    """
-    missing = expected_features - provided_features
-    extra = provided_features - expected_features
-    # TODO (jadechoghari): provide a dynamic rename map suggestion to the user.
-    raise ValueError(
-        f"Feature mismatch between dataset/environment and policy config.\n"
-        f"- Missing features: {sorted(missing) if missing else 'None'}\n"
-        f"- Extra features: {sorted(extra) if extra else 'None'}\n\n"
-        f"Please ensure your dataset and policy use consistent feature names.\n"
-        f"If your dataset uses different observation keys (e.g., cameras named differently), "
-        f"use the `--rename_map` argument, for example:\n"
-        f'  --rename_map=\'{{"observation.images.left": "observation.images.camera1", '
-        f'"observation.images.top": "observation.images.camera2"}}\''
-    )
-
-
-def validate_visual_features_consistency(
-    cfg: PreTrainedConfig,
-    features: dict[str, PolicyFeature],
-) -> None:
-    """
-    Validates visual feature consistency between a policy config and provided dataset/environment features.
-
-    Args:
-        cfg (PreTrainedConfig): The model or policy configuration containing input_features and type.
-        features (Dict[str, PolicyFeature]): A mapping of feature names to PolicyFeature objects.
-    """
-    expected_visuals = {k for k, v in cfg.input_features.items() if v.type == FeatureType.VISUAL}
-    provided_visuals = {k for k, v in features.items() if v.type == FeatureType.VISUAL}
-    if not provided_visuals.issubset(expected_visuals):
-        raise_feature_mismatch_error(provided_visuals, expected_visuals)

src/lerobot/robots/openarms/__init__.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .config_openarms_follower import OpenArmsFollowerConfig
+from .openarms_follower import OpenArmsFollower
+
+__all__ = ["OpenArmsFollower", "OpenArmsFollowerConfig"]

src/lerobot/robots/openarms/config_openarms_follower.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+
+from lerobot.cameras import CameraConfig
+from lerobot.motors.damiao.tables import MotorType
+
+from ..config import RobotConfig
+
+
+@RobotConfig.register_subclass("openarms_follower")
+@dataclass
+class OpenArmsFollowerConfig(RobotConfig):
+    """Configuration for the OpenArms follower robot with Damiao motors."""
+    
+    # CAN interfaces - one per arm
+    # Right arm CAN interface (e.g., "can0")
+    # Left arm CAN interface (e.g., "can1")
+    # Linux: "can0", "can1", etc.
+    # macOS: "/dev/cu.usbmodem*" (serial device)
+    port_right: str = "can0"    # CAN interface for right arm
+    port_left: str = "can1"     # CAN interface for left arm
+    
+    # CAN interface type: "socketcan" (Linux), "slcan" (macOS/serial), or "auto" (auto-detect)
+    can_interface: str = "socketcan"
+    
+    # CAN FD settings (OpenArms uses CAN FD by default)
+    use_can_fd: bool = True
+    can_bitrate: int = 1000000      # Nominal bitrate (1 Mbps)
+    can_data_bitrate: int = 5000000  # Data bitrate for CAN FD (5 Mbps)
+    
+    # Whether to disable torque when disconnecting
+    disable_torque_on_disconnect: bool = True
+    
+    # Safety limit for relative target positions
+    # Set to a positive scalar for all motors, or a dict mapping motor names to limits
+    max_relative_target: Optional[float | Dict[str, float]] = None
+    
+    # Camera configurations
+    cameras: Dict[str, CameraConfig] = field(default_factory=dict)
+    
+    # Motor configuration for OpenArms (7 DOF per arm)
+    # Maps motor names to (send_can_id, recv_can_id, motor_type)
+    # Based on: https://docs.openarm.dev/software/setup/configure-test
+    # OpenArms uses 4 types of motors:
+    # - DM8009 (DM-J8009P-2EC) for shoulders (high torque)
+    # - DM4340P and DM4340 for shoulder rotation and elbow
+    # - DM4310 (DM-J4310-2EC V1.1) for wrist and gripper
+    motor_config: Dict[str, tuple[int, int, str]] = field(default_factory=lambda: {
+        "joint_1": (0x01, 0x11, "dm8009"),   # J1 - Shoulder pan (DM8009)
+        "joint_2": (0x02, 0x12, "dm8009"),   # J2 - Shoulder lift (DM8009)
+        "joint_3": (0x03, 0x13, "dm4340"),   # J3 - Shoulder rotation (DM4340)
+        "joint_4": (0x04, 0x14, "dm4340"),   # J4 - Elbow flex (DM4340)
+        "joint_5": (0x05, 0x15, "dm4310"),   # J5 - Wrist roll (DM4310)
+        "joint_6": (0x06, 0x16, "dm4310"),   # J6 - Wrist pitch (DM4310)
+        "joint_7": (0x07, 0x17, "dm4310"),   # J7 - Wrist rotation (DM4310)
+        "gripper": (0x08, 0x18, "dm4310"),   # J8 - Gripper (DM4310)
+    })
+    
+    # MIT control parameters for position control (per motor)
+    # Values: [joint_1, joint_2, joint_3, joint_4, joint_5, joint_6, joint_7, gripper]
+    position_kp: list[float] = field(default_factory=lambda: [240.0, 240.0, 240.0, 240.0, 24.0, 31.0, 25.0, 16.0])
+    position_kd: list[float] = field(default_factory=lambda: [3.0, 3.0, 3.0, 3.0, 0.2, 0.2, 0.2, 0.2])
+    
+    # Calibration parameters
+    calibration_mode: str = "manual"  # "manual" or "auto"
+    zero_position_on_connect: bool = False  # Set zero position on connect

src/lerobot/robots/openarms/openarms_follower.py

@@ -0,0 +1,509 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import time
+from functools import cached_property
+from typing import Any, Dict
+
+import numpy as np
+import pinocchio as pin
+
+from lerobot.cameras.utils import make_cameras_from_configs
+from lerobot.motors import Motor, MotorCalibration, MotorNormMode
+from lerobot.motors.damiao import DamiaoMotorsBus
+from lerobot.motors.damiao.tables import MotorType
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
+
+from ..robot import Robot
+from ..utils import ensure_safe_goal_position
+from .config_openarms_follower import OpenArmsFollowerConfig
+
+logger = logging.getLogger(__name__)
+
+
+class OpenArmsFollower(Robot):
+    """
+    OpenArms Follower Robot which uses CAN bus communication to control 7 DOF arm with a gripper.
+    The arm uses Damiao motors in MIT control mode.
+    """
+
+    config_class = OpenArmsFollowerConfig
+    name = "openarms_follower"
+
+    def __init__(self, config: OpenArmsFollowerConfig):
+        super().__init__(config)
+        self.config = config
+        
+        norm_mode_body = MotorNormMode.DEGREES  # Always use degrees for Damiao motors
+        
+        # Right arm motors (on port_right)
+        # Each arm uses the same CAN IDs since they're on separate buses
+        motors_right = {}
+        for motor_name, (send_id, recv_id, motor_type_str) in config.motor_config.items():
+            motor = Motor(send_id, motor_type_str, norm_mode_body)
+            motor.recv_id = recv_id
+            motor.motor_type = getattr(MotorType, motor_type_str.upper().replace("-", "_"))
+            motors_right[motor_name] = motor
+        
+        # Left arm motors (on port_left, same IDs as right since separate bus)
+        motors_left = {}
+        for motor_name, (send_id, recv_id, motor_type_str) in config.motor_config.items():
+            motor = Motor(send_id, motor_type_str, norm_mode_body)
+            motor.recv_id = recv_id
+            motor.motor_type = getattr(MotorType, motor_type_str.upper().replace("-", "_"))
+            motors_left[motor_name] = motor
+        
+        # Initialize separate Damiao motors buses (one per arm) with CAN FD support
+        self.bus_right = DamiaoMotorsBus(
+            port=self.config.port_right,
+            motors=motors_right,
+            calibration={k.replace("right_", ""): v for k, v in (self.calibration or {}).items() if k.startswith("right_")},
+            can_interface=self.config.can_interface,
+            use_can_fd=self.config.use_can_fd,
+            bitrate=self.config.can_bitrate,
+            data_bitrate=self.config.can_data_bitrate if self.config.use_can_fd else None,
+        )
+        
+        self.bus_left = DamiaoMotorsBus(
+            port=self.config.port_left,
+            motors=motors_left,
+            calibration={k.replace("left_", ""): v for k, v in (self.calibration or {}).items() if k.startswith("left_")},
+            can_interface=self.config.can_interface,
+            use_can_fd=self.config.use_can_fd,
+            bitrate=self.config.can_bitrate,
+            data_bitrate=self.config.can_data_bitrate if self.config.use_can_fd else None,
+        )
+        
+        # Initialize cameras
+        self.cameras = make_cameras_from_configs(config.cameras)
+        
+        # Initialize Pinocchio robot model for dynamics (optional)
+        self.pin_robot = None
+        try:
+            # Try to load URDF if available
+            # TODO: Add OpenArms URDF file to repository
+            self.pin_robot = pin.RobotWrapper.BuildFromURDF("urdf/openarms.urdf", "urdf")
+            logger.info("Loaded OpenArms URDF for dynamics computation")
+        except Exception as e:
+            logger.warning(f"Could not load URDF for dynamics: {e}. Gravity compensation will not be available.")
+
+    @property
+    def _motors_ft(self) -> Dict[str, type]:
+        """Motor features for observation and action spaces."""
+        features = {}
+        # Right arm motors
+        for motor in self.bus_right.motors:
+            features[f"right_{motor}.pos"] = float
+            features[f"right_{motor}.vel"] = float
+            features[f"right_{motor}.torque"] = float
+        # Left arm motors
+        for motor in self.bus_left.motors:
+            features[f"left_{motor}.pos"] = float
+            features[f"left_{motor}.vel"] = float
+            features[f"left_{motor}.torque"] = float
+        return features
+
+    @property
+    def _cameras_ft(self) -> Dict[str, tuple]:
+        """Camera features for observation space."""
+        return {
+            cam: (self.config.cameras[cam].height, self.config.cameras[cam].width, 3)
+            for cam in self.cameras
+        }
+
+    @cached_property
+    def observation_features(self) -> Dict[str, type | tuple]:
+        """Combined observation features from motors and cameras."""
+        return {**self._motors_ft, **self._cameras_ft}
+
+    @cached_property
+    def action_features(self) -> Dict[str, type]:
+        """Action features (motor positions only)."""
+        return self._motors_ft
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if robot is connected."""
+        return (self.bus_right.is_connected and 
+                self.bus_left.is_connected and 
+                all(cam.is_connected for cam in self.cameras.values()))
+
+    def connect(self, calibrate: bool = True) -> None:
+        """
+        Connect to the robot and optionally calibrate.
+        
+        We assume that at connection time, the arms are in a safe rest position,
+        and torque can be safely disabled to run calibration if needed.
+        """
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(f"{self} already connected")
+
+        # Connect to both CAN buses
+        logger.info(f"Connecting right arm on {self.config.port_right}...")
+        self.bus_right.connect()
+        logger.info(f"Connecting left arm on {self.config.port_left}...")
+        self.bus_left.connect()
+        
+        # Run calibration if needed
+        if not self.is_calibrated and calibrate:
+            logger.info(
+                "No calibration found or calibration mismatch. Running calibration..."
+            )
+            self.calibrate()
+        
+        # Connect cameras
+        for cam in self.cameras.values():
+            cam.connect()
+        
+        # Configure motors
+        self.configure()
+        
+        # Optionally set zero position
+        if self.config.zero_position_on_connect:
+            logger.info("Setting current position as zero...")
+            self.bus_right.set_zero_position()
+            self.bus_left.set_zero_position()
+        
+        logger.info(f"{self} connected.")
+
+    @property
+    def is_calibrated(self) -> bool:
+        """Check if robot is calibrated."""
+        return self.bus_right.is_calibrated and self.bus_left.is_calibrated
+
+    def calibrate(self) -> None:
+        """
+        Run calibration procedure for OpenArms robot.
+        
+        The calibration procedure:
+        1. Disable torque
+        2. Ask user to position arms in hanging position with grippers closed
+        3. Set this as zero position
+        4. Record range of motion for each joint
+        5. Save calibration
+        """
+        if self.calibration:
+            # Ask user whether to use existing calibration
+            user_input = input(
+                f"Press ENTER to use existing calibration for {self.id}, "
+                f"or type 'c' and press ENTER to run new calibration: "
+            )
+            if user_input.strip().lower() != "c":
+                logger.info(f"Using existing calibration for {self.id}")
+                # Split calibration for each bus
+                cal_right = {k.replace("right_", ""): v for k, v in self.calibration.items() if k.startswith("right_")}
+                cal_left = {k.replace("left_", ""): v for k, v in self.calibration.items() if k.startswith("left_")}
+                self.bus_right.write_calibration(cal_right)
+                self.bus_left.write_calibration(cal_left)
+                return
+        
+        logger.info(f"\nRunning calibration for {self}")
+        
+        # Calibrate each arm separately
+        self._calibrate_arm("right", self.bus_right)
+        self._calibrate_arm("left", self.bus_left)
+        
+        print(f"\nCalibration complete and saved to {self.calibration_fpath}")
+    
+    def _calibrate_arm(self, arm_name: str, bus: DamiaoMotorsBus) -> None:
+        """Calibrate a single arm."""
+        logger.info(f"\n=== Calibrating {arm_name.upper()} arm ===")
+        
+        # Disable torque for manual positioning
+        bus.disable_torque()
+        time.sleep(0.1)
+        
+        # Step 1: Set zero position
+        input(
+            f"\nCalibration: Zero Position ({arm_name.upper()} arm)\n"
+            "Position the arm in the following configuration:\n"
+            "  - Arm hanging straight down\n"
+            "  - Gripper closed\n"
+            "Press ENTER when ready..."
+        )
+        
+        # Set current position as zero for all motors
+        bus.set_zero_position()
+        logger.info(f"{arm_name.capitalize()} arm zero position set.")
+        
+        # Automatically set range to -90° to +90° for all joints
+        print(
+            f"\nAutomatically setting range: -90° to +90° for all joints"
+        )
+        
+        # Create calibration data with fixed ranges
+        if self.calibration is None:
+            self.calibration = {}
+            
+        for motor_name, motor in bus.motors.items():
+            # Prefix motor name with arm name for storage
+            prefixed_name = f"{arm_name}_{motor_name}"
+            
+            # Use -90 to +90 for all joints and gripper (integers required)
+            self.calibration[prefixed_name] = MotorCalibration(
+                id=motor.id,
+                drive_mode=0,  # Normal direction
+                homing_offset=0,  # Already set via set_zero_position
+                range_min=-90,  # -90 degrees (integer)
+                range_max=90,   # +90 degrees (integer)
+            )
+            logger.info(f"  {prefixed_name}: range set to [-90°, +90°]")
+        
+        # Write calibration to this arm's motors
+        cal_for_bus = {k.replace(f"{arm_name}_", ""): v for k, v in self.calibration.items() if k.startswith(f"{arm_name}_")}
+        bus.write_calibration(cal_for_bus)
+        
+        # Re-enable torque
+        bus.enable_torque()
+        
+        # Save calibration after each arm
+        self._save_calibration()
+
+    def configure(self) -> None:
+        """Configure motors with appropriate settings."""
+        # Configure right arm
+        with self.bus_right.torque_disabled():
+            self.bus_right.configure_motors()
+        
+        # Configure left arm
+        with self.bus_left.torque_disabled():
+            self.bus_left.configure_motors()
+
+    def setup_motors(self) -> None:
+        raise NotImplementedError("Motor ID configuration is typically done via manufacturer tools for CAN motors.")
+
+    def get_observation(self) -> Dict[str, Any]:
+        """Get current observation from robot including position, velocity, and torque."""
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+        
+        obs_dict = {}
+        
+        # Read motor positions, velocities, and torques from right arm
+        start = time.perf_counter()
+        positions_right = self.bus_right.sync_read("Present_Position")
+        velocities_right = self.bus_right.sync_read("Present_Velocity")
+        torques_right = self.bus_right.sync_read("Present_Torque")
+        
+        for motor in self.bus_right.motors:
+            obs_dict[f"right_{motor}.pos"] = positions_right.get(motor, 0.0)
+            obs_dict[f"right_{motor}.vel"] = velocities_right.get(motor, 0.0)
+            obs_dict[f"right_{motor}.torque"] = torques_right.get(motor, 0.0)
+        
+        # Read motor positions, velocities, and torques from left arm
+        positions_left = self.bus_left.sync_read("Present_Position")
+        velocities_left = self.bus_left.sync_read("Present_Velocity")
+        torques_left = self.bus_left.sync_read("Present_Torque")
+        
+        for motor in self.bus_left.motors:
+            obs_dict[f"left_{motor}.pos"] = positions_left.get(motor, 0.0)
+            obs_dict[f"left_{motor}.vel"] = velocities_left.get(motor, 0.0)
+            obs_dict[f"left_{motor}.torque"] = torques_left.get(motor, 0.0)
+        
+        dt_ms = (time.perf_counter() - start) * 1e3
+        logger.debug(f"{self} read state: {dt_ms:.1f}ms")
+        
+        # Capture images from cameras
+        for cam_key, cam in self.cameras.items():
+            start = time.perf_counter()
+            obs_dict[cam_key] = cam.async_read()
+            dt_ms = (time.perf_counter() - start) * 1e3
+            logger.debug(f"{self} read {cam_key}: {dt_ms:.1f}ms")
+        
+        return obs_dict
+
+    def send_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Send action command to robot.
+        
+        The action magnitude may be clipped based on safety limits.
+        
+        Args:
+            action: Dictionary with motor positions (e.g., "right_joint_1.pos", "left_joint_2.pos")
+            
+        Returns:
+            The action actually sent (potentially clipped)
+        """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+        
+        # Extract motor positions from action and split by arm
+        goal_pos_right = {}
+        goal_pos_left = {}
+        
+        for key, val in action.items():
+            if key.endswith(".pos"):
+                motor_name = key.removesuffix(".pos")
+                if motor_name.startswith("right_"):
+                    # Remove "right_" prefix for bus access
+                    goal_pos_right[motor_name.removeprefix("right_")] = val
+                elif motor_name.startswith("left_"):
+                    # Remove "left_" prefix for bus access
+                    goal_pos_left[motor_name.removeprefix("left_")] = val
+        
+        # Apply safety limits if configured
+        if self.config.max_relative_target is not None:
+            # Get current positions
+            present_pos_right = self.bus_right.sync_read("Present_Position")
+            present_pos_left = self.bus_left.sync_read("Present_Position")
+            
+            # Apply safety limits to right arm
+            if goal_pos_right:
+                goal_present_pos_right = {
+                    key: (g_pos, present_pos_right.get(key, 0.0)) 
+                    for key, g_pos in goal_pos_right.items()
+                }
+                goal_pos_right = ensure_safe_goal_position(
+                    goal_present_pos_right, 
+                    self.config.max_relative_target
+                )
+            
+            # Apply safety limits to left arm
+            if goal_pos_left:
+                goal_present_pos_left = {
+                    key: (g_pos, present_pos_left.get(key, 0.0)) 
+                    for key, g_pos in goal_pos_left.items()
+                }
+                goal_pos_left = ensure_safe_goal_position(
+                    goal_present_pos_left, 
+                    self.config.max_relative_target
+                )
+        
+        # Motor name to index mapping for gains
+        motor_index = {
+            "joint_1": 0,
+            "joint_2": 1,
+            "joint_3": 2,
+            "joint_4": 3,
+            "joint_5": 4,
+            "joint_6": 5,
+            "joint_7": 6,
+            "gripper": 7,
+        }
+        
+        # Send MIT control commands to right arm
+        for motor_name, position_degrees in goal_pos_right.items():
+            # Get per-motor gains from config
+            idx = motor_index.get(motor_name, 0)
+            kp = self.config.position_kp[idx]
+            kd = self.config.position_kd[idx]
+            
+            # Send MIT control command (position is in degrees)
+            self.bus_right._mit_control(
+                motor_name,
+                kp=kp,
+                kd=kd,
+                position_degrees=position_degrees,
+                velocity_deg_per_sec=0.0,
+                torque=0.0
+            )
+        
+        # Send MIT control commands to left arm
+        for motor_name, position_degrees in goal_pos_left.items():
+            # Get per-motor gains from config
+            idx = motor_index.get(motor_name, 0)
+            kp = self.config.position_kp[idx]
+            kd = self.config.position_kd[idx]
+            
+            # Send MIT control command (position is in degrees)
+            self.bus_left._mit_control(
+                motor_name,
+                kp=kp,
+                kd=kd,
+                position_degrees=position_degrees,
+                velocity_deg_per_sec=0.0,
+                torque=0.0
+            )
+        
+        # Return the actions that were actually sent
+        result = {}
+        for motor, val in goal_pos_right.items():
+            result[f"right_{motor}.pos"] = val
+        for motor, val in goal_pos_left.items():
+            result[f"left_{motor}.pos"] = val
+        return result
+
+    def disconnect(self):
+        """Disconnect from robot."""
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+        
+        # Disconnect from CAN buses
+        self.bus_right.disconnect(self.config.disable_torque_on_disconnect)
+        self.bus_left.disconnect(self.config.disable_torque_on_disconnect)
+        
+        # Disconnect cameras
+        for cam in self.cameras.values():
+            cam.disconnect()
+        
+        logger.info(f"{self} disconnected.")
+    
+    def _deg_to_rad(self, deg: Dict[str, float | int]) -> Dict[str, float]:
+        """Convert degrees to radians for all motors."""
+        return {m: np.deg2rad(float(v)) for m, v in deg.items()}
+    
+    def _gravity_from_q(self, q_rad: Dict[str, float]) -> Dict[str, float]:
+        """
+        Compute g(q) [N·m] for all joints in the robot.
+        The order of joints in the URDF matches the concatenated motor lists (right then left).
+        
+        Args:
+            q_rad: Dictionary mapping motor names (with arm prefix) to positions in radians
+            
+        Returns:
+            Dictionary mapping motor names to gravity torques in N·m
+            
+        Raises:
+            RuntimeError: If URDF model is not loaded
+        """
+        if self.pin_robot is None:
+            raise RuntimeError(
+                "Cannot compute gravity: URDF model not loaded. "
+                "Ensure urdf/openarms.urdf exists and is valid."
+            )
+        
+        # Build position vector in the order of motors (right arm, then left arm)
+        q = np.zeros(self.pin_robot.model.nq)
+        idx = 0
+        
+        # Right arm motors
+        for motor_name in self.bus_right.motors:
+            full_name = f"right_{motor_name}"
+            q[idx] = q_rad.get(full_name, 0.0)
+            idx += 1
+        
+        # Left arm motors
+        for motor_name in self.bus_left.motors:
+            full_name = f"left_{motor_name}"
+            q[idx] = q_rad.get(full_name, 0.0)
+            idx += 1
+        
+        # Compute generalized gravity vector
+        g = pin.computeGeneralizedGravity(self.pin_robot.model, self.pin_robot.data, q)
+        
+        # Map back to motor names
+        result = {}
+        idx = 0
+        for motor_name in self.bus_right.motors:
+            result[f"right_{motor_name}"] = float(g[idx])
+            idx += 1
+        for motor_name in self.bus_left.motors:
+            result[f"left_{motor_name}"] = float(g[idx])
+            idx += 1
+        
+        return result
+    

src/lerobot/teleoperators/openarms/__init__.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .config_openarms_leader import OpenArmsLeaderConfig
+from .openarms_leader import OpenArmsLeader
+
+__all__ = ["OpenArmsLeader", "OpenArmsLeaderConfig"]

src/lerobot/teleoperators/openarms/config_openarms_leader.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+from typing import Dict
+
+from ..config import TeleoperatorConfig
+
+
+@TeleoperatorConfig.register_subclass("openarms_leader")
+@dataclass
+class OpenArmsLeaderConfig(TeleoperatorConfig):
+    """Configuration for the OpenArms leader/teleoperator with Damiao motors."""
+    
+    # CAN interfaces - one per arm
+    # Right arm CAN interface (e.g., "can2")
+    # Left arm CAN interface (e.g., "can3")
+    # Linux: "can0", "can1", etc.
+    # macOS: "/dev/cu.usbmodem*" (serial device)
+    port_right: str = "can2"    # CAN interface for right arm
+    port_left: str = "can3"     # CAN interface for left arm
+    
+    # CAN interface type: "socketcan" (Linux), "slcan" (macOS/serial), or "auto" (auto-detect)
+    can_interface: str = "socketcan"
+    
+    # CAN FD settings (OpenArms uses CAN FD by default)
+    use_can_fd: bool = True
+    can_bitrate: int = 1000000      # Nominal bitrate (1 Mbps)
+    can_data_bitrate: int = 5000000  # Data bitrate for CAN FD (5 Mbps)
+    
+    # Motor configuration for OpenArms (7 DOF per arm)
+    # Maps motor names to (send_can_id, recv_can_id, motor_type)
+    # Based on: https://docs.openarm.dev/software/setup/configure-test
+    # OpenArms uses 4 types of motors:
+    # - DM8009 (DM-J8009P-2EC) for shoulders (high torque)
+    # - DM4340P and DM4340 for shoulder rotation and elbow
+    # - DM4310 (DM-J4310-2EC V1.1) for wrist and gripper
+    motor_config: Dict[str, tuple[int, int, str]] = field(default_factory=lambda: {
+        "joint_1": (0x01, 0x11, "dm8009"),   # J1 - Shoulder pan (DM8009)
+        "joint_2": (0x02, 0x12, "dm8009"),   # J2 - Shoulder lift (DM8009)
+        "joint_3": (0x03, 0x13, "dm4340"),   # J3 - Shoulder rotation (DM4340)
+        "joint_4": (0x04, 0x14, "dm4340"),   # J4 - Elbow flex (DM4340)
+        "joint_5": (0x05, 0x15, "dm4310"),   # J5 - Wrist roll (DM4310)
+        "joint_6": (0x06, 0x16, "dm4310"),   # J6 - Wrist pitch (DM4310)
+        "joint_7": (0x07, 0x17, "dm4310"),   # J7 - Wrist rotation (DM4310)
+        "gripper": (0x08, 0x18, "dm4310"),   # J8 - Gripper (DM4310)
+    })
+    
+    # Torque mode settings for manual control
+    # When enabled, motors have torque disabled for manual movement
+    manual_control: bool = True

src/lerobot/teleoperators/openarms/openarms_leader.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import time
+from typing import Any, Dict
+
+from lerobot.motors import Motor, MotorCalibration, MotorNormMode
+from lerobot.motors.damiao import DamiaoMotorsBus
+from lerobot.motors.damiao.tables import MotorType
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
+
+from ..teleoperator import Teleoperator
+from .config_openarms_leader import OpenArmsLeaderConfig
+
+logger = logging.getLogger(__name__)
+
+
+class OpenArmsLeader(Teleoperator):
+    """
+    OpenArms Leader/Teleoperator Arm with Damiao motors.
+    
+    This teleoperator uses CAN bus communication to read positions from 
+    Damiao motors that are manually moved (torque disabled).
+    """
+
+    config_class = OpenArmsLeaderConfig
+    name = "openarms_leader"
+
+    def __init__(self, config: OpenArmsLeaderConfig):
+        super().__init__(config)
+        self.config = config
+        
+        norm_mode_body = MotorNormMode.DEGREES  # Always use degrees for Damiao motors
+        
+        # Right arm motors (on port_right)
+        # Each arm uses the same CAN IDs since they're on separate buses
+        motors_right = {}
+        for motor_name, (send_id, recv_id, motor_type_str) in config.motor_config.items():
+            motor = Motor(send_id, motor_type_str, norm_mode_body)
+            motor.recv_id = recv_id
+            motor.motor_type = getattr(MotorType, motor_type_str.upper().replace("-", "_"))
+            motors_right[motor_name] = motor
+        
+        # Left arm motors (on port_left, same IDs as right since separate bus)
+        motors_left = {}
+        for motor_name, (send_id, recv_id, motor_type_str) in config.motor_config.items():
+            motor = Motor(send_id, motor_type_str, norm_mode_body)
+            motor.recv_id = recv_id
+            motor.motor_type = getattr(MotorType, motor_type_str.upper().replace("-", "_"))
+            motors_left[motor_name] = motor
+        
+        # Initialize separate Damiao motors buses (one per arm) with CAN FD support
+        self.bus_right = DamiaoMotorsBus(
+            port=self.config.port_right,
+            motors=motors_right,
+            calibration={k.replace("right_", ""): v for k, v in (self.calibration or {}).items() if k.startswith("right_")},
+            can_interface=self.config.can_interface,
+            use_can_fd=self.config.use_can_fd,
+            bitrate=self.config.can_bitrate,
+            data_bitrate=self.config.can_data_bitrate if self.config.use_can_fd else None,
+        )
+        
+        self.bus_left = DamiaoMotorsBus(
+            port=self.config.port_left,
+            motors=motors_left,
+            calibration={k.replace("left_", ""): v for k, v in (self.calibration or {}).items() if k.startswith("left_")},
+            can_interface=self.config.can_interface,
+            use_can_fd=self.config.use_can_fd,
+            bitrate=self.config.can_bitrate,
+            data_bitrate=self.config.can_data_bitrate if self.config.use_can_fd else None,
+        )
+
+    @property
+    def action_features(self) -> Dict[str, type]:
+        """Features produced by this teleoperator."""
+        features = {}
+        # Right arm motors
+        for motor in self.bus_right.motors:
+            features[f"right_{motor}.pos"] = float
+            features[f"right_{motor}.vel"] = float
+            features[f"right_{motor}.torque"] = float
+        # Left arm motors
+        for motor in self.bus_left.motors:
+            features[f"left_{motor}.pos"] = float
+            features[f"left_{motor}.vel"] = float
+            features[f"left_{motor}.torque"] = float
+        return features
+
+    @property
+    def feedback_features(self) -> Dict[str, type]:
+        """Feedback features (not implemented for OpenArms)."""
+        return {}
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if teleoperator is connected."""
+        return self.bus_right.is_connected and self.bus_left.is_connected
+
+    def connect(self, calibrate: bool = True) -> None:
+        """
+        Connect to the teleoperator.
+        
+        For manual control, we disable torque after connecting so the
+        arm can be moved by hand.
+        """
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(f"{self} already connected")
+
+        # Connect to CAN buses
+        logger.info(f"Connecting right arm on {self.config.port_right}...")
+        self.bus_right.connect()
+        logger.info(f"Connecting left arm on {self.config.port_left}...")
+        self.bus_left.connect()
+        
+        # Run calibration if needed
+        if not self.is_calibrated and calibrate:
+            logger.info(
+                "No calibration found or calibration mismatch. Running calibration..."
+            )
+            self.calibrate()
+        
+        # Configure for manual control
+        self.configure()
+        
+        logger.info(f"{self} connected.")
+
+    @property
+    def is_calibrated(self) -> bool:
+        """Check if teleoperator is calibrated."""
+        return self.bus_right.is_calibrated and self.bus_left.is_calibrated
+
+    def calibrate(self) -> None:
+        """
+        Run calibration procedure for OpenArms leader.
+        
+        The calibration procedure:
+        1. Disable torque (if not already disabled)
+        2. Ask user to position arm in zero position (hanging with gripper closed)
+        3. Set this as zero position
+        4. Record range of motion for each joint
+        5. Save calibration
+        """
+        if self.calibration:
+            # Ask user whether to use existing calibration
+            user_input = input(
+                f"Press ENTER to use existing calibration for {self.id}, "
+                f"or type 'c' and press ENTER to run new calibration: "
+            )
+            if user_input.strip().lower() != "c":
+                logger.info(f"Using existing calibration for {self.id}")
+                # Split calibration for each bus
+                cal_right = {k.replace("right_", ""): v for k, v in self.calibration.items() if k.startswith("right_")}
+                cal_left = {k.replace("left_", ""): v for k, v in self.calibration.items() if k.startswith("left_")}
+                self.bus_right.write_calibration(cal_right)
+                self.bus_left.write_calibration(cal_left)
+                return
+        
+        logger.info(f"\nRunning calibration for {self}")
+        
+        # Calibrate each arm separately
+        self._calibrate_arm("right", self.bus_right)
+        self._calibrate_arm("left", self.bus_left)
+        
+        print(f"\nCalibration complete and saved to {self.calibration_fpath}")
+    
+    def _calibrate_arm(self, arm_name: str, bus: DamiaoMotorsBus) -> None:
+        """Calibrate a single arm."""
+        logger.info(f"\n=== Calibrating {arm_name.upper()} arm ===")
+        
+        # Ensure torque is disabled for manual positioning
+        bus.disable_torque()
+        time.sleep(0.1)
+        
+        # Step 1: Set zero position
+        input(
+            f"\nCalibration: Zero Position ({arm_name.upper()} arm)\n"
+            "Position the arm in the following configuration:\n"
+            "  - Arm hanging straight down\n"
+            "  - Gripper closed\n"
+            "Press ENTER when ready..."
+        )
+        
+        # Set current position as zero for all motors
+        bus.set_zero_position()
+        logger.info(f"{arm_name.capitalize()} arm zero position set.")
+        
+        # Automatically set range to -90° to +90° for all joints
+        print(
+            f"\nAutomatically setting range: -90° to +90° for all joints"
+        )
+        
+        # Create calibration data with fixed ranges
+        if self.calibration is None:
+            self.calibration = {}
+            
+        for motor_name, motor in bus.motors.items():
+            # Prefix motor name with arm name for storage
+            prefixed_name = f"{arm_name}_{motor_name}"
+            
+            # Use -90 to +90 for all joints and gripper (integers required)
+            self.calibration[prefixed_name] = MotorCalibration(
+                id=motor.id,
+                drive_mode=0,  # Normal direction
+                homing_offset=0,  # Already set via set_zero_position
+                range_min=-90,  # -90 degrees (integer)
+                range_max=90,   # +90 degrees (integer)
+            )
+            logger.info(f"  {prefixed_name}: range set to [-90°, +90°]")
+        
+        # Write calibration to this arm's motors
+        cal_for_bus = {k.replace(f"{arm_name}_", ""): v for k, v in self.calibration.items() if k.startswith(f"{arm_name}_")}
+        bus.write_calibration(cal_for_bus)
+        
+        # Save calibration after each arm
+        self._save_calibration()
+
+    def configure(self) -> None:
+        """
+        Configure motors for manual teleoperation.
+        
+        For manual control, we disable torque so the arm can be moved by hand.
+        """
+        if self.config.manual_control:
+            # Disable torque for manual control
+            logger.info("Disabling torque for manual control...")
+            self.bus_right.disable_torque()
+            self.bus_left.disable_torque()
+        else:
+            # Configure motors normally
+            self.bus_right.configure_motors()
+            self.bus_left.configure_motors()
+
+    def setup_motors(self) -> None:
+        raise NotImplementedError("Motor ID configuration is typically done via manufacturer tools for CAN motors.")
+
+
+    def get_action(self) -> Dict[str, Any]:
+        """
+        Get current action from the leader arm.
+        
+        This is the main method for teleoperators - it reads the current state
+        of the leader arm and returns it as an action that can be sent to a follower.
+        """
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+        
+        action_dict = {}
+        
+        # Read motor positions, velocities, and torques from right arm
+        start = time.perf_counter()
+        positions_right = self.bus_right.sync_read("Present_Position")
+        velocities_right = self.bus_right.sync_read("Present_Velocity")
+        torques_right = self.bus_right.sync_read("Present_Torque")
+        
+        for motor in self.bus_right.motors:
+            action_dict[f"right_{motor}.pos"] = positions_right.get(motor, 0.0)
+            action_dict[f"right_{motor}.vel"] = velocities_right.get(motor, 0.0)
+            action_dict[f"right_{motor}.torque"] = torques_right.get(motor, 0.0)
+        
+        # Read motor positions, velocities, and torques from left arm
+        positions_left = self.bus_left.sync_read("Present_Position")
+        velocities_left = self.bus_left.sync_read("Present_Velocity")
+        torques_left = self.bus_left.sync_read("Present_Torque")
+        
+        for motor in self.bus_left.motors:
+            action_dict[f"left_{motor}.pos"] = positions_left.get(motor, 0.0)
+            action_dict[f"left_{motor}.vel"] = velocities_left.get(motor, 0.0)
+            action_dict[f"left_{motor}.torque"] = torques_left.get(motor, 0.0)
+        
+        dt_ms = (time.perf_counter() - start) * 1e3
+        logger.debug(f"{self} read state: {dt_ms:.1f}ms")
+        
+        return action_dict
+
+    def send_feedback(self, feedback: Dict[str, float]) -> None:
+        raise NotImplementedError("Feedback is not yet implemented for OpenArms leader.")
+
+    def disconnect(self) -> None:
+        """Disconnect from teleoperator."""
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+        
+        # For manual control, ensure torque is disabled before disconnecting
+        if self.config.manual_control:
+            try:
+                self.bus_right.disable_torque()
+                self.bus_left.disable_torque()
+            except Exception as e:
+                logger.warning(f"Failed to disable torque during disconnect: {e}")
+        
+        # Disconnect from CAN buses
+        self.bus_right.disconnect(disable_torque=False)  # Already disabled above if needed
+        self.bus_left.disconnect(disable_torque=False)
+        
+        logger.info(f"{self} disconnected.")
+

tests/conftest.py

@@ -32,6 +32,39 @@ pytest_plugins = [
 ]
 
 
+def pytest_addoption(parser):
+    """Add custom command line option for hardware tests."""
+    parser.addoption(
+        "--run-hardware",
+        action="store_true",
+        default=False,
+        help="Run hardware tests that require actual motors connected",
+    )
+    parser.addoption(
+        "--can-port",
+        action="store",
+        default=None,
+        help="CAN interface port (e.g., 'can0' for Linux, '/dev/cu.usbmodem*' for macOS)",
+    )
+
+
+def pytest_configure(config):
+    """Register custom marker for hardware tests."""
+    config.addinivalue_line("markers", "hardware: mark test as requiring hardware")
+
+
+def pytest_collection_modifyitems(config, items):
+    """Skip hardware tests unless --run-hardware flag is provided."""
+    if config.getoption("--run-hardware"):
+        # --run-hardware given in cli: do not skip hardware tests
+        return
+    
+    skip_hardware = pytest.mark.skip(reason="need --run-hardware option to run")
+    for item in items:
+        if "hardware" in item.keywords:
+            item.add_marker(skip_hardware)
+
+
 def pytest_collection_finish():
     print(f"\nTesting with {DEVICE=}")
 

tests/envs/test_envs.py

@@ -17,7 +17,6 @@ import importlib
 from dataclasses import dataclass, field
 
 import gymnasium as gym
-import numpy as np
 import pytest
 import torch
 from gymnasium.envs.registration import register, registry as gym_registry
@@ -27,11 +26,7 @@ import lerobot
 from lerobot.configs.types import PolicyFeature
 from lerobot.envs.configs import EnvConfig
 from lerobot.envs.factory import make_env, make_env_config
-from lerobot.envs.utils import (
-    _normalize_hub_result,
-    _parse_hub_url,
-    preprocess_observation,
-)
+from lerobot.envs.utils import preprocess_observation
 from tests.utils import require_env
 
 OBS_TYPES = ["state", "pixels", "pixels_agent_pos"]
@@ -113,156 +108,3 @@ def test_factory_custom_gym_id():
     finally:
         if gym_id in gym_registry:
             del gym_registry[gym_id]
-
-
-# Hub environment loading tests
-
-
-def test_make_env_hub_url_parsing():
-    """Test URL parsing for hub environment references."""
-    # simple repo_id
-    repo_id, revision, file_path = _parse_hub_url("user/repo")
-    assert repo_id == "user/repo"
-    assert revision is None
-    assert file_path == "env.py"
-
-    # repo with revision
-    repo_id, revision, file_path = _parse_hub_url("user/repo@main")
-    assert repo_id == "user/repo"
-    assert revision == "main"
-    assert file_path == "env.py"
-
-    # repo with custom file path
-    repo_id, revision, file_path = _parse_hub_url("user/repo:custom_env.py")
-    assert repo_id == "user/repo"
-    assert revision is None
-    assert file_path == "custom_env.py"
-
-    # repo with revision and custom file path
-    repo_id, revision, file_path = _parse_hub_url("user/repo@v1.0:envs/my_env.py")
-    assert repo_id == "user/repo"
-    assert revision == "v1.0"
-    assert file_path == "envs/my_env.py"
-
-    # repo with commit hash
-    repo_id, revision, file_path = _parse_hub_url("org/repo@abc123def456")
-    assert repo_id == "org/repo"
-    assert revision == "abc123def456"
-    assert file_path == "env.py"
-
-
-def test_normalize_hub_result():
-    """Test normalization of different return types from hub make_env."""
-    # test with VectorEnv (most common case)
-    mock_vec_env = gym.vector.SyncVectorEnv([lambda: gym.make("CartPole-v1")])
-    result = _normalize_hub_result(mock_vec_env)
-    assert isinstance(result, dict)
-    assert len(result) == 1
-    suite_name = next(iter(result))
-    assert 0 in result[suite_name]
-    assert isinstance(result[suite_name][0], gym.vector.VectorEnv)
-    mock_vec_env.close()
-
-    # test with single Env
-    mock_env = gym.make("CartPole-v1")
-    result = _normalize_hub_result(mock_env)
-    assert isinstance(result, dict)
-    suite_name = next(iter(result))
-    assert 0 in result[suite_name]
-    assert isinstance(result[suite_name][0], gym.vector.VectorEnv)
-    result[suite_name][0].close()
-
-    # test with dict (already normalized)
-    mock_vec_env = gym.vector.SyncVectorEnv([lambda: gym.make("CartPole-v1")])
-    input_dict = {"my_suite": {0: mock_vec_env}}
-    result = _normalize_hub_result(input_dict)
-    assert result == input_dict
-    assert "my_suite" in result
-    assert 0 in result["my_suite"]
-    mock_vec_env.close()
-
-    # test with invalid type
-    with pytest.raises(ValueError, match="Hub `make_env` must return"):
-        _normalize_hub_result("invalid_type")
-
-
-def test_make_env_from_hub_requires_trust_remote_code():
-    """Test that loading from hub requires explicit trust_remote_code=True."""
-    hub_id = "lerobot/cartpole-env"
-
-    # Should raise RuntimeError when trust_remote_code=False (default)
-    with pytest.raises(RuntimeError, match="Refusing to execute remote code"):
-        make_env(hub_id, trust_remote_code=False)
-
-    # Should also raise when not specified (defaults to False)
-    with pytest.raises(RuntimeError, match="Refusing to execute remote code"):
-        make_env(hub_id)
-
-
-@pytest.mark.parametrize(
-    "hub_id",
-    [
-        "lerobot/cartpole-env",
-        "lerobot/cartpole-env@main",
-        "lerobot/cartpole-env:env.py",
-    ],
-)
-def test_make_env_from_hub_with_trust(hub_id):
-    """Test loading environment from Hugging Face Hub with trust_remote_code=True."""
-    # load environment from hub
-    envs_dict = make_env(hub_id, n_envs=2, trust_remote_code=True)
-
-    # verify structure
-    assert isinstance(envs_dict, dict)
-    assert len(envs_dict) >= 1
-
-    # get the first suite and task
-    suite_name = next(iter(envs_dict))
-    task_id = next(iter(envs_dict[suite_name]))
-    env = envs_dict[suite_name][task_id]
-
-    # verify it's a vector environment
-    assert isinstance(env, gym.vector.VectorEnv)
-    assert env.num_envs == 2
-
-    # test basic environment interaction
-    obs, info = env.reset()
-    assert obs is not None
-    assert isinstance(obs, (dict, np.ndarray))
-
-    # take a random action
-    action = env.action_space.sample()
-    obs, reward, terminated, truncated, info = env.step(action)
-    assert obs is not None
-    assert isinstance(reward, np.ndarray)
-    assert len(reward) == 2
-
-    # clean up
-    env.close()
-
-
-def test_make_env_from_hub_async():
-    """Test loading hub environment with async vector environments."""
-    hub_id = "lerobot/cartpole-env"
-
-    # load with async envs
-    envs_dict = make_env(hub_id, n_envs=2, use_async_envs=True, trust_remote_code=True)
-
-    suite_name = next(iter(envs_dict))
-    task_id = next(iter(envs_dict[suite_name]))
-    env = envs_dict[suite_name][task_id]
-
-    # verify it's an async vector environment
-    assert isinstance(env, gym.vector.AsyncVectorEnv)
-    assert env.num_envs == 2
-
-    # test basic interaction
-    obs, info = env.reset()
-    assert obs is not None
-
-    action = env.action_space.sample()
-    obs, reward, terminated, truncated, info = env.step(action)
-    assert len(reward) == 2
-
-    # clean up
-    env.close()

tests/motors/test_damiao.py

@@ -0,0 +1,338 @@
+#!/usr/bin/env python
+
+# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Test script for Damiao motor communication and control.
+
+This script tests basic functionality of a single Damiao motor via CAN bus:
+1. Connects to CAN interface
+2. Discovers and enables the motor
+3. Reads current position
+4. Sets zero position
+5. Writes target positions
+6. Disables torque
+
+Requirements:
+- Motor must be connected and powered (24V)
+- CAN interface must be configured (e.g., can0)
+- Motor ID must be set to 0x01 (send) and 0x11 (receive)
+
+Setup CAN interface:
+    sudo ip link set can0 type can bitrate 1000000
+    sudo ip link set can0 up
+    
+Verify connection:
+    candump can0  # In another terminal
+    cansend can0 001#FFFFFFFFFFFFFFFC  # Should enable motor and LED turns green
+"""
+
+import time
+
+import pytest
+
+from lerobot.motors import Motor, MotorNormMode
+from lerobot.motors.damiao import DamiaoMotorsBus
+from lerobot.motors.damiao.tables import MotorType
+
+@pytest.fixture
+def can_port(request):
+    """Get CAN port from command line or raise error if not provided."""
+    port = request.config.getoption("--can-port")
+    if port is None:
+        pytest.skip("CAN port not specified. Use --can-port to specify the CAN interface.")
+    return port
+
+
+@pytest.mark.hardware
+def test_single_motor_basic_operations(can_port):
+    """
+    Test basic operations with a single Damiao motor.
+    
+    This test requires actual hardware and is skipped by default.
+    To run with hardware, use: pytest tests/motors/test_damiao.py --run-hardware --can-port PORT
+    """
+    
+    # Configuration
+    MOTOR_ID = 0x01  # Sender CAN ID
+    MOTOR_RECV_ID = 0x11  # Receiver/Master ID
+    MOTOR_TYPE = "dm4310"
+    MOTOR_NAME = "test_motor"
+    
+    print(f"\n{'='*60}")
+    print("Damiao Motor Test - Single Motor Basic Operations")
+    print(f"{'='*60}\n")
+    
+    # Step 1: Create motor configuration
+    print(f"Step 1: Creating motor configuration...")
+    print(f"  - Motor ID: 0x{MOTOR_ID:02X} (send) / 0x{MOTOR_RECV_ID:02X} (recv)")
+    print(f"  - Motor Type: {MOTOR_TYPE}")
+    print(f"  - CAN Port: {can_port}")
+    
+    motor = Motor(MOTOR_ID, MOTOR_TYPE, MotorNormMode.DEGREES)
+    motor.recv_id = MOTOR_RECV_ID
+    motor.motor_type = MotorType.DM4310
+    
+    motors = {MOTOR_NAME: motor}
+    
+    # Step 2: Connect to CAN bus
+    print(f"\nStep 2: Connecting to CAN bus...")
+    bus = DamiaoMotorsBus(port=can_port, motors=motors)
+    
+    try:
+        bus.connect(handshake=True)
+        print(f"  ✓ Connected to {can_port}")
+    except Exception as e:
+        print(f"  ✗ Failed to connect: {e}")
+        print("\nTroubleshooting:")
+        print(f"  1. Check CAN interface is up: ip link show {can_port}")
+        print(f"  2. Setup if needed: sudo ip link set {can_port} type can bitrate 1000000")
+        print(f"  3. Bring up: sudo ip link set {can_port} up")
+        print(f"  4. Test with: cansend {can_port} 001#FFFFFFFFFFFFFFFC")
+        return
+    
+    try:
+        # Step 3: Enable motor (torque on)
+        print(f"\nStep 3: Enabling motor...")
+        bus.enable_torque(MOTOR_NAME)
+        time.sleep(0.1)
+        print(f"  ✓ Motor enabled (LED should be green)")
+        
+        # Step 4: Read current position
+        print(f"\nStep 4: Reading current position...")
+        current_pos = bus.read("Present_Position", MOTOR_NAME, normalize=False)
+        current_vel = bus.read("Present_Velocity", MOTOR_NAME, normalize=False)
+        current_torque = bus.read("Present_Torque", MOTOR_NAME, normalize=False)
+        
+        print(f"  Current State:")
+        print(f"    Position: {current_pos:8.2f}°")
+        print(f"    Velocity: {current_vel:8.2f}°/s")
+        print(f"    Torque:   {current_torque:8.3f} N·m")
+        
+        # Step 5: Set zero position
+        print(f"\nStep 5: Setting current position as zero...")
+        bus.set_zero_position([MOTOR_NAME])
+        time.sleep(0.2)
+        
+        new_pos = bus.read("Present_Position", MOTOR_NAME, normalize=False)
+        print(f"  Position after zero: {new_pos:8.2f}°")
+        print(f"  ✓ Zero position set")
+        
+        # Step 6: Test position commands
+        print(f"\nStep 6: Testing position control...")
+        
+        test_positions = [0.0, 45.0, -45.0, 0.0]
+        
+        for target_pos in test_positions:
+            print(f"\n  Moving to {target_pos:6.1f}°...")
+            bus.write("Goal_Position", MOTOR_NAME, target_pos, normalize=False)
+            time.sleep(1.0)  # Allow motor to move
+            
+            actual_pos = bus.read("Present_Position", MOTOR_NAME, normalize=False)
+            error = abs(actual_pos - target_pos)
+            
+            print(f"    Target:   {target_pos:8.2f}°")
+            print(f"    Actual:   {actual_pos:8.2f}°")
+            print(f"    Error:    {error:8.2f}°")
+            
+            if error > 10.0:
+                print(f"    ⚠ Large position error!")
+            else:
+                print(f"    ✓ Position reached")
+        
+        # Step 7: Test MIT control with custom gains
+        print(f"\nStep 7: Testing MIT control with custom gains...")
+        print(f"  Using lower gains for gentler movement...")
+        
+        # Lower gains for smoother motion
+        bus._mit_control(
+            MOTOR_NAME,
+            kp=5.0,   # Lower position gain
+            kd=0.3,   # Lower damping
+            position_degrees=30.0,
+            velocity_deg_per_sec=0.0,
+            torque=0.0
+        )
+        time.sleep(1.5)
+        
+        final_pos = bus.read("Present_Position", MOTOR_NAME, normalize=False)
+        print(f"  Final position: {final_pos:8.2f}°")
+        print(f"  ✓ MIT control test complete")
+        
+        # Step 8: Return to zero
+        print(f"\nStep 8: Returning to zero position...")
+        bus.write("Goal_Position", MOTOR_NAME, 0.0, normalize=False)
+        time.sleep(1.0)
+        
+        final_pos = bus.read("Present_Position", MOTOR_NAME, normalize=False)
+        print(f"  Final position: {final_pos:8.2f}°")
+        
+    finally:
+        # Step 9: Disable motor
+        print(f"\nStep 9: Disabling motor...")
+        if bus.is_connected:
+            bus.disable_torque(MOTOR_NAME)
+            time.sleep(0.1)
+            print(f"  ✓ Motor disabled (torque off)")
+        
+        # Step 10: Disconnect
+        print(f"\nStep 10: Disconnecting...")
+        if bus.is_connected:
+            bus.disconnect(disable_torque=False)  # Already disabled
+            print(f"  ✓ Disconnected from {can_port}")
+    
+    print(f"\n{'='*60}")
+    print("Test completed successfully!")
+    print(f"{'='*60}\n")
+
+
+@pytest.mark.hardware
+def test_motor_discovery_and_setup(can_port):
+    """
+    Test motor discovery and ID configuration.
+    
+    Note: This test requires the Damiao Debugging Tools for actual ID changes.
+    This test only demonstrates the bus scan functionality.
+    """
+    
+    print(f"\n{'='*60}")
+    print("Damiao Motor Discovery Test")
+    print(f"{'='*60}\n")
+    
+    print("Note: Motor ID configuration must be done via Damiao Debugging Tools")
+    print("See: https://docs.openarm.dev/software/setup/motor-id")
+    print()
+    
+    # Test if CAN interface is accessible
+    print(f"Testing CAN interface: {can_port}")
+    
+    # Create a minimal motor bus for testing
+    test_motor = Motor(0x01, "dm4310", MotorNormMode.DEGREES)
+    test_motor.recv_id = 0x11
+    test_motor.motor_type = MotorType.DM4310
+    
+    bus = DamiaoMotorsBus(port=can_port, motors={"test": test_motor})
+    
+    try:
+        bus.connect(handshake=False)
+        print(f"✓ CAN interface {can_port} is accessible")
+        
+        # Try to communicate with motor at 0x01
+        print(f"\nLooking for motor at ID 0x01...")
+        try:
+            bus._refresh_motor("test")
+            msg = bus._recv_motor_response(timeout=0.5)
+            if msg:
+                print(f"✓ Motor found at ID 0x01, response ID: 0x{msg.arbitration_id:02X}")
+            else:
+                print(f"✗ No response from motor")
+                print("\nTroubleshooting:")
+                print("  1. Verify motor is powered (24V)")
+                print("  2. Check CAN wiring (CANH, CANL)")
+                print("  3. Verify motor ID is set to 0x01")
+                print("  4. Enable with: cansend can0 001#FFFFFFFFFFFFFFFC")
+        except Exception as e:
+                print(f"✗ Error communicating with motor: {e}")
+        
+    except Exception as e:
+        print(f"✗ Failed to access CAN interface: {e}")
+        print("\nSetup CAN interface:")
+        print(f"  sudo ip link set {can_port} type can bitrate 1000000")
+        print(f"  sudo ip link set {can_port} up")
+    
+    finally:
+        if bus.is_connected:
+            bus.disconnect(disable_torque=True)
+    
+    print(f"\n{'='*60}\n")
+
+
+@pytest.mark.hardware
+def test_multi_motor_sync_operations(can_port):
+    """
+    Test synchronized read/write with multiple motors.
+    
+    This demonstrates how to control multiple motors simultaneously.
+    """
+    
+    print(f"\n{'='*60}")
+    print("Damiao Multi-Motor Sync Test")
+    print(f"{'='*60}\n")
+    
+    # Setup motors (adjust IDs as needed)
+    motors = {
+        "joint_1": Motor(0x01, "dm4310", MotorNormMode.DEGREES),
+        "joint_2": Motor(0x02, "dm4310", MotorNormMode.DEGREES),
+    }
+    
+    motors["joint_1"].recv_id = 0x11
+    motors["joint_1"].motor_type = MotorType.DM4310
+    motors["joint_2"].recv_id = 0x12
+    motors["joint_2"].motor_type = MotorType.DM4310
+    
+    bus = DamiaoMotorsBus(port=can_port, motors=motors)
+    
+    try:
+        bus.connect()
+        bus.enable_torque()
+        
+        print("Reading all motor positions...")
+        positions = bus.sync_read("Present_Position")
+        for motor, pos in positions.items():
+            print(f"  {motor}: {pos:.2f}°")
+        
+        print("\nMoving all motors to 45°...")
+        target_positions = {motor: 45.0 for motor in motors}
+        bus.sync_write("Goal_Position", target_positions)
+        time.sleep(2.0)
+        
+        positions = bus.sync_read("Present_Position")
+        print("Final positions:")
+        for motor, pos in positions.items():
+            print(f"  {motor}: {pos:.2f}°")
+        
+    except Exception as e:
+        print(f"✗ Test failed: {e}")
+        print("\nThis is expected on macOS without proper CAN hardware.")
+        print("macOS does not support SocketCAN natively (Linux-only feature).")
+        print("For macOS, you need a USB-CAN adapter with SLCAN support.")
+    finally:
+        if bus.is_connected:
+            bus.disable_torque()
+            bus.disconnect()
+    
+    print(f"\n{'='*60}\n")
+
+
+if __name__ == "__main__":
+    print("Damiao Motor Test Suite")
+    print("=" * 60)
+    print("\nThese tests require actual hardware to run.")
+    print("Please ensure:")
+    print("  1. Motor is connected and powered (24V)")
+    print("  2. CAN interface is configured")
+    print("  3. Motor ID is set to 0x01/0x11")
+    print("\nTo run tests with hardware:")
+    print("\n  Linux (SocketCAN):")
+    print("    sudo ip link set can0 type can bitrate 1000000")
+    print("    sudo ip link set can0 up")
+    print("    pytest tests/motors/test_damiao.py --run-hardware --can-port can0")
+    print("\n  macOS (USB-CAN adapter with SLCAN):")
+    print("    pytest tests/motors/test_damiao.py --run-hardware --can-port /dev/cu.usbmodem00000000050C1")
+    print("\nTo run without hardware (tests will be skipped):")
+    print("  pytest tests/motors/test_damiao.py")
+    print("\nNote: The --run-hardware and --can-port flags are configured in tests/conftest.py")
+    print("=" * 60)
+

tests/training/test_visual_validation.py

@@ -1,157 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Visual Feature Consistency Tests
-
-This module tests the `validate_visual_features_consistency` function,
-which ensures that visual features (camera observations) in a dataset/env
-match the expectations defined in a policy configuration.
-
-The purpose of this check is to prevent mismatches between what a policy expects
-(e.g., `observation.images.camera1`, `camera2`, `camera3`) and what a dataset or
-environment actually provides (e.g., `observation.images.top`, `side`, or fewer cameras).
-"""
-
-from pathlib import Path
-
-import numpy as np
-import pytest
-
-from lerobot.configs.default import DatasetConfig
-from lerobot.configs.policies import PreTrainedConfig
-from lerobot.configs.train import TrainPipelineConfig
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.policies.factory import make_policy_config
-from lerobot.scripts.lerobot_train import train
-from lerobot.utils.utils import auto_select_torch_device
-
-pytest.importorskip("transformers")
-
-DUMMY_REPO_ID = "dummy/repo"
-
-
-@pytest.fixture
-def temp_dir(tmp_path):
-    return tmp_path
-
-
-DUMMY_STATE_DIM = 6
-DUMMY_ACTION_DIM = 6
-IMAGE_SIZE = 8
-DEVICE = auto_select_torch_device()
-
-
-def make_dummy_dataset(camera_keys, tmp_path):
-    """Creates a minimal dummy dataset for testing rename_mapping logic."""
-    features = {
-        "action": {"dtype": "float32", "shape": (DUMMY_ACTION_DIM,), "names": None},
-        "observation.state": {"dtype": "float32", "shape": (DUMMY_STATE_DIM,), "names": None},
-    }
-    for cam in camera_keys:
-        features[f"observation.images.{cam}"] = {
-            "dtype": "image",
-            "shape": (IMAGE_SIZE, IMAGE_SIZE, 3),
-            "names": ["height", "width", "channel"],
-        }
-    dataset = LeRobotDataset.create(
-        repo_id=DUMMY_REPO_ID,
-        fps=30,
-        features=features,
-        root=tmp_path / "_dataset",
-    )
-    root = tmp_path / "_dataset"
-    for ep_idx in range(2):
-        for _ in range(3):
-            frame = {
-                "action": np.random.randn(DUMMY_ACTION_DIM).astype(np.float32),
-                "observation.state": np.random.randn(DUMMY_STATE_DIM).astype(np.float32),
-            }
-            for cam in camera_keys:
-                frame[f"observation.images.{cam}"] = np.random.randint(
-                    0, 255, size=(IMAGE_SIZE, IMAGE_SIZE, 3), dtype=np.uint8
-                )
-            frame["task"] = f"task_{ep_idx}"
-            dataset.add_frame(frame)
-        dataset.save_episode()
-
-    dataset.finalize()
-    return dataset, root
-
-
-def custom_validate(train_config: TrainPipelineConfig, policy_path: str, empty_cameras: int):
-    train_config.policy = PreTrainedConfig.from_pretrained(policy_path)
-    train_config.policy.pretrained_path = Path(policy_path)
-    # override empty_cameras and push_to_hub for testing
-    train_config.policy.empty_cameras = empty_cameras
-    train_config.policy.push_to_hub = False
-    if train_config.use_policy_training_preset:
-        train_config.optimizer = train_config.policy.get_optimizer_preset()
-        train_config.scheduler = train_config.policy.get_scheduler_preset()
-    return train_config
-
-
-@pytest.mark.skip(reason="Skipping this test as it results OOM")
-@pytest.mark.parametrize(
-    "camera_keys, empty_cameras, rename_map, expect_success",
-    [
-        # case 1: dataset has fewer cameras than policy (3 instead of 4), but we specify empty_cameras=1 for smolvla, pi0, pi05
-        (["camera1", "camera2", "camera3"], 1, {}, True),
-        # case 2: dataset has 2 cameras with different names, rename_mapping provided
-        (
-            ["top", "side"],
-            0,
-            {
-                "observation.images.top": "observation.images.camera1",
-                "observation.images.side": "observation.images.camera2",
-            },
-            True,
-        ),
-        # case 3: dataset has 2 cameras, policy expects 3, names do not match, no empty_cameras
-        (["top", "side"], 0, {}, False),
-        # TODO: case 4: dataset has 2 cameras, policy expects 3, no rename_map, no empty_cameras, should raise for smolvla
-        # (["camera1", "camera2"], 0, {}, False),
-    ],
-)
-def test_train_with_camera_mismatch(camera_keys, empty_cameras, rename_map, expect_success, tmp_path):
-    """Tests that training works or fails depending on camera/feature alignment."""
-
-    _dataset, root = make_dummy_dataset(camera_keys, tmp_path)
-    pretrained_path = "lerobot/smolvla_base"
-    dataset_config = DatasetConfig(repo_id=DUMMY_REPO_ID, root=root)
-    policy_config = make_policy_config(
-        "smolvla",
-        optimizer_lr=0.01,
-        push_to_hub=False,
-        pretrained_path=pretrained_path,
-        device=DEVICE,
-    )
-    policy_config.empty_cameras = empty_cameras
-    train_config = TrainPipelineConfig(
-        dataset=dataset_config,
-        policy=policy_config,
-        rename_map=rename_map,
-        output_dir=tmp_path / "_output",
-        steps=1,
-    )
-    train_config = custom_validate(train_config, policy_path=pretrained_path, empty_cameras=empty_cameras)
-    # HACK: disable the internal CLI validation step for tests, we did it with custom_validate
-    train_config.validate = lambda: None
-    if expect_success:
-        train(train_config)
-    else:
-        with pytest.raises(ValueError):
-            train(train_config)