add check for cfg.policy in force_cpu line

* Fix SDK link and enhance setup instructions

Updated the Frodobots SDK link and added credential setup instructions.

Signed-off-by: ./c² <cagataycali@icloud.com>

* Update docs/source/earthrover_mini_plus.mdx

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Signed-off-by: ./c² <cagataycali@icloud.com>

* Update docs/source/earthrover_mini_plus.mdx

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Signed-off-by: Steven Palma <imstevenpmwork@ieee.org>

---------

Signed-off-by: ./c² <cagataycali@icloud.com>
Signed-off-by: Steven Palma <imstevenpmwork@ieee.org>
Co-authored-by: Steven Palma <imstevenpmwork@ieee.org>

.github/PULL_REQUEST_TEMPLATE.md

@@ -22,20 +22,21 @@ Short, imperative summary (e.g., "fix(robots): handle None in sensor parser"). S
 - Short, concrete bullets of the modifications (files/behaviour).
 - Short note if this introduces breaking changes and migration steps.
 
-## How was this tested
+## How was this tested (or how to run locally)
 
 - Tests added: list new tests or test files.
 - Manual checks / dataset runs performed.
+- Instructions for the reviewer
 
-## How to run locally (reviewer)
+Example:
 
-- Run the relevant tests:
+- Ran the relevant tests:
 
   ```bash
   pytest -q tests/ -k <keyword>
   ```
 
-- Run a quick example or CLI (if applicable):
+- Reproduce with a quick example or CLI (if applicable):
 
   ```bash
   lerobot-train --some.option=true

.github/workflows/full_tests.yml

@@ -186,15 +186,18 @@ jobs:
     steps:
       - name: Get Docker Hub Token and Delete Image
         # zizmor: ignore[template-injection]
+        env:
+          DOCKERHUB_LEROBOT_USERNAME: ${{ secrets.DOCKERHUB_LEROBOT_USERNAME }}
+          DOCKERHUB_LEROBOT_PASSWORD: ${{ secrets.DOCKERHUB_LEROBOT_PASSWORD }}
+          IMAGE_FULL: ${{ needs.build-and-push-docker.outputs.image_tag }}
         run: |
-          IMAGE_NAME=$(echo "${{ needs.build-and-push-docker.outputs.image_tag }}" | cut -d':' -f1)
-          IMAGE_TAG=$(echo "${{ needs.build-and-push-docker.outputs.image_tag }}" | cut -d':' -f2)
-
+          IMAGE_NAME=$(echo "$IMAGE_FULL" | cut -d':' -f1)
+          IMAGE_TAG=$(echo "$IMAGE_FULL" | cut -d':' -f2-)
           echo "Attempting to delete image: $IMAGE_NAME:$IMAGE_TAG"
 
           TOKEN=$(curl -s -H "Content-Type: application/json" \
                        -X POST \
-                       -d '{"username": "${{ secrets.DOCKERHUB_LEROBOT_USERNAME }}", "password": "${{ secrets.DOCKERHUB_LEROBOT_PASSWORD }}"}' \
+                       -d "{\"username\": \"$DOCKERHUB_LEROBOT_USERNAME\", \"password\": \"$DOCKERHUB_LEROBOT_PASSWORD\"}" \
                        https://hub.docker.com/v2/users/login/ | jq -r .token)
 
           if [ "$TOKEN" == "null" ] || [ -z "$TOKEN" ]; then
@@ -205,7 +208,7 @@ jobs:
           HTTP_RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" \
                                -H "Authorization: JWT ${TOKEN}" \
                                -X DELETE \
-                               https://hub.docker.com/v2/repositories/${IMAGE_NAME}/tags/${IMAGE_TAG}/)
+                               https://hub.docker.com/v2/repositories/${IMAGE_NAME}/tags/$IMAGE_TAG)
 
           if [ "$HTTP_RESPONSE" -eq 204 ]; then
             echo "Successfully deleted Docker image tag: $IMAGE_NAME:$IMAGE_TAG"

.github/workflows/unbound_deps_tests.yml

@@ -162,15 +162,19 @@ jobs:
     steps:
       - name: Get Docker Hub Token and Delete Image
         # zizmor: ignore[template-injection]
+        env:
+          DOCKERHUB_LEROBOT_USERNAME: ${{ secrets.DOCKERHUB_LEROBOT_USERNAME }}
+          DOCKERHUB_LEROBOT_PASSWORD: ${{ secrets.DOCKERHUB_LEROBOT_PASSWORD }}
+          IMAGE_FULL: ${{ needs.build-and-push-docker.outputs.image_tag }}
         run: |
-          IMAGE_NAME=$(echo "${{ needs.build-and-push-docker.outputs.image_tag }}" | cut -d':' -f1)
-          IMAGE_TAG=$(echo "${{ needs.build-and-push-docker.outputs.image_tag }}" | cut -d':' -f2)
+          IMAGE_NAME=$(echo "$IMAGE_FULL" | cut -d':' -f1)
+          IMAGE_TAG=$(echo "$IMAGE_FULL" | cut -d':' -f2)
 
           echo "Attempting to delete image: $IMAGE_NAME:$IMAGE_TAG"
 
           TOKEN=$(curl -s -H "Content-Type: application/json" \
                        -X POST \
-                       -d '{"username": "${{ secrets.DOCKERHUB_LEROBOT_USERNAME }}", "password": "${{ secrets.DOCKERHUB_LEROBOT_PASSWORD }}"}' \
+                       -d "{\"username\": \"$DOCKERHUB_LEROBOT_USERNAME\", \"password\": \"$DOCKERHUB_LEROBOT_PASSWORD\"}" \
                        https://hub.docker.com/v2/users/login/ | jq -r .token)
 
           if [ "$TOKEN" == "null" ] || [ -z "$TOKEN" ]; then
@@ -181,7 +185,7 @@ jobs:
           HTTP_RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" \
                                -H "Authorization: JWT ${TOKEN}" \
                                -X DELETE \
-                               https://hub.docker.com/v2/repositories/${IMAGE_NAME}/tags/${IMAGE_TAG}/)
+                               https://hub.docker.com/v2/repositories/${IMAGE_NAME}/tags/$IMAGE_TAG)
 
           if [ "$HTTP_RESPONSE" -eq 204 ]; then
             echo "Successfully deleted Docker image tag: $IMAGE_NAME:$IMAGE_TAG"

README.md

@@ -10,6 +10,7 @@
 [![Status](https://img.shields.io/pypi/status/lerobot)](https://pypi.org/project/lerobot/)
 [![Version](https://img.shields.io/pypi/v/lerobot)](https://pypi.org/project/lerobot/)
 [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.1-ff69b4.svg)](https://github.com/huggingface/lerobot/blob/main/CODE_OF_CONDUCT.md)
+[![Discord](https://img.shields.io/badge/Discord-Join_Us-5865F2?style=flat&logo=discord&logoColor=white)](https://discord.gg/q8Dzzpym3f)
 
 </div>
 
@@ -99,11 +100,11 @@ lerobot-train \
   --dataset.repo_id=lerobot/aloha_mobile_cabinet
 ```
 
-| Category                   | Models                                                                                                                                                                 |
-| -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Imitation Learning**     | [ACT](./docs/source/policy_act_README.md), [Diffusion](./docs/source/policy_diffusion_README.md), [VQ-BeT](./docs/source/policy_vqbet_README.md)                       |
-| **Reinforcement Learning** | [HIL-SERL](./docs/source/hilserl.mdx), [TDMPC](./docs/source/policy_tdmpc_README.md) & QC-FQL (coming soon)                                                            |
-| **VLAs Models**            | [Pi0.5](./docs/source/pi05.mdx), [GR00T N1.5](./docs/source/policy_groot_README.md), [SmolVLA](./docs/source/policy_smolvla_README.md), [XVLA](./docs/source/xvla.mdx) |
+| Category                   | Models                                                                                                                                                                                                       |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| **Imitation Learning**     | [ACT](./docs/source/policy_act_README.md), [Diffusion](./docs/source/policy_diffusion_README.md), [VQ-BeT](./docs/source/policy_vqbet_README.md)                                                             |
+| **Reinforcement Learning** | [HIL-SERL](./docs/source/hilserl.mdx), [TDMPC](./docs/source/policy_tdmpc_README.md) & QC-FQL (coming soon)                                                                                                  |
+| **VLAs Models**            | [Pi0Fast](./docs/source/pi0fast.mdx), [Pi0.5](./docs/source/pi05.mdx), [GR00T N1.5](./docs/source/policy_groot_README.md), [SmolVLA](./docs/source/policy_smolvla_README.md), [XVLA](./docs/source/xvla.mdx) |
 
 Similarly to the hardware, you can easily implement your own policy & leverage LeRobot's data collection, training, and visualization tools, and share your model to the HF Hub
 
@@ -127,7 +128,7 @@ Learn how to implement your own simulation environment or benchmark and distribu
 ## Resources
 
 - **[Documentation](https://huggingface.co/docs/lerobot/index):** The complete guide to tutorials & API.
-- **[Discord](https://discord.gg/3gxM6Avj):** Join the `LeRobot` server to discuss with the community.
+- **[Discord](https://discord.gg/q8Dzzpym3f):** Join the `LeRobot` server to discuss with the community.
 - **[X](https://x.com/LeRobotHF):** Follow us on X to stay up-to-date with the latest developments.
 - **[Robot Learning Tutorial](https://huggingface.co/spaces/lerobot/robot-learning-tutorial):** A free, hands-on course to learn robot learning using LeRobot.
 

docker/Dockerfile.internal

@@ -73,7 +73,7 @@ ENV HOME=/home/user_lerobot \
 RUN uv venv --python python${PYTHON_VERSION}
 
 # Install Python dependencies for caching
-COPY --chown=user_lerobot:user_lerobot pyproject.toml README.md MANIFEST.in ./
+COPY --chown=user_lerobot:user_lerobot setup.py pyproject.toml README.md MANIFEST.in ./
 COPY --chown=user_lerobot:user_lerobot src/ src/
 
 ARG UNBOUND_DEPS=false

docker/Dockerfile.user

@@ -59,7 +59,7 @@ ENV HOME=/home/user_lerobot \
 RUN uv venv
 
 # Install Python dependencies for caching
-COPY --chown=user_lerobot:user_lerobot pyproject.toml README.md MANIFEST.in ./
+COPY --chown=user_lerobot:user_lerobot setup.py pyproject.toml README.md MANIFEST.in ./
 COPY --chown=user_lerobot:user_lerobot src/ src/
 
 ARG UNBOUND_DEPS=false

docs/source/_toctree.yml

@@ -19,6 +19,8 @@
     title: Train RL in Simulation
   - local: multi_gpu_training
     title: Multi GPU training
+  - local: peft_training
+    title: Training with PEFT (e.g., LoRA)
   title: "Tutorials"
 - sections:
   - local: lerobot-dataset-v3
@@ -35,6 +37,8 @@
     title: SmolVLA
   - local: pi0
     title: π₀ (Pi0)
+  - local: pi0fast
+    title: π₀-FAST (Pi0Fast)
   - local: pi05
     title: π₀.₅ (Pi05)
   - local: groot
@@ -59,6 +63,8 @@
     title: Environments from the Hub
   - local: envhub_leisaac
     title: Control & Train Robots in Sim (LeIsaac)
+  - local: envhub_isaaclab_arena
+    title: NVIDIA IsaacLab Arena Environments
   - local: libero
     title: Using Libero
   - local: metaworld

docs/source/async.mdx

@@ -169,7 +169,7 @@ python -m lerobot.async_inference.robot_client \
 <!-- prettier-ignore-start -->
 ```python
 import threading
-from lerobot.robots.so100_follower import SO100FollowerConfig
+from lerobot.robots.so_follower import SO100FollowerConfig
 from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
 from lerobot.async_inference.configs import RobotClientConfig
 from lerobot.async_inference.robot_client import RobotClient

docs/source/earthrover_mini_plus.mdx

@@ -12,23 +12,42 @@ The EarthRover Mini Plus is a fully open source mobile robot that connects throu
 
 ### Setting Up the Frodobots SDK
 
-The robot needs the [Frodobots SDK](https://github.com/Frodobots/earth-rovers-sdk) running on your computer. Here's how:
+The robot needs the [Frodobots SDK](https://github.com/frodobots-org/earth-rovers-sdk) running on your computer. Here's how:
 
 1. Download and install the SDK:
 
 ```bash
-git clone https://github.com/Frodobots/earth-rovers-sdk.git
+git clone https://github.com/frodobots-org/earth-rovers-sdk.git
 cd earth-rovers-sdk
 pip install -r requirements.txt
 ```
 
-2. Start the SDK:
+2. Save Credentials:
+
+Write your .env variables with the SDK API key and bot name provided by the Frodobots team.
+
+```bash
+SDK_API_TOKEN=your_sdk_api_token_here
+BOT_SLUG=your_bot_slug_here
+CHROME_EXECUTABLE_PATH=/path/to/chrome_or_chromium
+# Default value is MAP_ZOOM_LEVEL=18 https://wiki.openstreetmap.org/wiki/Zoom_levels
+MAP_ZOOM_LEVEL=18
+MISSION_SLUG=your_mission_slug_here
+# Image quality between 0.1 and 1.0 (default: 0.8)
+# Recommended: 0.8 for better performance
+IMAGE_QUALITY=0.8
+# Image format: jpeg, png or webp (default: png)
+# Recommended: jpeg for better performance and lower bandwidth usage
+IMAGE_FORMAT=jpeg
+```
+
+3. Start the SDK:
 
 ```bash
 hypercorn main:app --reload
 ```
 
-3. Open your web browser and go to `http://localhost:8000`, then click "Join"
+4. Open your web browser and go to `http://localhost:8000`, then click "Join"
 
 The SDK gives you:
 

docs/source/envhub.mdx

@@ -2,14 +2,32 @@
 
 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
+## What is EnvHub?
 
-With EnvHub, you can:
+EnvHub lets you create custom robotics simulation environments with your own robot models and scenarios, and make them easily usable by anyone through the LeRobot framework.
 
-- 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
+EnvHub packages are stored on the Hugging Face Hub, and can be seamlessly pulled and used in your AI robotics projects through LeRobot with a single line of code.
+
+Thanks to EnvHub, you can:
+
+1. **Create and publish environments** to the Hugging Face Hub as Git repositories, and distribute complex physics simulations without packaging hassles
+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, or create your own custom robot and environment without worrying about dependency conflicts or complex installation procedures.
+
+When you create an EnvHub package, you can build anything you want inside it and use any simulation tool you like: this is your own space to play with. The only requirement is that the package contains an `env.py` file that defines the environment and allows LeRobot to load and use your EnvHub package.
+
+This `env.py` file needs to expose a small API so LeRobot can load and run it. In particular, you must provide a `make_env(n_envs: int = 1, use_async_envs: bool = False)` or `make_env(n_envs: int = 1, use_async_envs: bool = False, cfg: EnvConfig)` function, which is the main entry point for LeRobot. It 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)
+
+You can also pass an `EnvConfig` object to `make_env` to configure the environment (e.g. the number of environments, task, camera name, initial states, control mode, episode length, etc.).
+
+Finally, your environment must implement the standard `gym.vector.VectorEnv` interface so it works with LeRobot, including methods like `reset` and `step`.
 
 ## Quick Start
 
@@ -29,17 +47,6 @@ env = make_env("lerobot/cartpole-env", trust_remote_code=True)
   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:

docs/source/envhub_isaaclab_arena.mdx

@@ -0,0 +1,510 @@
+# NVIDIA IsaacLab Arena & LeRobot
+
+LeRobot EnvHub now supports **GPU-accelerated simulation** with IsaacLab Arena for policy evaluation at scale.
+Train and evaluate imitation learning policies with high-fidelity simulation — all integrated into the LeRobot ecosystem.
+
+<img
+  src="https://huggingface.co/nvidia/isaaclab-arena-envs/resolve/main/assets/Gr1OpenMicrowaveEnvironment.png"
+  alt="IsaacLab Arena - GR1 Microwave Environment"
+  style={{ maxWidth: "100%", borderRadius: "8px", marginBottom: "1rem" }}
+/>
+
+[IsaacLab Arena](https://github.com/isaac-sim/IsaacLab-Arena) integrates with NVIDIA IsaacLab to provide:
+
+- 🤖 **Humanoid embodiments**: GR1, G1, Galileo with various configurations
+- 🎯 **Manipulation & loco-manipulation tasks**: Door opening, pick-and-place, button pressing, and more
+- ⚡ **GPU-accelerated rollouts**: Parallel environment execution on NVIDIA GPUs
+- 🖼️ **RTX Rendering**: Evaluate vision-based policies with realistic rendering, reflections and refractions
+- 📦 **LeRobot-compatible datasets**: Ready for training with GR00T N1x, PI0, SmolVLA, ACT, and Diffusion policies
+- 🔄 **EnvHub integration**: Load environments from HuggingFace EnvHub with one line
+
+## Installation
+
+### Prerequisites
+
+Hardware requirements are shared with Isaac Sim, and are detailed in [Isaac Sim Requirements](https://docs.isaacsim.omniverse.nvidia.com/5.1.0/installation/requirements.html).
+
+- NVIDIA GPU with CUDA support
+- NVIDIA driver compatible with IsaacSim 5.1.0
+- Linux (Ubuntu 22.04 / 24.04)
+
+### Setup
+
+```bash
+# 1. Create conda environment
+conda create -y -n lerobot-arena python=3.11
+conda activate lerobot-arena
+conda install -y -c conda-forge ffmpeg=7.1.1
+
+# 2. Install Isaac Sim 5.1.0
+pip install "isaacsim[all,extscache]==5.1.0" --extra-index-url https://pypi.nvidia.com
+
+# Accept NVIDIA EULA (required)
+export ACCEPT_EULA=Y
+export PRIVACY_CONSENT=Y
+
+# 3. Install IsaacLab 2.3.0
+git clone https://github.com/isaac-sim/IsaacLab.git
+cd IsaacLab
+git checkout v2.3.0
+./isaaclab.sh -i
+cd ..
+
+# 4. Install IsaacLab Arena
+git clone https://github.com/isaac-sim/IsaacLab-Arena.git
+cd IsaacLab-Arena
+git checkout release/0.1.1
+pip install -e .
+cd ..
+
+
+# 5. Install LeRobot
+git clone https://github.com/huggingface/lerobot.git
+cd lerobot
+pip install -e .
+cd ..
+
+
+# 6. Install additional dependencies
+pip install onnxruntime==1.23.2 lightwheel-sdk==1.0.1 vuer[all]==0.0.70 qpsolvers==4.8.1
+pip install numpy==1.26.0 # Isaac Sim 5.1 depends on numpy==1.26.0, this will be fixed in next release
+```
+
+## Evaluating Policies
+
+### Pre-trained Policies
+
+The following trained policies are available:
+
+| Policy                      | Architecture | Task          | Link                                                                     |
+| :-------------------------- | :----------- | :------------ | :----------------------------------------------------------------------- |
+| pi05-arena-gr1-microwave    | PI0.5        | GR1 Microwave | [HuggingFace](https://huggingface.co/nvidia/pi05-arena-gr1-microwave)    |
+| smolvla-arena-gr1-microwave | SmolVLA      | GR1 Microwave | [HuggingFace](https://huggingface.co/nvidia/smolvla-arena-gr1-microwave) |
+
+### Evaluate SmolVLA
+
+```bash
+pip install -e ".[smolvla]"
+pip install numpy==1.26.0 # revert numpy to version 1.26
+```
+
+```bash
+lerobot-eval \
+    --policy.path=nvidia/smolvla-arena-gr1-microwave \
+    --env.type=isaaclab_arena \
+    --env.hub_path=nvidia/isaaclab-arena-envs \
+    --rename_map='{"observation.images.robot_pov_cam_rgb": "observation.images.robot_pov_cam"}' \
+    --policy.device=cuda \
+    --env.environment=gr1_microwave \
+    --env.embodiment=gr1_pink \
+    --env.object=mustard_bottle \
+    --env.headless=false \
+    --env.enable_cameras=true \
+    --env.video=true \
+    --env.video_length=10 \
+    --env.video_interval=15 \
+    --env.state_keys=robot_joint_pos \
+    --env.camera_keys=robot_pov_cam_rgb \
+    --trust_remote_code=True \
+    --eval.batch_size=1
+```
+
+### Evaluate PI0.5
+
+```bash
+pip install -e ".[pi]"
+pip install numpy==1.26.0 # revert numpy to version 1.26
+```
+
+<Tip>PI0.5 requires disabling torch compile for evaluation:</Tip>
+
+```bash
+TORCH_COMPILE_DISABLE=1 TORCHINDUCTOR_DISABLE=1 lerobot-eval \
+    --policy.path=nvidia/pi05-arena-gr1-microwave \
+    --env.type=isaaclab_arena \
+    --env.hub_path=nvidia/isaaclab-arena-envs \
+    --rename_map='{"observation.images.robot_pov_cam_rgb": "observation.images.robot_pov_cam"}' \
+    --policy.device=cuda \
+    --env.environment=gr1_microwave \
+    --env.embodiment=gr1_pink \
+    --env.object=mustard_bottle \
+    --env.headless=false \
+    --env.enable_cameras=true \
+    --env.video=true \
+    --env.video_length=15 \
+    --env.video_interval=15 \
+    --env.state_keys=robot_joint_pos \
+    --env.camera_keys=robot_pov_cam_rgb \
+    --trust_remote_code=True \
+    --eval.batch_size=1
+```
+
+<Tip>
+  To change the number of parallel environments, use the ```--eval.batch_size```
+  flag.
+</Tip>
+
+### What to Expect
+
+During evaluation, you will see a progress bar showing the running success rate:
+
+```
+Stepping through eval batches:   8%|██████▍    | 4/50 [00:45<08:06, 10.58s/it, running_success_rate=25.0%]
+```
+
+### Video Recording
+
+To enable video recording during evaluation, add the following flags to your command:
+
+```bash
+--env.video=true \
+--env.video_length=15 \
+--env.video_interval=15
+```
+
+For more details on video recording, see the [IsaacLab Recording Documentation](https://isaac-sim.github.io/IsaacLab/main/source/how-to/record_video.html).
+
+<Tip>
+When running headless with `--env.headless=true`, you must also enable cameras explicitly for camera enabled environments:
+
+```bash
+--env.headless=true --env.enable_cameras=true
+```
+
+</Tip>
+
+### Output Directory
+
+Evaluation videos are saved to the output directory with the following structure:
+
+```
+outputs/eval/<date>/<timestamp>_<env>_<policy>/videos/<task>_<env_id>/eval_episode_<n>.mp4
+```
+
+For example:
+
+```
+outputs/eval/2026-01-02/14-38-01_isaaclab_arena_smolvla/videos/gr1_microwave_0/eval_episode_0.mp4
+```
+
+## Training Policies
+
+To learn more about training policies with LeRobot, please refer to the training documentation:
+
+- [SmolVLA](./smolvla)
+- [Pi0.5](./pi05)
+- [GR00T N1.5](./groot)
+
+Sample IsaacLab Arena datasets are available on HuggingFace Hub for experimentation:
+
+| Dataset                                                                                                   | Description                | Frames |
+| :-------------------------------------------------------------------------------------------------------- | :------------------------- | :----- |
+| [Arena-GR1-Manipulation-Task](https://huggingface.co/datasets/nvidia/Arena-GR1-Manipulation-Task-v3)      | GR1 microwave manipulation | ~4K    |
+| [Arena-G1-Loco-Manipulation-Task](https://huggingface.co/datasets/nvidia/Arena-G1-Loco-Manipulation-Task) | G1 loco-manipulation       | ~4K    |
+
+## Environment Configuration
+
+### Full Configuration Options
+
+```python
+from lerobot.envs.configs import IsaaclabArenaEnv
+
+config = IsaaclabArenaEnv(
+    # Environment selection
+    environment="gr1_microwave",      # Task environment
+    embodiment="gr1_pink",            # Robot embodiment
+    object="power_drill",             # Object to manipulate
+
+    # Simulation settings
+    episode_length=300,               # Max steps per episode
+    headless=True,                    # Run without GUI
+    device="cuda:0",                  # GPU device
+    seed=42,                          # Random seed
+
+    # Observation configuration
+    state_keys="robot_joint_pos",     # State observation keys (comma-separated)
+    camera_keys="robot_pov_cam_rgb",  # Camera observation keys (comma-separated)
+    state_dim=54,                     # Expected state dimension
+    action_dim=36,                    # Expected action dimension
+    camera_height=512,                # Camera image height
+    camera_width=512,                 # Camera image width
+    enable_cameras=True,              # Enable camera observations
+
+    # Video recording
+    video=False,                      # Enable video recording
+    video_length=100,                 # Frames per video
+    video_interval=200,               # Steps between recordings
+
+    # Advanced
+    mimic=False,                      # Enable mimic mode
+    teleop_device=None,               # Teleoperation device
+    disable_fabric=False,             # Disable fabric optimization
+    enable_pinocchio=True,            # Enable Pinocchio for IK
+)
+```
+
+### Using Environment Hub directly for advanced usage
+
+Create a file called `test_env_load_arena.py` or [download from the EnvHub](https://huggingface.co/nvidia/isaaclab-arena-envs/blob/main/tests/test_env_load_arena.py):
+
+```python
+import logging
+from dataclasses import asdict
+from pprint import pformat
+import torch
+import tqdm
+from lerobot.configs import parser
+from lerobot.configs.eval import EvalPipelineConfig
+
+
+@parser.wrap()
+def main(cfg: EvalPipelineConfig):
+    """Run random action rollout for IsaacLab Arena environment."""
+    logging.info(pformat(asdict(cfg)))
+
+    from lerobot.envs.factory import make_env
+
+    env_dict = make_env(
+        cfg.env,
+        n_envs=cfg.env.num_envs,
+        trust_remote_code=True,
+    )
+    env = next(iter(env_dict.values()))[0]
+    env.reset()
+    for _ in tqdm.tqdm(range(cfg.env.episode_length)):
+        with torch.inference_mode():
+            actions = env.action_space.sample()
+            obs, rewards, terminated, truncated, info = env.step(actions)
+            if terminated.any() or truncated.any():
+                obs, info = env.reset()
+    env.close()
+
+
+if __name__ == "__main__":
+    main()
+```
+
+Run with:
+
+```bash
+python test_env_load_arena.py \
+    --env.environment=g1_locomanip_pnp \
+    --env.embodiment=gr1_pink \
+    --env.object=cracker_box \
+    --env.num_envs=4 \
+    --env.enable_cameras=true \
+    --env.seed=1000 \
+    --env.video=true \
+    --env.video_length=10 \
+    --env.video_interval=15 \
+    --env.headless=false \
+    --env.hub_path=nvidia/isaaclab-arena-envs \
+    --env.type=isaaclab_arena
+```
+
+## Creating New Environments
+
+First create a new IsaacLab Arena environment by following the [IsaacLab Arena Documentation](https://isaac-sim.github.io/IsaacLab-Arena/release/0.1.1/index.html).
+
+Clone our EnvHub repo:
+
+```bash
+git clone https://huggingface.co/nvidia/isaaclab-arena-envs
+```
+
+Modify the `example_envs.yaml` file based on your new environment.
+[Upload](./envhub#step-3-upload-to-the-hub) your modified repo to HuggingFace EnvHub.
+
+<Tip>
+  Your IsaacLab Arena environment code must be locally available during
+  evaluation. Users can clone your environment repository separately, or you can
+  bundle the environment code and assets directly in your EnvHub repo.
+</Tip>
+
+Then, when evaluating, use your new environment:
+
+```bash
+lerobot-eval \
+    --env.hub_path=<your-env-hub-path>/isaaclab-arena-envs \
+    --env.environment=<your new environment> \
+    ...other flags...
+```
+
+We look forward to your contributions!
+
+## Troubleshooting
+
+### CUDA out of memory
+
+Reduce `batch_size` or use a GPU with more VRAM:
+
+```bash
+--eval.batch_size=1
+```
+
+### EULA not accepted
+
+Set environment variables before running:
+
+```bash
+export ACCEPT_EULA=Y
+export PRIVACY_CONSENT=Y
+```
+
+### Video recording not working
+
+Enable cameras when running headless:
+
+```bash
+--env.video=true --env.enable_cameras=true --env.headless=true
+```
+
+### Policy output dimension mismatch
+
+Ensure `action_dim` matches your policy:
+
+```bash
+--env.action_dim=36
+```
+
+### libGLU.so.1 Errors during Isaac Sim initialization
+
+Ensure you have the following dependencies installed, this is likely to happen on headless machines.
+
+```bash
+sudo apt update && sudo apt install -y libglu1-mesa libxt6
+```
+
+## See Also
+
+- [EnvHub Documentation](./envhub.mdx) - General EnvHub usage
+- [IsaacLab Arena GitHub](https://github.com/isaac-sim/IsaacLab-Arena)
+- [IsaacLab Documentation](https://isaac-sim.github.io/IsaacLab/)
+
+## Lightwheel LW-BenchHub
+
+[Lightwheel](https://www.lightwheel.ai) is bringing `Lightwheel-Libero-Tasks` and `Lightwheel-RoboCasa-Tasks` with 268 tasks to the LeRobot ecosystem.
+LW-BenchHub collects and generates large-scale datasets via teleoperation that comply with the LeRobot specification, enabling out-of-the-box training and evaluation workflows.
+With the unified interface provided by EnvHub, developers can quickly build end-to-end experimental pipelines.
+
+### Install
+
+Assuming you followed the [Installation](#installation) steps, you can install LW-BenchHub with:
+
+```bash
+conda install pinocchio -c conda-forge -y
+pip install numpy==1.26.0 # revert numpy to version 1.26
+
+sudo apt-get install git-lfs && git lfs install
+
+git clone https://github.com/LightwheelAI/lw_benchhub
+git lfs pull # Ensure LFS files (e.g., .usd assets) are downloaded
+
+cd lw_benchhub
+pip install -e .
+```
+
+For more detailed instructions, please refer to the [LW-BenchHub Documentation](https://docs.lightwheel.net/lw_benchhub/usage/Installation).
+
+### Lightwheel Tasks Dataset
+
+LW-BenchHub datasets are available on HuggingFace Hub:
+
+| Dataset                                                                                                       | Description             | Tasks | Frames |
+| :------------------------------------------------------------------------------------------------------------ | :---------------------- | :---- | :----- |
+| [Lightwheel-Tasks-X7S](https://huggingface.co/datasets/LightwheelAI/Lightwheel-Tasks-X7S)                     | X7S LIBERO and RoboCasa | 117   | ~10.3M |
+| [Lightwheel-Tasks-Double-Piper](https://huggingface.co/datasets/LightwheelAI/Lightwheel-Tasks-Double-Piper)   | Double-Piper LIBERO     | 130   | ~6.0M  |
+| [Lightwheel-Tasks-G1-Controller](https://huggingface.co/datasets/LightwheelAI/Lightwheel-Tasks-G1-Controller) | G1-Controller LIBERO    | 62    | ~2.7M  |
+| [Lightwheel-Tasks-G1-WBC](https://huggingface.co/datasets/LightwheelAI/Lightwheel-Tasks-G1-WBC)               | G1-WBC RoboCasa         | 32    | ~1.5M  |
+
+For training policies, refer to the [Training Policies](#training-policies) section.
+
+### Evaluating Policies
+
+#### Pre-trained Policies
+
+The following trained policies are available:
+
+| Policy                   | Architecture | Task                           | Layout     | Robot           | Link                                                                                  |
+| :----------------------- | :----------- | :----------------------------- | :--------- | :-------------- | :------------------------------------------------------------------------------------ |
+| smolvla-double-piper-pnp | SmolVLA      | L90K1PutTheBlackBowlOnThePlate | libero-1-1 | DoublePiper-Abs | [HuggingFace](https://huggingface.co/LightwheelAI/smolvla-double-piper-pnp/tree/main) |
+
+#### Evaluate SmolVLA
+
+```bash
+lerobot-eval \
+  --policy.path=LightwheelAI/smolvla-double-piper-pnp \
+  --env.type=isaaclab_arena \
+  --rename_map='{"observation.images.left_hand_camera_rgb": "observation.images.left_hand", "observation.images.right_hand_camera_rgb": "observation.images.right_hand", "observation.images.first_person_camera_rgb": "observation.images.first_person"}' \
+  --env.hub_path=LightwheelAI/lw_benchhub_env \
+  --env.kwargs='{"config_path": "configs/envhub/example.yml"}' \
+  --trust_remote_code=true \
+  --env.state_keys=joint_pos \
+  --env.action_dim=12 \
+  --env.camera_keys=left_hand_camera_rgb,right_hand_camera_rgb,first_person_camera_rgb \
+  --policy.device=cuda \
+  --eval.batch_size=10 \
+  --eval.n_episodes=100
+```
+
+### Environment Configuration
+
+Evaluation can be quickly launched by modifying the `robot`, `task`, and `layout` settings in the configuration file.
+
+#### Full Configuration Options
+
+```yml
+# =========================
+# Basic Settings
+# =========================
+disable_fabric: false
+device: cuda:0
+sensitivity: 1.0
+step_hz: 50
+enable_cameras: true
+execute_mode: eval
+episode_length_s: 20.0 # Episode length in seconds, increase if episodes timeout during eval
+
+# =========================
+# Robot Settings
+# =========================
+robot: DoublePiper-Abs # Robot type, DoublePiper-Abs, X7S-Abs, G1-Controller or G1-Controller-DecoupledWBC
+robot_scale: 1.0
+
+# =========================
+# Task & Scene Settings
+# =========================
+task: L90K1PutTheBlackBowlOnThePlate # Task name
+scene_backend: robocasa
+task_backend: robocasa
+debug_assets: null
+layout: libero-1-1 # Layout and style ID
+sources:
+  - objaverse
+  - lightwheel
+  - aigen_objs
+object_projects: []
+usd_simplify: false
+seed: 42
+
+# =========================
+# Object Placement Retry Settings
+# =========================
+max_scene_retry: 4
+max_object_placement_retry: 3
+
+resample_objects_placement_on_reset: true
+resample_robot_placement_on_reset: true
+
+# =========================
+# Replay Configuration Settings
+# =========================
+replay_cfgs:
+  add_camera_to_observation: true
+  render_resolution: [640, 480]
+```
+
+### See Also
+
+- [LW-BenchHub GitHub](https://github.com/LightwheelAI/LW-BenchHub)
+- [LW-BenchHub Documentation](https://docs.lightwheel.net/lw_benchhub/)

docs/source/envhub_leisaac.mdx

@@ -137,7 +137,8 @@ from lerobot.teleoperators import (  # noqa: F401
     Teleoperator,
     TeleoperatorConfig,
     make_teleoperator_from_config,
-    so101_leader,
+    so_leader,
+    bi_so_leader,
 )
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.utils import init_logging
@@ -196,7 +197,7 @@ def teleop_loop(teleop: Teleoperator, env: gym.Env, fps: int):
             obs, info = env.reset()
 
         dt_s = time.perf_counter() - loop_start
-        precise_sleep(1 / fps - dt_s)
+        precise_sleep(max(1 / fps - dt_s, 0.0))
         loop_s = time.perf_counter() - loop_start
         print(f"\ntime: {loop_s * 1e3:.2f}ms ({1 / loop_s:.0f} Hz)")
 
@@ -222,7 +223,7 @@ def teleoperate(cfg: TeleoperateConfig):
 
 def main():
     teleoperate(TeleoperateConfig(
-        teleop=so101_leader.SO101LeaderConfig(
+        teleop=so_leader.SO101LeaderConfig(
             port="/dev/ttyACM0",
             id='leader',
             use_degrees=False,

docs/source/groot.mdx

@@ -12,6 +12,12 @@ Developers and researchers can post-train GR00T N1.5 with their own real or synt
 
 GR00T N1.5 (specifically the GR00T-N1.5-3B model) is built using pre-trained vision and language encoders. It utilizes a flow matching action transformer to model a chunk of actions, conditioned on vision, language, and proprioception.
 
+<img
+  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/lerobot-groot-paper1%20(1).png"
+  alt="An overview of GR00T"
+  width="80%"
+/>
+
 Its strong performance comes from being trained on an expansive and diverse humanoid dataset, which includes:
 
 - Real captured data from robots.
@@ -103,7 +109,7 @@ Once you have trained your model using your parameters you can run inference in
 
 ```bash
 lerobot-record \
-  --robot.type=bi_so100_follower \
+  --robot.type=bi_so_follower \
   --robot.left_arm_port=/dev/ttyACM1 \
   --robot.right_arm_port=/dev/ttyACM0 \
   --robot.id=bimanual_follower \

docs/source/il_robots.mdx

@@ -58,8 +58,8 @@ lerobot-teleoperate \
 
 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so101_leader import SO101LeaderConfig, SO101Leader
-from lerobot.robots.so101_follower import SO101FollowerConfig, SO101Follower
+from lerobot.teleoperators.so_leader import SO101LeaderConfig, SO101Leader
+from lerobot.robots.so_follower import SO101FollowerConfig, SO101Follower
 
 robot_config = SO101FollowerConfig(
     port="/dev/tty.usbmodem58760431541",
@@ -195,9 +195,9 @@ lerobot-record \
 from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
 from lerobot.datasets.lerobot_dataset import LeRobotDataset
 from lerobot.datasets.utils import hw_to_dataset_features
-from lerobot.robots.so100_follower import SO100Follower, SO100FollowerConfig
-from lerobot.teleoperators.so100_leader.config_so100_leader import SO100LeaderConfig
-from lerobot.teleoperators.so100_leader.so100_leader import SO100Leader
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.teleoperators.so_leader.config_so100_leader import SO100LeaderConfig
+from lerobot.teleoperators.so_leader.so100_leader import SO100Leader
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say
 from lerobot.utils.visualization_utils import init_rerun
@@ -408,8 +408,8 @@ lerobot-replay \
 import time
 
 from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
+from lerobot.robots.so_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so_follower.so100_follower import SO100Follower
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.utils import log_say
 
@@ -432,7 +432,7 @@ for idx in range(dataset.num_frames):
     }
     robot.send_action(action)
 
-    precise_sleep(1.0 / dataset.fps - (time.perf_counter() - t0))
+    precise_sleep(max(1.0 / dataset.fps - (time.perf_counter() - t0), 0.0))
 
 robot.disconnect()
 ```
@@ -531,8 +531,8 @@ from lerobot.datasets.lerobot_dataset import LeRobotDataset
 from lerobot.datasets.utils import hw_to_dataset_features
 from lerobot.policies.act.modeling_act import ACTPolicy
 from lerobot.policies.factory import make_pre_post_processors
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
+from lerobot.robots.so_follower.config_so100_follower import SO100FollowerConfig
+from lerobot.robots.so_follower.so100_follower import SO100Follower
 from lerobot.scripts.lerobot_record import record_loop
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say

docs/source/integrate_hardware.mdx

@@ -18,7 +18,7 @@ If you're using Feetech or Dynamixel motors, LeRobot provides built-in bus inter
 - [`DynamixelMotorsBus`](https://github.com/huggingface/lerobot/blob/main/src/lerobot/motors/dynamixel/dynamixel.py) – for controlling Dynamixel servos
 
 Please refer to the [`MotorsBus`](https://github.com/huggingface/lerobot/blob/main/src/lerobot/motors/motors_bus.py) abstract class to learn about its API.
-For a good example of how it can be used, you can have a look at our own [SO101 follower implementation](https://github.com/huggingface/lerobot/blob/main/src/lerobot/robots/so101_follower/so101_follower.py)
+For a good example of how it can be used, you can have a look at our own [SO101 follower implementation](https://github.com/huggingface/lerobot/blob/main/src/lerobot/robots/so_follower/so101_follower/so101_follower.py)
 
 Use these if compatible. Otherwise, you'll need to find or write a Python interface (not covered in this tutorial):
 

docs/source/lekiwi.mdx

@@ -204,7 +204,7 @@ lerobot-calibrate \
 
 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so100_leader import SO100LeaderConfig, SO100Leader
+from lerobot.teleoperators.so_leader import SO100LeaderConfig, SO100Leader
 
 config = SO100LeaderConfig(
     port="/dev/tty.usbmodem58760431551",

docs/source/openarms.mdx

@@ -1,328 +0,0 @@
-# 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/peft_training.mdx

@@ -0,0 +1,62 @@
+# Parameter efficient fine-tuning with 🤗 PEFT
+
+[🤗 PEFT](https://github.com/huggingface/peft) (Parameter-Efficient Fine-Tuning) is a library for efficiently adapting
+large pretrained models such as pre-trained policies (e.g., SmolVLA, π₀, ...) to new tasks without training all
+of the model's parameters while yielding comparable performance.
+
+Install the `lerobot[peft]` optional package to enable PEFT support.
+
+To read about all the possible methods of adaption, please refer to the [🤗 PEFT docs](https://huggingface.co/docs/peft/index).
+
+## Training SmolVLA
+
+In this section we'll show you how to train a pre-trained SmolVLA policy with PEFT on the libero dataset.
+For brevity we're only training on the `libero_spatial` subset. We will use `lerobot/smolvla_base` as the model
+to parameter efficiently fine-tune:
+
+```
+lerobot-train \
+ --policy.path=lerobot/smolvla_base \
+ --policy.repo_id=your_hub_name/my_libero_smolvla \
+ --dataset.repo_id=HuggingFaceVLA/libero \
+ --policy.output_features=null \
+ --policy.input_features=null \
+ --policy.optimizer_lr=1e-3 \
+ --policy.scheduler_decay_lr=1e-4 \
+ --env.type=libero \
+ --env.task=libero_spatial \
+ --steps=100000 \
+ --batch_size=32 \
+ --peft.method_type=LORA \
+ --peft.r=64
+```
+
+Note the `--peft.method_type` parameter that let's you select which PEFT method to use. Here we use
+[LoRA](https://huggingface.co/docs/peft/main/en/package_reference/lora) (Low-Rank Adapter) which is probably the most
+popular fine-tuning method to date. Low-rank adaption means that we only fine-tune a matrix with comparably low rank
+instead of the full weight matrix. This rank can be specified using the `--peft.r` parameter. The higher the rank
+the closer you get to full fine-tuning
+
+There are more complex methods that have more parameters. These are not yet supported, feel free to raise an issue
+if you want to see a specific PEFT method supported.
+
+By default, PEFT will target the `q_proj` and `v_proj` layers of the LM expert in SmolVLA. It will also target the
+state and action projection matrices as they are most likely task-dependent. If you need to target different layers
+you can use `--peft.target_modules` to specify which layers to target. You can refer to the respective PEFT method's
+documentation to see what inputs are supported, (e.g., [LoRA's target_modules documentation](https://huggingface.co/docs/peft/main/en/package_reference/lora#peft.LoraConfig.target_modules)).
+Usually a list of suffixes or a regex are supported. For example, to target the MLPs of the `lm_expert` instead of
+the `q` and `v` projections, use:
+
+```
+--peft.target_modules='(model\.vlm_with_expert\.lm_expert\..*\.(down|gate|up)_proj|.*\.(state_proj|action_in_proj|action_out_proj|action_time_mlp_in|action_time_mlp_out))'
+```
+
+In case you need to fully fine-tune a layer instead of just adapting it, you can supply a list of layer suffixes
+to the `--peft.full_training_modules` parameter:
+
+```
+--peft.full_training_modules=["state_proj"]
+```
+
+The learning rate and the scheduled target learning rate can usually be scaled by a factor of 10 compared to the
+learning rate used for full fine-tuning (e.g., 1e-4 normal, so 1e-3 using LoRA).

docs/source/phone_teleop.mdx

@@ -44,7 +44,7 @@ Modify the examples to use `PhoneOS.IOS` or `PhoneOS.ANDROID` in `PhoneConfig`.
 
 Teleoperation example:
 
-```36:43:examples/phone_so100_teleop.py
+```python
 from lerobot.teleoperators.phone.config_phone import PhoneConfig, PhoneOS
 
 teleop_config = PhoneConfig(phone_os=PhoneOS.IOS)  # or PhoneOS.ANDROID
@@ -103,7 +103,7 @@ Additionally you can customize mapping or safety limits by editing the processor
 
 - Kinematics are used in multiple steps. We use [Placo](https://github.com/Rhoban/placo) which is a wrapper around Pinocchio for handling our kinematics. We construct the kinematics object by passing the robot's URDF and target frame. We set `target_frame_name` to the gripper frame.
 
-  ```examples/phone_to_so100/teleoperate.py
+  ```python
   kinematics_solver = RobotKinematics(
     urdf_path="./SO101/so101_new_calib.urdf",
     target_frame_name="gripper_frame_link",
@@ -114,7 +114,7 @@ Additionally you can customize mapping or safety limits by editing the processor
 
 - The `MapPhoneActionToRobotAction` step converts the calibrated phone pose and inputs into target deltas and gripper commands, below is shown what the step outputs.
 
-  ```src/lerobot/teleoperators/phone/phone_processor.py
+  ```python
   action["enabled"] = enabled
         action["target_x"] = -pos[1] if enabled else 0.0
         action["target_y"] = pos[0] if enabled else 0.0
@@ -127,7 +127,7 @@ Additionally you can customize mapping or safety limits by editing the processor
 
 - The `EEReferenceAndDelta` step converts target deltas to an absolute desired EE pose, storing a reference on enable, the `end_effector_step_sizes` are the step sizes for the EE pose and can be modified to change the motion speed.
 
-  ```examples/phone_to_so100/teleoperate.py
+  ```python
   EEReferenceAndDelta(
       kinematics=kinematics_solver,
       end_effector_step_sizes={"x": 0.5, "y": 0.5, "z": 0.5},
@@ -138,7 +138,7 @@ Additionally you can customize mapping or safety limits by editing the processor
 
 - The `EEBoundsAndSafety` step clamps EE motion to a workspace and checks for large ee step jumps to ensure safety. The `end_effector_bounds` are the bounds for the EE pose and can be modified to change the workspace. The `max_ee_step_m` are the step limits for the EE pose and can be modified to change the safety limits.
 
-  ```examples/phone_to_so100/teleoperate.py
+  ```python
   EEBoundsAndSafety(
       end_effector_bounds={"min": [-1.0, -1.0, -1.0], "max": [1.0, 1.0, 1.0]},
       max_ee_step_m=0.10,
@@ -147,7 +147,7 @@ Additionally you can customize mapping or safety limits by editing the processor
 
 - The `GripperVelocityToJoint` step turns a velocity‑like gripper input into absolute gripper position using the current measured state. The `speed_factor` is the factor by which the velocity is multiplied.
 
-  ```examples/phone_to_so100/teleoperate.py
+  ```python
   GripperVelocityToJoint(speed_factor=20.0)
   ```
 
@@ -157,7 +157,7 @@ We use different IK initial guesses in the kinematic steps. As initial guess eit
 
 - Closed loop (used in record/eval): sets `initial_guess_current_joints=True` so IK starts from the measured joints each frame.
 
-  ```examples/phone_to_so100/record.py
+  ```python
   InverseKinematicsEEToJoints(
       kinematics=kinematics_solver,
       motor_names=list(robot.bus.motors.keys()),
@@ -167,7 +167,7 @@ We use different IK initial guesses in the kinematic steps. As initial guess eit
 
 - Open loop (used in replay): sets `initial_guess_current_joints=False` so IK continues from the previous IK solution rather than the measured state. This preserves action stability when we replay without feedback.
 
-  ```examples/phone_to_so100/replay.py
+  ```python
   InverseKinematicsEEToJoints(
       kinematics=kinematics_solver,
       motor_names=list(robot.bus.motors.keys()),

docs/source/pi0.mdx

@@ -6,6 +6,12 @@
 
 π₀ represents a breakthrough in robotics as the first general-purpose robot foundation model developed by [Physical Intelligence](https://www.physicalintelligence.company/blog/pi0). Unlike traditional robot programs that are narrow specialists programmed for repetitive motions, π₀ is designed to be a generalist policy that can understand visual inputs, interpret natural language instructions, and control a variety of different robots across diverse tasks.
 
+<img
+  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/lerobot-pi0%20(1).png"
+  alt="An overview of Pi0"
+  width="85%"
+/>
+
 ### The Vision for Physical Intelligence
 
 As described by Physical Intelligence, while AI has achieved remarkable success in digital domains, from chess-playing to drug discovery, human intelligence still dramatically outpaces AI in the physical world. To paraphrase Moravec's paradox, winning a game of chess represents an "easy" problem for AI, but folding a shirt or cleaning up a table requires solving some of the most difficult engineering problems ever conceived. π₀ represents a first step toward developing artificial physical intelligence that enables users to simply ask robots to perform any task they want, just like they can with large language models.
@@ -64,6 +70,8 @@ python src/lerobot/scripts/lerobot_train.py \
     --policy.compile_model=true \
     --policy.gradient_checkpointing=true \
     --policy.dtype=bfloat16 \
+    --policy.freeze_vision_encoder=false \
+    --policy.train_expert_only=false \
     --steps=3000 \
     --policy.device=cuda \
     --batch_size=32
@@ -79,6 +87,15 @@ python src/lerobot/scripts/lerobot_train.py \
   - [lerobot/pi0_base](https://huggingface.co/lerobot/pi0_base)
   - [lerobot/pi0_libero](https://huggingface.co/lerobot/pi0_libero) (specifically trained on the Libero dataset)
 
+### Training Parameters Explained
+
+| Parameter               | Default | Description                                 |
+| ----------------------- | ------- | ------------------------------------------- |
+| `freeze_vision_encoder` | `false` | Do not freeze the vision encoder            |
+| `train_expert_only`     | `false` | Do not freeze the VLM, train all parameters |
+
+**💡 Tip**: Setting `train_expert_only=true` freezes the VLM and trains only the action expert and projections, allowing finetuning with reduced memory usage.
+
 ## License
 
 This model follows the **Apache 2.0 License**, consistent with the original [OpenPI repository](https://github.com/Physical-Intelligence/openpi).

docs/source/pi05.mdx

@@ -67,6 +67,8 @@ python src/lerobot/scripts/lerobot_train.py\
     --policy.gradient_checkpointing=true \
     --wandb.enable=true \
     --policy.dtype=bfloat16 \
+    --policy.freeze_vision_encoder=false \
+    --policy.train_expert_only=false \
     --steps=3000 \
     --policy.device=cuda \
     --batch_size=32
@@ -82,6 +84,15 @@ python src/lerobot/scripts/lerobot_train.py\
   - [lerobot/pi05_base](https://huggingface.co/lerobot/pi05_base)
   - [lerobot/pi05_libero](https://huggingface.co/lerobot/pi05_libero) (specifically trained on the Libero dataset)
 
+### Training Parameters Explained
+
+| Parameter               | Default | Description                                 |
+| ----------------------- | ------- | ------------------------------------------- |
+| `freeze_vision_encoder` | `false` | Do not freeze the vision encoder            |
+| `train_expert_only`     | `false` | Do not freeze the VLM, train all parameters |
+
+**💡 Tip**: Setting `train_expert_only=true` freezes the VLM and trains only the action expert and projections, allowing finetuning with reduced memory usage.
+
 If your dataset is not converted with `quantiles`, you can convert it with the following command:
 
 ```bash

docs/source/pi0fast.mdx

@@ -0,0 +1,246 @@
+# π₀-FAST (Pi0-FAST)
+
+π₀-FAST is a **Vision-Language-Action model for general robot control** that uses autoregressive next-token prediction to model continuous robot actions.
+
+## Model Overview
+
+π₀-FAST combines the power of Vision-Language Models with a novel action tokenization approach called **FAST (Frequency-space Action Sequence Tokenization)**. This enables training autoregressive VLAs on highly dexterous tasks that are impossible with standard binning-based discretization, while training **up to 5x faster** than diffusion-based approaches like π₀.
+
+<img
+  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/lerobot-pifast.png"
+  alt="An overview of Pi0-FAST"
+  width="85%"
+/>
+
+### Why FAST?
+
+Standard approaches for robot action tokenization use simple per-dimension, per-timestep binning schemes. While passable for simple behaviors, this rapidly breaks down for complex and dexterous skills that require precision and high-frequency control.
+
+FAST solves this by compressing action sequences using signal processing techniques, resulting in a dense sequence of action tokens that can be predicted autoregressively—just like language tokens.
+
+### How FAST Tokenization Works
+
+The FAST tokenizer compresses action sequences through the following steps:
+
+1. **Normalize**: Take a continuous action chunk of shape `(H, D)` where `H` is the horizon and `D` is the action dimension. Normalize using one of the supported normalization methods (Quantiles recommended to handle outliers).
+
+2. **Discrete Cosine Transform (DCT)**: Apply DCT (via scipy) to each action dimension separately. DCT is a compression algorithm commonly used in image and audio codecs (JPEG, MP3).
+
+3. **Quantization**: Round and remove insignificant coefficients for each action dimension, producing a sparse frequency matrix.
+
+4. **Flatten**: Flatten the matrix into a 1D vector, with low-frequency components first.
+
+5. **Byte Pair Encoding (BPE)**: Train a BPE tokenizer to compress the DCT coefficients into dense action tokens, typically achieving **10x compression** over prior tokenization approaches.
+
+This approach can transform **any existing VLM** into a VLA by training it to predict these FAST tokens.
+
+## Installation Requirements
+
+1. Install LeRobot by following our [Installation Guide](./installation).
+2. Install π₀-FAST dependencies by running:
+
+   ```bash
+   pip install -e ".[pi]"
+   ```
+
+   > [!NOTE]
+   > For lerobot 0.4.0, if you want to install the 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 a Custom FAST Tokenizer
+
+You have two options for the FAST tokenizer:
+
+1. **Use the pre-trained tokenizer**: The `physical-intelligence/fast` tokenizer was trained on 1M+ real robot action sequences and works as a general-purpose tokenizer.
+
+2. **Train your own tokenizer**: For maximum performance on your specific dataset, you can finetune the tokenizer on your own data.
+
+### Training Your Own Tokenizer
+
+```bash
+lerobot-train-tokenizer \
+    --repo_id "user/my-lerobot-dataset" \
+    --action_horizon 10 \
+    --encoded_dims "0:6" \
+    --vocab_size 1024 \
+    --scale 10.0 \
+    --normalization_mode QUANTILES \
+    --output_dir "./my_fast_tokenizer" \
+    --push_to_hub \
+    --hub_repo_id "username/my-action-tokenizer"
+```
+
+### Key Tokenizer Parameters
+
+| Parameter              | Description                                                                       | Default      |
+| ---------------------- | --------------------------------------------------------------------------------- | ------------ |
+| `--repo_id`            | LeRobot dataset repository ID                                                     | Required     |
+| `--action_horizon`     | Number of future actions in each chunk                                            | `10`         |
+| `--encoded_dims`       | Comma-separated dimension ranges to encode (e.g., `"0:6,7:23"`)                   | `"0:6,7:23"` |
+| `--vocab_size`         | BPE vocabulary size                                                               | `1024`       |
+| `--scale`              | DCT scaling factor for quantization                                               | `10.0`       |
+| `--normalization_mode` | Normalization mode (`MEAN_STD`, `MIN_MAX`, `QUANTILES`, `QUANTILE10`, `IDENTITY`) | `QUANTILES`  |
+| `--sample_fraction`    | Fraction of chunks to sample per episode                                          | `0.1`        |
+
+## Usage
+
+To use π₀-FAST in LeRobot, specify the policy type as:
+
+```python
+policy.type=pi0_fast
+```
+
+## Training
+
+For training π₀-FAST, you can use the LeRobot training script:
+
+```bash
+lerobot-train \
+    --dataset.repo_id=your_dataset \
+    --policy.type=pi0_fast \
+    --output_dir=./outputs/pi0fast_training \
+    --job_name=pi0fast_training \
+    --policy.pretrained_path=lerobot/pi0_fast_base \
+    --policy.dtype=bfloat16 \
+    --policy.gradient_checkpointing=true \
+    --policy.chunk_size=10 \
+    --policy.n_action_steps=10 \
+    --policy.max_action_tokens=256 \
+    --steps=100000 \
+    --batch_size=4 \
+    --policy.device=cuda
+```
+
+### Key Training Parameters
+
+| Parameter                              | Description                                        | Default                      |
+| -------------------------------------- | -------------------------------------------------- | ---------------------------- |
+| `--policy.gradient_checkpointing=true` | Reduces memory usage significantly during training | `false`                      |
+| `--policy.dtype=bfloat16`              | Use mixed precision training for efficiency        | `float32`                    |
+| `--policy.chunk_size`                  | Number of action steps to predict (action horizon) | `50`                         |
+| `--policy.n_action_steps`              | Number of action steps to execute                  | `50`                         |
+| `--policy.max_action_tokens`           | Maximum number of FAST tokens per action chunk     | `256`                        |
+| `--policy.action_tokenizer_name`       | FAST tokenizer to use                              | `physical-intelligence/fast` |
+| `--policy.compile_model=true`          | Enable torch.compile for faster training           | `false`                      |
+
+## Inference
+
+### KV-Caching for Fast Inference
+
+π₀-FAST supports **KV-caching**, a widely used optimization in LLM inference. This caches the key-value pairs from the attention mechanism, avoiding redundant computation during autoregressive decoding.
+
+```python
+# KV-caching is enabled by default
+policy.use_kv_cache=true
+```
+
+### Inference Example
+
+```python
+from lerobot.policies.pi0_fast import PI0FastPolicy, PI0FastConfig
+
+# Load the policy
+policy = PI0FastPolicy.from_pretrained("your-model-path")
+
+# During inference
+actions = policy.predict_action_chunk(batch)
+```
+
+## Model Architecture
+
+π₀-FAST uses a PaliGemma-based architecture:
+
+- **Vision Encoder**: SigLIP vision tower for image understanding
+- **Language Model**: Gemma 2B for processing language instructions and predicting action tokens
+
+The model takes images, text instructions, and robot state as input, and outputs discrete FAST tokens that are decoded back to continuous actions.
+
+## Configuration Options
+
+| Parameter            | Description                                     | Default    |
+| -------------------- | ----------------------------------------------- | ---------- |
+| `paligemma_variant`  | VLM backbone variant (`gemma_300m`, `gemma_2b`) | `gemma_2b` |
+| `max_state_dim`      | Maximum state vector dimension (padded)         | `32`       |
+| `max_action_dim`     | Maximum action vector dimension (padded)        | `32`       |
+| `temperature`        | Sampling temperature (0.0 for greedy)           | `0.0`      |
+| `max_decoding_steps` | Maximum decoding steps                          | `256`      |
+| `use_kv_cache`       | Enable KV caching for faster inference          | `true`     |
+
+## Comparison with π₀
+
+| Feature               | π₀                        | π₀-FAST                      |
+| --------------------- | ------------------------- | ---------------------------- |
+| Action Representation | Flow Matching (Diffusion) | Autoregressive Tokens (FAST) |
+| Training Speed        | 1x                        | **5x faster**                |
+| Dexterity             | High                      | High                         |
+| Inference Method      | Iterative Denoising       | Autoregressive Decoding      |
+| KV-Caching            | N/A                       | Supported                    |
+
+## Reproducing π₀Fast results
+
+We reproduce the results of π₀Fast on the LIBERO benchmark using the LeRobot implementation. We take the LeRobot PiFast base model [lerobot/pi0fast-base](https://huggingface.co/lerobot/pi0fast-base) and finetune for an additional 40kk steps in bfloat16, with batch size of 256 on 8 H100 GPUs using the [HuggingFace LIBERO dataset](https://huggingface.co/datasets/HuggingFaceVLA/libero).
+
+The finetuned model can be found here:
+
+- **π₀Fast LIBERO**: [lerobot/pi0fast-libero](https://huggingface.co/lerobot/pi0fast-libero)
+
+With the following training command:
+
+```bash
+lerobot-train \
+  --dataset.repo_id=lerobot/libero \
+  --output_dir=outputs/libero_pi0fast \
+  --job_name=libero_pi0fast \
+  --policy.path=lerobot/pi0fast_base \
+  --policy.dtype=bfloat16 \
+  --steps=100000 \
+  --save_freq=20000 \
+  --batch_size=4 \
+  --policy.device=cuda \
+  --policy.scheduler_warmup_steps=4000 \
+  --policy.scheduler_decay_steps=100000 \
+  --policy.scheduler_decay_lr=1e-5 \
+  --policy.gradient_checkpointing=true \
+  --policy.chunk_size=10 \
+  --policy.n_action_steps=10 \
+  --policy.max_action_tokens=256 \
+  --policy.empty_cameras=1 \
+```
+
+We then evaluate the finetuned model using the LeRobot LIBERO implementation, by running the following command:
+
+```bash
+tasks="libero_object,libero_spatial,libero_goal,libero_10"
+lerobot-eval \
+  --policy.path=lerobot/pi0fast-libero \
+  --policy.max_action_tokens=256 \
+  --env.type=libero \
+  --policy.gradient_checkpointing=false \
+  --env.task=${tasks} \
+  --eval.batch_size=1 \
+  --eval.n_episodes=1 \
+  --rename_map='{"observation.images.image":"observation.images.base_0_rgb","observation.images.image2":"observation.images.left_wrist_0_rgb"}'
+```
+
+**Note:** We set `n_action_steps=10`, similar to the original OpenPI implementation.
+
+### Results
+
+We obtain the following results on the LIBERO benchmark:
+
+| Model       | LIBERO Spatial | LIBERO Object | LIBERO Goal | LIBERO 10 | Average  |
+| ----------- | -------------- | ------------- | ----------- | --------- | -------- |
+| **π₀-fast** | 70.0           | 100.0         | 100.0       | 60.0      | **82.5** |
+
+The full evaluation output folder, including videos, is available [here](https://drive.google.com/drive/folders/1HXpwPTRm4hx6g1sF2P7OOqGG0TwPU7LQ?usp=sharing)
+
+## License
+
+This model follows the **Apache 2.0 License**, consistent with the original [OpenPI repository](https://github.com/Physical-Intelligence/openpi).
+
+## References
+
+- [FAST: Efficient Robot Action Tokenization](https://www.physicalintelligence.company/research/fast) - Physical Intelligence Blog
+- [OpenPI Repository](https://github.com/Physical-Intelligence/openpi) - Original implementation
+- [FAST Tokenizer on Hugging Face](https://huggingface.co/physical-intelligence/fast) - Pre-trained tokenizer

docs/source/policy_walloss_README.md

@@ -1,20 +1,30 @@
 # WALL-OSS
 
-This repository contains the Hugging Face port of **WALL-OSS**, a Vision-Language-Action model for cross-embodiment robotic control based on Qwen2.5-VL with flow matching/FAST action prediction.
+This repository contains the Hugging Face port of [**WALL-OSS**](https://x2robot.com/en/research/68bc2cde8497d7f238dde690), a Vision-Language-Action model for cross-embodiment robotic control based on Qwen2.5-VL with flow matching/FAST action prediction.
 
 ---
 
 ## Model Overview
 
 | Feature            | Description                                           |
-| ------------------ | ----------------------------------------------------- | --- |
+| ------------------ | ----------------------------------------------------- |
 | Base Model         | Qwen2.5-VL (Vision-Language Model)                    |
 | Action Prediction  | Flow Matching (diffusion) or FAST (discrete tokens)   |
-| Architecture       | Mixture of Experts (MoE) with action-specific routing |     |
+| Architecture       | Mixture of Experts (MoE) with action-specific routing |
 | Multi-Modal Inputs | Vision (images/videos), Language, Proprioception      |
 
 ---
 
+## Additional Resources
+
+Paper: https://arxiv.org/pdf/2509.11766
+
+Official Repository: https://github.com/X-Square-Robot/wall-x
+
+Hugging Face: https://huggingface.co/x-square-robot
+
+---
+
 ## Citation
 
 If you use this work, please cite:
@@ -32,4 +42,4 @@ If you use this work, please cite:
 
 ## License
 
-This port follows the **Apache 2.0 License**.
+This model follows the **Apache 2.0 License**, consistent with the original [WallX repository](https://github.com/X-Square-Robot/wall-x).

docs/source/processors_robots_teleop.mdx

@@ -30,7 +30,7 @@ Each of these pipelines handle different conversions between different action an
 
 Below is an example of the three pipelines that we use in the phone to SO-100 follower examples:
 
-```69:90:examples/phone_so100_record.py
+```python
 phone_to_robot_ee_pose_processor = RobotProcessorPipeline[RobotAction, RobotAction]( # teleop -> dataset action
     steps=[
         MapPhoneActionToRobotAction(platform=teleop_config.phone_os),
@@ -84,7 +84,7 @@ Dataset features are determined by the keys saved in the dataset. Each step can
 
 Below is and example of how we declare features with the `transform_features` method in the phone to SO-100 follower examples:
 
-```src/lerobot/robots/so100_follower/robot_kinematic_processor.py
+```python
     def transform_features(
         self, features: dict[PipelineFeatureType, dict[str, PolicyFeature]]
     ) -> dict[PipelineFeatureType, dict[str, PolicyFeature]]:
@@ -103,7 +103,7 @@ Here we declare what PolicyFeatures we modify in this step, so we know what feat
 
 Below is an example of how we aggregate and merge features in the phone to SO-100 record example:
 
-```121:145:examples/phone_so100_record.py
+```python
 features=combine_feature_dicts(
         # Run the feature contract of the pipelines
         # This tells you how the features would look like after the pipeline steps

docs/source/rac.mdx

@@ -1,291 +0,0 @@
-# RaC: Recovery and Correction Training
-
-RaC (Recovery and Correction) is a human-in-the-loop data collection and training paradigm that improves robot policy performance on long-horizon tasks by explicitly teaching recovery and correction behaviors.
-
-**Key References:**
-- [RaC: Robot Learning for Long-Horizon Tasks by Scaling Recovery and Correction](https://arxiv.org/abs/2509.07953) (Hu et al., 2025)
-- [HG-DAgger: Interactive Imitation Learning with Human Experts](https://arxiv.org/abs/1810.02890) (Kelly et al., 2019)
-- [π∗0.6: a VLA That Learns From Experience](https://pi.website/blog/pistar06) (Physical Intelligence, 2025)
-- [SARM: Stage-Aware Reward Modeling](https://arxiv.org/abs/2509.25358) (Chen et al., 2025)
-
----
-
-## Why RaC? The Problem with Standard Data Collection
-
-### Standard Behavioral Cloning Data Collection Limitations
-
-Standard behavior cloning trains policies on successful demonstrations. This approach can be sensitive to distribution shift and compounding errors. Because during deployment small errors can cascade and push the robot into states never seen during training.
-This is where RaC and methods like Dagger and HG-DAgger come in.
-
-### Prior Human-in-the-Loop Methods
-
-**DAgger** (Dataset Aggregation) addresses distribution shift by:
-- Running the novice policy to collect states
-- Querying expert for correct actions at those states
-- Aggregating new labels into training set
-
-**HG-DAgger** (Human-Gated DAgger) improves on DAgger by:
-- Giving human full control authority during interventions
-- Human takes over when unsafe, provides correction, returns control
-- Better action labels because human has uninterrupted control
-
-### RaC
-
-RaC explicitly collects **recovery + correction** data:
-
-```
-BC/DAgger:   policy → mistake → human corrects → continue
-RaC:         policy → mistake → human RECOVERS (teleop back) → CORRECTS → END
-```
-
-The critical insight is **Rule 1 (Recover then Correct)**:
-- Every intervention starts with human teleoperating back to an in-distribution state
-- Then human provides correction to complete the current subtask
-- Both segments are recorded as training data
-- This teaches the policy: "when things go wrong, go back and retry"
-
-**Rule 2 (Terminate after Intervention)**:
-- Episode ends after correction completes
-- Avoids mixed policy/human data on later subtasks
-- Keeps data distribution clean
-
----
-
-## Comparison Table
-
-| Method | Data Type | Recovery Behavior | Correction Behavior |
-|--------|-----------|-------------------|---------------------|
-| BC | Success only | ✗ | ✗ |
-| DAgger | Success + corrections | ✗ | ✓ |
-| HG-DAgger | Success + corrections | Sometimes | ✓ |
-| RaC | Success + recovery + correction | ✓ Explicit | ✓ |
-
----
-
-## The RaC Pipeline
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│                         RaC Training Pipeline                           │
-├─────────────────────────────────────────────────────────────────────────┤
-│                                                                         │
-│  1. PRE-TRAINING (Standard BC)                                          │
-│     └─> Train initial policy on clean demonstrations                    │
-│                                                                         │
-│  2. RAC DATA COLLECTION (Human-in-the-loop)                             │
-│     ├─> Policy runs autonomously                                        │
-│     ├─> Human monitors and intervenes when failure imminent             │
-│     │   ├─> RECOVERY: Human teleoperates robot back to good state       │
-│     │   └─> CORRECTION: Human completes the current subtask             │
-│     └─> Episode terminates after correction (Rule 2)                    │
-│                                                                         │
-│  3. REWARD LABELING (Optional: SARM)                                    │
-│     └─> Compute progress rewards for advantage-weighted training        │
-│                                                                         │
-│  4. FINE-TUNING                                                         │
-│     └─> Train on combined demos + RaC data (optionally with RA-BC)      │
-│                                                                         │
-└─────────────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## Step-by-Step Guide
-
-### Step 1: Pre-train a Base Policy
-
-First, train a policy on your demonstration dataset:
-
-```bash
-python src/lerobot/scripts/lerobot_train.py \
-    --dataset.repo_id=your-username/demo-dataset \
-    --policy.type=pi0 \
-    --output_dir=outputs/pretrain \
-    --batch_size=32 \
-    --steps=50000
-```
-
-### Step 2: Collect RaC Data
-
-Run the RaC data collection script with your pre-trained policy:
-
-```bash
-python examples/rac/rac_data_collection.py \
-    --robot.type=so100_follower \
-    --robot.port=/dev/tty.usbmodem58760431541 \
-    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \
-    --teleop.type=so100_leader \
-    --teleop.port=/dev/tty.usbmodem58760431551 \
-    --policy.path=outputs/pretrain/checkpoints/last/pretrained_model \
-    --dataset.repo_id=your-username/rac-dataset \
-    --dataset.single_task="Pick up the cube and place it in the bowl" \
-    --dataset.num_episodes=50
-```
-
-**Controls (Keyboard + Foot Pedal):**
-
-| Key / Pedal | Action |
-|-------------|--------|
-| **SPACE** / Right pedal | Pause policy (teleop mirrors robot, no recording) |
-| **c** / Left pedal | Take control (start correction, recording resumes) |
-| **→** / Right pedal | End episode (save) - when in correction mode |
-| **←** | Re-record episode |
-| **ESC** | Stop session and push to hub |
-| Any key/pedal during reset | Start next episode |
-
-**The RaC Protocol:**
-
-1. Watch the policy run autonomously (teleop is idle/free)
-2. When you see imminent failure, press **SPACE** or **right pedal** to pause
-   - Policy stops
-   - Teleoperator moves to match robot position (torque enabled)
-   - No frames recorded during pause
-3. Press **c** or **left pedal** to take control
-   - Teleoperator torque disabled, free to move
-   - **RECOVERY**: Teleoperate back to a good state
-   - **CORRECTION**: Complete the subtask
-   - All movements are recorded
-4. Press **→** or **right pedal** to save and end episode
-5. **RESET**: Teleop moves to robot position, you can move robot to starting position
-6. Press any key/pedal to start next episode
-
-The recovery and correction segments teach the policy how to recover from errors.
-
-**Foot Pedal Setup (Linux):**
-
-If using a USB foot pedal (PCsensor FootSwitch), ensure access:
-```bash
-sudo setfacl -m u:$USER:rw /dev/input/by-id/usb-PCsensor_FootSwitch-event-kbd
-```
-
-### Step 3: (Optional) Compute SARM Rewards
-
-For advantage-weighted training (RA-BC / Pi0.6-style), compute SARM progress values:
-
-```bash
-python src/lerobot/policies/sarm/compute_rabc_weights.py \
-    --dataset-repo-id your-username/rac-dataset \
-    --reward-model-path your-username/sarm-model \
-    --head-mode sparse \
-    --push-to-hub
-```
-
-### Step 4: Fine-tune Policy
-
-Fine-tune on the RaC data:
-
-```bash
-# Without RA-BC (standard fine-tuning)
-python src/lerobot/scripts/lerobot_train.py \
-    --dataset.repo_id=your-username/rac-dataset \
-    --policy.type=pi0 \
-    --policy.pretrained_path=outputs/pretrain/checkpoints/last/pretrained_model \
-    --output_dir=outputs/rac_finetune \
-    --steps=20000
-
-# With RA-BC (advantage-weighted, Pi0.6-style)
-python src/lerobot/scripts/lerobot_train.py \
-    --dataset.repo_id=your-username/rac-dataset \
-    --policy.type=pi0 \
-    --policy.pretrained_path=outputs/pretrain/checkpoints/last/pretrained_model \
-    --output_dir=outputs/rac_finetune_rabc \
-    --use_rabc=true \
-    --rabc_kappa=0.01 \
-    --steps=20000
-```
-
----
-
-## Connection to Pi0.6 / RECAP
-
-Pi0.6's RECAP method shares similar principles:
-- Collect autonomous rollouts + expert interventions
-- Use value function to compute **advantages**: A(s,a) = V(s') - V(s)
-- **Advantage conditioning**: Weight training based on expected improvement
-
-In LeRobot, we can use **SARM** as the value function:
-- SARM progress φ(s) ∈ [0,1] measures task completion
-- Progress delta = φ(s') - φ(s) approximates advantage
-- RA-BC uses these to weight training samples (higher weight for good corrections)
-
----
-
-## Tips for Effective RaC Collection
-
-### When to Intervene
-
-Intervene when you see:
-- Robot about to make an irreversible mistake
-- Robot hesitating or showing uncertain behavior
-- Robot deviating from expected trajectory
-
-### Recovery: Teleoperating Back to Good State
-
-During recovery, teleoperate the robot back to a state where:
-- The robot is in a familiar, in-distribution configuration
-- The current subtask can still be completed
-- The recovery trajectory itself is informative training data
-
-### Quality of Corrections
-
-During correction:
-- Provide **confident, clean** trajectories
-- Complete the current subtask fully
-- Don't overcorrect or add unnecessary movements
-
----
-
-## Iterative Improvement
-
-RaC can be applied iteratively:
-
-```
-┌─────────────────────────────────────────────────────────────────────────┐
-│  Policy v0 (demos)                                                      │
-│       ↓                                                                 │
-│  RaC Collection (target current failure modes) → Policy v1              │
-│       ↓                                                                 │
-│  RaC Collection (target new failure modes) → Policy v2                  │
-│       ↓                                                                 │
-│  ... (repeat until satisfactory performance)                            │
-└─────────────────────────────────────────────────────────────────────────┘
-```
-
-Each iteration:
-1. Deploy current policy
-2. Collect RaC interventions on failure cases
-3. Fine-tune on accumulated data
-
----
-
-## References
-
-```bibtex
-@article{hu2025rac,
-  title={RaC: Robot Learning for Long-Horizon Tasks by Scaling Recovery and Correction},
-  author={Hu, Zheyuan and Wu, Robyn and Enock, Naveen and Li, Jasmine and Kadakia, Riya and Erickson, Zackory and Kumar, Aviral},
-  journal={arXiv preprint arXiv:2509.07953},
-  year={2025}
-}
-
-@article{kelly2019hgdagger,
-  title={HG-DAgger: Interactive Imitation Learning with Human Experts},
-  author={Kelly, Michael and Sidrane, Chelsea and Driggs-Campbell, Katherine and Kochenderfer, Mykel J},
-  journal={arXiv preprint arXiv:1810.02890},
-  year={2019}
-}
-
-@article{pi2025recap,
-  title={π∗0.6: a VLA That Learns From Experience},
-  author={Physical Intelligence},
-  year={2025}
-}
-
-@article{chen2025sarm,
-  title={SARM: Stage-Aware Reward Modeling for Long Horizon Robot Manipulation},
-  author={Chen, Qianzhong and Yu, Justin and Schwager, Mac and Abbeel, Pieter and Shentu, Yide and Wu, Philipp},
-  journal={arXiv preprint arXiv:2509.25358},
-  year={2025}
-}
-```
-

docs/source/reachy2.mdx

@@ -38,6 +38,7 @@ docker run --rm -it \
   start_rviz:=true start_sdk_server:=true mujoco:=true
 ```
 
+> [!NOTE]
 > If MuJoCo runs slowly (low simulation frequency), append `-e LD_LIBRARY_PATH="/opt/host-libs:$LD_LIBRARY_PATH" \` to the previous command to improve performance:
 >
 > ```
@@ -141,7 +142,7 @@ If you choose this option but still want to use the VR teleoperation application
 First add reachy2 and reachy2_teleoperator to the imports of the record script. Then you can use the following command:
 
 ```bash
-python -m lerobot.record \
+lerobot-record \
     --robot.type=reachy2 \
     --robot.ip_address=192.168.0.200 \
     --robot.id=r2-0000 \
@@ -150,6 +151,7 @@ python -m lerobot.record \
     --teleop.type=reachy2_teleoperator \
     --teleop.ip_address=192.168.0.200 \
     --teleop.with_mobile_base=false \
+    --robot.with_torso_camera=true \
     --dataset.repo_id=pollen_robotics/record_test \
     --dataset.single_task="Reachy 2 recording test" \
     --dataset.num_episodes=1 \
@@ -165,7 +167,7 @@ python -m lerobot.record \
 **Extended setup overview (all options included):**
 
 ```bash
-python -m lerobot.record \
+lerobot-record \
     --robot.type=reachy2 \
     --robot.ip_address=192.168.0.200 \
     --robot.use_external_commands=true \
@@ -177,6 +179,8 @@ python -m lerobot.record \
     --robot.with_left_teleop_camera=true \
     --robot.with_right_teleop_camera=true \
     --robot.with_torso_camera=false \
+    --robot.camera_width=640 \
+    --robot.camera_height=480 \
     --robot.disable_torque_on_disconnect=false \
     --robot.max_relative_target=5.0 \
     --teleop.type=reachy2_teleoperator \
@@ -212,9 +216,10 @@ Must be set to true if a compliant Reachy 2 is used to control another one.
 From our initial tests, recording **all** joints when only some are moving can reduce model quality with certain policies.
 To avoid this, you can exclude specific parts from recording and replay using:
 
-````
+```bash
 --robot.with_<part>=false
-```,
+```
+
 with `<part>` being one of : `mobile_base`, `l_arm`, `r_arm", `neck`, `antennas`.
 It determine whether the corresponding part is recorded in the observations. True if not set.
 
@@ -222,49 +227,60 @@ By default, **all parts are recorded**.
 
 The same per-part mechanism is available in `reachy2_teleoperator` as well.
 
-````
-
+```bash
 --teleop.with\_<part>
-
 ```
+
 with `<part>` being one of : `mobile_base`, `l_arm`, `r_arm", `neck`, `antennas`.
 Determine whether the corresponding part is recorded in the actions. True if not set.
 
 > **Important:** In a given session, the **enabled parts must match** on both the robot and the teleoperator.
-For example, if the robot runs with `--robot.with_mobile_base=false`, the teleoperator must disable the same part `--teleoperator.with_mobile_base=false`.
+> For example, if the robot runs with `--robot.with_mobile_base=false`, the teleoperator must disable the same part `--teleoperator.with_mobile_base=false`.
 
 ##### Use the relevant cameras
 
-You can do the same for **cameras**. By default, only the **teleoperation cameras** are recorded (both `left_teleop_camera` and `right_teleop_camera`). Enable or disable each camera with:
+You can do the same for **cameras**. Enable or disable each camera with default parameters using:
 
+```bash
+--robot.with_left_teleop_camera=<true|false> \
+--robot.with_right_teleop_camera=<true|false> \
+--robot.with_torso_camera=<true|false>
 ```
 
---robot.with_left_teleop_camera=<true|false>
---robot.with_right_teleop_camera=<true|false>
---robot.with_torso_camera=<true|false>
+By default, no camera is recorded, all camera arguments are set to `false`.
+If you want to, you can use custom `width` and `height` parameters for Reachy 2's cameras using the `--robot.camera_width` & `--robot.camera_height` argument:
 
-````
+```bash
+--robot.camera_width=1920 \
+--robot.camera_height=1080
+```
 
+This will change the resolution of all 3 default robot cameras (enabled by the above bool arguments).
+
+If you want, you can add additional cameras other than the ones in the robot as usual with:
+
+```bash
+--robot.cameras="{ extra: {type: opencv, index_or_path: 42, width: 640, height: 480, fps: 30}}" \
+```
 
 ## Step 2: Replay
 
 Make sure the robot is configured with the same parts as the dataset:
 
 ```bash
-python -m lerobot.replay \
+lerobot-replay \
     --robot.type=reachy2 \
     --robot.ip_address=192.168.0.200 \
     --robot.use_external_commands=false \
     --robot.with_mobile_base=false \
     --dataset.repo_id=pollen_robotics/record_test \
     --dataset.episode=0
-    --display_data=true
-````
+```
 
 ## Step 3: Train
 
 ```bash
-python -m lerobot.scripts.train \
+lerobot-train \
   --dataset.repo_id=pollen_robotics/record_test \
   --policy.type=act \
   --output_dir=outputs/train/reachy2_test \
@@ -277,10 +293,9 @@ python -m lerobot.scripts.train \
 ## Step 4: Evaluate
 
 ```bash
-python -m lerobot.record \
+lerobot-eval \
   --robot.type=reachy2 \
   --robot.ip_address=192.168.0.200 \
-  --display_data=false \
   --dataset.repo_id=pollen_robotics/eval_record_test \
   --dataset.single_task="Evaluate reachy2 policy" \
   --dataset.num_episodes=10 \

docs/source/sarm.mdx

@@ -4,6 +4,12 @@ SARM (Stage-Aware Reward Modeling) is a video-based reward modeling framework fo
 
 **Paper**: [SARM: Stage-Aware Reward Modeling for Long Horizon Robot Manipulation](https://arxiv.org/abs/2509.25358)
 
+<img
+  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/lerobot-sarm.png"
+  alt="An overview of SARM"
+  width="80%"
+/>
+
 ## Why Reward Models?
 
 Standard behavior cloning treats all demonstration frames equally, but real-world robot datasets are messy. They contain hesitations, corrections, and variable-quality trajectories. Reward models solve this by learning a generalizable notion of **task progress** from demonstrations: given video frames and a task description, they predict how close the robot is to completing the task (0→1). This learned "progress signal" can be used in multiple ways, two promising applications are: (1) **weighted imitation learning** (RA-BC), where high-progress frames receive more weight during policy training, and (2) **reinforcement learning**, where the reward model provides dense rewards for online or offline policy improvement.

docs/source/so100.mdx

@@ -103,7 +103,7 @@ lerobot-setup-motors \
 
 <!-- prettier-ignore-start -->
 ```python
-from lerobot.robots.so100_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
 
 config = SO100FollowerConfig(
     port="/dev/tty.usbmodem585A0076841",
@@ -177,7 +177,7 @@ lerobot-setup-motors \
 
 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so100_leader import SO100Leader, SO100LeaderConfig
+from lerobot.teleoperators.so_leader import SO100Leader, SO100LeaderConfig
 
 config = SO100LeaderConfig(
     port="/dev/tty.usbmodem585A0076841",
@@ -579,7 +579,7 @@ lerobot-calibrate \
 
 <!-- prettier-ignore-start -->
 ```python
-from lerobot.robots.so100_follower import SO100FollowerConfig, SO100Follower
+from lerobot.robots.so_follower import SO100FollowerConfig, SO100Follower
 
 config = SO100FollowerConfig(
     port="/dev/tty.usbmodem585A0076891",
@@ -617,7 +617,7 @@ lerobot-calibrate \
 
 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so100_leader import SO100LeaderConfig, SO100Leader
+from lerobot.teleoperators.so_leader import SO100LeaderConfig, SO100Leader
 
 config = SO100LeaderConfig(
     port="/dev/tty.usbmodem58760431551",

docs/source/so101.mdx

@@ -125,7 +125,7 @@ lerobot-setup-motors \
 
 <!-- prettier-ignore-start -->
 ```python
-from lerobot.robots.so101_follower import SO101Follower, SO101FollowerConfig
+from lerobot.robots.so_follower import SO101Follower, SO101FollowerConfig
 
 config = SO101FollowerConfig(
     port="/dev/tty.usbmodem585A0076841",
@@ -201,7 +201,7 @@ lerobot-setup-motors \
 
 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so101_leader import SO101Leader, SO101LeaderConfig
+from lerobot.teleoperators.so_leader import SO101Leader, SO101LeaderConfig
 
 config = SO101LeaderConfig(
     port="/dev/tty.usbmodem585A0076841",
@@ -364,7 +364,7 @@ lerobot-calibrate \
 
 <!-- prettier-ignore-start -->
 ```python
-from lerobot.robots.so101_follower import SO101FollowerConfig, SO101Follower
+from lerobot.robots.so_follower import SO101FollowerConfig, SO101Follower
 
 config = SO101FollowerConfig(
     port="/dev/tty.usbmodem585A0076891",
@@ -413,7 +413,7 @@ lerobot-calibrate \
 
 <!-- prettier-ignore-start -->
 ```python
-from lerobot.teleoperators.so101_leader import SO101LeaderConfig, SO101Leader
+from lerobot.teleoperators.so_leader import SO101LeaderConfig, SO101Leader
 
 config = SO101LeaderConfig(
     port="/dev/tty.usbmodem58760431551",

docs/source/unitree_g1.mdx

@@ -1,21 +1,21 @@
-# Unitree G1 Robot Setup and Control
+# Unitree G1
 
 This guide covers the complete setup process for the Unitree G1 humanoid, from initial connection to running gr00t_wbc locomotion.
 
-## About the Unitree G1
+## About
 
-We offer support for both 29 and 23 DOF G1. We introduce:
+We support both 29 and 23 DOF G1 EDU version. We introduce:
 
-- **`unitree g1` robot class, handling low level communication with the humanoid**
-- **ZMQ socket bridge** for remote communication over WiFi, allowing one to deploy policies remotely instead of over ethernet or directly on the Orin
-- **GR00T locomotion policy** for bipedal walking and balance
-- **MuJoCo simulation mode** for testing policies without the physical robot
+- **`unitree g1` robot class, handling low level read/write from/to the humanoid**
+- **ZMQ socket bridge** for remote communication and camera streaming, allowing for remote policy deployment over wlan, eth or directly on the robot
+- **Locomotion policies** from NVIDIA gr00t and Amazon FAR Holosoma
+- **Simulation mode** for testing policies without the physical robot in mujoco
 
 ---
 
-## Part 1: Connect to Robot over Ethernet
+## Connection guide
 
-### Step 1: Configure Your Computer's Ethernet Interface
+### Step 1: Configure Ethernet Interface
 
 Set a static IP on the same subnet as the robot:
 
@@ -26,7 +26,7 @@ sudo ip addr add 192.168.123.200/24 dev enp131s0
 sudo ip link set enp131s0 up
 ```
 
-**Note**: The robot's Ethernet IP is fixed at `192.168.123.164`. Your computer must use `192.168.123.x` where x ≠ 164.
+**Note**: The G1's Ethernet IP is fixed at `192.168.123.164`. Your computer must use `192.168.123.x` with x ≠ 164.
 
 ### Step 2: SSH into the Robot
 
@@ -35,25 +35,24 @@ ssh unitree@192.168.123.164
 # Password: 123
 ```
 
-You should now be connected to the robot's onboard computer.
+You should now be connected to the G1's Orin.
 
 ---
 
 ## Part 2: Enable WiFi on the Robot
 
-Once connected via Ethernet, follow these steps to enable WiFi:
+Wlan0 is disabled by default on the G1. To enable it:
 
 ### Step 1: Enable WiFi Hardware
 
 ```bash
-# Unblock WiFi radio
 sudo rfkill unblock wifi
 sudo rfkill unblock all
 
-# Bring up WiFi interface
+# Bring up wlan0
 sudo ip link set wlan0 up
 
-# Enable NetworkManager control
+# Enable NetworkManager control of wlan0
 sudo nmcli radio wifi on
 sudo nmcli device set wlan0 managed yes
 sudo systemctl restart NetworkManager
@@ -73,7 +72,7 @@ sudo iptables -A FORWARD -i wlp132s0f0 -o enp131s0 -m state --state RELATED,ESTA
 sudo iptables -A FORWARD -i enp131s0 -o wlp132s0f0 -j ACCEPT
 ```
 
-**On the robot:**
+**On the G1:**
 
 ```bash
 # Add laptop as default gateway
@@ -111,7 +110,7 @@ ssh unitree@<YOUR_ROBOT_IP>
 # Password: 123
 ```
 
-Replace `<YOUR_ROBOT_IP>` with your robot's actual WiFi IP address (e.g., `172.18.129.215`).
+Replace `<YOUR_ROBOT_IP>` with your robot's actual WiFi IP address.
 
 ---
 
@@ -147,9 +146,9 @@ python src/lerobot/robots/unitree_g1/run_g1_server.py
 
 ---
 
-## Part 4: Running GR00T Locomotion
+## Part 4: Controlling the robot
 
-With the robot server running, you can now control the robot from your laptop.
+With the robot server running, you can now control the robot remotely. Let's launch a locomotion policy
 
 ### Step 1: Install LeRobot on your machine
 
@@ -172,34 +171,30 @@ Edit the config file to match your robot's WiFi IP:
 robot_ip: str = "<YOUR_ROBOT_IP>"  # Replace with your robot's WiFi IP.
 ```
 
-**Note**: When running directly on the G1 (not remotely), set `robot_ip: str = "127.0.0.1"` instead.
-
 ### Step 3: Run the Locomotion Policy
 
 ```bash
 # Run GR00T locomotion controller
 python examples/unitree_g1/gr00t_locomotion.py --repo-id "nepyope/GR00T-WholeBodyControl_g1"
+
+# Run Holosoma locomotion controller
+python examples/unitree_g1/holosoma_locomotion.py
+
 ```
 
-### Step 4: Control with Remote
-
-- **Left stick**: Forward/backward and left/right movement
-- **Right stick**: Rotation
-- **R1 button**: Raise waist height
-- **R2 button**: Lower waist height
-
 Press `Ctrl+C` to stop the policy.
 
 ---
 
-## Extra: Running in Simulation Mode (MuJoCo)
+## Running in Simulation Mode (MuJoCo)
 
-You can now test and develop policies without a physical robot using MuJoCo. to do so set `is_simulation=True` in config.
+You can now test policies before unleashing them on the physical robot using MuJoCo. To do so simply set `is_simulation=True` in config.
 
 ## Additional Resources
 
 - [Unitree SDK Documentation](https://github.com/unitreerobotics/unitree_sdk2_python)
-- [GR00T Policy Repository](https://huggingface.co/nepyope/GR00T-WholeBodyControl_g1)
+- [GR00T-WholeBodyControl](https://github.com/NVlabs/GR00T-WholeBodyControl)
+- [Holosoma](https://github.com/amazon-far/holosoma)
 - [LeRobot Documentation](https://github.com/huggingface/lerobot)
 - [Unitree_IL_Lerobot](https://github.com/unitreerobotics/unitree_IL_lerobot)
 

docs/source/walloss.mdx

@@ -8,6 +8,12 @@ X Square Robot’s WALL-OSS is now integrated into Hugging Face’s LeRobot ecos
 
 The WALL-OSS team is building the embodied foundation model to capture and compress the world's most valuable data: the continuous, high-fidelity stream of physical interaction. By creating a direct feedback loop between the model's decisions and the body's lived experience, the emergence of a truly generalizable intelligence is enabled—one that understands not just how the world works, but how to act effectively within it.
 
+<img
+  src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/lerobot/walloss-lerobot-paper.png"
+  alt="An overview of WALL-OSS"
+  width="85%"
+/>
+
 Technically, WALL-OSS introduces a tightly coupled multimodal architecture (tightly-coupled MoE structure) that integrates both discrete and continuous action modeling strategies. Through a two-stage training pipeline (Inspiration → Integration), the model gradually unifies semantic reasoning and high-frequency action generation. Its core innovations include:
 
 - **Embodied perception–enhanced multimodal pretraining**: Large-scale training on unified vision–language–action data to strengthen spatial, causal, and manipulation understanding.

examples/backward_compatibility/replay.py

@@ -41,8 +41,7 @@ from lerobot.robots import (  # noqa: F401
     RobotConfig,
     koch_follower,
     make_robot_from_config,
-    so100_follower,
-    so101_follower,
+    so_follower,
 )
 from lerobot.utils.constants import ACTION
 from lerobot.utils.robot_utils import precise_sleep
@@ -97,7 +96,7 @@ def replay(cfg: ReplayConfig):
         robot.send_action(action)
 
         dt_s = time.perf_counter() - start_episode_t
-        precise_sleep(1 / dataset.fps - dt_s)
+        precise_sleep(max(1 / dataset.fps - dt_s, 0.0))
 
     robot.disconnect()
 

examples/lekiwi/record.py

@@ -21,7 +21,7 @@ from lerobot.robots.lekiwi.config_lekiwi import LeKiwiClientConfig
 from lerobot.robots.lekiwi.lekiwi_client import LeKiwiClient
 from lerobot.scripts.lerobot_record import record_loop
 from lerobot.teleoperators.keyboard import KeyboardTeleop, KeyboardTeleopConfig
-from lerobot.teleoperators.so100_leader import SO100Leader, SO100LeaderConfig
+from lerobot.teleoperators.so_leader import SO100Leader, SO100LeaderConfig
 from lerobot.utils.constants import ACTION, OBS_STR
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say

examples/lekiwi/teleoperate.py

@@ -18,7 +18,7 @@ import time
 
 from lerobot.robots.lekiwi import LeKiwiClient, LeKiwiClientConfig
 from lerobot.teleoperators.keyboard.teleop_keyboard import KeyboardTeleop, KeyboardTeleopConfig
-from lerobot.teleoperators.so100_leader import SO100Leader, SO100LeaderConfig
+from lerobot.teleoperators.so_leader import SO100Leader, SO100LeaderConfig
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.visualization_utils import init_rerun, log_rerun_data
 

examples/openarms/debug_can_communication.py

@@ -1,416 +0,0 @@
-#!/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/evaluate.py

@@ -1,360 +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.
-
-"""
-OpenArms Policy Evaluation
-
-Evaluates a trained policy on the OpenArms robot by running inference and recording
-the evaluation episodes to a dataset. Supports optional leader arm for manual resets.
-
-Example usage:
-    python examples/openarms/evaluate.py
-"""
-
-import time
-from pathlib import Path
-
-from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
-from lerobot.configs.policies import PreTrainedConfig
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.datasets.pipeline_features import aggregate_pipeline_dataset_features, create_initial_features
-from lerobot.datasets.utils import combine_feature_dicts
-from lerobot.policies.factory import make_policy, make_pre_post_processors
-from lerobot.processor import make_default_processors
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
-from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
-from lerobot.scripts.lerobot_record import record_loop
-from lerobot.teleoperators.openarms.config_openarms_leader import OpenArmsLeaderConfig
-from lerobot.teleoperators.openarms.openarms_leader import OpenArmsLeader
-from lerobot.utils.control_utils import init_keyboard_listener
-from lerobot.utils.utils import log_say
-from lerobot.utils.visualization_utils import init_rerun
-
-
-HF_MODEL_ID = "lerobot-data-collection/three-folds-pi0"  # TODO: Replace with your trained model
-HF_EVAL_DATASET_ID = "lerobot-data-collection/three-folds-pi0_eval7"  # TODO: Replace with your eval dataset name
-TASK_DESCRIPTION = "three-folds-dataset"  # TODO: Replace with your task, this should match!!
-
-NUM_EPISODES = 1
-FPS = 30
-EPISODE_TIME_SEC = 300
-RESET_TIME_SEC = 60
-
-# Robot CAN interfaces
-FOLLOWER_LEFT_PORT = "can0"
-FOLLOWER_RIGHT_PORT = "can1"
-
-# If enabled, you can manually reset the environment between evaluation episodes
-USE_LEADER_FOR_RESETS = True  # Set to False if you don't want to use leader
-LEADER_LEFT_PORT = "can2"
-LEADER_RIGHT_PORT = "can3"
-
-# Camera configuration
-CAMERA_CONFIG = {
-    "left_wrist": OpenCVCameraConfig(index_or_path="/dev/video5", width=640, height=480, fps=FPS),
-    "right_wrist": OpenCVCameraConfig(index_or_path="/dev/video1", width=640, height=480, fps=FPS),
-    "base": OpenCVCameraConfig(index_or_path="/dev/video3", width=640, height=480, fps=FPS),
-}
-
-def main():
-    """Main evaluation function."""
-    print("OpenArms Policy Evaluation")
-    print(f"\nModel: {HF_MODEL_ID}")
-    print(f"Evaluation Dataset: {HF_EVAL_DATASET_ID}")
-    print(f"Task: {TASK_DESCRIPTION}")
-    print(f"Episodes: {NUM_EPISODES}")
-    print(f"Episode Duration: {EPISODE_TIME_SEC}s")
-    print(f"Reset Duration: {RESET_TIME_SEC}s")
-    print(f"Use Leader for Resets: {USE_LEADER_FOR_RESETS}")
-    
-    follower_config = OpenArmsFollowerConfig(
-        port_left=FOLLOWER_LEFT_PORT,
-        port_right=FOLLOWER_RIGHT_PORT,
-        can_interface="socketcan",
-        id="openarms_follower",
-        disable_torque_on_disconnect=True,
-        max_relative_target=10.0,
-        cameras=CAMERA_CONFIG,
-    )
-    
-    follower = OpenArmsFollower(follower_config)
-    follower.connect(calibrate=False)
-    
-    if not follower.is_connected:
-        raise RuntimeError("Follower robot failed to connect!")
-
-    
-    leader = None
-    if USE_LEADER_FOR_RESETS:
-        leader_config = OpenArmsLeaderConfig(
-            port_left=LEADER_LEFT_PORT,
-            port_right=LEADER_RIGHT_PORT,
-            can_interface="socketcan",
-            id="openarms_leader",
-            manual_control=False,  # Enable torque control for gravity compensation
-        )
-        
-        leader = OpenArmsLeader(leader_config)
-        leader.connect(calibrate=False)
-        
-        if not leader.is_connected:
-            raise RuntimeError("Leader robot failed to connect!")
-        
-        # Enable gravity compensation
-        if leader.pin_robot is not None:
-            leader.bus_right.enable_torque()
-            leader.bus_left.enable_torque()
-            time.sleep(0.1)
-            print(f"Leader connected with gravity compensation ({LEADER_LEFT_PORT}, {LEADER_RIGHT_PORT})")
-        else:
-            print(f"Leader connected but gravity compensation unavailable (no URDF)")
-
-    # Build default processors for action and observation
-    teleop_action_processor, robot_action_processor, robot_observation_processor = make_default_processors()
-    
-    # Build dataset features from robot features and processors
-    # For actions, only include positions (no velocity or torque)
-    action_features_hw = {}
-    for key, value in follower.action_features.items():
-        if key.endswith(".pos"):
-            action_features_hw[key] = value
-    
-    dataset_features = combine_feature_dicts(
-        aggregate_pipeline_dataset_features(
-            pipeline=teleop_action_processor,
-            initial_features=create_initial_features(action=action_features_hw),
-            use_videos=True,
-        ),
-        aggregate_pipeline_dataset_features(
-            pipeline=robot_observation_processor,
-            initial_features=create_initial_features(observation=follower.observation_features),
-            use_videos=True,
-        ),
-    )
-    
-    # Check if dataset already exists
-    dataset_path = Path.home() / ".cache" / "huggingface" / "lerobot" / HF_EVAL_DATASET_ID
-    if dataset_path.exists():
-        print(f"Evaluation dataset already exists at: {dataset_path}")
-        print("This will append new episodes to the existing dataset.")
-        choice = input("  Continue? (y/n): ").strip().lower()
-        if choice != 'y':
-            print("  Aborting evaluation.")
-            follower.disconnect()
-            if leader:
-                leader.disconnect()
-            return
-    
-    # Create dataset
-    dataset = LeRobotDataset.create(
-        repo_id=HF_EVAL_DATASET_ID,
-        fps=FPS,
-        features=dataset_features,
-        robot_type=follower.name,
-        use_videos=True,
-        image_writer_processes=0,
-        image_writer_threads=12, 
-    )
-    
-    # Load policy config from pretrained model and create policy using factory
-    policy_config = PreTrainedConfig.from_pretrained(HF_MODEL_ID)
-    policy_config.pretrained_path = HF_MODEL_ID
-    policy = make_policy(policy_config, ds_meta=dataset.meta)
-    
-    preprocessor, postprocessor = make_pre_post_processors(
-        policy_cfg=policy.config,
-        pretrained_path=HF_MODEL_ID,
-        dataset_stats=dataset.meta.stats,
-        preprocessor_overrides={
-            "device_processor": {"device": str(policy.config.device)}
-        },
-    )
-
-    print(f"\nRunning evaluation...")
-    # Initialize keyboard listener and visualization
-    listener, events = init_keyboard_listener()
-    init_rerun(session_name="openarms_evaluation")
-    episode_idx = 0
-    
-    try:
-        while episode_idx < NUM_EPISODES and not events["stop_recording"]:
-            log_say(f"Evaluating episode {episode_idx + 1} of {NUM_EPISODES}")
-            print(f"\nRunning inference for episode {episode_idx + 1}...")
-            
-            # Run inference with policy
-            record_loop(
-                robot=follower,
-                events=events,
-                fps=FPS,
-                teleop_action_processor=teleop_action_processor,
-                robot_action_processor=robot_action_processor,
-                robot_observation_processor=robot_observation_processor,
-                policy=policy,
-                preprocessor=preprocessor,
-                postprocessor=postprocessor,
-                dataset=dataset,
-                control_time_s=EPISODE_TIME_SEC,
-                single_task=TASK_DESCRIPTION,
-                display_data=True,
-            )
-            
-            # Handle re-recording
-            if events["rerecord_episode"]:
-                log_say("Re-recording episode")
-                events["rerecord_episode"] = False
-                events["exit_early"] = False
-                dataset.clear_episode_buffer()
-                continue
-            
-            # Save episode
-            if dataset.episode_buffer is not None and dataset.episode_buffer.get("size", 0) > 0:
-                print(f"Saving episode {episode_idx + 1} ({dataset.episode_buffer['size']} frames)...")
-                dataset.save_episode()
-                episode_idx += 1
-            
-            # Reset environment between episodes (if not last episode)
-            if not events["stop_recording"] and episode_idx < NUM_EPISODES:
-                if USE_LEADER_FOR_RESETS and leader:
-                    log_say("Reset the environment using leader arms")
-                    print(f"\nManual reset period ({RESET_TIME_SEC}s)...")
-                    
-                    # Use leader for manual reset with gravity compensation
-                    import numpy as np
-                    
-                    dt = 1 / FPS
-                    reset_start_time = time.perf_counter()
-                    
-                    while time.perf_counter() - reset_start_time < RESET_TIME_SEC:
-                        if events["exit_early"] or events["stop_recording"]:
-                            break
-                        
-                        loop_start = time.perf_counter()
-                        
-                        # Get leader state
-                        leader_action = leader.get_action()
-                        
-                        # Extract positions and velocities
-                        leader_positions_deg = {}
-                        leader_velocities_deg_per_sec = {}
-                        
-                        for motor in leader.bus_right.motors:
-                            pos_key = f"right_{motor}.pos"
-                            vel_key = f"right_{motor}.vel"
-                            if pos_key in leader_action:
-                                leader_positions_deg[f"right_{motor}"] = leader_action[pos_key]
-                            if vel_key in leader_action:
-                                leader_velocities_deg_per_sec[f"right_{motor}"] = leader_action[vel_key]
-                        
-                        for motor in leader.bus_left.motors:
-                            pos_key = f"left_{motor}.pos"
-                            vel_key = f"left_{motor}.vel"
-                            if pos_key in leader_action:
-                                leader_positions_deg[f"left_{motor}"] = leader_action[pos_key]
-                            if vel_key in leader_action:
-                                leader_velocities_deg_per_sec[f"left_{motor}"] = leader_action[vel_key]
-                        
-                        # Calculate gravity and friction torques
-                        leader_positions_rad = {k: np.deg2rad(v) for k, v in leader_positions_deg.items()}
-                        leader_gravity_torques_nm = leader._gravity_from_q(leader_positions_rad)
-                        
-                        leader_velocities_rad_per_sec = {k: np.deg2rad(v) for k, v in leader_velocities_deg_per_sec.items()}
-                        leader_friction_torques_nm = leader._friction_from_velocity(
-                            leader_velocities_rad_per_sec,
-                            friction_scale=1.0
-                        )
-                        
-                        # Combine torques
-                        leader_total_torques_nm = {}
-                        for motor_name in leader_gravity_torques_nm:
-                            gravity = leader_gravity_torques_nm.get(motor_name, 0.0)
-                            friction = leader_friction_torques_nm.get(motor_name, 0.0)
-                            leader_total_torques_nm[motor_name] = gravity + friction
-                        
-                        # Apply compensation
-                        for motor in leader.bus_right.motors:
-                            full_name = f"right_{motor}"
-                            position = leader_positions_deg.get(full_name, 0.0)
-                            torque = leader_total_torques_nm.get(full_name, 0.0)
-                            kd = leader.get_damping_kd(motor)
-                            
-                            leader.bus_right._mit_control(
-                                motor=motor, kp=0.0, kd=kd,
-                                position_degrees=position,
-                                velocity_deg_per_sec=0.0,
-                                torque=torque,
-                            )
-                        
-                        for motor in leader.bus_left.motors:
-                            full_name = f"left_{motor}"
-                            position = leader_positions_deg.get(full_name, 0.0)
-                            torque = leader_total_torques_nm.get(full_name, 0.0)
-                            kd = leader.get_damping_kd(motor)
-                            
-                            leader.bus_left._mit_control(
-                                motor=motor, kp=0.0, kd=kd,
-                                position_degrees=position,
-                                velocity_deg_per_sec=0.0,
-                                torque=torque,
-                            )
-                        
-                        # Send leader positions to follower
-                        follower_action = {}
-                        for joint in leader_positions_deg.keys():
-                            pos_key = f"{joint}.pos"
-                            if pos_key in leader_action:
-                                follower_action[pos_key] = leader_action[pos_key]
-                        
-                        if follower_action:
-                            follower.send_action(follower_action)
-                        
-                        # Maintain loop rate
-                        loop_duration = time.perf_counter() - loop_start
-                        sleep_time = dt - loop_duration
-                        if sleep_time > 0:
-                            time.sleep(sleep_time)
-                    
-                    print("Reset complete")
-                else:
-                    log_say("Waiting for manual reset")
-                    print(f"Manually reset the environment and press ENTER to continue")
-                    input("Press ENTER when ready...")
-        
-        print(f"Evaluation complete! {episode_idx} episodes recorded")
-        log_say("Evaluation complete", blocking=True)
-    
-    except KeyboardInterrupt:
-        print("\n\nEvaluation interrupted by user")
-    
-    finally:
-        if leader:
-            leader.bus_right.disable_torque()
-            leader.bus_left.disable_torque()
-            time.sleep(0.1)
-            leader.disconnect()
-
-        follower.disconnect()
-        
-        if listener is not None:
-            listener.stop()
-        
-        dataset.finalize()
-        print("\nUploading to Hugging Face Hub...")
-        dataset.push_to_hub(private=True)
-
-
-if __name__ == "__main__":
-    main()
-

examples/openarms/evaluate_with_rtc.py

@@ -1,703 +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.
-
-"""
-OpenArms Policy Evaluation with Real-Time Chunking (RTC)
-
-Evaluates a trained policy on the OpenArms robot using RTC for smooth, continuous motion.
-RTC enables large flow-matching policies (Pi0, Pi0.5, SmolVLA) to produce reactive motion
-despite high inference latency by asynchronously generating action chunks.
-
-Features:
-- Thread-based asynchronous action generation and execution
-- RTC for smooth transitions between action chunks
-- Dataset recording for evaluation episodes
-
-Example usage:
-    python examples/openarms/evaluate_with_rtc.py
-
-    # With custom RTC parameters
-    python examples/openarms/evaluate_with_rtc.py \
-        --rtc.execution_horizon=12 \
-        --rtc.max_guidance_weight=10.0
-"""
-
-import logging
-import math
-import sys
-import time
-import traceback
-from dataclasses import dataclass, field
-from pathlib import Path
-from threading import Event, Lock, Thread
-
-import torch
-from torch import Tensor
-
-from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
-from lerobot.configs import parser
-from lerobot.configs.policies import PreTrainedConfig
-from lerobot.configs.types import RTCAttentionSchedule
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.datasets.pipeline_features import aggregate_pipeline_dataset_features, create_initial_features
-from lerobot.datasets.utils import build_dataset_frame, combine_feature_dicts, hw_to_dataset_features
-from lerobot.policies.factory import get_policy_class, make_pre_post_processors
-from lerobot.policies.rtc.action_queue import ActionQueue
-from lerobot.policies.rtc.configuration_rtc import RTCConfig
-from lerobot.policies.rtc.latency_tracker import LatencyTracker
-from lerobot.processor import make_default_processors
-from lerobot.rl.process import ProcessSignalHandler
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
-from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
-from lerobot.utils.hub import HubMixin
-from lerobot.utils.utils import init_logging, log_say
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-# ============================================================================
-# Default Configuration Constants
-# ============================================================================
-
-DEFAULT_HF_MODEL_ID = "lerobot-data-collection/three-folds-pi0"
-DEFAULT_HF_EVAL_DATASET_ID = "lerobot-data-collection/three-folds-pi0_eval_rtc"
-DEFAULT_TASK_DESCRIPTION = "three-folds-dataset"
-
-DEFAULT_NUM_EPISODES = 1
-DEFAULT_FPS = 30
-DEFAULT_EPISODE_TIME_SEC = 300
-DEFAULT_RESET_TIME_SEC = 60
-
-DEFAULT_FOLLOWER_LEFT_PORT = "can0"
-DEFAULT_FOLLOWER_RIGHT_PORT = "can1"
-
-DEFAULT_CAMERA_CONFIG = {
-    "left_wrist": OpenCVCameraConfig(index_or_path="/dev/video5", width=640, height=480, fps=DEFAULT_FPS),
-    "right_wrist": OpenCVCameraConfig(index_or_path="/dev/video1", width=640, height=480, fps=DEFAULT_FPS),
-    "base": OpenCVCameraConfig(index_or_path="/dev/video3", width=640, height=480, fps=DEFAULT_FPS),
-}
-
-
-# ============================================================================
-# Thread-Safe Robot Wrapper
-# ============================================================================
-
-
-class RobotWrapper:
-    """Thread-safe wrapper for robot operations."""
-
-    def __init__(self, robot: OpenArmsFollower):
-        self.robot = robot
-        self.lock = Lock()
-
-    def get_observation(self) -> dict[str, Tensor]:
-        with self.lock:
-            return self.robot.get_observation()
-
-    def send_action(self, action: dict) -> None:
-        with self.lock:
-            self.robot.send_action(action)
-
-    @property
-    def observation_features(self) -> dict:
-        with self.lock:
-            return self.robot.observation_features
-
-    @property
-    def action_features(self) -> dict:
-        with self.lock:
-            return self.robot.action_features
-
-    @property
-    def name(self) -> str:
-        return self.robot.name
-
-
-# ============================================================================
-# Configuration
-# ============================================================================
-
-
-@dataclass
-class OpenArmsRTCEvalConfig(HubMixin):
-    """Configuration for OpenArms evaluation with RTC."""
-
-    policy: PreTrainedConfig | None = None
-
-    rtc: RTCConfig = field(
-        default_factory=lambda: RTCConfig(
-            enabled=True,
-            execution_horizon=10,
-            max_guidance_weight=10.0,
-            prefix_attention_schedule=RTCAttentionSchedule.EXP,
-        )
-    )
-
-    model_id: str = DEFAULT_HF_MODEL_ID
-    eval_dataset_id: str = DEFAULT_HF_EVAL_DATASET_ID
-    task: str = DEFAULT_TASK_DESCRIPTION
-
-    num_episodes: int = DEFAULT_NUM_EPISODES
-    fps: float = DEFAULT_FPS
-    episode_time_sec: float = DEFAULT_EPISODE_TIME_SEC
-    reset_time_sec: float = DEFAULT_RESET_TIME_SEC
-
-    follower_left_port: str = DEFAULT_FOLLOWER_LEFT_PORT
-    follower_right_port: str = DEFAULT_FOLLOWER_RIGHT_PORT
-
-    device: str = "cuda"
-
-    # Should be higher than inference_delay + execution_horizon
-    action_queue_size_to_get_new_actions: int = 30
-
-    record_dataset: bool = True
-    push_to_hub: bool = True
-
-    interpolation: bool = False
-
-    use_torch_compile: bool = False
-    torch_compile_backend: str = "inductor"
-    torch_compile_mode: str = "default"
-    torch_compile_disable_cudagraphs: bool = True
-
-    def __post_init__(self):
-        policy_path = parser.get_path_arg("policy")
-        if policy_path:
-            cli_overrides = parser.get_cli_overrides("policy")
-            self.policy = PreTrainedConfig.from_pretrained(policy_path, cli_overrides=cli_overrides)
-            self.policy.pretrained_path = policy_path
-            self.model_id = policy_path
-        elif self.model_id:
-            self.policy = PreTrainedConfig.from_pretrained(self.model_id)
-            self.policy.pretrained_path = self.model_id
-
-    @classmethod
-    def __get_path_fields__(cls) -> list[str]:
-        return ["policy"]
-
-
-# ============================================================================
-# Action Generation Thread
-# ============================================================================
-
-
-def get_actions_thread(
-    policy,
-    robot: RobotWrapper,
-    robot_observation_processor,
-    action_queue: ActionQueue,
-    shutdown_event: Event,
-    cfg: OpenArmsRTCEvalConfig,
-    episode_active: Event,
-):
-    """Thread function to asynchronously generate action chunks from the policy."""
-    try:
-        logger.info("[GET_ACTIONS] Starting action generation thread")
-
-        latency_tracker = LatencyTracker()
-        time_per_chunk = 1.0 / cfg.fps
-
-        hw_features = hw_to_dataset_features(robot.observation_features, "observation")
-        policy_device = policy.config.device
-
-        logger.info(f"[GET_ACTIONS] Loading preprocessor/postprocessor from {cfg.policy.pretrained_path}")
-
-        preprocessor, postprocessor = make_pre_post_processors(
-            policy_cfg=cfg.policy,
-            pretrained_path=cfg.policy.pretrained_path,
-            dataset_stats=None,
-            preprocessor_overrides={
-                "device_processor": {"device": cfg.device},
-            },
-        )
-
-        logger.info("[GET_ACTIONS] Preprocessor/postprocessor loaded successfully")
-
-        get_actions_threshold = cfg.action_queue_size_to_get_new_actions
-        if not cfg.rtc.enabled:
-            get_actions_threshold = 0
-
-        while not shutdown_event.is_set():
-            if not episode_active.is_set():
-                time.sleep(0.01)
-                continue
-
-            if action_queue.qsize() <= get_actions_threshold:
-                current_time = time.perf_counter()
-                action_index_before_inference = action_queue.get_action_index()
-                prev_actions = action_queue.get_left_over()
-
-                inference_latency = latency_tracker.max()
-                inference_delay = math.ceil(inference_latency / time_per_chunk) if inference_latency else 0
-
-                obs = robot.get_observation()
-                obs_processed = robot_observation_processor(obs)
-
-                obs_with_policy_features = build_dataset_frame(
-                    hw_features, obs_processed, prefix="observation"
-                )
-
-                for name in obs_with_policy_features:
-                    obs_with_policy_features[name] = torch.from_numpy(obs_with_policy_features[name])
-                    if "image" in name:
-                        obs_with_policy_features[name] = (
-                            obs_with_policy_features[name].type(torch.float32) / 255
-                        )
-                        obs_with_policy_features[name] = (
-                            obs_with_policy_features[name].permute(2, 0, 1).contiguous()
-                        )
-                    obs_with_policy_features[name] = obs_with_policy_features[name].unsqueeze(0)
-                    obs_with_policy_features[name] = obs_with_policy_features[name].to(policy_device)
-
-                obs_with_policy_features["task"] = [cfg.task]
-                obs_with_policy_features["robot_type"] = robot.name
-
-                preprocessed_obs = preprocessor(obs_with_policy_features)
-
-                actions = policy.predict_action_chunk(
-                    preprocessed_obs,
-                    inference_delay=inference_delay,
-                    prev_chunk_left_over=prev_actions,
-                )
-
-                original_actions = actions.squeeze(0).clone()
-                postprocessed_actions = postprocessor(actions).squeeze(0)
-
-                new_latency = time.perf_counter() - current_time
-                new_delay = math.ceil(new_latency / time_per_chunk)
-                latency_tracker.add(new_latency)
-
-                if cfg.action_queue_size_to_get_new_actions < cfg.rtc.execution_horizon + new_delay:
-                    logger.warning(
-                        "[GET_ACTIONS] action_queue_size_to_get_new_actions too small. "
-                        "Should be higher than inference delay + execution horizon."
-                    )
-
-                action_queue.merge(
-                    original_actions, postprocessed_actions, new_delay, action_index_before_inference
-                )
-
-                logger.debug(
-                    f"[GET_ACTIONS] Generated chunk, latency={new_latency:.3f}s, "
-                    f"delay={new_delay}, queue_size={action_queue.qsize()}"
-                )
-            else:
-                time.sleep(0.01)
-
-        logger.info("[GET_ACTIONS] Action generation thread shutting down")
-    except Exception as e:
-        logger.error(f"[GET_ACTIONS] Fatal exception: {e}")
-        logger.error(traceback.format_exc())
-        shutdown_event.set()
-        sys.exit(1)
-
-
-# ============================================================================
-# Action Execution Thread
-# ============================================================================
-
-
-def actor_thread(
-    robot: RobotWrapper,
-    robot_action_processor,
-    action_queue: ActionQueue,
-    shutdown_event: Event,
-    cfg: OpenArmsRTCEvalConfig,
-    episode_active: Event,
-    dataset: LeRobotDataset | None,
-    dataset_lock: Lock,
-    teleop_action_processor,
-    robot_observation_processor,
-):
-    """Thread function to execute actions on the robot."""
-    try:
-        action_keys = [k for k in robot.action_features.keys() if k.endswith(".pos")]
-
-        if cfg.interpolation:
-            interp_factor = 2
-            robot_interval = 1.0 / (cfg.fps * interp_factor)
-            logger.info(f"[ACTOR] Interpolation ON: policy={cfg.fps}Hz -> robot={cfg.fps * interp_factor}Hz (2x)")
-        else:
-            interp_factor = 1
-            robot_interval = 1.0 / cfg.fps
-            logger.info(f"[ACTOR] Interpolation OFF: policy={cfg.fps}Hz, robot={cfg.fps}Hz")
-
-        prev_action: Tensor | None = None
-        interpolated_actions: list[Tensor] = []
-        interp_idx = 0
-
-        robot_send_count = 0
-        policy_consume_count = 0
-        last_hz_print = time.perf_counter()
-        last_dataset_time = 0.0
-
-        while not shutdown_event.is_set():
-            if not episode_active.is_set():
-                prev_action = None
-                interpolated_actions = []
-                interp_idx = 0
-                robot_send_count = 0
-                policy_consume_count = 0
-                last_hz_print = time.perf_counter()
-                time.sleep(0.01)
-                continue
-
-            start_time = time.perf_counter()
-
-            if interp_idx >= len(interpolated_actions):
-                new_action = action_queue.get()
-                if new_action is not None:
-                    current_action = new_action.cpu()
-                    policy_consume_count += 1
-
-                    if cfg.interpolation and prev_action is not None:
-                        mid = prev_action + 0.5 * (current_action - prev_action)
-                        interpolated_actions = [mid, current_action]
-                    else:
-                        interpolated_actions = [current_action]
-
-                    prev_action = current_action
-                    interp_idx = 0
-
-            if interp_idx < len(interpolated_actions):
-                action_to_send = interpolated_actions[interp_idx]
-                interp_idx += 1
-
-                action_dict = {}
-                for i, key in enumerate(action_keys):
-                    if i < len(action_to_send):
-                        action_dict[key] = action_to_send[i].item()
-
-                action_processed = robot_action_processor((action_dict, None))
-                robot.send_action(action_processed)
-                robot_send_count += 1
-
-                if cfg.record_dataset and dataset is not None:
-                    now = time.perf_counter()
-                    if now - last_dataset_time >= (1.0 / cfg.fps):
-                        last_dataset_time = now
-                        with dataset_lock:
-                            obs = robot.get_observation()
-                            obs_processed = robot_observation_processor(obs)
-                            action_for_dataset = teleop_action_processor((action_dict, None))
-                            frame = {}
-                            for key, value in obs_processed.items():
-                                frame[f"observation.{key}"] = value
-                            for key, value in action_for_dataset.items():
-                                frame[f"action.{key}"] = value
-                            frame["task"] = cfg.task
-                            dataset.add_frame(frame)
-
-            now = time.perf_counter()
-            if now - last_hz_print >= 5.0:
-                elapsed = now - last_hz_print
-                actual_robot_hz = robot_send_count / elapsed if elapsed > 0 else 0
-                actual_policy_hz = policy_consume_count / elapsed if elapsed > 0 else 0
-                logger.info(f"[ACTOR] Actual Hz - Robot: {actual_robot_hz:.1f}, Policy: {actual_policy_hz:.1f}")
-                robot_send_count = 0
-                policy_consume_count = 0
-                last_hz_print = now
-
-            dt_s = time.perf_counter() - start_time
-            sleep_time = max(0, robot_interval - dt_s - 0.001)
-            if sleep_time > 0:
-                time.sleep(sleep_time)
-
-        logger.info("[ACTOR] Shutting down")
-    except Exception as e:
-        logger.error(f"[ACTOR] Fatal exception: {e}")
-        logger.error(traceback.format_exc())
-        shutdown_event.set()
-        sys.exit(1)
-
-
-# ============================================================================
-# Main Evaluation Function
-# ============================================================================
-
-
-def _apply_torch_compile(policy, cfg: OpenArmsRTCEvalConfig):
-    """Apply torch.compile to the policy's predict_action_chunk method."""
-    if policy.name in ["pi05", "pi0"]:
-        return policy
-
-    try:
-        if not hasattr(torch, "compile"):
-            logger.warning(
-                f"torch.compile not available. Requires PyTorch 2.0+. "
-                f"Current version: {torch.__version__}. Skipping compilation."
-            )
-            return policy
-
-        logger.info("Applying torch.compile to predict_action_chunk...")
-
-        compile_kwargs = {
-            "backend": cfg.torch_compile_backend,
-            "mode": cfg.torch_compile_mode,
-        }
-
-        if cfg.torch_compile_disable_cudagraphs:
-            compile_kwargs["options"] = {"triton.cudagraphs": False}
-
-        original_method = policy.predict_action_chunk
-        compiled_method = torch.compile(original_method, **compile_kwargs)
-        policy.predict_action_chunk = compiled_method
-        logger.info("Successfully compiled predict_action_chunk")
-
-    except Exception as e:
-        logger.error(f"Failed to apply torch.compile: {e}")
-        logger.warning("Continuing without torch.compile")
-
-    return policy
-
-
-@parser.wrap()
-def main(cfg: OpenArmsRTCEvalConfig):
-    """Main evaluation function with RTC."""
-    init_logging()
-
-    print("=" * 60)
-    print("OpenArms Policy Evaluation with RTC")
-    print("=" * 60)
-    print(f"\nModel: {cfg.model_id}")
-    print(f"Evaluation Dataset: {cfg.eval_dataset_id}")
-    print(f"Task: {cfg.task}")
-    print(f"Episodes: {cfg.num_episodes}")
-    print(f"Episode Duration: {cfg.episode_time_sec}s")
-    print(f"RTC Enabled: {cfg.rtc.enabled}")
-    print(f"RTC Execution Horizon: {cfg.rtc.execution_horizon}")
-    print(f"RTC Max Guidance Weight: {cfg.rtc.max_guidance_weight}")
-    print(f"Policy Hz: {cfg.fps}")
-    print(f"Robot Hz: {cfg.fps * 2 if cfg.interpolation else cfg.fps}")
-    print(f"Interpolation: {cfg.interpolation}")
-    print(f"Device: {cfg.device}")
-    print("=" * 60)
-
-    signal_handler = ProcessSignalHandler(use_threads=True, display_pid=False)
-    shutdown_event = signal_handler.shutdown_event
-    episode_active = Event()
-
-    # Initialize Robot
-    follower_config = OpenArmsFollowerConfig(
-        port_left=cfg.follower_left_port,
-        port_right=cfg.follower_right_port,
-        can_interface="socketcan",
-        id="openarms_follower",
-        disable_torque_on_disconnect=True,
-        max_relative_target=10.0,
-        cameras=DEFAULT_CAMERA_CONFIG,
-    )
-
-    follower = OpenArmsFollower(follower_config)
-    follower.connect(calibrate=False)
-
-    if not follower.is_connected:
-        raise RuntimeError("Follower robot failed to connect!")
-
-    robot = RobotWrapper(follower)
-    logger.info("Follower robot connected")
-
-    # Build Processors and Dataset Features
-    teleop_action_processor, robot_action_processor, robot_observation_processor = make_default_processors()
-
-    action_features_hw = {}
-    for key, value in follower.action_features.items():
-        if key.endswith(".pos"):
-            action_features_hw[key] = value
-
-    dataset_features = combine_feature_dicts(
-        aggregate_pipeline_dataset_features(
-            pipeline=teleop_action_processor,
-            initial_features=create_initial_features(action=action_features_hw),
-            use_videos=True,
-        ),
-        aggregate_pipeline_dataset_features(
-            pipeline=robot_observation_processor,
-            initial_features=create_initial_features(observation=follower.observation_features),
-            use_videos=True,
-        ),
-    )
-
-    # Create or Load Dataset
-    dataset = None
-    dataset_lock = Lock()
-
-    if cfg.record_dataset:
-        dataset_path = Path.home() / ".cache" / "huggingface" / "lerobot" / cfg.eval_dataset_id
-        if dataset_path.exists():
-            logger.info(f"Evaluation dataset exists at: {dataset_path}")
-            logger.info("New episodes will be appended.")
-            choice = input("Continue? (y/n): ").strip().lower()
-            if choice != "y":
-                logger.info("Aborting evaluation.")
-                follower.disconnect()
-                return
-
-        dataset = LeRobotDataset.create(
-            repo_id=cfg.eval_dataset_id,
-            fps=int(cfg.fps),
-            features=dataset_features,
-            robot_type=follower.name,
-            use_videos=True,
-            image_writer_processes=0,
-            image_writer_threads=12,
-        )
-        logger.info(f"Dataset created: {cfg.eval_dataset_id}")
-
-    # Load Policy
-    logger.info(f"Loading policy from: {cfg.model_id}")
-
-    policy_class = get_policy_class(cfg.policy.type)
-    config = PreTrainedConfig.from_pretrained(cfg.policy.pretrained_path)
-
-    if cfg.policy.type in ["pi05", "pi0"]:
-        config.compile_model = cfg.use_torch_compile
-
-    policy = policy_class.from_pretrained(cfg.policy.pretrained_path, config=config)
-
-    policy.config.rtc_config = cfg.rtc
-    policy.init_rtc_processor()
-
-    assert policy.name in ["smolvla", "pi05", "pi0"], "Only smolvla, pi05, and pi0 are supported for RTC"
-
-    policy = policy.to(cfg.device)
-    policy.eval()
-
-    if cfg.use_torch_compile:
-        policy = _apply_torch_compile(policy, cfg)
-
-    logger.info(f"Policy loaded: {policy.name}")
-
-    # Create Action Queue and Start Threads
-    action_queue = ActionQueue(cfg.rtc)
-
-    get_actions_t = Thread(
-        target=get_actions_thread,
-        args=(
-            policy,
-            robot,
-            robot_observation_processor,
-            action_queue,
-            shutdown_event,
-            cfg,
-            episode_active,
-        ),
-        daemon=True,
-        name="GetActions",
-    )
-    get_actions_t.start()
-    logger.info("Started action generation thread")
-
-    actor_t = Thread(
-        target=actor_thread,
-        args=(
-            robot,
-            robot_action_processor,
-            action_queue,
-            shutdown_event,
-            cfg,
-            episode_active,
-            dataset,
-            dataset_lock,
-            teleop_action_processor,
-            robot_observation_processor,
-        ),
-        daemon=True,
-        name="Actor",
-    )
-    actor_t.start()
-    logger.info("Started actor thread")
-
-    # Run Evaluation Episodes
-    episode_idx = 0
-
-    try:
-        while episode_idx < cfg.num_episodes and not shutdown_event.is_set():
-            log_say(f"Evaluating episode {episode_idx + 1} of {cfg.num_episodes}")
-            logger.info(f"\n{'='*40}")
-            logger.info(f"Episode {episode_idx + 1} / {cfg.num_episodes}")
-            logger.info(f"{'='*40}")
-
-            action_queue = ActionQueue(cfg.rtc)
-            episode_active.set()
-            episode_start_time = time.time()
-
-            while (time.time() - episode_start_time) < cfg.episode_time_sec:
-                if shutdown_event.is_set():
-                    break
-
-                elapsed = time.time() - episode_start_time
-                if int(elapsed) % 10 == 0 and int(elapsed) > 0:
-                    logger.info(
-                        f"[MAIN] Episode progress: {elapsed:.0f}/{cfg.episode_time_sec}s, "
-                        f"queue_size={action_queue.qsize()}"
-                    )
-
-                time.sleep(0.5)
-
-            episode_active.clear()
-            logger.info(f"Episode {episode_idx + 1} completed")
-
-            if cfg.record_dataset and dataset is not None:
-                with dataset_lock:
-                    if dataset.episode_buffer is not None and dataset.episode_buffer.get("size", 0) > 0:
-                        logger.info(
-                            f"Saving episode {episode_idx + 1} "
-                            f"({dataset.episode_buffer['size']} frames)"
-                        )
-                        dataset.save_episode()
-
-            episode_idx += 1
-
-            # Manual reset between episodes
-            if not shutdown_event.is_set() and episode_idx < cfg.num_episodes:
-                log_say("Waiting for manual reset")
-                logger.info("Manually reset the environment and press ENTER to continue")
-                input("Press ENTER when ready...")
-
-        logger.info(f"Evaluation complete! {episode_idx} episodes recorded")
-        log_say("Evaluation complete", blocking=True)
-
-    except KeyboardInterrupt:
-        logger.info("\n\nEvaluation interrupted by user")
-
-    finally:
-        shutdown_event.set()
-        episode_active.clear()
-
-        if get_actions_t.is_alive():
-            logger.info("Waiting for action generation thread to finish...")
-            get_actions_t.join(timeout=5.0)
-
-        if actor_t.is_alive():
-            logger.info("Waiting for actor thread to finish...")
-            actor_t.join(timeout=5.0)
-
-        follower.disconnect()
-        logger.info("Follower disconnected")
-
-        if cfg.record_dataset and dataset is not None:
-            dataset.finalize()
-            if cfg.push_to_hub:
-                logger.info("Uploading to Hugging Face Hub...")
-                dataset.push_to_hub(private=True)
-
-        logger.info("Cleanup completed")
-
-
-if __name__ == "__main__":
-    main()

examples/openarms/friction_compensation.py

@@ -1,216 +0,0 @@
-import time
-import numpy as np
-
-from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
-
-
-# Friction model parameters from OpenArms config/follower.yaml
-# τ_fric(ω) = Fo + Fv·ω + Fc·tanh(k·ω)
-# For 8 motors: [joint_1, joint_2, joint_3, joint_4, joint_5, joint_6, joint_7, gripper]
-FRICTION_PARAMS = {
-    "Fc": [0.306, 0.306, 0.40, 0.166, 0.050, 0.093, 0.172, 0.0512],  # Coulomb friction [Nm]
-    "k": [28.417, 28.417, 29.065, 130.038, 151.771, 242.287, 7.888, 4.000],  # tanh steepness
-    "Fv": [0.063, 0.0630, 0.604, 0.813, 0.029, 0.072, 0.084, 0.084],  # Viscous friction [Nm·s/rad]
-    "Fo": [0.088, 0.088, 0.008, -0.058, 0.005, 0.009, -0.059, -0.050],  # Offset torque [Nm]
-}
-
-# Constants from OpenArms C++ implementation
-AMP_TMP = 1.0
-COEF_TMP = 0.1
-
-FRICTION_SCALE = 1.0  # OpenArms C++ uses 0.3 factor in unilateral mode
-DAMPING_KD = [0.5, 0.5, 0.5, 0.5, 0.1, 0.1, 0.1, 0.1]  # Damping gains for stability
-
-def compute_friction_torque(velocity_rad_per_sec: float, motor_index: int) -> float:
-    """
-    Compute friction torque for a single motor using the tanh friction model.
-    
-    Args:
-        velocity_rad_per_sec: Angular velocity in rad/s
-        motor_index: Index of the motor (0-7)
-        
-    Returns:
-        Friction torque in N·m (scaled for stability)
-    """
-    
-    Fc = FRICTION_PARAMS["Fc"][motor_index]
-    k = FRICTION_PARAMS["k"][motor_index]
-    Fv = FRICTION_PARAMS["Fv"][motor_index]
-    Fo = FRICTION_PARAMS["Fo"][motor_index]
-    
-    # Friction model: τ_fric = amp * Fc * tanh(coef * k * ω) + Fv * ω + Fo
-    friction_torque = (
-        AMP_TMP * Fc * np.tanh(COEF_TMP * k * velocity_rad_per_sec) +
-        Fv * velocity_rad_per_sec +
-        Fo
-    )
-    
-    # Scale down friction compensation for stability at lower control rates
-    # (OpenArms C++ uses 0.3 factor in unilateral mode)!!
-    friction_torque *= FRICTION_SCALE
-    
-    return friction_torque
-
-
-def main() -> None:
-    config = OpenArmsFollowerConfig(
-        port_left="can0",
-        port_right="can1",
-        can_interface="socketcan",
-        id="openarms_follower",
-        disable_torque_on_disconnect=True,
-        max_relative_target=5.0,
-    )
-    
-    print("Initializing robot...")
-    follower = OpenArmsFollower(config)
-    follower.connect(calibrate=True)
-    
-    print(f"Applying friction compensation")
-    print("  1. Support the arm before starting")
-    print("  2. The arm will be held in place by friction compensation")
-    print("  3. You should be able to move it with gentle force")
-    print("\nPress ENTER when ready to start...")
-    input()
-    
-    print(f"✓ Motors enabled")
-    print("\nStarting friction compensation loop...")
-    print("Press Ctrl+C to stop\n")
-    
-    loop_times = []
-    last_print_time = time.perf_counter()
-    
-    # Motor name to index mapping
-    motor_name_to_index = {
-        "joint_1": 0,
-        "joint_2": 1,
-        "joint_3": 2,
-        "joint_4": 3,
-        "joint_5": 4,
-        "joint_6": 5,
-        "joint_7": 6,
-        "gripper": 7,
-    }
-    
-    try:
-        while True:
-            loop_start = time.perf_counter()
-            
-            # Get current joint positions and velocities from robot
-            obs = follower.get_observation()
-            
-            # Extract velocities in degrees per second
-            velocities_deg_per_sec = {}
-            positions_deg = {}
-            
-            for motor in follower.bus_right.motors:
-                vel_key = f"right_{motor}.vel"
-                pos_key = f"right_{motor}.pos"
-                if vel_key in obs:
-                    velocities_deg_per_sec[f"right_{motor}"] = obs[vel_key]
-                if pos_key in obs:
-                    positions_deg[f"right_{motor}"] = obs[pos_key]
-            
-            for motor in follower.bus_left.motors:
-                vel_key = f"left_{motor}.vel"
-                pos_key = f"left_{motor}.pos"
-                if vel_key in obs:
-                    velocities_deg_per_sec[f"left_{motor}"] = obs[vel_key]
-                if pos_key in obs:
-                    positions_deg[f"left_{motor}"] = obs[pos_key]
-            
-            # Convert velocities to rad/s and compute friction torques
-            friction_torques_nm = {}
-            for motor_full_name, velocity_deg_per_sec in velocities_deg_per_sec.items():
-                # Extract motor name without arm prefix
-                if motor_full_name.startswith("right_"):
-                    motor_name = motor_full_name.removeprefix("right_")
-                elif motor_full_name.startswith("left_"):
-                    motor_name = motor_full_name.removeprefix("left_")
-                else:
-                    continue
-                
-                # Get motor index for friction parameters
-                motor_index = motor_name_to_index.get(motor_name, 0)
-                
-                # Convert velocity to rad/s
-                velocity_rad_per_sec = np.deg2rad(velocity_deg_per_sec)
-                
-                # Compute friction torque
-                friction_torque = compute_friction_torque(velocity_rad_per_sec, motor_index)
-                friction_torques_nm[motor_full_name] = friction_torque
-            
-            # Apply friction compensation to right arm (all joints INCLUDING gripper)
-            for motor in follower.bus_right.motors:
-                full_name = f"right_{motor}"
-                position = positions_deg.get(full_name, 0.0)
-                torque = friction_torques_nm.get(full_name, 0.0)
-                
-                # Get motor index for damping gain
-                motor_index = motor_name_to_index.get(motor, 0)
-                kd = DAMPING_KD[motor_index]
-                
-                # Send MIT control command with friction compensation + damping
-                follower.bus_right._mit_control(
-                    motor=motor,
-                    kp=0.0,  # No position control
-                    kd=kd,   # Add damping for stability
-                    position_degrees=position,
-                    velocity_deg_per_sec=0.0,
-                    torque=torque
-                )
-
-            # Apply friction compensation to left arm (all joints INCLUDING gripper)
-            for motor in follower.bus_left.motors:
-                full_name = f"left_{motor}"
-                position = positions_deg.get(full_name, 0.0)
-                torque = friction_torques_nm.get(full_name, 0.0)
-                
-                # Get motor index for damping gain
-                motor_index = motor_name_to_index.get(motor, 0)
-                kd = DAMPING_KD[motor_index]
-                
-                # Send MIT control command with friction compensation + damping
-                follower.bus_left._mit_control(
-                    motor=motor,
-                    kp=0.0,  # No position control
-                    kd=kd,   # Add damping for stability
-                    position_degrees=position,
-                    velocity_deg_per_sec=0.0,
-                    torque=torque
-                )
-            
-            # Measure loop time
-            loop_end = time.perf_counter()
-            loop_time = loop_end - loop_start
-            loop_times.append(loop_time)
-            
-            # Print status 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
-                    
-                    print(f"{current_hz:.1f} Hz")
-
-                    loop_times = []
-                    last_print_time = loop_end
-            
-            time.sleep(0.001)
-            
-    except KeyboardInterrupt:
-        print("\n\nStopping friction compensation...")
-    
-    finally:
-        print("\nDisabling all motors and disconnecting...")
-        follower.bus_right.disable_torque()
-        follower.bus_left.disable_torque()
-        time.sleep(0.1)
-        follower.disconnect()
-        print("✓ Safe shutdown complete")
-
-
-if __name__ == "__main__":
-    main()
-

examples/openarms/gravity_compensation.py

@@ -1,142 +0,0 @@
-import time
-import numpy as np
-import pinocchio as pin
-from os.path import join, dirname, exists, expanduser
-
-from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
-
-
-def main() -> None:
-    config = OpenArmsFollowerConfig(
-        port_left="can0",
-        port_right="can1",
-        can_interface="socketcan",
-        id="openarms_follower",
-        disable_torque_on_disconnect=True,
-        max_relative_target=5.0,
-    )
-    
-    
-    print("Initializing robot...")
-    follower = OpenArmsFollower(config)
-    follower.connect(calibrate=True)
-    
-    # Load URDF for Pinocchio dynamics
-    urdf_path = "/home/croissant/Documents/openarm_description/openarm_bimanual_pybullet.urdf"
-    
-    pin_robot = pin.RobotWrapper.BuildFromURDF(urdf_path, dirname(urdf_path))
-    pin_robot.data = pin_robot.model.createData()
-    print(f"✓ Loaded Pinocchio model with {pin_robot.nq} DoFs")
-    
-    follower.pin_robot = pin_robot
-    
-    print(f"Applying gravity compensation")
-    print("  1. Support the arm before starting")
-    print("  2. The arm will be held in place by gravity compensation")
-    print("  3. You should be able to move it with gentle force")
-    print("\nPress ENTER when ready to start...")
-    input()
-    
-    print(f"✓ Motors enabled")
-    print("\nStarting gravity compensation loop...")
-    print("Press Ctrl+C to stop\n")
-    
-    loop_times = []
-    last_print_time = time.perf_counter()
-    
-    try:
-        while True:
-            loop_start = time.perf_counter()
-            
-            # Get current joint positions from robot
-            obs = follower.get_observation()
-            
-            # Extract positions in degrees
-            positions_deg = {}
-            for motor in follower.bus_right.motors:
-                key = f"right_{motor}.pos"
-                if key in obs:
-                    positions_deg[f"right_{motor}"] = obs[key]
-            
-            for motor in follower.bus_left.motors:
-                key = f"left_{motor}.pos"
-                if key in obs:
-                    positions_deg[f"left_{motor}"] = obs[key]
-            
-            # Convert to radians and calculate gravity torques
-            # Use the built-in method from OpenArmsFollower
-            positions_rad = {k: np.deg2rad(v) for k, v in positions_deg.items()}
-            torques_nm = follower._gravity_from_q(positions_rad)
-            
-            # Apply gravity compensation to right arm (all joints except gripper)
-            for motor in follower.bus_right.motors:
-                if motor == "gripper":
-                    continue  # Skip gripper
-                    
-                full_name = f"right_{motor}"
-                position = positions_deg.get(full_name, 0.0)
-                torque = torques_nm.get(full_name, 0.0)
-                
-                # Send MIT control command with gravity compensation torque
-                follower.bus_right._mit_control(
-                    motor=motor,
-                    kp=0.0,  # No position control
-                    kd=0.0,  # No velocity damping
-                    position_degrees=position,
-                    velocity_deg_per_sec=0.0,
-                    torque=torque
-                )
-
-            # Apply gravity compensation to left arm (all joints except gripper)
-            for motor in follower.bus_left.motors:
-                if motor == "gripper":
-                    continue  # Skip gripper
-                    
-                full_name = f"left_{motor}"
-                position = positions_deg.get(full_name, 0.0)
-                torque = torques_nm.get(full_name, 0.0)
-                
-                # Send MIT control command with gravity compensation torque
-                follower.bus_left._mit_control(
-                    motor=motor,
-                    kp=0.0,  # No position control
-                    kd=0.0,  # No velocity damping
-                    position_degrees=position,
-                    velocity_deg_per_sec=0.0,
-                    torque=torque
-                )
-            
-            # Measure loop time
-            loop_end = time.perf_counter()
-            loop_time = loop_end - loop_start
-            loop_times.append(loop_time)
-            
-            # Print status 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
-                    
-                    print(f"{current_hz:.1f} Hz ({avg_time*1000:.1f} ms)")
-
-                    loop_times = []
-                    last_print_time = loop_end
-            
-            time.sleep(0.005)
-            
-    except KeyboardInterrupt:
-        print("\n\nStopping gravity compensation...")
-    
-    finally:
-        print("\nDisabling all motors and disconnecting...")
-        follower.bus_right.disable_torque()
-        follower.bus_left.disable_torque()
-        time.sleep(0.1)
-        follower.disconnect()
-        print("✓ Safe shutdown complete")
-
-
-if __name__ == "__main__":
-    main()
-

examples/openarms/record_with_compensation.py

@@ -1,395 +0,0 @@
-"""
-OpenArms Dataset Recording with Gravity + Friction Compensation
-
-Records a dataset using OpenArms follower robot with leader teleoperator.
-Leader arms have gravity and friction compensation for weightless, easy movement.
-Includes 3 cameras: left wrist, right wrist, and base camera.
-
-Uses the same compensation approach as teleop_with_compensation.py
-"""
-
-import shutil
-import time
-from pathlib import Path
-
-import numpy as np
-
-from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.datasets.utils import build_dataset_frame, hw_to_dataset_features
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
-from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
-from lerobot.teleoperators.openarms.config_openarms_leader import OpenArmsLeaderConfig
-from lerobot.teleoperators.openarms.openarms_leader import OpenArmsLeader
-from lerobot.utils.control_utils import init_keyboard_listener
-from lerobot.utils.utils import log_say
-from lerobot.utils.visualization_utils import init_rerun, log_rerun_data
-
-# Recording parameters
-NUM_EPISODES = 1
-FPS = 30
-EPISODE_TIME_SEC = 600
-RESET_TIME_SEC = 120
-TASK_DESCRIPTION = "OpenArms task description"
-
-# Friction compensation scale factor (1.0 = full, 0.3 = 30% for stability)
-FRICTION_SCALE = 1.0
-
-def record_loop_with_compensation(
-    robot,
-    leader,
-    events,
-    fps,
-    dataset,
-    dataset_features,
-    control_time_s,
-    single_task,
-    display_data=True,
-):
-    """
-    Custom record loop that applies gravity + friction compensation to leader.
-    Based on record_loop but with integrated compensation.
-    """
-    dt = 1 / fps
-    episode_start_time = time.perf_counter()
-    
-    # All joints (both arms)
-    all_joints = []
-    for motor in leader.bus_right.motors:
-        all_joints.append(f"right_{motor}")
-    for motor in leader.bus_left.motors:
-        all_joints.append(f"left_{motor}")
-    
-    while True:
-        loop_start = time.perf_counter()
-        elapsed = loop_start - episode_start_time
-        
-        # Check if we should exit
-        if elapsed >= control_time_s or events["exit_early"] or events["stop_recording"]:
-            break
-        
-        # Get leader state
-        leader_action = leader.get_action()
-        
-        # Extract positions and velocities in degrees
-        leader_positions_deg = {}
-        leader_velocities_deg_per_sec = {}
-        
-        for motor in leader.bus_right.motors:
-            pos_key = f"right_{motor}.pos"
-            vel_key = f"right_{motor}.vel"
-            if pos_key in leader_action:
-                leader_positions_deg[f"right_{motor}"] = leader_action[pos_key]
-            if vel_key in leader_action:
-                leader_velocities_deg_per_sec[f"right_{motor}"] = leader_action[vel_key]
-        
-        for motor in leader.bus_left.motors:
-            pos_key = f"left_{motor}.pos"
-            vel_key = f"left_{motor}.vel"
-            if pos_key in leader_action:
-                leader_positions_deg[f"left_{motor}"] = leader_action[pos_key]
-            if vel_key in leader_action:
-                leader_velocities_deg_per_sec[f"left_{motor}"] = leader_action[vel_key]
-        
-        # Calculate gravity torques for leader using built-in method
-        leader_positions_rad = {k: np.deg2rad(v) for k, v in leader_positions_deg.items()}
-        leader_gravity_torques_nm = leader._gravity_from_q(leader_positions_rad)
-        
-        # Calculate friction torques for leader using built-in method
-        leader_velocities_rad_per_sec = {k: np.deg2rad(v) for k, v in leader_velocities_deg_per_sec.items()}
-        leader_friction_torques_nm = leader._friction_from_velocity(
-            leader_velocities_rad_per_sec,
-            friction_scale=FRICTION_SCALE
-        )
-        
-        # Combine gravity + friction torques
-        leader_total_torques_nm = {}
-        for motor_name in leader_gravity_torques_nm:
-            gravity = leader_gravity_torques_nm.get(motor_name, 0.0)
-            friction = leader_friction_torques_nm.get(motor_name, 0.0)
-            leader_total_torques_nm[motor_name] = gravity + friction
-        
-        # Apply gravity + friction compensation to leader RIGHT arm (all joints including gripper)
-        for motor in leader.bus_right.motors:
-            full_name = f"right_{motor}"
-            position = leader_positions_deg.get(full_name, 0.0)
-            torque = leader_total_torques_nm.get(full_name, 0.0)
-            
-            # Get damping gain for stability
-            kd = leader.get_damping_kd(motor)
-            
-            leader.bus_right._mit_control(
-                motor=motor,
-                kp=0.0,
-                kd=kd,  # Add damping for stability
-                position_degrees=position,
-                velocity_deg_per_sec=0.0,
-                torque=torque,
-            )
-        
-        # Apply gravity + friction compensation to leader LEFT arm (all joints including gripper)
-        for motor in leader.bus_left.motors:
-            full_name = f"left_{motor}"
-            position = leader_positions_deg.get(full_name, 0.0)
-            torque = leader_total_torques_nm.get(full_name, 0.0)
-            
-            # Get damping gain for stability
-            kd = leader.get_damping_kd(motor)
-            
-            leader.bus_left._mit_control(
-                motor=motor,
-                kp=0.0,
-                kd=kd,  # Add damping for stability
-                position_degrees=position,
-                velocity_deg_per_sec=0.0,
-                torque=torque,
-            )
-        
-        # Send leader positions to follower (both arms)
-        follower_action = {}
-        for joint in all_joints:
-            pos_key = f"{joint}.pos"
-            if pos_key in leader_action:
-                follower_action[pos_key] = leader_action[pos_key]
-        
-        # Send action to robot
-        if follower_action:
-            robot.send_action(follower_action)
-        
-        # Get observation from robot (includes camera images)
-        observation = robot.get_observation()
-        
-        # Add to dataset if we have a dataset
-        if dataset is not None:
-            # Build properly formatted observation frame
-            obs_frame = build_dataset_frame(dataset_features, observation, prefix="observation")
-            
-            # Build properly formatted action frame (keep .pos suffix - it matches the feature names)
-            action_frame = build_dataset_frame(dataset_features, follower_action, prefix="action")
-            
-            # Combine into single frame
-            frame = {**obs_frame, **action_frame}
-            
-            # Add metadata (task is required, timestamp will be auto-calculated by add_frame)
-            frame["task"] = single_task
-            
-            dataset.add_frame(frame)
-        
-        # Display data if requested
-        if display_data:
-            log_rerun_data(observation=observation, action=follower_action)
-        
-        # Maintain loop rate
-        loop_duration = time.perf_counter() - loop_start
-        sleep_time = dt - loop_duration
-        if sleep_time > 0:
-            time.sleep(sleep_time)
-
-
-def main():
-    """Main recording loop with gravity compensation."""
-    
-    print("=" * 70)
-    print("OpenArms Dataset Recording with Compensation")
-    print("=" * 70)
-    
-    # Create camera configurations (3 cameras: left wrist, right wrist, base)
-    # Using actual device paths found by lerobot-find-cameras opencv
-    camera_config = {
-        "left_wrist": OpenCVCameraConfig(index_or_path="/dev/video0", width=640, height=480, fps=FPS),
-        "right_wrist": OpenCVCameraConfig(index_or_path="/dev/video1", width=640, height=480, fps=FPS),
-        "base": OpenCVCameraConfig(index_or_path="/dev/video7", width=640, height=480, fps=FPS),
-    }
-    
-    # Configure follower robot with cameras
-    follower_config = OpenArmsFollowerConfig(
-        port_left="can2",
-        port_right="can3",
-        can_interface="socketcan",
-        id="openarms_follower",
-        disable_torque_on_disconnect=True,
-        max_relative_target=10.0,
-        cameras=camera_config,
-    )
-    
-    # Configure leader teleoperator (no cameras needed)
-    leader_config = OpenArmsLeaderConfig(
-        port_left="can0",
-        port_right="can1",
-        can_interface="socketcan",
-        id="openarms_leader",
-        manual_control=False,  # Enable torque control for gravity compensation
-    )
-    
-    # Initialize robot and teleoperator
-    print("\nInitializing devices...")
-    follower = OpenArmsFollower(follower_config)
-    leader = OpenArmsLeader(leader_config)
-    
-    # Connect devices
-    print("Connecting and calibrating...")
-    follower.connect(calibrate=True)
-    leader.connect(calibrate=True)
-    
-    # Verify URDF is loaded for gravity compensation
-    if leader.pin_robot is None:
-        raise RuntimeError("URDF model not loaded on leader. Gravity compensation not available.")
-    
-    # Configure the dataset features
-    # For actions, we only want to record positions (not velocity or torque)
-    action_features_hw = {}
-    for key, value in follower.action_features.items():
-        if key.endswith(".pos"):
-            action_features_hw[key] = value
-    
-    action_features = hw_to_dataset_features(action_features_hw, "action")
-    obs_features = hw_to_dataset_features(follower.observation_features, "observation")
-    dataset_features = {**action_features, **obs_features}
-    
-    # Create the dataset
-    print("\nCreating dataset...")
-    repo_id = "<hf_username>/<dataset_repo_id>"  # TODO: Replace with your Hugging Face repo
-    
-    # Check if dataset already exists and prompt user
-    dataset_path = Path.home() / ".cache" / "huggingface" / "lerobot" / repo_id
-    while dataset_path.exists():
-        print(f"\nDataset already exists at: {dataset_path}")
-        print("\nOptions:")
-        print("  1. Overwrite existing dataset")
-        print("  2. Use a different name")
-        print("  3. Abort")
-        
-        choice = input("\nEnter your choice (1/2/3): ").strip()
-        
-        if choice == '1':
-            print(f"Removing existing dataset...")
-            shutil.rmtree(dataset_path)
-            print("✓ Existing dataset removed")
-            break
-        elif choice == '2':
-            print("\nCurrent repo_id:", repo_id)
-            new_repo_id = input("Enter new repo_id (format: <username>/<dataset_name>): ").strip()
-            if new_repo_id and '/' in new_repo_id:
-                repo_id = new_repo_id
-                dataset_path = Path.home() / ".cache" / "huggingface" / "lerobot" / repo_id
-                print(f"✓ Using new repo_id: {repo_id}")
-                # Loop will continue if this new path also exists
-            else:
-                print("Invalid repo_id format. Please use format: <username>/<dataset_name>")
-        elif choice == '3':
-            print("Aborting. Please remove the existing dataset manually or restart with a different repo_id.")
-            follower.disconnect()
-            leader.disconnect()
-            return
-        else:
-            print("Invalid choice. Please enter 1, 2, or 3.")
-    
-    dataset = LeRobotDataset.create(
-        repo_id=repo_id,
-        fps=FPS,
-        features=dataset_features,
-        robot_type=follower.name,
-        use_videos=True,
-        image_writer_threads=4,
-    )
-    
-    # Initialize keyboard listener and visualization
-    _, events = init_keyboard_listener()
-    init_rerun(session_name="openarms_recording")
-    
-    # Enable motors on both leader arms for gravity compensation
-    leader.bus_right.enable_torque()
-    leader.bus_left.enable_torque()
-    time.sleep(0.1)
-    
-    print("\n" + "=" * 70)
-    print(f"Recording {NUM_EPISODES} episodes")
-    print(f"Task: {TASK_DESCRIPTION}")
-    print("=" * 70)
-    print("\nLeader BOTH arms: Gravity + Friction comp | Follower BOTH arms: Teleop")
-    print("\nKeyboard controls:")
-    print("  - Press 'q' to stop recording")
-    print("  - Press 'r' to re-record current episode")
-    print("=" * 70)
-    
-    episode_idx = 0
-    
-    try:
-        while episode_idx < NUM_EPISODES and not events["stop_recording"]:
-            log_say(f"Recording episode {episode_idx + 1} of {NUM_EPISODES}")
-            
-            # Record episode with compensation active
-            record_loop_with_compensation(
-                robot=follower,
-                leader=leader,
-                events=events,
-                fps=FPS,
-                dataset=dataset,
-                dataset_features=dataset_features,
-                control_time_s=EPISODE_TIME_SEC,
-                single_task=TASK_DESCRIPTION,
-                display_data=True,
-            )
-            
-            # Reset the environment if not stopping or re-recording
-            if not events["stop_recording"] and (episode_idx < NUM_EPISODES - 1 or events["rerecord_episode"]):
-                log_say("Reset the environment")
-                record_loop_with_compensation(
-                    robot=follower,
-                    leader=leader,
-                    events=events,
-                    fps=FPS,
-                    dataset=None,  # Don't save reset period
-                    dataset_features=dataset_features,
-                    control_time_s=RESET_TIME_SEC,
-                    single_task=TASK_DESCRIPTION,
-                    display_data=True,
-                )
-            
-            # Handle re-recording
-            if events["rerecord_episode"]:
-                log_say("Re-recording episode")
-                events["rerecord_episode"] = False
-                events["exit_early"] = False
-                dataset.clear_episode_buffer()
-                continue
-            
-            # Only save episode if frames were recorded
-            if dataset.episode_buffer is not None and dataset.episode_buffer["size"] > 0:
-                dataset.save_episode()
-                episode_idx += 1
-            else:
-                log_say("No frames recorded, skipping episode save")
-                # Clear the empty buffer
-                dataset.episode_buffer = None
-    
-    except KeyboardInterrupt:
-        print("\n\nStopping recording...")
-    
-    finally:
-        # Clean up
-        log_say("Stop recording")
-        try:
-            leader.bus_right.disable_torque()
-            leader.bus_left.disable_torque()
-            time.sleep(0.1)
-            leader.disconnect()
-            follower.disconnect()
-            print("✓ Shutdown complete")
-        except Exception as e:
-            print(f"Shutdown error: {e}")
-        
-        # Upload dataset
-        print("\nUploading dataset to Hugging Face Hub...")
-        try:
-            dataset.push_to_hub()
-            print("✓ Dataset uploaded successfully")
-        except Exception as e:
-            print(f"Warning: Failed to upload dataset: {e}")
-            print("You can manually upload later using: dataset.push_to_hub()")
-        
-        print("✓ Recording complete!")
-
-
-if __name__ == "__main__":
-    main()

examples/openarms/replay.py

@@ -1,166 +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.
-
-"""
-OpenArms Dataset Replay Example
-
-Replays position actions from a recorded dataset on an OpenArms follower robot.
-Only position commands (ending with .pos) are replayed, not velocity or torque.
-
-Example usage:
-    python examples/openarms/replay.py
-"""
-
-import time
-
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
-from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
-from lerobot.utils.constants import ACTION
-from lerobot.utils.robot_utils import busy_wait
-from lerobot.utils.utils import log_say
-
-# Configuration
-EPISODE_IDX = 0
-DATASET_REPO_ID = "lerobot-data-collection/replay-this-2025-11-02-17-58"  # TODO: Replace with your dataset
-DATASET_ROOT = None  # Use default cache location, or specify custom path
-
-# Robot configuration - adjust these to match your setup
-ROBOT_CONFIG = OpenArmsFollowerConfig(
-    port_left="can2",      # CAN interface for left arm
-    port_right="can3",     # CAN interface for right arm
-    can_interface="socketcan", 
-    id="openarms_follower",
-    disable_torque_on_disconnect=True,
-    max_relative_target=10.0,  # Safety limit: max degrees to move per step
-)
-
-
-def main():
-    """Main replay function."""
-    print("=" * 70)
-    print("OpenArms Dataset Replay")
-    print("=" * 70)
-    print(f"\nDataset: {DATASET_REPO_ID}")
-    print(f"Episode: {EPISODE_IDX}")
-    print(f"Robot: {ROBOT_CONFIG.id}")
-    print(f"  Left arm: {ROBOT_CONFIG.port_left}")
-    print(f"  Right arm: {ROBOT_CONFIG.port_right}")
-    print("\n" + "=" * 70)
-    
-    # Initialize the robot
-    print("\n[1/3] Initializing robot...")
-    robot = OpenArmsFollower(ROBOT_CONFIG)
-    
-    # Load the dataset
-    print(f"\n[2/3] Loading dataset '{DATASET_REPO_ID}'...")
-    dataset = LeRobotDataset(
-        DATASET_REPO_ID,
-        root=DATASET_ROOT,
-        episodes=[EPISODE_IDX]
-    )
-    
-    # Filter dataset to only include frames from the specified episode
-    # (required for dataset V3.0 where episodes are chunked)
-    episode_frames = dataset.hf_dataset.filter(
-        lambda x: x["episode_index"] == EPISODE_IDX
-    )
-    
-    if len(episode_frames) == 0:
-        raise ValueError(
-            f"No frames found for episode {EPISODE_IDX} in dataset {DATASET_REPO_ID}"
-        )
-    
-    print(f"  Found {len(episode_frames)} frames in episode {EPISODE_IDX}")
-    
-    # Extract action features from dataset
-    action_features = dataset.features.get(ACTION, {})
-    action_names = action_features.get("names", [])
-    
-    # Filter to only position actions (ending with .pos)
-    position_action_names = [name for name in action_names if name.endswith(".pos")]
-    
-    if not position_action_names:
-        raise ValueError(
-            f"No position actions found in dataset. Action names: {action_names}"
-        )
-    
-    print(f"  Found {len(position_action_names)} position actions to replay")
-    print(f"  Actions: {', '.join(position_action_names[:5])}{'...' if len(position_action_names) > 5 else ''}")
-    
-    # Select only action columns from dataset
-    actions = episode_frames.select_columns(ACTION)
-    
-    # Connect to the robot
-    print(f"\n[3/3] Connecting to robot...")
-    robot.connect(calibrate=False)  # Skip calibration for replay
-    
-    if not robot.is_connected:
-        raise RuntimeError("Robot failed to connect!")
-    
-    print("\n" + "=" * 70)
-    print("Ready to replay!")
-    print("=" * 70)
-    print("\nThe robot will replay the recorded positions.")
-    print("Press Ctrl+C to stop at any time.\n")
-    
-    input("Press ENTER to start replaying...")
-    
-    # Replay loop
-    log_say(f"Replaying episode {EPISODE_IDX}", blocking=True)
-    
-    try:
-        for idx in range(len(episode_frames)):
-            loop_start = time.perf_counter()
-            
-            # Extract action array from dataset
-            action_array = actions[idx][ACTION]
-            
-            # Build action dictionary, but only include position actions
-            action = {}
-            for i, name in enumerate(action_names):
-                # Only include position actions (ending with .pos)
-                if name.endswith(".pos"):
-                    action[name] = float(action_array[i])
-            
-            # Send action to robot
-            robot.send_action(action)
-            
-            # Maintain replay rate (use dataset fps)
-            loop_duration = time.perf_counter() - loop_start
-            dt_s = 1.0 / dataset.fps - loop_duration
-            busy_wait(dt_s)
-            
-            # Progress indicator every 100 frames
-            if (idx + 1) % 100 == 0:
-                progress = (idx + 1) / len(episode_frames) * 100
-                print(f"Progress: {idx + 1}/{len(episode_frames)} frames ({progress:.1f}%)")
-        
-        print(f"\n✓ Successfully replayed {len(episode_frames)} frames")
-        log_say("Replay complete", blocking=True)
-        
-    except KeyboardInterrupt:
-        print("\n\nReplay interrupted by user")
-    finally:
-        # Disconnect robot
-        print("\nDisconnecting robot...")
-        robot.disconnect()
-        print("✓ Replay complete!")
-
-
-if __name__ == "__main__":
-    main()
-

examples/openarms/setup_can.sh

@@ -1,73 +0,0 @@
-#!/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

@@ -1,148 +0,0 @@
-"""
-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="can2",   # CAN interface for follower left arm
-    port_right="can3",  # 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="can0",   # CAN interface for leader left arm
-    port_right="can1",  # 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!")

examples/openarms/teleop_openarms_mini.py

@@ -1,197 +0,0 @@
-"""
-OpenArms Mini Teleoperation Example
-
-This script demonstrates teleoperation of an OpenArms follower robot using 
-an OpenArms Mini leader (Feetech-based) with dual arms (16 motors total).
-
-The OpenArms Mini has:
-- Right arm: 8 motors (joint_1 to joint_7 + gripper)
-- Left arm: 8 motors (joint_1 to joint_7 + gripper)
-
-Note on gripper normalization:
-- OpenArms Mini gripper: 0-100 scale (0=closed, 100=open)
-- OpenArms follower gripper: degrees (0=closed, -65=open)
-- This script automatically converts between the two ranges
-"""
-
-import time
-import os
-import sys
-
-from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
-from lerobot.teleoperators.openarms_mini.openarms_mini import OpenArmsMini
-from lerobot.teleoperators.openarms_mini.config_openarms_mini import OpenArmsMiniConfig
-from lerobot.utils.robot_utils import busy_wait
-
-# Target control frequency
-TARGET_FPS = 30
-
-# Configure the OpenArms follower (Damiao motors on CAN bus)
-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=10.0,  # Safety limit (degrees per step)
-)
-
-# Configure the OpenArms Mini leader (Feetech motors on serial)
-leader_config = OpenArmsMiniConfig(
-    port_right="/dev/ttyACM0",  # Serial port for right arm
-    port_left="/dev/ttyACM1",   # Serial port for left arm
-    id="openarms_mini",
-    use_degrees=True,
-)
-
-print("OpenArms Mini → OpenArms Follower Teleoperation")
-
-# Initialize devices
-follower = OpenArmsFollower(follower_config)
-leader = OpenArmsMini(leader_config)
-
-# Connect and calibrate follower
-print("Note: If you have existing calibration, just press ENTER to use it.")
-follower.connect(calibrate=True)
-
-# Connect and calibrate leader
-print("Note: The leader arms will have torque disabled for manual control.")
-leader.connect(calibrate=True)
-
-print("\nPress ENTER to start teleoperation...")
-input()
-
-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 = []
-avg_loop_time = 0.0
-min_loop_time = float('inf')
-max_loop_time = 0.0
-stats_update_interval = 1.0  # Update stats every 1 second
-last_stats_update = time.perf_counter()
-
-
-SWAPPED_JOINTS = {
-    "right_joint_6": "right_joint_7",
-    "right_joint_7": "right_joint_6",
-    "left_joint_6": "left_joint_7",
-    "left_joint_7": "left_joint_6",
-}
-
-try:
-    while True:
-        loop_start = time.perf_counter()
-
-        # Get actions and observations
-        leader_action = leader.get_action()
-        follower_obs = follower.get_observation()
-
-        joint_action = {}
-        for joint in all_joints:
-            leader_key = f"{joint}.pos"
-
-            # Determine which follower joint this leader joint controls
-            follower_joint = SWAPPED_JOINTS.get(joint, joint)
-            follower_key = f"{follower_joint}.pos"
-
-            # Get leader position (default 0 if missing)
-            pos = leader_action.get(leader_key, 0.0)
-
-            # Convert gripper values: Mini uses 0-100, OpenArms uses 0 to -65 degrees
-            if "gripper" in joint:
-                # Map 0-100 (Mini) to 0 to -65 (OpenArms)
-                # 0 (closed) -> 0°, 100 (open) -> -65°
-                pos = (pos / 100.0) * -65.0
-
-            # Store in action dict for follower
-            joint_action[follower_key] = pos
-
-        follower.send_action(joint_action)
-
-        # Loop timing
-        loop_end = time.perf_counter()
-        loop_time = loop_end - loop_start
-        loop_times.append(loop_time)
-
-        # Update stats periodically
-        current_time = time.perf_counter()
-        if current_time - last_stats_update >= stats_update_interval:
-            if loop_times:
-                avg_loop_time = sum(loop_times) / len(loop_times)
-                min_loop_time = min(loop_times)
-                max_loop_time = max(loop_times)
-                loop_times = []
-                last_stats_update = current_time
-
-        # Display everything
-        sys.stdout.write("\033[H\033[J")  # Clear screen
-        
-        # Show timing stats at the top
-        if avg_loop_time > 0:
-            avg_hz = 1.0 / avg_loop_time
-            min_hz = 1.0 / max_loop_time if max_loop_time > 0 else 0
-            max_hz = 1.0 / min_loop_time if min_loop_time > 0 and min_loop_time < float('inf') else 0
-            print(f"[Performance] Target: {TARGET_FPS} Hz | Avg: {avg_hz:.1f} Hz | Range: {min_hz:.1f}-{max_hz:.1f} Hz | Loop: {avg_loop_time*1000:.1f} ms\n")
-        else:
-            print(f"[Performance] Target: {TARGET_FPS} Hz | Measuring...\n")
-
-        # Show joint positions
-        print(f"{'Joint':<20} {'Leader':>15} {'Follower':>15}")
-        print(f"{'':20} {'(0-100/deg)':>15} {'(deg)':>15}")
-        print("-" * 52)
-
-        for joint in all_joints:
-            leader_key = f"{joint}.pos"
-            follower_joint = SWAPPED_JOINTS.get(joint, joint)
-            follower_key = f"{follower_joint}.pos"
-
-            leader_pos = leader_action.get(leader_key, 0.0)
-            follower_pos = follower_obs.get(follower_key, 0.0)
-
-            print(f"{joint:<20} {leader_pos:>15.2f} {follower_pos:>15.2f}")
-
-        # Smart sleep to maintain target FPS
-        dt_s = time.perf_counter() - loop_start
-        busy_wait(max(0, 1.0 / TARGET_FPS - dt_s))
-            
-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!")
-

examples/openarms/teleop_with_compensation.py

@@ -1,202 +0,0 @@
-"""
-OpenArms Teleoperation with Gravity + Friction Compensation
-
-Leader arms (both LEFT and RIGHT): Gravity + Friction compensation (weightless, easy to move)
-Follower arms (both LEFT and RIGHT): Mirror leader movements
-
-Uses the URDF file from the lerobot repository.
-"""
-
-import time
-
-import numpy as np
-
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
-from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
-from lerobot.teleoperators.openarms.config_openarms_leader import OpenArmsLeaderConfig
-from lerobot.teleoperators.openarms.openarms_leader import OpenArmsLeader
-
-# Friction compensation scale factor (1.0 = full, 0.3 = 30% for stability)
-FRICTION_SCALE = 1.0
-
-def main():
-    """Main teleoperation loop with gravity compensation"""
-
-    print("=" * 70)
-    print("OpenArms Teleoperation with Gravity Compensation")
-    print("=" * 70)
-
-    # Configuration
-    follower_config = OpenArmsFollowerConfig(
-        port_left="can2",
-        port_right="can3",
-        can_interface="socketcan",
-        id="openarms_follower",
-        disable_torque_on_disconnect=True,
-        max_relative_target=10.0,
-    )
-
-    leader_config = OpenArmsLeaderConfig(
-        port_left="can0",
-        port_right="can1",
-        can_interface="socketcan",
-        id="openarms_leader",
-        manual_control=False,  # Enable torque control for gravity compensation
-    )
-
-    # Initialize and connect
-    print("\nInitializing devices...")
-    follower = OpenArmsFollower(follower_config)
-    leader = OpenArmsLeader(leader_config)
-
-    follower.connect()
-    leader.connect()
-
-    # URDF is automatically loaded in the leader constructor
-    if leader.pin_robot is None:
-        raise RuntimeError("URDF model not loaded on leader. Gravity compensation not available.")
-
-    print("\nLeader BOTH arms: Gravity + Friction comp | Follower BOTH arms: Teleop")
-    print("Press ENTER to start...")
-    input()
-
-    # Enable motors on both leader arms for gravity compensation
-    leader.bus_right.enable_torque()
-    leader.bus_left.enable_torque()
-    time.sleep(0.1)
-
-    print("Press Ctrl+C to stop\n")
-
-    # Main control loop
-    loop_times = []
-    last_print_time = time.perf_counter()
-
-    # All joints (both arms)
-    all_joints = []
-    for motor in leader.bus_right.motors:
-        all_joints.append(f"right_{motor}")
-    for motor in leader.bus_left.motors:
-        all_joints.append(f"left_{motor}")
-
-    try:
-        while True:
-            loop_start = time.perf_counter()
-
-            # Get leader state
-            leader_action = leader.get_action()
-
-            # Extract positions and velocities in degrees
-            leader_positions_deg = {}
-            leader_velocities_deg_per_sec = {}
-            
-            for motor in leader.bus_right.motors:
-                pos_key = f"right_{motor}.pos"
-                vel_key = f"right_{motor}.vel"
-                if pos_key in leader_action:
-                    leader_positions_deg[f"right_{motor}"] = leader_action[pos_key]
-                if vel_key in leader_action:
-                    leader_velocities_deg_per_sec[f"right_{motor}"] = leader_action[vel_key]
-
-            for motor in leader.bus_left.motors:
-                pos_key = f"left_{motor}.pos"
-                vel_key = f"left_{motor}.vel"
-                if pos_key in leader_action:
-                    leader_positions_deg[f"left_{motor}"] = leader_action[pos_key]
-                if vel_key in leader_action:
-                    leader_velocities_deg_per_sec[f"left_{motor}"] = leader_action[vel_key]
-
-            # Calculate gravity torques for leader using built-in method
-            leader_positions_rad = {k: np.deg2rad(v) for k, v in leader_positions_deg.items()}
-            leader_gravity_torques_nm = leader._gravity_from_q(leader_positions_rad)
-            
-            # Calculate friction torques for leader using built-in method
-            leader_velocities_rad_per_sec = {k: np.deg2rad(v) for k, v in leader_velocities_deg_per_sec.items()}
-            leader_friction_torques_nm = leader._friction_from_velocity(
-                leader_velocities_rad_per_sec,
-                friction_scale=FRICTION_SCALE
-            )
-            
-            # Combine gravity + friction torques 
-            leader_total_torques_nm = {}
-            for motor_name in leader_gravity_torques_nm:
-                gravity = leader_gravity_torques_nm.get(motor_name, 0.0)
-                friction = leader_friction_torques_nm.get(motor_name, 0.0)
-                leader_total_torques_nm[motor_name] = gravity + friction
-
-            # Apply gravity + friction compensation to leader RIGHT arm (all joints including gripper)
-            for motor in leader.bus_right.motors:
-                full_name = f"right_{motor}"
-                position = leader_positions_deg.get(full_name, 0.0)
-                torque = leader_total_torques_nm.get(full_name, 0.0)
-                
-                # Get damping gain for stability
-                kd = leader.get_damping_kd(motor)
-
-                leader.bus_right._mit_control(
-                    motor=motor,
-                    kp=0.0,
-                    kd=kd,  # Add damping for stability
-                    position_degrees=position,
-                    velocity_deg_per_sec=0.0,
-                    torque=torque,
-                )
-
-            # Apply gravity + friction compensation to leader LEFT arm (all joints including gripper)
-            for motor in leader.bus_left.motors:
-                full_name = f"left_{motor}"
-                position = leader_positions_deg.get(full_name, 0.0)
-                torque = leader_total_torques_nm.get(full_name, 0.0)
-                
-                # Get damping gain for stability
-                kd = leader.get_damping_kd(motor)
-
-                leader.bus_left._mit_control(                    
-                    motor=motor,
-                    kp=0.0,
-                    kd=kd,  # Add damping for stability
-                    position_degrees=position,
-                    velocity_deg_per_sec=0.0,
-                    torque=torque,
-                )
-
-            # Send leader positions to follower (both arms)
-            follower_action = {}
-            for joint in all_joints:
-                pos_key = f"{joint}.pos"
-                if pos_key in leader_action:
-                    follower_action[pos_key] = leader_action[pos_key]
-
-            if follower_action:
-                follower.send_action(follower_action)
-
-            # Performance monitoring
-            loop_end = time.perf_counter()
-            loop_time = loop_end - loop_start
-            loop_times.append(loop_time)
-
-            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
-
-                    print(f"{current_hz:.1f} Hz ({avg_time*1000:.1f} ms)")
-
-                    loop_times = []
-                    last_print_time = loop_end
-
-    except KeyboardInterrupt:
-        print("\n\nStopping...")
-    finally:
-        try:
-            leader.bus_right.disable_torque()
-            leader.bus_left.disable_torque()
-            time.sleep(0.1)
-            leader.disconnect()
-            follower.disconnect()
-            print("✓ Shutdown complete")
-        except Exception as e:
-            print(f"Shutdown error: {e}")
-
-
-if __name__ == "__main__":
-    main()

examples/openarms/unify_task.py

@@ -1,152 +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.
-
-"""
-Unify all tasks in a dataset to a single task (modifies in-place).
-
-This script:
-1. Loads a dataset
-2. Sets all task_index to 0 and task description to "fold"
-3. Updates tasks.parquet and task_index in data files (in-place, no copying)
-
-Usage:
-    python examples/openarms/unify_task.py --repo-id lerobot-data-collection/level1_rac1
-"""
-
-from __future__ import annotations
-
-import argparse
-import logging
-from pathlib import Path
-
-import pandas as pd
-from tqdm import tqdm
-
-from lerobot.datasets.lerobot_dataset import LeRobotDatasetMetadata
-from lerobot.datasets.utils import (
-    DATA_DIR,
-    write_info,
-    write_tasks,
-)
-from lerobot.utils.constants import HF_LEROBOT_HOME
-
-
-# Single unified task
-UNIFIED_TASK = "fold"
-
-
-def unify_dataset_tasks(
-    repo_id: str,
-    root: Path | None = None,
-    push_to_hub: bool = False,
-) -> None:
-    """Unify all tasks in a dataset to a single task (modifies in-place).
-
-    Args:
-        repo_id: Dataset repository ID.
-        root: Optional root path for dataset.
-        push_to_hub: Whether to push the result to HuggingFace Hub.
-    """
-    input_root = root if root else HF_LEROBOT_HOME / repo_id
-    input_repo_id = repo_id
-
-    logging.info(f"Loading metadata from {repo_id}")
-
-    # Load source metadata
-    src_meta = LeRobotDatasetMetadata(repo_id, root=input_root)
-
-    logging.info(f"Source dataset: {src_meta.total_episodes} episodes, {src_meta.total_frames} frames")
-    logging.info(f"Original tasks: {len(src_meta.tasks)}")
-
-    # Modify in-place (input_root == output_root supported)
-    data_dir = input_root / DATA_DIR
-
-    # Process data files - set all task_index to 0
-    logging.info("Processing data files (in-place)...")
-    for parquet_file in tqdm(sorted(data_dir.rglob("*.parquet")), desc="Processing data"):
-        df = pd.read_parquet(parquet_file)
-        df["task_index"] = 0  # All tasks unified to index 0
-        df.to_parquet(parquet_file)
-
-    # Process episodes metadata - set all tasks to unified task
-    logging.info("Processing episodes metadata (in-place)...")
-    episodes_dir = input_root / "meta" / "episodes"
-    if episodes_dir.exists():
-        for parquet_file in tqdm(sorted(episodes_dir.rglob("*.parquet")), desc="Processing episodes"):
-            df = pd.read_parquet(parquet_file)
-            df["tasks"] = [[UNIFIED_TASK]] * len(df)  # All episodes get the unified task
-            df.to_parquet(parquet_file)
-    else:
-        logging.warning(f"No episodes directory found at {episodes_dir}, skipping")
-
-    # Update tasks.parquet with single task
-    logging.info(f"Creating single task: {UNIFIED_TASK}")
-    new_tasks = pd.DataFrame({"task_index": [0]}, index=[UNIFIED_TASK])
-    write_tasks(new_tasks, input_root)
-
-    # Update info.json
-    new_info = src_meta.info.copy()
-    new_info["total_tasks"] = 1
-    write_info(new_info, input_root)
-
-    logging.info(f"Dataset modified in-place at {input_root}")
-    logging.info(f"Task: {UNIFIED_TASK}")
-
-    if push_to_hub:
-        from lerobot.datasets.lerobot_dataset import LeRobotDataset
-
-        logging.info(f"Pushing {input_repo_id} to hub")
-        dataset = LeRobotDataset(input_repo_id, root=input_root)
-        dataset.push_to_hub(private=True)
-        logging.info("Push complete!")
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Unify all tasks in a dataset to a single task 'fold' (modifies in-place)."
-    )
-
-    parser.add_argument(
-        "--repo-id",
-        type=str,
-        required=True,
-        help="Dataset repository ID",
-    )
-    parser.add_argument(
-        "--root",
-        type=Path,
-        default=None,
-        help="Optional root path (defaults to HF_LEROBOT_HOME/repo_id)",
-    )
-    parser.add_argument(
-        "--push-to-hub",
-        action="store_true",
-        help="Push result to HuggingFace Hub",
-    )
-
-    args = parser.parse_args()
-
-    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-
-    unify_dataset_tasks(
-        repo_id=args.repo_id,
-        root=args.root,
-        push_to_hub=args.push_to_hub,
-    )
-
-
-if __name__ == "__main__":
-    main()

examples/openarms_web_interface/App.css

@@ -1,745 +0,0 @@
-body {
-  margin: 0;
-  padding: 0;
-  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
-  background: #f5f5f5;
-}
-
-main {
-  min-height: 100vh;
-  padding: 2rem;
-}
-
-header {
-  text-align: center;
-  margin-bottom: 2rem;
-}
-
-h1 {
-  font-size: 2rem;
-  font-weight: 600;
-  color: #333;
-  margin: 0;
-}
-
-h2 {
-  font-size: 1.25rem;
-  font-weight: 600;
-  color: #333;
-  margin: 0 0 1rem 0;
-}
-
-h3 {
-  font-size: 0.875rem;
-  font-weight: 600;
-  color: #666;
-  margin: 0 0 0.5rem 0;
-  text-transform: uppercase;
-  letter-spacing: 0.5px;
-}
-
-.container {
-  max-width: 1920px;
-  margin: 0 auto;
-  display: grid;
-  grid-template-columns: minmax(500px, 600px) 1fr;
-  gap: 2rem;
-  align-items: start;
-}
-
-/* Left column container */
-.left-column {
-  display: flex;
-  flex-direction: column;
-  gap: 1.5rem;
-}
-
-/* Right column container */
-.right-column {
-  display: flex;
-  flex-direction: column;
-  gap: 1.5rem;
-}
-
-/* Responsive: Stack on smaller screens */
-@media (max-width: 1200px) {
-  .container {
-    grid-template-columns: 1fr;
-  }
-}
-
-.panel {
-  background: white;
-  border-radius: 8px;
-  padding: 1.5rem;
-  box-shadow: 0 1px 3px rgba(0,0,0,0.1);
-}
-
-.config-panel {
-  border: 2px solid #e5e7eb;
-}
-
-.config-header {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  cursor: pointer;
-  user-select: none;
-  padding: 0.5rem 0;
-}
-
-.config-header:hover {
-  opacity: 0.7;
-}
-
-.toggle-icon {
-  font-size: 1rem;
-  color: #6b7280;
-  transition: transform 0.2s;
-}
-
-.config-content {
-  margin-top: 1rem;
-  padding-top: 1rem;
-  border-top: 1px solid #e5e7eb;
-}
-
-.robot-setup {
-  margin-bottom: 0.5rem;
-}
-
-.robot-status {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  padding: 1rem;
-  border-radius: 6px;
-  font-weight: 500;
-  gap: 1rem;
-}
-
-.robot-status.ready {
-  background: linear-gradient(135deg, #d1fae5 0%, #a7f3d0 100%);
-  color: #065f46;
-  border: 1px solid #10b981;
-}
-
-.robot-status.not-ready {
-  background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
-  color: #92400e;
-  border: 1px solid #f59e0b;
-}
-
-.btn-setup {
-  background: #10b981;
-  color: white;
-  border: none;
-  padding: 0.5rem 1rem;
-  border-radius: 4px;
-  font-size: 0.875rem;
-  font-weight: 500;
-  cursor: pointer;
-  transition: background 0.2s;
-}
-
-.btn-setup:hover:not(:disabled) {
-  background: #059669;
-}
-
-.btn-setup:disabled {
-  background: #d1d5db;
-  cursor: not-allowed;
-}
-
-.btn-zero {
-  background: #8b5cf6;
-  color: white;
-  border: none;
-  padding: 0.5rem 1rem;
-  border-radius: 4px;
-  font-size: 0.875rem;
-  font-weight: 500;
-  cursor: pointer;
-  transition: background 0.2s;
-}
-
-.btn-zero:hover:not(:disabled) {
-  background: #7c3aed;
-}
-
-.btn-zero:disabled {
-  background: #d1d5db;
-  cursor: not-allowed;
-}
-
-.zero-position-section {
-  margin-top: 1rem;
-  padding-top: 1rem;
-  border-top: 1px solid #e5e7eb;
-}
-
-.btn-zero-large {
-  width: 100%;
-  background: #8b5cf6;
-  color: white;
-  border: none;
-  padding: 0.875rem 1.5rem;
-  border-radius: 8px;
-  font-size: 1rem;
-  font-weight: 600;
-  cursor: pointer;
-  transition: all 0.2s;
-  box-shadow: 0 2px 4px rgba(139, 92, 246, 0.2);
-}
-
-.btn-zero-large:hover:not(:disabled) {
-  background: #7c3aed;
-  box-shadow: 0 4px 8px rgba(139, 92, 246, 0.3);
-  transform: translateY(-1px);
-}
-
-.btn-zero-large:disabled {
-  background: #d1d5db;
-  cursor: not-allowed;
-  box-shadow: none;
-  transform: none;
-}
-
-.delete-episode-section {
-  margin-top: 1rem;
-  padding-top: 1rem;
-  border-top: 1px solid #e5e7eb;
-}
-
-.btn-delete {
-  width: 100%;
-  background: #ef4444;
-  color: white;
-  border: none;
-  padding: 0.875rem 1.5rem;
-  border-radius: 8px;
-  font-size: 1rem;
-  font-weight: 600;
-  cursor: pointer;
-  transition: all 0.2s;
-  box-shadow: 0 2px 4px rgba(239, 68, 68, 0.2);
-}
-
-.btn-delete:hover:not(:disabled) {
-  background: #dc2626;
-  box-shadow: 0 4px 8px rgba(239, 68, 68, 0.3);
-  transform: translateY(-1px);
-}
-
-.btn-delete:disabled {
-  background: #d1d5db;
-  cursor: not-allowed;
-  box-shadow: none;
-  transform: none;
-}
-
-.delete-info {
-  margin-top: 0.5rem;
-  font-size: 0.875rem;
-  color: #666;
-  text-align: center;
-  font-style: italic;
-}
-
-.btn-disconnect {
-  background: #ef4444;
-  color: white;
-  border: none;
-  padding: 0.5rem 1rem;
-  border-radius: 4px;
-  font-size: 0.875rem;
-  font-weight: 500;
-  cursor: pointer;
-  transition: background 0.2s;
-}
-
-.btn-disconnect:hover {
-  background: #dc2626;
-}
-
-.btn-refresh {
-  background: #3b82f6;
-  color: white;
-  border: none;
-  padding: 0.4rem 0.8rem;
-  border-radius: 4px;
-  font-size: 0.75rem;
-  font-weight: 500;
-  cursor: pointer;
-  transition: background 0.2s;
-}
-
-.btn-refresh:hover:not(:disabled) {
-  background: #2563eb;
-}
-
-.btn-refresh:disabled {
-  background: #d1d5db;
-  cursor: not-allowed;
-}
-
-.control-panel {
-  border: 2px solid #10b981;
-}
-
-.status-banner {
-  display: flex;
-  align-items: center;
-  gap: 1rem;
-  padding: 1rem 1.5rem;
-  border-radius: 6px;
-  margin-bottom: 1.5rem;
-  font-weight: 500;
-  font-size: 0.95rem;
-}
-
-.status-banner.initializing {
-  background: linear-gradient(135deg, #dbeafe 0%, #bfdbfe 100%);
-  color: #1e40af;
-  border-left: 4px solid #3b82f6;
-}
-
-.status-banner.encoding {
-  background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
-  color: #92400e;
-  border-left: 4px solid #f59e0b;
-}
-
-.status-banner.uploading {
-  background: linear-gradient(135deg, #e0e7ff 0%, #c7d2fe 100%);
-  color: #3730a3;
-  border-left: 4px solid #6366f1;
-}
-
-.status-banner.success {
-  background: linear-gradient(135deg, #d1fae5 0%, #a7f3d0 100%);
-  color: #065f46;
-  border-left: 4px solid #10b981;
-}
-
-.status-banner.warning {
-  background: linear-gradient(135deg, #fee2e2 0%, #fecaca 100%);
-  color: #991b1b;
-  border-left: 4px solid #ef4444;
-}
-
-.spinner {
-  width: 20px;
-  height: 20px;
-  border: 3px solid rgba(0, 0, 0, 0.1);
-  border-top-color: currentColor;
-  border-radius: 50%;
-  animation: spin 0.8s linear infinite;
-}
-
-@keyframes spin {
-  to { transform: rotate(360deg); }
-}
-
-.control-horizontal {
-  display: flex;
-  flex-direction: column;
-  gap: 1.5rem;
-}
-
-.control-left {
-  display: flex;
-  flex-direction: column;
-  gap: 1rem;
-}
-
-.control-right {
-  display: flex;
-  align-items: center;
-  justify-content: center;
-}
-
-.input-group {
-  display: flex;
-  gap: 0.5rem;
-  margin-bottom: 0;
-}
-
-input[type="text"] {
-  flex: 1;
-  padding: 0.75rem;
-  border: 1px solid #ddd;
-  border-radius: 4px;
-  font-size: 1rem;
-}
-
-input[type="text"]:disabled {
-  background: #f5f5f5;
-  cursor: not-allowed;
-}
-
-input[type="text"]:focus {
-  outline: none;
-  border-color: #10b981;
-}
-
-button {
-  padding: 0.75rem 1.5rem;
-  border: none;
-  border-radius: 4px;
-  font-size: 1rem;
-  font-weight: 500;
-  cursor: pointer;
-  transition: all 0.2s;
-}
-
-.btn-set-task {
-  background: #3b82f6;
-  color: white;
-  min-width: 120px;
-}
-
-.btn-set-task:hover:not(:disabled) {
-  background: #2563eb;
-}
-
-.btn-set-task:disabled {
-  background: #d1d5db;
-  cursor: not-allowed;
-}
-
-.btn-start {
-  background: #10b981;
-  color: white;
-}
-
-.btn-start:hover:not(:disabled) {
-  background: #059669;
-}
-
-.btn-start:disabled {
-  background: #d1d5db;
-  cursor: not-allowed;
-}
-
-.btn-stop {
-  background: #ef4444;
-  color: white;
-}
-
-.btn-stop:hover {
-  background: #dc2626;
-}
-
-.btn-reset {
-  padding: 0.5rem 1rem;
-  background: #6b7280;
-  color: white;
-  font-size: 0.875rem;
-}
-
-.btn-reset:hover {
-  background: #4b5563;
-}
-
-.status {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-  padding: 1rem;
-  border-radius: 4px;
-  margin-bottom: 1rem;
-}
-
-.status.recording {
-  background: #fee2e2;
-  color: #991b1b;
-}
-
-.status.recording.recording-active {
-  display: flex;
-  flex-direction: column;
-  gap: 1rem;
-  background: #dc2626;
-  color: white;
-  padding: 1.5rem;
-  border: 4px solid #991b1b;
-  box-shadow: 0 4px 12px rgba(220, 38, 38, 0.4);
-  font-weight: 700;
-  font-size: 1rem;
-}
-
-.status.recording.recording-active .indicator {
-  width: 20px;
-  height: 20px;
-  background: #fef2f2;
-  animation: pulse-strong 1s ease-in-out infinite;
-}
-
-@keyframes pulse-strong {
-  0%, 100% { 
-    opacity: 1;
-    transform: scale(1);
-  }
-  50% { 
-    opacity: 0.7;
-    transform: scale(1.1);
-  }
-}
-
-.status.recording.recording-active .time-display {
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-  font-size: 1.5rem;
-  font-weight: 700;
-  color: white;
-}
-
-.fps-display {
-  font-size: 1rem;
-  font-weight: 500;
-  opacity: 0.95;
-}
-
-.fps-warning {
-  color: #fef2f2;
-  animation: pulse-warning 1s ease-in-out infinite;
-}
-
-@keyframes pulse-warning {
-  0%, 100% { opacity: 1; }
-  50% { opacity: 0.5; }
-}
-
-.status.recording.recording-active .btn-stop {
-  align-self: stretch;
-}
-
-.ramp-up-countdown {
-  display: flex;
-  justify-content: center;
-  margin-bottom: 1rem;
-}
-
-.countdown-box {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  padding: 2rem 3rem;
-  background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
-  border: 4px solid #f59e0b;
-  border-radius: 16px;
-  box-shadow: 0 6px 20px rgba(245, 158, 11, 0.4);
-  min-width: 280px;
-  animation: pulse-warm 1.5s ease-in-out infinite;
-}
-
-@keyframes pulse-warm {
-  0%, 100% {
-    box-shadow: 0 6px 20px rgba(245, 158, 11, 0.4);
-  }
-  50% {
-    box-shadow: 0 6px 25px rgba(245, 158, 11, 0.6);
-  }
-}
-
-.countdown-label {
-  font-size: 1rem;
-  color: #92400e;
-  text-transform: uppercase;
-  letter-spacing: 1.5px;
-  font-weight: 800;
-  margin-bottom: 1rem;
-  text-align: center;
-}
-
-.countdown-value {
-  font-size: 4.5rem;
-  font-weight: 900;
-  color: #d97706;
-  font-family: 'Courier New', monospace;
-  line-height: 1;
-  text-shadow: 2px 2px 6px rgba(0, 0, 0, 0.15);
-  margin-bottom: 0.5rem;
-}
-
-.countdown-subtitle {
-  font-size: 0.875rem;
-  color: #78350f;
-  font-weight: 600;
-  font-style: italic;
-  text-align: center;
-  margin-top: 0.5rem;
-}
-
-.status.idle {
-  background: #f3f4f6;
-  color: #374151;
-}
-
-.indicator {
-  width: 12px;
-  height: 12px;
-  border-radius: 50%;
-  background: #ef4444;
-  animation: pulse 1.5s ease-in-out infinite;
-}
-
-@keyframes pulse {
-  0%, 100% { opacity: 1; }
-  50% { opacity: 0.5; }
-}
-
-.counter {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: 0.75rem;
-  padding: 1.5rem;
-  background: linear-gradient(135deg, #f9fafb 0%, #f3f4f6 100%);
-  border-radius: 8px;
-  border: 2px solid #e5e7eb;
-  min-width: 200px;
-}
-
-.counter-label {
-  font-size: 0.75rem;
-  color: #6b7280;
-  text-transform: uppercase;
-  letter-spacing: 0.5px;
-  font-weight: 600;
-}
-
-.counter-value {
-  font-size: 3rem;
-  font-weight: 700;
-  color: #10b981;
-  line-height: 1;
-}
-
-.time-display {
-  font-size: 1.5rem;
-  font-weight: 600;
-  font-family: 'Courier New', monospace;
-}
-
-.error-box {
-  padding: 1rem;
-  background: #fee2e2;
-  color: #991b1b;
-  border-radius: 4px;
-  border-left: 4px solid #ef4444;
-  font-size: 0.875rem;
-}
-
-.config-section {
-  margin-bottom: 1.5rem;
-}
-
-.config-section:last-child {
-  margin-bottom: 0;
-}
-
-.config-grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-  gap: 1rem;
-}
-
-label {
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-  font-size: 0.875rem;
-  color: #374151;
-  font-weight: 500;
-}
-
-select {
-  padding: 0.5rem;
-  border: 1px solid #ddd;
-  border-radius: 4px;
-  font-size: 0.875rem;
-  background: white;
-}
-
-select:disabled {
-  background: #f5f5f5;
-  cursor: not-allowed;
-}
-
-/* Camera Layout */
-.camera-layout {
-  display: flex;
-  flex-direction: column;
-  gap: 1.5rem;
-}
-
-.camera-base {
-  width: 100%;
-}
-
-.camera-wrist-container {
-  display: grid;
-  grid-template-columns: repeat(2, 1fr);
-  gap: 1.5rem;
-}
-
-.camera-wrist {
-  width: 100%;
-}
-
-.camera {
-  border: 1px solid #e5e7eb;
-  border-radius: 4px;
-  overflow: hidden;
-}
-
-.camera h3 {
-  padding: 0.75rem;
-  background: #f9fafb;
-  border-bottom: 1px solid #e5e7eb;
-  margin: 0;
-}
-
-.camera img {
-  width: 100%;
-  height: auto;
-  display: block;
-  background: #000;
-  min-height: 300px;
-  object-fit: cover;
-}
-
-.camera-placeholder {
-  text-align: center;
-  padding: 4rem 2rem;
-  background: #f9fafb;
-  border-radius: 4px;
-  border: 2px dashed #d1d5db;
-}
-
-.camera-placeholder p {
-  margin: 0.5rem 0;
-  font-size: 1rem;
-  color: #6b7280;
-}
-
-.camera-placeholder p:first-child {
-  font-size: 1.25rem;
-  font-weight: 500;
-  color: #374151;
-}
-
-.hint {
-  margin-top: 0.5rem;
-  font-size: 0.75rem;
-  color: #6b7280;
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  flex-wrap: wrap;
-}
-

examples/openarms_web_interface/App.jsx

@@ -1,857 +0,0 @@
-import { useState, useEffect, useCallback, useRef } from 'react';
-import './App.css';
-
-const API_BASE = 'http://localhost:8000/api';
-
-function App() {
-  // State
-  const [task, setTask] = useState('');
-  const [isRecording, setIsRecording] = useState(false);
-  const [isInitializing, setIsInitializing] = useState(false);
-  const [isEncoding, setIsEncoding] = useState(false);
-  const [isUploading, setIsUploading] = useState(false);
-  const [robotsReady, setRobotsReady] = useState(false);
-  const [elapsedTime, setElapsedTime] = useState(0);
-  const [currentFps, setCurrentFps] = useState(0);
-  const [loopFps, setLoopFps] = useState(0);
-  const [episodeCount, setEpisodeCount] = useState(0);
-  const [error, setError] = useState(null);
-  const [statusMessage, setStatusMessage] = useState('Ready');
-  const [uploadStatus, setUploadStatus] = useState(null);
-  const [rampUpRemaining, setRampUpRemaining] = useState(0);
-  const [movingToZero, setMovingToZero] = useState(false);
-  const [configExpanded, setConfigExpanded] = useState(false);
-  const [latestRepoId, setLatestRepoId] = useState(null);
-
-  // Configuration
-  const [config, setConfig] = useState({
-    leader_type: 'openarms',  // 'openarms' or 'openarms_mini'
-    leader_left: 'can0',
-    leader_right: 'can1',
-    follower_left: 'can2',
-    follower_right: 'can3',
-    left_wrist: '/dev/video0',
-    right_wrist: '/dev/video1',
-    base: '/dev/video4'
-  });
-
-  // Available options
-  const [availableCameras, setAvailableCameras] = useState([]);
-  const [availableUsbPorts, setAvailableUsbPorts] = useState([]);
-  const canInterfaces = ['can0', 'can1', 'can2', 'can3'];
-
-  const statusIntervalRef = useRef(null);
-  const hasInitializedRef = useRef(false);
-
-  const loadConfig = () => {
-    try {
-      const saved = localStorage.getItem('openarms_config');
-      if (saved) {
-        const loadedConfig = JSON.parse(saved);
-        setConfig(prev => ({ ...prev, ...loadedConfig }));
-      }
-    } catch (e) {
-      console.error('Load config error:', e);
-    }
-  };
-
-  const saveConfig = (newConfig) => {
-    try {
-      localStorage.setItem('openarms_config', JSON.stringify(newConfig || config));
-    } catch (e) {
-      console.error('Save config error:', e);
-    }
-  };
-
-  // Fetch status periodically
-  const fetchStatus = async () => {
-    try {
-      const response = await fetch(`${API_BASE}/status`);
-      const data = await response.json();
-
-      setIsRecording(data.is_recording);
-      setIsInitializing(data.is_initializing);
-      setIsEncoding(data.is_encoding);
-      setIsUploading(data.is_uploading);
-      setRobotsReady(data.robots_ready);
-      setElapsedTime(data.elapsed_time);
-      setCurrentFps(data.current_fps || 0);
-      setLoopFps(data.loop_fps || 0);
-      setEpisodeCount(data.episode_count);
-      setError(data.error);
-      setStatusMessage(data.status_message || 'Ready');
-      setUploadStatus(data.upload_status);
-      setRampUpRemaining(data.ramp_up_remaining || 0);
-      setMovingToZero(data.moving_to_zero || false);
-      
-      // Track the latest repo_id from the backend
-      if (data.latest_repo_id) {
-        setLatestRepoId(data.latest_repo_id);
-      }
-
-      if (data.config) {
-        // Only merge server config if we don't have a saved config (first load)
-        if (!localStorage.getItem('openarms_config')) {
-          setConfig(prev => {
-            const merged = { ...data.config, ...prev };
-            localStorage.setItem('openarms_config', JSON.stringify(merged));
-            return merged;
-          });
-        }
-      }
-    } catch (e) {
-      console.error('Failed to fetch status:', e);
-    }
-  };
-
-  const setupRobots = async () => {
-    // Show warning to verify camera positions
-    const confirmed = window.confirm(
-      '⚠️ IMPORTANT: Before connecting robots, please verify:\n\n' +
-      '📹 Check that cameras are correctly positioned:\n' +
-      '   • LEFT wrist camera is actually on the LEFT arm\n' +
-      '   • RIGHT wrist camera is actually on the RIGHT arm\n' +
-      '   • BASE camera is actually the BASE/overhead camera\n\n' +
-      'Incorrect camera positioning will result in invalid training data!\n\n' +
-      'Click OK to continue with robot setup, or Cancel to review configuration.'
-    );
-    
-    if (!confirmed) {
-      return; // User cancelled, don't proceed
-    }
-    
-    setError(null);
-    try {
-      const response = await fetch(`${API_BASE}/robots/setup`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(config)
-      });
-
-      if (!response.ok) {
-        const data = await response.json();
-        throw new Error(data.detail || 'Failed to setup robots');
-      }
-
-      await response.json();
-      saveConfig(config);
-    } catch (e) {
-      setError(`Robot setup failed: ${e.message}`);
-    }
-  };
-
-  // Disconnect robots
-  const disconnectRobots = async () => {
-    try {
-      await fetch(`${API_BASE}/robots/disconnect`, { method: 'POST' });
-      setRobotsReady(false);
-    } catch (e) {
-      console.error('Failed to disconnect robots:', e);
-    }
-  };
-
-  // Discover cameras
-  const discoverCameras = async () => {
-    try {
-      const response = await fetch(`${API_BASE}/cameras/discover`);
-      const data = await response.json();
-      const cameras = data.cameras || [];
-      setAvailableCameras(cameras);
-
-      // Get list of valid camera IDs
-      const validCameraIds = cameras.map(cam => String(cam.id));
-
-      // Auto-fix config if current values are invalid or not set
-      const updated = { ...config };
-      let changed = false;
-
-      // Auto-fix invalid camera config
-      if (!config.left_wrist || !validCameraIds.includes(config.left_wrist)) {
-        if (cameras.length >= 1) {
-          updated.left_wrist = String(cameras[0].id);
-          changed = true;
-        }
-      }
-
-      if (!config.right_wrist || !validCameraIds.includes(config.right_wrist)) {
-        if (cameras.length >= 2) {
-          updated.right_wrist = String(cameras[1].id);
-          changed = true;
-        }
-      }
-
-      if (!config.base || !validCameraIds.includes(config.base)) {
-        if (cameras.length >= 3) {
-          updated.base = String(cameras[2].id);
-          changed = true;
-        }
-      }
-
-      if (changed) {
-        setConfig(updated);
-        saveConfig(updated);
-      }
-
-      if (cameras.length === 0) {
-        setError('No cameras detected! Please connect cameras and refresh.');
-      }
-    } catch (e) {
-      console.error('Failed to discover cameras:', e);
-      setError(`Camera discovery failed: ${e.message}`);
-    }
-  };
-
-  // Discover USB ports
-  const discoverUsbPorts = async () => {
-    try {
-      const response = await fetch(`${API_BASE}/usb/discover`);
-      const data = await response.json();
-      const ports = data.ports || [];
-      setAvailableUsbPorts(ports);
-
-      // Auto-fix config if OpenArms Mini is selected and ports are invalid
-      if (config.leader_type === 'openarms_mini') {
-        const updated = { ...config };
-        let changed = false;
-
-        if (ports.length >= 1 && !ports.includes(config.leader_left)) {
-          updated.leader_left = ports[0];
-          changed = true;
-        }
-
-        if (ports.length >= 2 && !ports.includes(config.leader_right)) {
-          updated.leader_right = ports[1];
-          changed = true;
-        }
-
-        if (changed) {
-          setConfig(updated);
-          saveConfig(updated);
-        }
-      }
-
-      if (ports.length === 0) {
-        console.warn('No USB ports detected for OpenArms Mini');
-      }
-    } catch (e) {
-      console.error('Failed to discover USB ports:', e);
-    }
-  };
-
-  // Set task only (for pedal use)
-  const setTaskOnly = async () => {
-    if (!task.trim()) {
-      setError('Please enter a task description');
-      return;
-    }
-
-    setError(null);
-
-    try {
-      const response = await fetch(`${API_BASE}/recording/set-task`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ task, ...config })
-      });
-
-      if (!response.ok) {
-        const data = await response.json();
-        throw new Error(data.detail || 'Failed to set task');
-      }
-
-      const result = await response.json();
-      setStatusMessage(result.message || `Task set: ${task}`);
-      saveConfig(config);
-      
-      // Clear success message after 3 seconds
-      setTimeout(() => {
-        if (!isRecording && !isInitializing) {
-          setStatusMessage('Ready');
-        }
-      }, 3000);
-    } catch (e) {
-      setError(e.message);
-    }
-  };
-
-  // Start recording
-  const startRecording = async () => {
-    if (!task.trim()) {
-      setError('Please enter a task description');
-      return;
-    }
-
-    setError(null);
-
-    try {
-      const response = await fetch(`${API_BASE}/recording/start`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ task, ...config })
-      });
-
-      if (!response.ok) {
-        const data = await response.json();
-        throw new Error(data.detail || 'Failed to start recording');
-      }
-
-      await response.json();
-      saveConfig(config);
-    } catch (e) {
-      setError(e.message);
-    }
-  };
-
-  // Stop recording
-  const stopRecording = async () => {
-    try {
-      const response = await fetch(`${API_BASE}/recording/stop`, {
-        method: 'POST'
-      });
-
-      if (!response.ok) {
-        const data = await response.json();
-        throw new Error(data.detail || 'Failed to stop recording');
-      }
-
-      const data = await response.json();
-      setError(null);
-      // Update latest repo_id after recording
-      if (data.dataset_name) {
-        setLatestRepoId(`lerobot-data-collection/${data.dataset_name}`);
-      }
-    } catch (e) {
-      setError(e.message);
-    }
-  };
-
-  const deleteLatestEpisode = async () => {
-    if (!latestRepoId) {
-      setError('No episode to delete');
-      return;
-    }
-    
-    const confirmed = window.confirm(
-      `WARNING: This will permanently delete the repository:\n\n${latestRepoId}\n\nThis action cannot be undone. Continue?`
-    );
-    
-    if (!confirmed) {
-      return;
-    }
-    
-    try {
-      const response = await fetch(`${API_BASE}/recording/delete-latest`, { method: 'POST' });
-      
-      if (!response.ok) {
-        const data = await response.json();
-        throw new Error(data.detail || 'Failed to delete episode');
-      }
-
-      const data = await response.json();
-      setLatestRepoId(null);
-      setEpisodeCount(Math.max(0, episodeCount - 1));
-      setStatusMessage(`Deleted: ${data.deleted_repo}`);
-      
-      setTimeout(() => {
-        if (!isRecording && !isInitializing) {
-          setStatusMessage('Ready');
-        }
-      }, 3000);
-    } catch (e) {
-      setError(`Delete failed: ${e.message}`);
-    }
-  };
-
-  // Reset counter
-  const resetCounter = async () => {
-    try {
-      await fetch(`${API_BASE}/counter/reset`, { method: 'POST' });
-      setEpisodeCount(0);
-    } catch (e) {
-      console.error('Failed to reset counter:', e);
-    }
-  };
-
-  // Move robot to zero position
-  const moveToZero = async () => {
-    setError(null);
-    try {
-      const response = await fetch(`${API_BASE}/robots/move-to-zero`, { method: 'POST' });
-      if (!response.ok) {
-        const data = await response.json();
-        throw new Error(data.detail || 'Failed to move to zero position');
-      }
-      await response.json();
-    } catch (e) {
-      setError(`Move to zero failed: ${e.message}`);
-    }
-  };
-
-  // Format time as MM:SS
-  const formatTime = (seconds) => {
-    const mins = Math.floor(seconds / 60);
-    const secs = Math.floor(seconds % 60);
-    return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
-  };
-
-  // Update config and save
-  const updateConfig = (key, value) => {
-    const updated = { ...config, [key]: value };
-    setConfig(updated);
-    saveConfig(updated);
-  };
-
-  // Initialize on mount only
-  useEffect(() => {
-    // Prevent double-initialization in development
-    if (hasInitializedRef.current) {
-      return;
-    }
-    hasInitializedRef.current = true;
-
-    loadConfig();
-    discoverCameras();
-    discoverUsbPorts();
-    fetchStatus();
-    statusIntervalRef.current = setInterval(fetchStatus, 1000);
-
-    return () => {
-      if (statusIntervalRef.current) {
-        clearInterval(statusIntervalRef.current);
-      }
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []); // Run only once on mount
-
-  // Discover USB ports when leader type changes to Mini
-  useEffect(() => {
-    if (config.leader_type === 'openarms_mini') {
-      discoverUsbPorts();
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [config.leader_type]);
-
-  return (
-    <main>
-      <header>
-        <h1>OpenArms Recording</h1>
-      </header>
-
-      <div className="container">
-        {/* Left Column: Configuration and Recording Control */}
-        <div className="left-column">
-          {/* Configuration Panel */}
-          <section className="panel config-panel">
-          <div
-            className="config-header"
-            onClick={() => setConfigExpanded(!configExpanded)}
-            role="button"
-            tabIndex={0}
-            onKeyDown={(e) => e.key === 'Enter' && setConfigExpanded(!configExpanded)}
-          >
-            <h2>⚙️ Configuration</h2>
-            <span className="toggle-icon">{configExpanded ? '▼' : '▶'}</span>
-          </div>
-
-          {configExpanded && (
-            <div className="config-content">
-              {/* Robot Setup */}
-              <div className="config-section">
-                <h3>🤖 Robot Setup</h3>
-                <div className="robot-setup">
-                  {robotsReady ? (
-                    <div className="robot-status ready">
-                      <span>✅ Robots Ready - Recording will start instantly</span>
-                      <button onClick={disconnectRobots} className="btn-disconnect">
-                        Disconnect Robots
-                      </button>
-                    </div>
-                  ) : (
-                    <div className="robot-status not-ready">
-                      <span>⚠️ Robots not initialized - Recording will take ~10 seconds</span>
-                      <button
-                        onClick={setupRobots}
-                        disabled={isRecording || isInitializing}
-                        className="btn-setup"
-                      >
-                        🚀 Setup Robots
-                      </button>
-                    </div>
-                  )}
-                </div>
-              </div>
-
-              {/* Leader Type Selection */}
-              <div className="config-section">
-                <h3>🎮 Leader Type</h3>
-                <div className="config-grid">
-                  <label style={{gridColumn: '1 / -1'}}>
-                    Leader Arm Type
-                    <select
-                      value={config.leader_type}
-                      onChange={(e) => updateConfig('leader_type', e.target.value)}
-                      disabled={isRecording || robotsReady}
-                    >
-                      <option value="openarms">OpenArms (CAN Bus - Damiao Motors)</option>
-                      <option value="openarms_mini">OpenArms Mini (USB - Feetech Motors)</option>
-                    </select>
-                  </label>
-                </div>
-              </div>
-
-              {/* Leader Interfaces (CAN or USB based on type) */}
-              <div className="config-section">
-                <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '0.5rem' }}>
-                  <h3>
-                    {config.leader_type === 'openarms_mini' 
-                      ? `Leader Ports (USB/Serial) ${availableUsbPorts.length > 0 ? `(${availableUsbPorts.length} detected)` : ''}` 
-                      : 'Leader Interfaces (CAN)'}
-                  </h3>
-                  {config.leader_type === 'openarms_mini' && (
-                    <button
-                      onClick={discoverUsbPorts}
-                      className="btn-refresh"
-                      disabled={isRecording || robotsReady}
-                    >
-                      🔄 Refresh
-                    </button>
-                  )}
-                </div>
-                
-                <div className="config-grid">
-                  <label>
-                    Leader Left
-                    <select
-                      value={config.leader_left}
-                      onChange={(e) => updateConfig('leader_left', e.target.value)}
-                      disabled={isRecording || robotsReady}
-                    >
-                      {config.leader_type === 'openarms_mini' ? (
-                        availableUsbPorts.length > 0 ? (
-                          availableUsbPorts.map((port) => (
-                            <option key={port} value={port}>{port}</option>
-                          ))
-                        ) : (
-                          <option value="">No USB ports detected</option>
-                        )
-                      ) : (
-                        canInterfaces.map((iface) => (
-                          <option key={iface} value={iface}>{iface}</option>
-                        ))
-                      )}
-                    </select>
-                  </label>
-
-                  <label>
-                    Leader Right
-                    <select
-                      value={config.leader_right}
-                      onChange={(e) => updateConfig('leader_right', e.target.value)}
-                      disabled={isRecording || robotsReady}
-                    >
-                      {config.leader_type === 'openarms_mini' ? (
-                        availableUsbPorts.length > 0 ? (
-                          availableUsbPorts.map((port) => (
-                            <option key={port} value={port}>{port}</option>
-                          ))
-                        ) : (
-                          <option value="">No USB ports detected</option>
-                        )
-                      ) : (
-                        canInterfaces.map((iface) => (
-                          <option key={iface} value={iface}>{iface}</option>
-                        ))
-                      )}
-                    </select>
-                  </label>
-                </div>
-              </div>
-
-              {/* Follower CAN Interfaces */}
-              <div className="config-section">
-                <h3>Follower Interfaces (CAN)</h3>
-                
-                <div className="config-grid">
-                  <label>
-                    Follower Left
-                    <select
-                      value={config.follower_left}
-                      onChange={(e) => updateConfig('follower_left', e.target.value)}
-                      disabled={isRecording || robotsReady}
-                    >
-                      {canInterfaces.map((iface) => (
-                        <option key={iface} value={iface}>{iface}</option>
-                      ))}
-                    </select>
-                  </label>
-
-                  <label>
-                    Follower Right
-                    <select
-                      value={config.follower_right}
-                      onChange={(e) => updateConfig('follower_right', e.target.value)}
-                      disabled={isRecording || robotsReady}
-                    >
-                      {canInterfaces.map((iface) => (
-                        <option key={iface} value={iface}>{iface}</option>
-                      ))}
-                    </select>
-                  </label>
-                </div>
-              </div>
-
-              {/* Camera Configuration */}
-              <div className="config-section">
-                <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '0.5rem' }}>
-                  <h3>Cameras {availableCameras.length > 0 && `(${availableCameras.length} detected)`}</h3>
-                  <button
-                    onClick={discoverCameras}
-                    className="btn-refresh"
-                    disabled={isRecording || robotsReady}
-                  >
-                    🔄 Refresh
-                  </button>
-                </div>
-                <div className="config-grid">
-                  <label>
-                    Left Wrist
-                    <select
-                      value={config.left_wrist}
-                      onChange={(e) => updateConfig('left_wrist', e.target.value)}
-                      disabled={isRecording || robotsReady}
-                    >
-                      {availableCameras.map((cam) => (
-                        <option key={cam.id} value={String(cam.id)}>
-                          {cam.name || `Camera @ ${cam.id}`}
-                        </option>
-                      ))}
-                    </select>
-                  </label>
-
-                  <label>
-                    Right Wrist
-                    <select
-                      value={config.right_wrist}
-                      onChange={(e) => updateConfig('right_wrist', e.target.value)}
-                      disabled={isRecording || robotsReady}
-                    >
-                      {availableCameras.map((cam) => (
-                        <option key={cam.id} value={String(cam.id)}>
-                          {cam.name || `Camera @ ${cam.id}`}
-                        </option>
-                      ))}
-                    </select>
-                  </label>
-
-                  <label>
-                    Base Camera
-                    <select
-                      value={config.base}
-                      onChange={(e) => updateConfig('base', e.target.value)}
-                      disabled={isRecording || robotsReady}
-                    >
-                      {availableCameras.map((cam) => (
-                        <option key={cam.id} value={String(cam.id)}>
-                          {cam.name || `Camera @ ${cam.id}`}
-                        </option>
-                      ))}
-                    </select>
-                  </label>
-                </div>
-              </div>
-            </div>
-          )}
-        </section>
-
-        {/* Control Panel */}
-        <section className="panel control-panel">
-          <h2>🎬 Recording Control</h2>
-
-          {/* Status Banner - Always show important statuses */}
-          {isInitializing && (
-            <div className="status-banner initializing">
-              <div className="spinner"></div>
-              <span>{statusMessage}</span>
-            </div>
-          )}
-
-          {isEncoding && (
-            <div className="status-banner encoding">
-              <div className="spinner"></div>
-              <span>📹 {statusMessage}</span>
-            </div>
-          )}
-
-          {isUploading && (
-            <div className="status-banner uploading">
-              <div className="spinner"></div>
-              <span>☁️ {statusMessage}</span>
-            </div>
-          )}
-
-          {uploadStatus && !isRecording && !isEncoding && !isUploading && (
-            <div className={`status-banner ${uploadStatus.startsWith('✓') ? 'success' : 'warning'}`}>
-              <span>{uploadStatus}</span>
-            </div>
-          )}
-
-          <div className="control-horizontal">
-            {/* Task Input and Status */}
-            <div className="control-left">
-              <div className="input-group">
-                <input
-                  type="text"
-                  value={task}
-                  onChange={(e) => setTask(e.target.value)}
-                  placeholder="Task description (e.g., 'pick and place')"
-                  disabled={isRecording || isInitializing || isEncoding || isUploading}
-                  onKeyPress={(e) => {
-                    if (e.key === 'Enter' && robotsReady) {
-                      setTaskOnly();
-                    }
-                  }}
-                />
-                <button
-                  onClick={setTaskOnly}
-                  disabled={isRecording || isInitializing || isEncoding || isUploading || !robotsReady}
-                  className="btn-set-task"
-                  title={!robotsReady ? 'Please setup robots first' : 'Store task for pedal use (Enter key)'}
-                >
-                  💾 Set Task
-                </button>
-                <button
-                  onClick={startRecording}
-                  disabled={isRecording || isInitializing || isEncoding || isUploading || !robotsReady}
-                  className="btn-start"
-                  title={!robotsReady ? 'Please setup robots first' : ''}
-                >
-                  {isInitializing
-                    ? '⏳ Initializing...'
-                    : isRecording
-                    ? '⏺ Recording...'
-                    : robotsReady
-                    ? '⏺ Start Recording'
-                    : '⏺ Setup Robots First'}
-                </button>
-              </div>
-
-              {/* Ramp-up Countdown */}
-              {isRecording && rampUpRemaining > 0 && (
-                <div className="ramp-up-countdown">
-                  <div className="countdown-box">
-                    <div className="countdown-label">⚡ WARMING UP - PID RAMP-UP</div>
-                    <div className="countdown-value">{rampUpRemaining.toFixed(1)}s</div>
-                    <div className="countdown-subtitle">Recording will start automatically...</div>
-                  </div>
-                </div>
-              )}
-
-              {/* Recording Status - Only show after ramp-up */}
-              {isRecording && rampUpRemaining <= 0 && (
-                <div className="status recording recording-active">
-                  <div className="indicator"></div>
-                  <div className="time-display">
-                    <span>{formatTime(elapsedTime)}</span>
-                    <span className="fps-display">
-                      Loop: {loopFps.toFixed(1)} Hz
-                      {loopFps > 0 && loopFps < 29 && <span className="fps-warning"> ⚠️</span>}
-                    </span>
-                    <span className="fps-display">Recording: {currentFps.toFixed(1)} FPS</span>
-                  </div>
-                  <button onClick={stopRecording} className="btn-stop">
-                    ⏹ Stop
-                  </button>
-                </div>
-              )}
-            </div>
-
-            {/* Episode Counter */}
-            <div className="control-right">
-              <div className="counter">
-                <div className="counter-label">Episodes Recorded</div>
-                <div className="counter-value">{episodeCount}</div>
-                <button onClick={resetCounter} className="btn-reset">
-                  Reset
-                </button>
-              </div>
-            </div>
-          </div>
-
-          {/* Delete Latest Episode Button */}
-          {!isRecording && !isInitializing && latestRepoId && (
-            <div className="delete-episode-section">
-              <button 
-                onClick={deleteLatestEpisode}
-                className="btn-delete"
-                title="Delete the latest recorded episode from HuggingFace Hub"
-              >
-                Delete Latest Episode
-              </button>
-              <div className="delete-info">Will delete: {latestRepoId}</div>
-            </div>
-          )}
-
-          {/* Move to Zero Button */}
-          {robotsReady && !isRecording && !isInitializing && (
-            <div className="zero-position-section">
-              <button 
-                onClick={moveToZero} 
-                disabled={movingToZero}
-                className="btn-zero-large"
-                title="Move both leader and follower robots to zero position (2s)"
-              >
-                {movingToZero ? '⏳ Moving to Zero Position...' : '🎯 Move to Zero Position (Leader + Follower)'}
-              </button>
-            </div>
-          )}
-
-          {/* Error Display */}
-          {error && (
-            <div className="error-box">
-              ⚠️ {error}
-            </div>
-          )}
-        </section>
-        </div>
-
-        {/* Right Column: Camera Feeds */}
-        <div className="right-column">
-          <section className="panel cameras">
-          <h2>📹 Camera Views</h2>
-          {robotsReady || isRecording || isInitializing ? (
-            <div className="camera-layout">
-              {/* Base camera - full width */}
-              <div className="camera camera-base">
-                <h3>Base Camera</h3>
-                <img src={`${API_BASE}/camera/stream/base`} alt="Base Camera" />
-              </div>
-
-              {/* Wrist cameras - side by side */}
-              <div className="camera-wrist-container">
-                <div className="camera camera-wrist">
-                  <h3>Left Wrist</h3>
-                  <img src={`${API_BASE}/camera/stream/left_wrist`} alt="Left Wrist Camera" />
-                </div>
-
-                <div className="camera camera-wrist">
-                  <h3>Right Wrist</h3>
-                  <img src={`${API_BASE}/camera/stream/right_wrist`} alt="Right Wrist Camera" />
-                </div>
-              </div>
-            </div>
-          ) : (
-            <div className="camera-placeholder">
-              <p>📷 Camera feeds will appear when robots are set up</p>
-              <p className="hint">Click "Setup Robots" above to preview camera feeds</p>
-            </div>
-          )}
-        </section>
-        </div>
-
-      </div>
-    </main>
-  );
-}
-
-export default App;
-

examples/openarms_web_interface/README.md

@@ -1,41 +0,0 @@
-# OpenArms Web Recording Interface
-
-A web interface for recording OpenArms datasets.
-
-## Installation
-
-```bash
-cd examples/openarms_web_interface
-npm install
-```
-
-## Usage
-
-**Start everything with one command:**
-
-```bash
-./launch.sh
-```
-
-This will:
-- Start the FastAPI backend on port 8000
-- Start the React frontend on port 5173
-- Show live logs from both services
-
-Then open your browser to: **http://localhost:5173**
-
-**Stop with:** `Ctrl+C`
-
----
-
-## Workflow
-
-1. **Configure CAN interfaces** and **camera paths** in the dropdowns
-2. Click **"Setup Robots"** to initialize (once at start)
-3. Enter a **task description**
-4. Click **"Start Recording"** to begin an episode
-5. Click **"Stop Recording"** when done
-6. Dataset is automatically encoded and uploaded to HuggingFace Hub as **private**
-7. Repeat steps 3-6 for more episodes (no need to re-setup robots!)
-
----

examples/openarms_web_interface/index.html

@@ -1,12 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>OpenArms Recording Interface</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/main.jsx"></script>
-  </body>
-</html>

examples/openarms_web_interface/launch.sh

@@ -1,142 +0,0 @@
-#!/bin/bash
-
-# OpenArms Web Interface Launcher
-# Starts Rerun viewer, FastAPI backend, and React frontend
-
-set -e
-
-# Colors for output
-GREEN='\033[0;32m'
-BLUE='\033[0;34m'
-YELLOW='\033[1;33m'
-RED='\033[0;31m'
-NC='\033[0m' # No Color
-
-# Get script directory
-SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-cd "$SCRIPT_DIR"
-
-echo -e "${BLUE}╔════════════════════════════════════════╗${NC}"
-echo -e "${BLUE}║   OpenArms Web Recording Interface    ║${NC}"
-echo -e "${BLUE}╚════════════════════════════════════════╝${NC}"
-echo ""
-
-# Function to cleanup on exit
-cleanup() {
-    echo ""
-    echo -e "${YELLOW}Shutting down services...${NC}"
-    
-    # Kill all child processes
-    pkill -P $$ 2>/dev/null || true
-    
-    # Kill specific services by port
-    lsof -ti:8000 | xargs kill -9 2>/dev/null || true  # Backend
-    lsof -ti:5173 | xargs kill -9 2>/dev/null || true  # Frontend
-    lsof -ti:9876 | xargs kill -9 2>/dev/null || true  # Rerun (if spawned)
-    
-    echo -e "${GREEN}✓ Services stopped${NC}"
-    exit 0
-}
-
-# Register cleanup on script exit
-trap cleanup EXIT INT TERM
-
-# Check if required commands exist
-command -v rerun >/dev/null 2>&1 || { 
-    echo -e "${RED}✗ Error: 'rerun' not found. Please install: pip install rerun-sdk${NC}"
-    exit 1
-}
-
-command -v python >/dev/null 2>&1 || { 
-    echo -e "${RED}✗ Error: 'python' not found${NC}"
-    exit 1
-}
-
-command -v npm >/dev/null 2>&1 || { 
-    echo -e "${RED}✗ Error: 'npm' not found${NC}"
-    exit 1
-}
-
-# Check if node_modules exists
-if [ ! -d "node_modules" ]; then
-    echo -e "${YELLOW}⚠ node_modules not found. Running npm install...${NC}"
-    npm install
-    echo -e "${GREEN}✓ Dependencies installed${NC}"
-    echo ""
-fi
-
-echo -e "${GREEN}Starting services...${NC}"
-echo ""
-
-# 1. Start FastAPI backend (Rerun will start when recording begins)
-echo -e "${BLUE}[1/2]${NC} Starting FastAPI backend on port 8000..."
-cd "$SCRIPT_DIR"
-
-# Use Python from current environment (if lerobot env is active, it will use that)
-# Otherwise, check if we need to use conda run
-if [[ "$CONDA_DEFAULT_ENV" == "lerobot" ]]; then
-    # Already in lerobot environment
-    echo -e "${GREEN}✓ Using active lerobot environment${NC}"
-    PYTHON_CMD="python"
-elif command -v conda >/dev/null 2>&1 && conda env list | grep -q "^lerobot "; then
-    # lerobot env exists but not active - use conda run
-    echo -e "${YELLOW}Using conda run with lerobot environment...${NC}"
-    PYTHON_CMD="conda run -n lerobot --no-capture-output python"
-else
-    # Fall back to system python
-    echo -e "${YELLOW}⚠ Warning: lerobot environment not found, using system python${NC}"
-    PYTHON_CMD="python"
-fi
-
-$PYTHON_CMD web_record_server.py > /tmp/openarms_backend.log 2>&1 &
-BACKEND_PID=$!
-sleep 3
-
-if ps -p $BACKEND_PID > /dev/null; then
-    echo -e "${GREEN}✓ Backend started${NC} (PID: $BACKEND_PID)"
-    echo -e "      URL: ${BLUE}http://localhost:8000${NC}"
-else
-    echo -e "${RED}✗ Failed to start backend${NC}"
-    echo -e "${YELLOW}Check logs: tail -f /tmp/openarms_backend.log${NC}"
-    exit 1
-fi
-echo ""
-
-# 2. Start React frontend
-echo -e "${BLUE}[2/2]${NC} Starting React frontend on port 5173..."
-cd "$SCRIPT_DIR"
-npm run dev > /tmp/openarms_frontend.log 2>&1 &
-FRONTEND_PID=$!
-sleep 3
-
-if ps -p $FRONTEND_PID > /dev/null; then
-    echo -e "${GREEN}✓ Frontend started${NC} (PID: $FRONTEND_PID)"
-    echo -e "      URL: ${BLUE}http://localhost:5173${NC}"
-else
-    echo -e "${RED}✗ Failed to start frontend${NC}"
-    echo -e "${YELLOW}Check logs: tail -f /tmp/openarms_frontend.log${NC}"
-    exit 1
-fi
-echo ""
-
-# Display status
-echo -e "${GREEN}╔════════════════════════════════════════╗${NC}"
-echo -e "${GREEN}║     All services running! 🚀           ║${NC}"
-echo -e "${GREEN}╚════════════════════════════════════════╝${NC}"
-echo ""
-echo -e "🔧 ${BLUE}Backend:${NC}  http://localhost:8000"
-echo -e "🌐 ${BLUE}Frontend:${NC} http://localhost:5173"
-echo -e "📊 ${BLUE}Rerun:${NC}    Will spawn automatically when recording starts"
-echo ""
-echo -e "${YELLOW}Open your browser to:${NC} ${BLUE}http://localhost:5173${NC}"
-echo ""
-echo -e "${YELLOW}Logs:${NC}"
-echo -e "  • Backend:  tail -f /tmp/openarms_backend.log"
-echo -e "  • Frontend: tail -f /tmp/openarms_frontend.log"
-echo ""
-echo -e "${RED}Press Ctrl+C to stop all services${NC}"
-echo ""
-
-# Keep script running and wait for any service to exit
-wait
-

examples/openarms_web_interface/main.jsx

@@ -1,7 +0,0 @@
-import { createRoot } from 'react-dom/client'
-import App from './App.jsx'
-
-createRoot(document.getElementById('root')).render(
-  <App />
-)
-

examples/openarms_web_interface/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "openarms-web-interface",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "build": "vite build",
-    "preview": "vite preview"
-  },
-  "dependencies": {
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1"
-  },
-  "devDependencies": {
-    "@types/react": "^18.3.12",
-    "@types/react-dom": "^18.3.1",
-    "@vitejs/plugin-react": "^4.3.4",
-    "vite": "^6.0.1"
-  }
-}

examples/openarms_web_interface/vite.config.js

@@ -1,17 +0,0 @@
-import { defineConfig } from 'vite'
-import react from '@vitejs/plugin-react'
-
-// https://vite.dev/config/
-export default defineConfig({
-  plugins: [react()],
-  server: {
-    port: 5173,
-    strictPort: false,
-    host: true,
-    open: false
-  },
-  build: {
-    outDir: 'dist',
-    sourcemap: true
-  }
-})

examples/phone_to_so100/evaluate.py

@@ -34,12 +34,11 @@ from lerobot.processor.converters import (
     transition_to_observation,
     transition_to_robot_action,
 )
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.robot_kinematic_processor import (
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so_follower.robot_kinematic_processor import (
     ForwardKinematicsJointsToEE,
     InverseKinematicsEEToJoints,
 )
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.scripts.lerobot_record import record_loop
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say

examples/phone_to_so100/record.py

@@ -26,15 +26,14 @@ from lerobot.processor.converters import (
     transition_to_observation,
     transition_to_robot_action,
 )
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.robot_kinematic_processor import (
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so_follower.robot_kinematic_processor import (
     EEBoundsAndSafety,
     EEReferenceAndDelta,
     ForwardKinematicsJointsToEE,
     GripperVelocityToJoint,
     InverseKinematicsEEToJoints,
 )
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.scripts.lerobot_record import record_loop
 from lerobot.teleoperators.phone.config_phone import PhoneConfig, PhoneOS
 from lerobot.teleoperators.phone.phone_processor import MapPhoneActionToRobotAction

examples/phone_to_so100/replay.py

@@ -23,11 +23,10 @@ from lerobot.processor.converters import (
     robot_action_observation_to_transition,
     transition_to_robot_action,
 )
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.robot_kinematic_processor import (
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so_follower.robot_kinematic_processor import (
     InverseKinematicsEEToJoints,
 )
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.utils.constants import ACTION
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.utils import log_say
@@ -96,7 +95,7 @@ def main():
         # Send action to robot
         _ = robot.send_action(joint_action)
 
-        precise_sleep(1.0 / dataset.fps - (time.perf_counter() - t0))
+        precise_sleep(max(1.0 / dataset.fps - (time.perf_counter() - t0), 0.0))
 
     # Clean up
     robot.disconnect()

examples/phone_to_so100/teleoperate.py

@@ -21,14 +21,13 @@ from lerobot.processor.converters import (
     robot_action_observation_to_transition,
     transition_to_robot_action,
 )
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.robot_kinematic_processor import (
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so_follower.robot_kinematic_processor import (
     EEBoundsAndSafety,
     EEReferenceAndDelta,
     GripperVelocityToJoint,
     InverseKinematicsEEToJoints,
 )
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.teleoperators.phone.config_phone import PhoneConfig, PhoneOS
 from lerobot.teleoperators.phone.phone_processor import MapPhoneActionToRobotAction
 from lerobot.teleoperators.phone.teleop_phone import Phone

examples/rac/rac_data_collection.py

@@ -1,638 +0,0 @@
-#!/usr/bin/env python
-"""
-RaC (Recovery and Correction) Data Collection with Policy Rollout + Human Intervention.
-
-This implements the RaC paradigm from "RaC: Robot Learning for Long-Horizon Tasks
-by Scaling Recovery and Correction" (Hu et al., 2025) for LeRobot.
-
-RaC improves upon standard data collection (BC) and prior human-in-the-loop methods
-(DAgger, HG-DAgger) by explicitly collecting recovery and correction behaviors:
-
-The workflow:
-1. Policy runs autonomously
-2. Press SPACE to pause - robot holds position
-3. Press 'c' to take control - human provides RECOVERY + CORRECTION
-4. Press → to end episode (save and continue to next)
-5. Reset, then do next rollout
-
-Key RaC Rules:
-- Rule 1 (Recover then Correct): Every intervention = recovery + correction (both human)
-- Rule 2 (Terminate after Intervention): Episode ends after correction
-
-The recovery segment (teleoperating back to good state) is recorded as training data -
-this teaches the policy how to recover from errors.
-
-Keyboard Controls:
-    SPACE  - Pause policy (robot holds position, no recording)
-    c      - Take control (start correction, recording resumes)
-    →      - End episode (save and continue to next)
-    ←      - Re-record episode
-    ESC    - Stop recording and push dataset to hub
-
-Usage:
-    python examples/rac/rac_data_collection.py \
-        --robot.type=so100_follower \
-        --robot.port=/dev/tty.usbmodem58760431541 \
-        --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \
-        --teleop.type=so100_leader \
-        --teleop.port=/dev/tty.usbmodem58760431551 \
-        --policy.path=outputs/train/my_policy/checkpoints/last/pretrained_model \
-        --dataset.repo_id=my_user/rac_dataset \
-        --dataset.single_task="Pick up the cube"
-"""
-
-import logging
-import time
-from dataclasses import dataclass, field
-from pathlib import Path
-from pprint import pformat
-from typing import Any
-
-from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig  # noqa: F401
-from lerobot.cameras.realsense.configuration_realsense import RealSenseCameraConfig  # noqa: F401
-from lerobot.configs import parser
-from lerobot.configs.policies import PreTrainedConfig
-from lerobot.datasets.image_writer import safe_stop_image_writer
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.datasets.pipeline_features import aggregate_pipeline_dataset_features, create_initial_features
-from lerobot.datasets.utils import build_dataset_frame, combine_feature_dicts
-from lerobot.datasets.video_utils import VideoEncodingManager
-from lerobot.policies.factory import make_policy, make_pre_post_processors
-from lerobot.policies.pretrained import PreTrainedPolicy
-from lerobot.policies.utils import make_robot_action
-from lerobot.processor import (
-    IdentityProcessor,
-    PolicyAction,
-    PolicyProcessorPipeline,
-    RobotAction,
-    RobotObservation,
-    RobotProcessorPipeline,
-)
-from lerobot.processor.converters import (
-    observation_to_transition,
-    robot_action_observation_to_transition,
-    transition_to_observation,
-    transition_to_robot_action,
-)
-from lerobot.processor.rename_processor import rename_stats
-from lerobot.robots import Robot, RobotConfig, make_robot_from_config
-from lerobot.teleoperators import Teleoperator, TeleoperatorConfig, make_teleoperator_from_config
-from lerobot.utils.constants import ACTION, OBS_STR
-from lerobot.utils.control_utils import is_headless, predict_action
-from lerobot.utils.robot_utils import precise_sleep
-from lerobot.utils.utils import get_safe_torch_device, init_logging, log_say
-from lerobot.utils.visualization_utils import init_rerun, log_rerun_data
-
-
-@dataclass
-class RaCDatasetConfig:
-    repo_id: str
-    single_task: str
-    root: str | Path | None = None
-    fps: int = 30
-    episode_time_s: float = 120
-    reset_time_s: float = 30
-    num_episodes: int = 50
-    video: bool = True
-    push_to_hub: bool = True
-    private: bool = False
-    tags: list[str] | None = None
-    num_image_writer_processes: int = 0
-    num_image_writer_threads_per_camera: int = 4
-    video_encoding_batch_size: int = 1
-    rename_map: dict[str, str] = field(default_factory=dict)
-
-
-@dataclass
-class RaCConfig:
-    robot: RobotConfig
-    dataset: RaCDatasetConfig
-    policy: PreTrainedConfig
-    teleop: TeleoperatorConfig
-    display_data: bool = True
-    play_sounds: bool = True
-    resume: bool = False
-
-    def __post_init__(self):
-        policy_path = parser.get_path_arg("policy")
-        if policy_path:
-            cli_overrides = parser.get_cli_overrides("policy")
-            self.policy = PreTrainedConfig.from_pretrained(policy_path, cli_overrides=cli_overrides)
-            self.policy.pretrained_path = policy_path
-
-    @classmethod
-    def __get_path_fields__(cls) -> list[str]:
-        return ["policy"]
-
-
-def init_rac_keyboard_listener():
-    """Initialize keyboard listener with RaC-specific controls."""
-    events = {
-        "exit_early": False,
-        "rerecord_episode": False,
-        "stop_recording": False,
-        "policy_paused": False,      # SPACE pressed - policy paused, teleop tracking robot
-        "correction_active": False,  # 'c' pressed - human controlling, recording correction
-        "in_reset": False,           # True during reset period
-        "start_next_episode": False, # Signal to start next episode
-    }
-
-    if is_headless():
-        logging.warning("Headless environment - keyboard controls unavailable")
-        return None, events
-
-    from pynput import keyboard
-
-    def on_press(key):
-        try:
-            if events["in_reset"]:
-                # During reset: any action key starts next episode
-                if key == keyboard.Key.space or key == keyboard.Key.right:
-                    print("\n[RaC] Starting next episode...")
-                    events["start_next_episode"] = True
-                elif hasattr(key, 'char') and key.char == 'c':
-                    print("\n[RaC] Starting next episode...")
-                    events["start_next_episode"] = True
-                elif key == keyboard.Key.esc:
-                    print("[RaC] ESC - Stop recording, pushing to hub...")
-                    events["stop_recording"] = True
-                    events["start_next_episode"] = True
-            else:
-                # During episode
-                if key == keyboard.Key.space:
-                    if not events["policy_paused"] and not events["correction_active"]:
-                        print("\n[RaC] ⏸ PAUSED - Policy stopped, teleop moving to robot position")
-                        print("      Press 'c' or START to take control")
-                        events["policy_paused"] = True
-                elif hasattr(key, 'char') and key.char == 'c':
-                    if events["policy_paused"] and not events["correction_active"]:
-                        print("\n[RaC] ▶ START pressed - taking control")
-                        events["start_next_episode"] = True
-                elif key == keyboard.Key.right:
-                    print("[RaC] → End episode")
-                    events["exit_early"] = True
-                elif key == keyboard.Key.left:
-                    print("[RaC] ← Re-record episode")
-                    events["rerecord_episode"] = True
-                    events["exit_early"] = True
-                elif key == keyboard.Key.esc:
-                    print("[RaC] ESC - Stop recording, pushing to hub...")
-                    events["stop_recording"] = True
-                    events["exit_early"] = True
-        except Exception as e:
-            print(f"Key error: {e}")
-
-    listener = keyboard.Listener(on_press=on_press)
-    listener.start()
-    
-    start_pedal_listener(events)
-    
-    return listener, events
-
-
-def start_pedal_listener(events: dict):
-    """Start foot pedal listener thread if evdev is available."""
-    import threading
-    
-    try:
-        from evdev import InputDevice, ecodes
-    except ImportError:
-        logging.info("[Pedal] evdev not installed - pedal support disabled")
-        return
-    
-    PEDAL_DEVICE = "/dev/input/by-id/usb-PCsensor_FootSwitch-event-kbd"
-    KEY_LEFT = "KEY_A"   # Left pedal
-    KEY_RIGHT = "KEY_C"  # Right pedal
-    
-    def pedal_reader():
-        try:
-            dev = InputDevice(PEDAL_DEVICE)
-            print(f"[Pedal] Connected: {dev.name}")
-            print(f"[Pedal] Right=pause/next, Left=take control/start")
-            
-            for ev in dev.read_loop():
-                if ev.type != ecodes.EV_KEY:
-                    continue
-                
-                from evdev import categorize
-                key = categorize(ev)
-                code = key.keycode
-                if isinstance(code, (list, tuple)):
-                    code = code[0]
-                
-                # Only trigger on key down
-                if key.keystate != 1:
-                    continue
-                
-                if events["in_reset"]:
-                    # During reset: either pedal starts next episode
-                    if code in [KEY_LEFT, KEY_RIGHT]:
-                        print("\n[Pedal] Starting next episode...")
-                        events["start_next_episode"] = True
-                else:
-                    # During episode
-                    if code == KEY_RIGHT:
-                        # Right pedal: SPACE (pause) when running, → (next) when in correction
-                        if events["correction_active"]:
-                            print("\n[Pedal] → End episode")
-                            events["exit_early"] = True
-                        elif not events["policy_paused"]:
-                            print("\n[Pedal] ⏸ PAUSED - Policy stopped, teleop moving to robot")
-                            print("        Press left pedal to take control")
-                            events["policy_paused"] = True
-                    
-                    elif code == KEY_LEFT:
-                        # Left pedal: START (take control) when paused
-                        if events["policy_paused"] and not events["correction_active"]:
-                            print("\n[Pedal] ▶ START pressed - taking control")
-                            events["start_next_episode"] = True
-                        
-        except FileNotFoundError:
-            logging.info(f"[Pedal] Device not found: {PEDAL_DEVICE}")
-        except PermissionError:
-            logging.warning(f"[Pedal] Permission denied. Run: sudo setfacl -m u:$USER:rw {PEDAL_DEVICE}")
-        except Exception as e:
-            logging.debug(f"[Pedal] Error: {e}")
-    
-    thread = threading.Thread(target=pedal_reader, daemon=True)
-    thread.start()
-
-
-def make_identity_processors():
-    """Create identity processors for RaC recording."""
-    teleop_proc = RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction](
-        steps=[IdentityProcessor()],
-        to_transition=robot_action_observation_to_transition,
-        to_output=transition_to_robot_action,
-    )
-    robot_proc = RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction](
-        steps=[IdentityProcessor()],
-        to_transition=robot_action_observation_to_transition,
-        to_output=transition_to_robot_action,
-    )
-    obs_proc = RobotProcessorPipeline[RobotObservation, RobotObservation](
-        steps=[IdentityProcessor()],
-        to_transition=observation_to_transition,
-        to_output=transition_to_observation,
-    )
-    return teleop_proc, robot_proc, obs_proc
-
-
-def move_robot_to_zero(robot: Robot, duration_s: float = 2.0, fps: int = 50):
-    """Smoothly move all robot joints to zero position."""
-    obs = robot.get_observation()
-    current_pos = {k: v for k, v in obs.items() if k.endswith(".pos")}
-    target_pos = {k: 0.0 for k in current_pos}
-    
-    print(f"[RaC] Moving robot to zero position ({duration_s}s)...")
-    steps = int(duration_s * fps)
-    for step in range(steps + 1):
-        t = step / steps
-        interp_pos = {k: current_pos[k] * (1 - t) + target_pos[k] * t for k in current_pos}
-        robot.send_action(interp_pos)
-        time.sleep(1 / fps)
-    print("[RaC] Robot at zero position.")
-
-@safe_stop_image_writer
-def rac_rollout_loop(
-    robot: Robot,
-    teleop: Teleoperator,
-    policy: PreTrainedPolicy,
-    preprocessor: PolicyProcessorPipeline[dict[str, Any], dict[str, Any]],
-    postprocessor: PolicyProcessorPipeline[PolicyAction, PolicyAction],
-    dataset: LeRobotDataset,
-    events: dict,
-    fps: int,
-    control_time_s: float,
-    single_task: str,
-    display_data: bool = True,
-) -> dict:
-    """
-    RaC rollout loop with two-stage intervention:
-    
-    1. Policy runs autonomously (recording)
-    2. SPACE: Policy pauses (NOT recording) - robot holds position
-    3. 'c': Human takes control (recording correction)
-    4. →: End episode
-    """
-    policy.reset()
-    preprocessor.reset()
-    postprocessor.reset()
-
-    device = get_safe_torch_device(policy.config.device)
-    frame_buffer = []
-
-    stats = {
-        "total_frames": 0,
-        "autonomous_frames": 0,
-        "paused_frames": 0,
-        "correction_frames": 0,
-    }
-
-    last_robot_action = None
-    was_paused = False
-    was_correction_active = False
-    waiting_for_takeover = False
-    timestamp = 0
-    start_t = time.perf_counter()
-
-    while timestamp < control_time_s:
-        loop_start = time.perf_counter()
-
-        if events["exit_early"]:
-            events["exit_early"] = False
-            events["policy_paused"] = False
-            events["correction_active"] = False
-            break
-
-        # Detect transition to paused state
-        if events["policy_paused"] and not was_paused:
-            obs = robot.get_observation()
-            robot_pos = {k: v for k, v in obs.items() if k.endswith(".pos")}
-            print("[RaC] Moving teleop to robot position (2s smooth transition)...")
-            teleop.smooth_move_to(robot_pos, duration_s=2.0, fps=50)
-            print("[RaC] Teleop aligned. Press START to take control.")
-            events["start_next_episode"] = False
-            waiting_for_takeover = True
-            was_paused = True
-
-        # Wait for start button before enabling correction mode
-        if waiting_for_takeover and events["start_next_episode"]:
-            print("[RaC] Start pressed - enabling teleop control...")
-            events["start_next_episode"] = False
-            events["correction_active"] = True
-            waiting_for_takeover = False
-            was_correction_active = True
-
-        obs = robot.get_observation()
-        obs_frame = build_dataset_frame(dataset.features, obs, prefix=OBS_STR)
-
-        if events["correction_active"]:
-            # Human controlling - record correction data
-            robot_action = teleop.get_action()
-            robot.send_action(robot_action)
-            stats["correction_frames"] += 1
-            
-            # Record this frame
-            action_frame = build_dataset_frame(dataset.features, robot_action, prefix=ACTION)
-            frame = {**obs_frame, **action_frame, "task": single_task}
-            frame_buffer.append(frame)
-            stats["total_frames"] += 1
-            
-        elif waiting_for_takeover:
-            # Waiting for START - policy stopped, no recording, robot holds position
-            if last_robot_action is not None:
-                robot.send_action(last_robot_action)
-            stats["paused_frames"] += 1
-            
-        elif events["policy_paused"]:
-            # Paused and user acknowledged - hold last position, don't record
-            if last_robot_action is not None:
-                robot.send_action(last_robot_action)
-            stats["paused_frames"] += 1
-            robot_action = last_robot_action
-            
-        else:
-            # Normal policy execution - record
-            action_values = predict_action(
-                observation=obs_frame,
-                policy=policy,
-                device=device,
-                preprocessor=preprocessor,
-                postprocessor=postprocessor,
-                use_amp=policy.config.use_amp,
-                task=single_task,
-                robot_type=robot.robot_type,
-            )
-            robot_action: RobotAction = make_robot_action(action_values, dataset.features)
-            robot.send_action(robot_action)
-            last_robot_action = robot_action
-            stats["autonomous_frames"] += 1
-            
-            # Record this frame
-            action_frame = build_dataset_frame(dataset.features, robot_action, prefix=ACTION)
-            frame = {**obs_frame, **action_frame, "task": single_task}
-            frame_buffer.append(frame)
-            stats["total_frames"] += 1
-
-        if display_data and robot_action is not None:
-            log_rerun_data(observation=obs, action=robot_action)
-
-        dt = time.perf_counter() - loop_start
-        precise_sleep(1 / fps - dt)
-        timestamp = time.perf_counter() - start_t
-
-    for frame in frame_buffer:
-        dataset.add_frame(frame)
-
-    return stats
-
-
-def reset_loop(
-    robot: Robot,
-    teleop: Teleoperator,
-    events: dict,
-    fps: int,
-):
-    """Reset period where human repositions environment. Two-stage: enable teleop, then start episode."""
-    print("\n" + "=" * 65)
-    print("  [RaC] RESET - Moving teleop to robot position...")
-    print("=" * 65)
-    
-    # Enter reset mode
-    events["in_reset"] = True
-    events["start_next_episode"] = False
-    
-    # Move teleop to match robot position to avoid sudden jumps
-    obs = robot.get_observation()
-    robot_pos = {k: v for k, v in obs.items() if k.endswith(".pos")}
-    teleop.smooth_move_to(robot_pos, duration_s=2.0, fps=50)
-    
-    # Stage 1: Wait for user to press start to enable teleoperation
-    print("  Teleop aligned. Press any key/pedal to enable teleoperation")
-    while not events["start_next_episode"] and not events["stop_recording"]:
-        precise_sleep(0.05)
-    
-    if events["stop_recording"]:
-        return
-    
-    # Stage 2: Enable teleop and let user move robot to starting position
-    events["start_next_episode"] = False
-    teleop.disable_torque()
-    print("  Teleop enabled - move robot to starting position")
-    print("  Press any key/pedal to start next episode")
-
-    # Wait for user to signal ready for next episode
-    while not events["start_next_episode"] and not events["stop_recording"]:
-        loop_start = time.perf_counter()
-
-        action = teleop.get_action()
-        robot.send_action(action)
-
-        dt = time.perf_counter() - loop_start
-        precise_sleep(1 / fps - dt)
-    
-    # Exit reset mode and clear flags for next episode
-    events["in_reset"] = False
-    events["start_next_episode"] = False
-    events["exit_early"] = False
-    events["policy_paused"] = False
-    events["correction_active"] = False
-
-
-@parser.wrap()
-def rac_collect(cfg: RaCConfig) -> LeRobotDataset:
-    """Main RaC data collection function."""
-    init_logging()
-    logging.info(pformat(cfg.__dict__))
-
-    if cfg.display_data:
-        init_rerun(session_name="rac_collection")
-
-    robot = make_robot_from_config(cfg.robot)
-    teleop = make_teleoperator_from_config(cfg.teleop)
-
-    teleop_proc, robot_proc, obs_proc = make_identity_processors()
-
-    dataset_features = combine_feature_dicts(
-        aggregate_pipeline_dataset_features(
-            pipeline=teleop_proc,
-            initial_features=create_initial_features(action=robot.action_features),
-            use_videos=cfg.dataset.video,
-        ),
-        aggregate_pipeline_dataset_features(
-            pipeline=obs_proc,
-            initial_features=create_initial_features(observation=robot.observation_features),
-            use_videos=cfg.dataset.video,
-        ),
-    )
-
-    dataset = None
-    listener = None
-
-    try:
-        if cfg.resume:
-            dataset = LeRobotDataset(
-                cfg.dataset.repo_id,
-                root=cfg.dataset.root,
-                batch_encoding_size=cfg.dataset.video_encoding_batch_size,
-            )
-            if hasattr(robot, "cameras") and robot.cameras:
-                dataset.start_image_writer(
-                    num_processes=cfg.dataset.num_image_writer_processes,
-                    num_threads=cfg.dataset.num_image_writer_threads_per_camera * len(robot.cameras),
-                )
-        else:
-            dataset = LeRobotDataset.create(
-                cfg.dataset.repo_id,
-                cfg.dataset.fps,
-                root=cfg.dataset.root,
-                robot_type=robot.name,
-                features=dataset_features,
-                use_videos=cfg.dataset.video,
-                image_writer_processes=cfg.dataset.num_image_writer_processes,
-                image_writer_threads=cfg.dataset.num_image_writer_threads_per_camera
-                * len(robot.cameras if hasattr(robot, "cameras") else []),
-                batch_encoding_size=cfg.dataset.video_encoding_batch_size,
-            )
-
-        policy = make_policy(cfg.policy, ds_meta=dataset.meta)
-        preprocessor, postprocessor = make_pre_post_processors(
-            policy_cfg=cfg.policy,
-            pretrained_path=cfg.policy.pretrained_path,
-            dataset_stats=rename_stats(dataset.meta.stats, cfg.dataset.rename_map),
-            preprocessor_overrides={
-                "device_processor": {"device": cfg.policy.device},
-                "rename_observations_processor": {"rename_map": cfg.dataset.rename_map},
-            },
-        )
-
-        robot.connect()
-        teleop.connect()
-        listener, events = init_rac_keyboard_listener()
-
-        print("\n" + "=" * 65)
-        print("  RaC (Recovery and Correction) Data Collection")
-        print("=" * 65)
-        print("  Policy runs autonomously until you intervene.")
-        print()
-        print("  Controls:")
-        print("    SPACE  - Pause policy (robot holds position, no recording)")
-        print("    c      - Take control (start correction, recording)")
-        print("    →      - End episode (save)")
-        print("    ←      - Re-record episode")
-        print("    ESC    - Stop session and push to hub")
-        print("=" * 65 + "\n")
-
-        with VideoEncodingManager(dataset):
-            recorded = 0
-            while recorded < cfg.dataset.num_episodes and not events["stop_recording"]:
-                log_say(f"RaC episode {dataset.num_episodes}", cfg.play_sounds)
-                
-                move_robot_to_zero(robot, duration_s=2.0, fps=cfg.dataset.fps)
-
-                stats = rac_rollout_loop(
-                    robot=robot,
-                    teleop=teleop,
-                    policy=policy,
-                    preprocessor=preprocessor,
-                    postprocessor=postprocessor,
-                    dataset=dataset,
-                    events=events,
-                    fps=cfg.dataset.fps,
-                    control_time_s=cfg.dataset.episode_time_s,
-                    single_task=cfg.dataset.single_task,
-                    display_data=cfg.display_data,
-                )
-
-                logging.info(f"Episode stats: {stats}")
-
-                if events["rerecord_episode"]:
-                    log_say("Re-recording", cfg.play_sounds)
-                    events["rerecord_episode"] = False
-                    events["exit_early"] = False
-                    dataset.clear_episode_buffer()
-                    continue
-
-                dataset.save_episode()
-                recorded += 1
-
-                # Reset between episodes
-                if recorded < cfg.dataset.num_episodes and not events["stop_recording"]:
-                    reset_loop(
-                        robot=robot,
-                        teleop=teleop,
-                        events=events,
-                        fps=cfg.dataset.fps,
-                    )
-
-    finally:
-        log_say("Stop recording", cfg.play_sounds, blocking=True)
-
-        if dataset:
-            dataset.finalize()
-
-        if robot.is_connected:
-            robot.disconnect()
-        if teleop.is_connected:
-            teleop.disconnect()
-
-        if not is_headless() and listener:
-            listener.stop()
-
-        if cfg.dataset.push_to_hub:
-            dataset.push_to_hub(tags=cfg.dataset.tags, private=cfg.dataset.private)
-
-    return dataset
-
-
-def main():
-    from lerobot.utils.import_utils import register_third_party_plugins
-
-    register_third_party_plugins()
-    rac_collect()
-
-
-if __name__ == "__main__":
-    main()
-

examples/rac/rac_data_collection_openarms.py

@@ -1,659 +0,0 @@
-#!/usr/bin/env python
-"""
-RaC (Recovery and Correction) Data Collection for OpenArms Robot.
-
-This implements the RaC paradigm from "RaC: Robot Learning for Long-Horizon Tasks
-by Scaling Recovery and Correction" (Hu et al., 2025) for LeRobot with OpenArms.
-
-RaC improves upon standard data collection (BC) and prior human-in-the-loop methods
-(DAgger, HG-DAgger) by explicitly collecting recovery and correction behaviors:
-
-The workflow:
-1. Policy runs autonomously (teleop is idle/free)
-2. Press SPACE to pause - teleop moves to match robot position
-3. Press 'c' to take control - teleop is free, human provides RECOVERY + CORRECTION
-4. Press → to end episode (save and continue to next)
-5. Reset, then do next rollout
-
-Key RaC Rules:
-- Rule 1 (Recover then Correct): Every intervention = recovery + correction (both human)
-- Rule 2 (Terminate after Intervention): Episode ends after correction
-
-The recovery segment (teleoperating back to good state) is recorded as training data -
-this teaches the policy how to recover from errors.
-
-Keyboard Controls:
-    SPACE  - Pause policy (teleop mirrors robot, no recording)
-    c      - Take control (teleop free, recording correction)
-    →      - End episode (save and continue to next)
-    ←      - Re-record episode
-    ESC    - Stop recording and push dataset to hub
-
-Usage:
-    python examples/rac/rac_data_collection_openarms.py \
-        --robot.type=openarms_follower \
-        --robot.port_right=can0 \
-        --robot.port_left=can1 \
-        --robot.cameras="{ left_wrist: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, right_wrist: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
-        --teleop.type=openarms_mini \
-        --teleop.port_right=/dev/ttyUSB0 \
-        --teleop.port_left=/dev/ttyUSB1 \
-        --policy.path=outputs/train/my_policy/checkpoints/last/pretrained_model \
-        --dataset.repo_id=my_user/rac_openarms_dataset \
-        --dataset.single_task="Pick up the cube"
-"""
-
-import logging
-import time
-from dataclasses import dataclass, field
-from pathlib import Path
-from pprint import pformat
-from typing import Any
-
-from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig  # noqa: F401
-from lerobot.cameras.realsense.configuration_realsense import RealSenseCameraConfig  # noqa: F401
-from lerobot.configs import parser
-from lerobot.configs.policies import PreTrainedConfig
-from lerobot.datasets.image_writer import safe_stop_image_writer
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.datasets.pipeline_features import aggregate_pipeline_dataset_features, create_initial_features
-from lerobot.datasets.utils import build_dataset_frame, combine_feature_dicts
-from lerobot.datasets.video_utils import VideoEncodingManager
-from lerobot.policies.factory import make_policy, make_pre_post_processors
-from lerobot.policies.pretrained import PreTrainedPolicy
-from lerobot.policies.utils import make_robot_action
-from lerobot.processor import (
-    IdentityProcessorStep,
-    PolicyAction,
-    PolicyProcessorPipeline,
-    RobotAction,
-    RobotObservation,
-    RobotProcessorPipeline,
-)
-from lerobot.processor.converters import (
-    observation_to_transition,
-    robot_action_observation_to_transition,
-    transition_to_observation,
-    transition_to_robot_action,
-)
-from lerobot.processor.rename_processor import rename_stats
-from lerobot.robots import Robot, RobotConfig, make_robot_from_config
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig  # noqa: F401
-from lerobot.teleoperators import Teleoperator, TeleoperatorConfig, make_teleoperator_from_config
-from lerobot.teleoperators.openarms_mini.config_openarms_mini import OpenArmsMiniConfig  # noqa: F401
-from lerobot.utils.constants import ACTION, OBS_STR
-from lerobot.utils.control_utils import is_headless, predict_action
-from lerobot.utils.robot_utils import precise_sleep
-from lerobot.utils.utils import get_safe_torch_device, init_logging, log_say
-from lerobot.utils.visualization_utils import init_rerun, log_rerun_data
-
-
-@dataclass
-class RaCDatasetConfig:
-    repo_id: str
-    single_task: str
-    root: str | Path | None = None
-    fps: int = 30
-    episode_time_s: float = 120
-    reset_time_s: float = 30
-    num_episodes: int = 50
-    video: bool = True
-    push_to_hub: bool = True
-    private: bool = False
-    tags: list[str] | None = None
-    num_image_writer_processes: int = 0
-    num_image_writer_threads_per_camera: int = 4
-    video_encoding_batch_size: int = 1
-    rename_map: dict[str, str] = field(default_factory=dict)
-
-
-@dataclass
-class RaCConfig:
-    robot: RobotConfig
-    dataset: RaCDatasetConfig
-    teleop: TeleoperatorConfig
-    policy: PreTrainedConfig | None = None
-    display_data: bool = True
-    play_sounds: bool = True
-    resume: bool = False
-
-    def __post_init__(self):
-        policy_path = parser.get_path_arg("policy")
-        if policy_path:
-            cli_overrides = parser.get_cli_overrides("policy")
-            self.policy = PreTrainedConfig.from_pretrained(policy_path, cli_overrides=cli_overrides)
-            self.policy.pretrained_path = policy_path
-        if self.policy is None:
-            raise ValueError("policy.path is required")
-
-    @classmethod
-    def __get_path_fields__(cls) -> list[str]:  
-        return ["policy"]
-
-
-def init_rac_keyboard_listener():
-    """Initialize keyboard listener with RaC-specific controls."""
-    events = {
-        "exit_early": False,
-        "rerecord_episode": False,
-        "stop_recording": False,
-        "policy_paused": False,      # SPACE pressed - policy paused, teleop tracking robot
-        "correction_active": False,  # 'c' pressed - human controlling, recording correction
-        "in_reset": False,           # True during reset period
-        "start_next_episode": False, # Signal to start next episode
-    }
-
-    if is_headless():
-        logging.warning("Headless environment - keyboard controls unavailable")
-        return None, events
-
-    from pynput import keyboard
-
-    def on_press(key):
-        try:
-            if events["in_reset"]:
-                # During reset: any action key starts next episode
-                if key == keyboard.Key.space or key == keyboard.Key.right:
-                    print("\n[RaC] Starting next episode...")
-                    events["start_next_episode"] = True
-                elif hasattr(key, 'char') and key.char == 'c':
-                    print("\n[RaC] Starting next episode...")
-                    events["start_next_episode"] = True
-                elif key == keyboard.Key.esc:
-                    print("[RaC] ESC - Stop recording, pushing to hub...")
-                    events["stop_recording"] = True
-                    events["start_next_episode"] = True
-            else:
-                # During episode
-                if key == keyboard.Key.space:
-                    if not events["policy_paused"] and not events["correction_active"]:
-                        print("\n[RaC] ⏸ PAUSED - Policy stopped, teleop moving to robot position")
-                        print("      Press 'c' or START to take control")
-                        events["policy_paused"] = True
-                elif hasattr(key, 'char') and key.char == 'c':
-                    if events["policy_paused"] and not events["correction_active"]:
-                        print("\n[RaC] ▶ START pressed - taking control")
-                        events["start_next_episode"] = True
-                elif key == keyboard.Key.right:
-                    print("[RaC] → End episode")
-                    events["exit_early"] = True
-                elif key == keyboard.Key.left:
-                    print("[RaC] ← Re-record episode")
-                    events["rerecord_episode"] = True
-                    events["exit_early"] = True
-                elif key == keyboard.Key.esc:
-                    print("[RaC] ESC - Stop recording, pushing to hub...")
-                    events["stop_recording"] = True
-                    events["exit_early"] = True
-        except Exception as e:
-            print(f"Key error: {e}")
-
-    listener = keyboard.Listener(on_press=on_press)
-    listener.start()
-    
-    start_pedal_listener(events)
-    
-    return listener, events
-
-
-def start_pedal_listener(events: dict):
-    """Start foot pedal listener thread if evdev is available."""
-    import threading
-    
-    try:
-        from evdev import InputDevice, ecodes
-    except ImportError:
-        logging.info("[Pedal] evdev not installed - pedal support disabled")
-        return
-    
-    PEDAL_DEVICE = "/dev/input/by-id/usb-PCsensor_FootSwitch-event-kbd"
-    KEY_LEFT = "KEY_A"   # Left pedal
-    KEY_RIGHT = "KEY_C"  # Right pedal
-    
-    def pedal_reader():
-        try:
-            dev = InputDevice(PEDAL_DEVICE)
-            print(f"[Pedal] Connected: {dev.name}")
-            print(f"[Pedal] Right=pause/next, Left=take control/start")
-            
-            for ev in dev.read_loop():
-                if ev.type != ecodes.EV_KEY:
-                    continue
-                
-                from evdev import categorize
-                key = categorize(ev)
-                code = key.keycode
-                if isinstance(code, (list, tuple)):
-                    code = code[0]
-                
-                # Only trigger on key down
-                if key.keystate != 1:
-                    continue
-                
-                if events["in_reset"]:
-                    # During reset: either pedal starts next episode
-                    if code in [KEY_LEFT, KEY_RIGHT]:
-                        print("\n[Pedal] Starting next episode...")
-                        events["start_next_episode"] = True
-                else:
-                    # During episode
-                    if code == KEY_RIGHT:
-                        # Right pedal: SPACE (pause) when running, → (next) when in correction
-                        if events["correction_active"]:
-                            print("\n[Pedal] → End episode")
-                            events["exit_early"] = True
-                        elif not events["policy_paused"]:
-                            print("\n[Pedal] ⏸ PAUSED - Policy stopped, teleop moving to robot")
-                            print("        Press left pedal to take control")
-                            events["policy_paused"] = True
-                    
-                    elif code == KEY_LEFT:
-                        # Left pedal: START (take control) when paused
-                        if events["policy_paused"] and not events["correction_active"]:
-                            print("\n[Pedal] ▶ START pressed - taking control")
-                            events["start_next_episode"] = True
-                        
-        except FileNotFoundError:
-            logging.info(f"[Pedal] Device not found: {PEDAL_DEVICE}")
-        except PermissionError:
-            logging.warning(f"[Pedal] Permission denied. Run: sudo setfacl -m u:$USER:rw {PEDAL_DEVICE}")
-        except Exception as e:
-            logging.debug(f"[Pedal] Error: {e}")
-    
-    thread = threading.Thread(target=pedal_reader, daemon=True)
-    thread.start()
-
-
-def make_identity_processors():
-    """Create identity processors for RaC recording."""
-    teleop_proc = RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction](
-        steps=[IdentityProcessorStep()],
-        to_transition=robot_action_observation_to_transition,
-        to_output=transition_to_robot_action,
-    )
-    robot_proc = RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction](
-        steps=[IdentityProcessorStep()],
-        to_transition=robot_action_observation_to_transition,
-        to_output=transition_to_robot_action,
-    )
-    obs_proc = RobotProcessorPipeline[RobotObservation, RobotObservation](
-        steps=[IdentityProcessorStep()],
-        to_transition=observation_to_transition,
-        to_output=transition_to_observation,
-    )
-    return teleop_proc, robot_proc, obs_proc
-
-
-def move_robot_to_zero(robot: Robot, duration_s: float = 2.0, fps: int = 50):
-    """Smoothly move all robot joints to zero position."""
-    obs = robot.get_observation()
-    current_pos = {k: v for k, v in obs.items() if k.endswith(".pos")}
-    target_pos = {k: 0.0 for k in current_pos}
-    
-    print(f"[RaC] Moving robot to zero position ({duration_s}s)...")
-    steps = int(duration_s * fps)
-    for step in range(steps + 1):
-        t = step / steps
-        interp_pos = {k: current_pos[k] * (1 - t) + target_pos[k] * t for k in current_pos}
-        robot.send_action(interp_pos)
-        time.sleep(1 / fps)
-    print("[RaC] Robot at zero position.")
-
-
-@safe_stop_image_writer
-def rac_rollout_loop(
-    robot: Robot,
-    teleop: Teleoperator,
-    policy: PreTrainedPolicy,
-    preprocessor: PolicyProcessorPipeline[dict[str, Any], dict[str, Any]],
-    postprocessor: PolicyProcessorPipeline[PolicyAction, PolicyAction],
-    dataset: LeRobotDataset,
-    events: dict,
-    fps: int,
-    control_time_s: float,
-    single_task: str,
-    display_data: bool = True,
-) -> dict:
-    """
-    RaC rollout loop with two-stage intervention:
-    
-    1. Policy runs autonomously (recording) - teleop free/idle
-    2. SPACE: Policy pauses, teleop mirrors robot position (NOT recording)
-    3. 'c': Human takes control, teleop torque disabled (recording correction)
-    4. →: End episode
-    
-    This allows smooth handoff - teleop tracks robot only when paused.
-    """
-    policy.reset()
-    preprocessor.reset()
-    postprocessor.reset()
-
-    device = get_safe_torch_device(policy.config.device)
-    frame_buffer = []
-
-    stats = {
-        "total_frames": 0,
-        "autonomous_frames": 0,
-        "paused_frames": 0,
-        "correction_frames": 0,
-    }
-
-    # Start with teleop torque disabled - only enable when paused to track robot
-    teleop.disable_torque()
-    was_paused = False
-    was_correction_active = False
-    waiting_for_takeover = False
-
-    timestamp = 0
-    start_t = time.perf_counter()
-
-    while timestamp < control_time_s:
-        loop_start = time.perf_counter()
-
-        if events["exit_early"]:
-            events["exit_early"] = False
-            events["policy_paused"] = False
-            events["correction_active"] = False
-            break
-
-        # Detect transition to paused state - smooth move teleop to robot position
-        if events["policy_paused"] and not was_paused:
-            obs = robot.get_observation()
-            obs_filtered = {k: v for k, v in obs.items() if k in robot.observation_features}
-            robot_pos = {k: v for k, v in obs_filtered.items() if k.endswith(".pos")}
-            print("[RaC] Moving teleop to robot position (2s smooth transition)...")
-            teleop.smooth_move_to(robot_pos, duration_s=2.0, fps=50)
-            print("[RaC] Teleop aligned. Press START to take control.")
-            events["start_next_episode"] = False
-            waiting_for_takeover = True
-            was_paused = True
-
-        # Wait for start button before enabling correction mode
-        if waiting_for_takeover and events["start_next_episode"]:
-            print("[RaC] Start pressed - enabling teleop control...")
-            teleop.disable_torque()
-            events["start_next_episode"] = False
-            events["correction_active"] = True
-            waiting_for_takeover = False
-            was_correction_active = True
-
-        obs = robot.get_observation()
-        obs_filtered = {k: v for k, v in obs.items() if k in robot.observation_features}
-        obs_frame = build_dataset_frame(dataset.features, obs_filtered, prefix=OBS_STR)
-
-        if events["correction_active"]:
-            # Human controlling - record correction data
-            robot_action = teleop.get_action()
-            # Convert gripper from teleop range (0-100) to robot degrees (-65 to 0)
-            for key in robot_action:
-                if "gripper" in key:
-                    robot_action[key] = -0.65 * robot_action[key]
-            robot.send_action(robot_action)
-            stats["correction_frames"] += 1
-            
-            # Record this frame
-            action_frame = build_dataset_frame(dataset.features, robot_action, prefix=ACTION)
-            frame = {**obs_frame, **action_frame, "task": single_task}
-            frame_buffer.append(frame)
-            stats["total_frames"] += 1
-            
-        elif waiting_for_takeover:
-            # Waiting for START - policy stopped, no recording, robot holds position
-            stats["paused_frames"] += 1
-            
-        elif events["policy_paused"]:
-            # Paused and user acknowledged - teleop tracks robot position, don't record
-            robot_action = {k: v for k, v in obs_filtered.items() if k.endswith(".pos")}
-            teleop.send_feedback(robot_action)
-            stats["paused_frames"] += 1
-            
-        else:
-            # Normal policy execution - record (teleop is free/idle)
-            action_values = predict_action(
-                observation=obs_frame,
-                policy=policy,
-                device=device,
-                preprocessor=preprocessor,
-                postprocessor=postprocessor,
-                use_amp=policy.config.use_amp,
-                task=single_task,
-                robot_type=robot.robot_type,
-            )
-            robot_action: RobotAction = make_robot_action(action_values, dataset.features)
-            robot.send_action(robot_action)
-            stats["autonomous_frames"] += 1
-            
-            # Record this frame
-            action_frame = build_dataset_frame(dataset.features, robot_action, prefix=ACTION)
-            frame = {**obs_frame, **action_frame, "task": single_task}
-            frame_buffer.append(frame)
-            stats["total_frames"] += 1
-
-        if display_data:
-            log_rerun_data(observation=obs_filtered, action=robot_action)
-
-        dt = time.perf_counter() - loop_start
-        precise_sleep(1 / fps - dt)
-        timestamp = time.perf_counter() - start_t
-
-    # Ensure teleoperator torque is disabled at end
-    teleop.disable_torque()
-
-    for frame in frame_buffer:
-        dataset.add_frame(frame)
-
-    return stats
-
-
-def reset_loop(
-    robot: Robot,
-    teleop: Teleoperator,
-    events: dict,
-    fps: int,
-):
-    """Reset period where human repositions environment. Two-stage: enable teleop, then start episode."""
-    print("\n" + "=" * 65)
-    print("  [RaC] RESET - Moving teleop to robot position...")
-    print("=" * 65)
-    
-    # Enter reset mode
-    events["in_reset"] = True
-    events["start_next_episode"] = False
-    
-    # First move teleop to match robot position to avoid sudden jumps
-    obs = robot.get_observation()
-    robot_pos = {k: v for k, v in obs.items() if k.endswith(".pos") and k in robot.observation_features}
-    teleop.smooth_move_to(robot_pos, duration_s=2.0, fps=50)
-    
-    # Stage 1: Wait for user to press start to enable teleoperation
-    print("  Teleop aligned. Press any key/pedal to enable teleoperation")
-    while not events["start_next_episode"] and not events["stop_recording"]:
-        precise_sleep(0.05)
-    
-    if events["stop_recording"]:
-        return
-    
-    # Stage 2: Enable teleop and let user move robot to starting position
-    events["start_next_episode"] = False
-    teleop.disable_torque()
-    print("  Teleop enabled - move robot to starting position")
-    print("  Press any key/pedal to start next episode")
-
-    # Wait for user to signal ready for next episode
-    while not events["start_next_episode"] and not events["stop_recording"]:
-        loop_start = time.perf_counter()
-
-        action = teleop.get_action()
-        # Convert gripper from teleop range (0-100) to robot degrees (-65 to 0)
-        for key in action:
-            if "gripper" in key:
-                action[key] = -0.65 * action[key]
-        robot.send_action(action)
-
-        dt = time.perf_counter() - loop_start
-        precise_sleep(1 / fps - dt)
-    
-    # Exit reset mode and clear flags for next episode
-    events["in_reset"] = False
-    events["start_next_episode"] = False
-    events["exit_early"] = False
-    events["policy_paused"] = False
-    events["correction_active"] = False
-
-
-@parser.wrap()
-def rac_collect(cfg: RaCConfig) -> LeRobotDataset:
-    """Main RaC data collection function."""
-    init_logging()
-    logging.info(pformat(cfg.__dict__))
-
-    if cfg.display_data:
-        init_rerun(session_name="rac_collection_openarms")
-
-    robot = make_robot_from_config(cfg.robot)
-    teleop = make_teleoperator_from_config(cfg.teleop)
-
-    teleop_proc, robot_proc, obs_proc = make_identity_processors()
-
-    dataset_features = combine_feature_dicts(
-        aggregate_pipeline_dataset_features(
-            pipeline=teleop_proc,
-            initial_features=create_initial_features(action=robot.action_features),
-            use_videos=cfg.dataset.video,
-        ),
-        aggregate_pipeline_dataset_features(
-            pipeline=obs_proc,
-            initial_features=create_initial_features(observation=robot.observation_features),
-            use_videos=cfg.dataset.video,
-        ),
-    )
-
-    dataset = None
-    listener = None
-
-    try:
-        if cfg.resume:
-            dataset = LeRobotDataset(
-                cfg.dataset.repo_id,
-                root=cfg.dataset.root,
-                batch_encoding_size=cfg.dataset.video_encoding_batch_size,
-            )
-            if hasattr(robot, "cameras") and robot.cameras:
-                dataset.start_image_writer(
-                    num_processes=cfg.dataset.num_image_writer_processes,
-                    num_threads=cfg.dataset.num_image_writer_threads_per_camera * len(robot.cameras),
-                )
-        else:
-            dataset = LeRobotDataset.create(
-                cfg.dataset.repo_id,
-                cfg.dataset.fps,
-                root=cfg.dataset.root,
-                robot_type=robot.name,
-                features=dataset_features,
-                use_videos=cfg.dataset.video,
-                image_writer_processes=cfg.dataset.num_image_writer_processes,
-                image_writer_threads=cfg.dataset.num_image_writer_threads_per_camera
-                * len(robot.cameras if hasattr(robot, "cameras") else []),
-                batch_encoding_size=cfg.dataset.video_encoding_batch_size,
-            )
-
-        policy = make_policy(cfg.policy, ds_meta=dataset.meta)
-        preprocessor, postprocessor = make_pre_post_processors(
-            policy_cfg=cfg.policy,
-            pretrained_path=cfg.policy.pretrained_path,
-            dataset_stats=rename_stats(dataset.meta.stats, cfg.dataset.rename_map),
-            preprocessor_overrides={
-                "device_processor": {"device": cfg.policy.device},
-                "rename_observations_processor": {"rename_map": cfg.dataset.rename_map},
-            },
-        )
-
-        robot.connect()
-        teleop.connect()
-        listener, events = init_rac_keyboard_listener()
-
-        print("\n" + "=" * 65)
-        print("  RaC (Recovery and Correction) Data Collection - OpenArms")
-        print("=" * 65)
-        print("  Policy runs autonomously until you intervene.")
-        print()
-        print("  Controls:")
-        print("    SPACE  - Pause policy (teleop tracks robot, no recording)")
-        print("    c      - Take control (start correction, recording)")
-        print("    →      - End episode (save)")
-        print("    ←      - Re-record episode")
-        print("    ESC    - Stop session and push to hub")
-        print("=" * 65 + "\n")
-
-        with VideoEncodingManager(dataset):
-            recorded = 0
-            while recorded < cfg.dataset.num_episodes and not events["stop_recording"]:
-                log_say(f"RaC episode {dataset.num_episodes}", cfg.play_sounds)
-                
-                move_robot_to_zero(robot, duration_s=2.0, fps=cfg.dataset.fps)
-
-                stats = rac_rollout_loop(
-                    robot=robot,
-                    teleop=teleop,
-                    policy=policy,
-                    preprocessor=preprocessor,
-                    postprocessor=postprocessor,
-                    dataset=dataset,
-                    events=events,
-                    fps=cfg.dataset.fps,
-                    control_time_s=cfg.dataset.episode_time_s,
-                    single_task=cfg.dataset.single_task,
-                    display_data=cfg.display_data,
-                )
-
-                logging.info(f"Episode stats: {stats}")
-
-                if events["rerecord_episode"]:
-                    log_say("Re-recording", cfg.play_sounds)
-                    events["rerecord_episode"] = False
-                    events["exit_early"] = False
-                    dataset.clear_episode_buffer()
-                    continue
-
-                dataset.save_episode()
-                recorded += 1
-
-                # Reset between episodes
-                if recorded < cfg.dataset.num_episodes and not events["stop_recording"]:
-                    reset_loop(
-                        robot=robot,
-                        teleop=teleop,
-                        events=events,
-                        fps=cfg.dataset.fps,
-                    )
-
-    finally:
-        log_say("Stop recording", cfg.play_sounds, blocking=True)
-
-        if dataset:
-            dataset.finalize()
-
-        if robot.is_connected:
-            robot.disconnect()
-        if teleop.is_connected:
-            teleop.disconnect()
-
-        if not is_headless() and listener:
-            listener.stop()
-
-        if cfg.dataset.push_to_hub:
-            dataset.push_to_hub(tags=cfg.dataset.tags, private=cfg.dataset.private)
-
-    return dataset
-
-
-def main():
-    from lerobot.utils.import_utils import register_third_party_plugins
-
-    register_third_party_plugins()
-    rac_collect()
-
-
-if __name__ == "__main__":
-    main()
-

examples/rac/rac_data_collection_openarms_rtc.py

@@ -1,877 +0,0 @@
-#!/usr/bin/env python
-"""
-RaC (Recovery and Correction) Data Collection for OpenArms Robot with RTC.
-
-This combines RaC data collection with Real-Time Chunking (RTC) for smooth policy execution.
-RTC enables large flow-matching policies (Pi0, Pi0.5, SmolVLA) to produce reactive motion
-despite high inference latency by asynchronously generating action chunks.
-
-The workflow:
-1. Policy runs autonomously with RTC (teleop is idle/free)
-2. Press SPACE to pause - teleop moves to match robot position
-3. Press 'c' to take control - teleop is free, human provides RECOVERY + CORRECTION
-4. Press → to end episode (save and continue to next)
-5. Reset, then do next rollout
-
-Usage:
-    python examples/rac/rac_data_collection_openarms_rtc.py \
-        --robot.port_right=can0 \
-        --robot.port_left=can1 \
-        --teleop.port_right=/dev/ttyUSB0 \
-        --teleop.port_left=/dev/ttyUSB1 \
-        --policy.path=outputs/train/my_policy/checkpoints/last/pretrained_model \
-        --dataset.repo_id=my_user/rac_openarms_dataset \
-        --dataset.single_task="Pick up the cube"
-"""
-
-import logging
-import math
-import time
-from dataclasses import dataclass, field
-from pathlib import Path
-from pprint import pformat
-from threading import Event, Lock, Thread
-from typing import Any
-
-import torch
-from torch import Tensor
-
-from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig  # noqa: F401
-from lerobot.cameras.realsense.configuration_realsense import RealSenseCameraConfig  # noqa: F401
-from lerobot.configs import parser
-from lerobot.configs.policies import PreTrainedConfig
-from lerobot.configs.types import RTCAttentionSchedule
-from lerobot.datasets.image_writer import safe_stop_image_writer
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.datasets.pipeline_features import aggregate_pipeline_dataset_features, create_initial_features
-from lerobot.datasets.utils import build_dataset_frame, combine_feature_dicts, hw_to_dataset_features
-from lerobot.datasets.video_utils import VideoEncodingManager
-from lerobot.policies.factory import get_policy_class, make_pre_post_processors
-from lerobot.policies.pretrained import PreTrainedPolicy
-from lerobot.policies.rtc.action_queue import ActionQueue
-from lerobot.policies.rtc.configuration_rtc import RTCConfig
-from lerobot.policies.rtc.latency_tracker import LatencyTracker
-from lerobot.policies.utils import make_robot_action
-from lerobot.processor import (
-    IdentityProcessorStep,
-    PolicyAction,
-    PolicyProcessorPipeline,
-    RobotAction,
-    RobotObservation,
-    RobotProcessorPipeline,
-)
-from lerobot.processor.converters import (
-    observation_to_transition,
-    robot_action_observation_to_transition,
-    transition_to_observation,
-    transition_to_robot_action,
-)
-from lerobot.processor.rename_processor import rename_stats
-from lerobot.robots import Robot, RobotConfig, make_robot_from_config
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig  # noqa: F401
-from lerobot.teleoperators import Teleoperator, TeleoperatorConfig, make_teleoperator_from_config
-from lerobot.teleoperators.openarms_mini.config_openarms_mini import OpenArmsMiniConfig  # noqa: F401
-from lerobot.utils.constants import ACTION, OBS_STR
-from lerobot.utils.control_utils import is_headless, predict_action
-from lerobot.utils.robot_utils import precise_sleep
-from lerobot.utils.utils import get_safe_torch_device, init_logging, log_say
-from lerobot.utils.visualization_utils import init_rerun, log_rerun_data
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-# ============================================================================
-# Configuration
-# ============================================================================
-
-@dataclass
-class RaCRTCDatasetConfig:
-    repo_id: str = "lerobot/rac_openarms_rtc"
-    single_task: str = "default task"
-    root: str | Path | None = None
-    fps: int = 30
-    episode_time_s: float = 500
-    reset_time_s: float = 30
-    num_episodes: int = 50
-    video: bool = True
-    push_to_hub: bool = True
-    private: bool = False
-    tags: list[str] | None = None
-    num_image_writer_processes: int = 0
-    num_image_writer_threads_per_camera: int = 4
-    video_encoding_batch_size: int = 1
-    rename_map: dict[str, str] = field(default_factory=dict)
-
-
-@dataclass
-class RaCRTCConfig:
-    robot: RobotConfig = field(default_factory=lambda: OpenArmsFollowerConfig(
-        port_left="can0",
-        port_right="can1",
-    ))
-    teleop: TeleoperatorConfig = field(default_factory=lambda: OpenArmsMiniConfig(
-        port_left="/dev/ttyUSB1",
-        port_right="/dev/ttyUSB0",
-    ))
-    dataset: RaCRTCDatasetConfig = field(default_factory=RaCRTCDatasetConfig)
-    policy: PreTrainedConfig | None = None
-    
-    rtc: RTCConfig = field(default_factory=lambda: RTCConfig(
-        enabled=True, 
-        execution_horizon=20,
-        max_guidance_weight=5.0,
-        prefix_attention_schedule=RTCAttentionSchedule.LINEAR,
-    ))
-    
-    interpolation: bool = True
-    display_data: bool = True
-    play_sounds: bool = True
-    resume: bool = False
-    device: str = "cuda"
-    action_queue_size_to_get_new_actions: int = 30
-
-    def __post_init__(self):
-        policy_path = parser.get_path_arg("policy")
-        if policy_path:
-            cli_overrides = parser.get_cli_overrides("policy")
-            self.policy = PreTrainedConfig.from_pretrained(policy_path, cli_overrides=cli_overrides)
-            self.policy.pretrained_path = policy_path
-        if self.policy is None:
-            raise ValueError("policy.path is required")
-
-    @classmethod
-    def __get_path_fields__(cls) -> list[str]:
-        return ["policy"]
-
-
-# ============================================================================
-# Thread-Safe Robot Wrapper (from evaluate_with_rtc.py)
-# ============================================================================
-
-class RobotWrapper:
-    """Thread-safe wrapper for robot operations."""
-
-    def __init__(self, robot: Robot):
-        self.robot = robot
-        self.lock = Lock()
-
-    def get_observation(self) -> dict[str, Tensor]:
-        with self.lock:
-            return self.robot.get_observation()
-
-    def send_action(self, action: dict) -> None:
-        with self.lock:
-            self.robot.send_action(action)
-
-    @property
-    def observation_features(self) -> dict:
-        return self.robot.observation_features
-
-    @property
-    def action_features(self) -> dict:
-        return self.robot.action_features
-
-    @property
-    def name(self) -> str:
-        return self.robot.name
-    
-    @property
-    def robot_type(self) -> str:
-        return self.robot.robot_type
-
-
-# ============================================================================
-# Keyboard/Pedal Listeners
-# ============================================================================
-
-def init_rac_keyboard_listener():
-    """Initialize keyboard listener with RaC-specific controls."""
-    events = {
-        "exit_early": False,
-        "rerecord_episode": False,
-        "stop_recording": False,
-        "policy_paused": False,
-        "correction_active": False,
-        "in_reset": False,
-        "start_next_episode": False,
-    }
-
-    if is_headless():
-        logging.warning("Headless environment - keyboard controls unavailable")
-        return None, events
-
-    from pynput import keyboard
-
-    def on_press(key):
-        try:
-            if events["in_reset"]:
-                if key == keyboard.Key.space or key == keyboard.Key.right:
-                    print("\n[RaC] Starting next episode...")
-                    events["start_next_episode"] = True
-                elif hasattr(key, 'char') and key.char == 'c':
-                    print("\n[RaC] Starting next episode...")
-                    events["start_next_episode"] = True
-                elif key == keyboard.Key.esc:
-                    print("[RaC] ESC - Stop recording, pushing to hub...")
-                    events["stop_recording"] = True
-                    events["start_next_episode"] = True
-            else:
-                if key == keyboard.Key.space:
-                    if not events["policy_paused"] and not events["correction_active"]:
-                        print("\n[RaC] ⏸ PAUSED - Policy stopped, teleop moving to robot position")
-                        print("      Press 'c' or START to take control")
-                        events["policy_paused"] = True
-                elif hasattr(key, 'char') and key.char == 'c':
-                    if events["policy_paused"] and not events["correction_active"]:
-                        print("\n[RaC] ▶ START pressed - taking control")
-                        events["start_next_episode"] = True
-                elif key == keyboard.Key.right:
-                    print("[RaC] → End episode")
-                    events["exit_early"] = True
-                elif key == keyboard.Key.left:
-                    print("[RaC] ← Re-record episode")
-                    events["rerecord_episode"] = True
-                    events["exit_early"] = True
-                elif key == keyboard.Key.esc:
-                    print("[RaC] ESC - Stop recording, pushing to hub...")
-                    events["stop_recording"] = True
-                    events["exit_early"] = True
-        except Exception as e:
-            print(f"Key error: {e}")
-
-    listener = keyboard.Listener(on_press=on_press)
-    listener.start()
-    
-    start_pedal_listener(events)
-    
-    return listener, events
-
-
-def start_pedal_listener(events: dict):
-    """Start foot pedal listener thread if evdev is available."""
-    import threading
-    
-    try:
-        from evdev import InputDevice, ecodes  # noqa: F401
-    except ImportError:
-        logging.info("[Pedal] evdev not installed - pedal support disabled")
-        return
-    
-    PEDAL_DEVICE = "/dev/input/by-id/usb-PCsensor_FootSwitch-event-kbd"
-    KEY_LEFT = "KEY_A"
-    KEY_RIGHT = "KEY_C"
-    
-    def pedal_reader():
-        try:
-            dev = InputDevice(PEDAL_DEVICE)
-            print(f"[Pedal] Connected: {dev.name}")
-            
-            for ev in dev.read_loop():
-                if ev.type != ecodes.EV_KEY:
-                    continue
-                
-                from evdev import categorize  # noqa: F401
-                key = categorize(ev)
-                code = key.keycode
-                if isinstance(code, (list, tuple)):
-                    code = code[0]
-                
-                if key.keystate != 1:
-                    continue
-                
-                if events["in_reset"]:
-                    if code in [KEY_LEFT, KEY_RIGHT]:
-                        events["start_next_episode"] = True
-                else:
-                    if code == KEY_RIGHT:
-                        if events["correction_active"]:
-                            events["exit_early"] = True
-                        elif not events["policy_paused"]:
-                            events["policy_paused"] = True
-                    elif code == KEY_LEFT:
-                        if events["policy_paused"] and not events["correction_active"]:
-                            events["start_next_episode"] = True
-                        
-        except FileNotFoundError:
-            logging.info(f"[Pedal] Device not found: {PEDAL_DEVICE}")
-        except PermissionError:
-            logging.warning(f"[Pedal] Permission denied for {PEDAL_DEVICE}")
-        except Exception as e:
-            logging.debug(f"[Pedal] Error: {e}")
-    
-    thread = threading.Thread(target=pedal_reader, daemon=True)
-    thread.start()
-
-
-def make_identity_processors():
-    """Create identity processors for RaC recording."""
-    teleop_proc = RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction](
-        steps=[IdentityProcessorStep()],
-        to_transition=robot_action_observation_to_transition,
-        to_output=transition_to_robot_action,
-    )
-    robot_proc = RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction](
-        steps=[IdentityProcessorStep()],
-        to_transition=robot_action_observation_to_transition,
-        to_output=transition_to_robot_action,
-    )
-    obs_proc = RobotProcessorPipeline[RobotObservation, RobotObservation](
-        steps=[IdentityProcessorStep()],
-        to_transition=observation_to_transition,
-        to_output=transition_to_observation,
-    )
-    return teleop_proc, robot_proc, obs_proc
-
-
-# ============================================================================
-# RTC Inference Thread (from evaluate_with_rtc.py)
-# ============================================================================
-
-def rtc_inference_thread(
-    policy,
-    obs_holder: dict,
-    hw_features: dict,
-    preprocessor,
-    postprocessor,
-    queue_holder: dict,
-    shutdown_event: Event,
-    policy_active: Event,
-    cfg: RaCRTCConfig,
-):
-    """Background thread that generates action chunks using RTC."""
-    try:
-        logger.info("[RTC] ========== INFERENCE THREAD STARTED ==========")
-        logger.info(f"[RTC] policy={policy.name}, hw_features has {len(hw_features)} keys")
-        
-        latency_tracker = LatencyTracker()
-        time_per_chunk = 1.0 / cfg.dataset.fps
-        policy_device = policy.config.device
-        
-        get_actions_threshold = cfg.action_queue_size_to_get_new_actions
-        if not cfg.rtc.enabled:
-            get_actions_threshold = 0
-        
-        inference_count = 0
-        wait_logged = False
-        
-        while not shutdown_event.is_set():
-            if not policy_active.is_set():
-                if not wait_logged:
-                    logger.info("[RTC] Waiting for policy_active...")
-                    wait_logged = True
-                time.sleep(0.01)
-                continue
-            
-            wait_logged = False
-            
-            action_queue = queue_holder["queue"]
-            if action_queue is None:
-                logger.warning("[RTC] queue_holder['queue'] is None!")
-                time.sleep(0.01)
-                continue
-            
-            obs_filtered = obs_holder.get("obs")
-            if obs_filtered is None:
-                logger.warning("[RTC] obs_holder['obs'] is None!")
-                time.sleep(0.01)
-                continue
-            
-            qsize = action_queue.qsize()
-            if qsize <= get_actions_threshold:
-                try:
-                    if inference_count == 0:
-                        logger.info(f"[RTC] Starting first inference, obs keys={len(obs_filtered)}, qsize={qsize}")
-                    
-                    current_time = time.perf_counter()
-                    action_index_before_inference = action_queue.get_action_index()
-                    prev_actions = action_queue.get_left_over()
-                    
-                    inference_latency = latency_tracker.max()
-                    inference_delay = math.ceil(inference_latency / time_per_chunk) if inference_latency else 0
-                    
-                    obs_with_policy_features = build_dataset_frame(hw_features, obs_filtered, prefix="observation")
-                    
-                    for name in obs_with_policy_features:
-                        obs_with_policy_features[name] = torch.from_numpy(obs_with_policy_features[name])
-                        if "image" in name:
-                            obs_with_policy_features[name] = obs_with_policy_features[name].float() / 255
-                            obs_with_policy_features[name] = obs_with_policy_features[name].permute(2, 0, 1).contiguous()
-                        obs_with_policy_features[name] = obs_with_policy_features[name].unsqueeze(0).to(policy_device)
-                    
-                    obs_with_policy_features["task"] = [cfg.dataset.single_task]
-                    obs_with_policy_features["robot_type"] = obs_holder.get("robot_type", "openarms_follower")
-                    
-                    preprocessed_obs = preprocessor(obs_with_policy_features)
-                    
-                    actions = policy.predict_action_chunk(
-                        preprocessed_obs,
-                        inference_delay=inference_delay,
-                        prev_chunk_left_over=prev_actions,
-                    )
-                    
-                    original_actions = actions.squeeze(0).clone()
-                    postprocessed_actions = postprocessor(actions).squeeze(0)
-                    
-                    new_latency = time.perf_counter() - current_time
-                    new_delay = math.ceil(new_latency / time_per_chunk)
-                    latency_tracker.add(new_latency)
-                    
-                    action_queue.merge(original_actions, postprocessed_actions, new_delay, action_index_before_inference)
-                    
-                    inference_count += 1
-                    logger.info(f"[RTC] Inference #{inference_count}, latency={new_latency:.2f}s, queue={action_queue.qsize()}")
-                except Exception as e:
-                    logger.error(f"[RTC] Inference error: {e}")
-                    import traceback
-                    traceback.print_exc()
-                    time.sleep(1.0)
-            else:
-                time.sleep(0.01)
-        
-        logger.info("[RTC] Inference thread shutting down")
-    except Exception as e:
-        logger.error(f"[RTC] THREAD CRASHED: {e}")
-        import traceback
-        traceback.print_exc()
-
-
-# ============================================================================
-# Main Rollout Loop
-# ============================================================================
-
-@safe_stop_image_writer
-def rac_rtc_rollout_loop(
-    robot: RobotWrapper,
-    teleop: Teleoperator,
-    policy: PreTrainedPolicy,
-    preprocessor,
-    postprocessor,
-    dataset: LeRobotDataset,
-    events: dict,
-    cfg: RaCRTCConfig,
-    queue_holder: dict,
-    obs_holder: dict,  # Main loop writes obs here for RTC thread to read
-    policy_active: Event,
-    hw_features: dict,
-) -> dict:
-    """RaC rollout loop with RTC for smooth policy execution."""
-    fps = cfg.dataset.fps
-    single_task = cfg.dataset.single_task
-    control_time_s = cfg.dataset.episode_time_s
-    device = get_safe_torch_device(cfg.device)
-    
-    # Reset policy state
-    policy.reset()
-    preprocessor.reset()
-    postprocessor.reset()
-    
-    frame_buffer = []
-    stats = {
-        "total_frames": 0,
-        "autonomous_frames": 0,
-        "paused_frames": 0,
-        "correction_frames": 0,
-    }
-
-    teleop.disable_torque()
-    was_paused = False
-    waiting_for_takeover = False
-    
-    # Action keys for converting tensor to dict
-    action_keys = [k for k in robot.action_features.keys() if k.endswith(".pos")]
-    
-    # Interpolation state
-    prev_action: Tensor | None = None
-    interpolated_actions: list[Tensor] = []
-    interp_idx = 0
-    
-    if cfg.interpolation:
-        control_interval = 1.0 / (fps * 2)  # 2x rate
-    else:
-        control_interval = 1.0 / fps
-    
-    robot_action = {}
-    timestamp = 0
-    start_t = time.perf_counter()
-
-    while timestamp < control_time_s:
-        loop_start = time.perf_counter()
-
-        if events["exit_early"]:
-            events["exit_early"] = False
-            events["policy_paused"] = False
-            events["correction_active"] = False
-            break
-
-        # State transition: entering paused state
-        if events["policy_paused"] and not was_paused:
-            policy_active.clear()  # Stop RTC inference
-            obs = robot.get_observation()
-            obs_filtered = {k: v for k, v in obs.items() if k in robot.observation_features}
-            robot_pos = {k: v for k, v in obs_filtered.items() if k.endswith(".pos")}
-            print("[RaC] Moving teleop to robot position...")
-            teleop.smooth_move_to(robot_pos, duration_s=2.0, fps=50)
-            print("[RaC] Teleop aligned. Press 'c' to take control.")
-            events["start_next_episode"] = False
-            waiting_for_takeover = True
-            was_paused = True
-            # Reset interpolation
-            prev_action = None
-            interpolated_actions = []
-            interp_idx = 0
-
-        # Wait for takeover
-        if waiting_for_takeover and events["start_next_episode"]:
-            print("[RaC] Taking control...")
-            teleop.disable_torque()
-            events["start_next_episode"] = False
-            events["correction_active"] = True
-            waiting_for_takeover = False
-
-        # Get observation (ONLY the main loop reads from robot!)
-        obs = robot.get_observation()
-        obs_filtered = {k: v for k, v in obs.items() if k in robot.observation_features}
-        obs_frame = build_dataset_frame(dataset.features, obs_filtered, prefix=OBS_STR)
-        
-        # Share observation with RTC thread (thread reads, main loop writes)
-        obs_holder["obs"] = obs_filtered
-
-        if events["correction_active"]:
-            # Human controlling
-            robot_action = teleop.get_action()
-            for key in robot_action:
-                if "gripper" in key:
-                    robot_action[key] = -0.65 * robot_action[key]
-            robot.send_action(robot_action)
-            stats["correction_frames"] += 1
-            
-            action_frame = build_dataset_frame(dataset.features, robot_action, prefix=ACTION)
-            frame = {**obs_frame, **action_frame, "task": single_task}
-            frame_buffer.append(frame)
-            stats["total_frames"] += 1
-            
-        elif waiting_for_takeover:
-            stats["paused_frames"] += 1
-            
-        elif events["policy_paused"]:
-            robot_pos = {k: v for k, v in obs_filtered.items() if k.endswith(".pos")}
-            teleop.send_feedback(robot_pos)
-            stats["paused_frames"] += 1
-            
-        else:
-            # Policy execution with RTC
-            if not policy_active.is_set():
-                policy_active.set()
-                logger.info("[ROLLOUT] Policy activated, waiting for first actions...")
-            
-            action_queue = queue_holder["queue"]
-            
-            # Get action from queue (with interpolation)
-            if interp_idx >= len(interpolated_actions):
-                new_action = action_queue.get() if action_queue else None
-                
-                # Log queue status periodically
-                if stats["autonomous_frames"] == 0 and new_action is None:
-                    qsize = action_queue.qsize() if action_queue else -1
-                    if timestamp < 0.5 or int(timestamp * 10) % 10 == 0:
-                        logger.info(f"[ROLLOUT] Waiting for actions... queue_size={qsize}, obs_set={obs_holder.get('obs') is not None}")
-                
-                if new_action is not None:
-                    current_action = new_action.cpu()
-                    
-                    if cfg.interpolation and prev_action is not None:
-                        mid = prev_action + 0.5 * (current_action - prev_action)
-                        interpolated_actions = [mid, current_action]
-                    else:
-                        interpolated_actions = [current_action]
-                    
-                    prev_action = current_action
-                    interp_idx = 0
-                    
-                    if stats["autonomous_frames"] == 0:
-                        logger.info(f"[ROLLOUT] Got first action! Starting robot motion.")
-            
-            if interp_idx < len(interpolated_actions):
-                action_to_send = interpolated_actions[interp_idx]
-                interp_idx += 1
-                
-                robot_action = {}
-                for i, key in enumerate(action_keys):
-                    if i < len(action_to_send):
-                        robot_action[key] = action_to_send[i].item()
-                
-                robot.send_action(robot_action)
-                stats["autonomous_frames"] += 1
-                
-                # Record at original fps
-                action_frame = build_dataset_frame(dataset.features, robot_action, prefix=ACTION)
-                frame = {**obs_frame, **action_frame, "task": single_task}
-                frame_buffer.append(frame)
-                stats["total_frames"] += 1
-
-        if cfg.display_data:
-            log_rerun_data(observation=obs_filtered, action=robot_action)
-
-        dt = time.perf_counter() - loop_start
-        sleep_time = control_interval - dt
-        if sleep_time > 0:
-            precise_sleep(sleep_time)
-        timestamp = time.perf_counter() - start_t
-
-    policy_active.clear()
-    teleop.disable_torque()
-
-    for frame in frame_buffer:
-        dataset.add_frame(frame)
-
-    return stats
-
-
-def reset_loop(robot: RobotWrapper, teleop: Teleoperator, events: dict, fps: int):
-    """Reset period where human repositions environment."""
-    print("\n" + "=" * 65)
-    print("  [RaC] RESET")
-    print("=" * 65)
-    
-    events["in_reset"] = True
-    events["start_next_episode"] = False
-    
-    obs = robot.get_observation()
-    robot_pos = {k: v for k, v in obs.items() if k.endswith(".pos") and k in robot.observation_features}
-    teleop.smooth_move_to(robot_pos, duration_s=2.0, fps=50)
-    
-    print("  Press any key/pedal to enable teleoperation")
-    while not events["start_next_episode"] and not events["stop_recording"]:
-        precise_sleep(0.05)
-    
-    if events["stop_recording"]:
-        return
-    
-    events["start_next_episode"] = False
-    teleop.disable_torque()
-    print("  Teleop enabled - press any key/pedal to start episode")
-
-    while not events["start_next_episode"] and not events["stop_recording"]:
-        loop_start = time.perf_counter()
-        action = teleop.get_action()
-        for key in action:
-            if "gripper" in key:
-                action[key] = -0.65 * action[key]
-        robot.send_action(action)
-        dt = time.perf_counter() - loop_start
-        precise_sleep(1 / fps - dt)
-    
-    events["in_reset"] = False
-    events["start_next_episode"] = False
-    events["exit_early"] = False
-    events["policy_paused"] = False
-    events["correction_active"] = False
-
-
-# ============================================================================
-# Main Entry Point
-# ============================================================================
-
-@parser.wrap()
-def rac_rtc_collect(cfg: RaCRTCConfig) -> LeRobotDataset:
-    """Main RaC data collection function with RTC."""
-    init_logging()
-    logging.info(pformat(cfg.__dict__))
-
-    if cfg.display_data:
-        init_rerun(session_name="rac_rtc_collection_openarms")
-
-    robot_raw = make_robot_from_config(cfg.robot)
-    teleop = make_teleoperator_from_config(cfg.teleop)
-    
-    teleop_proc, robot_proc, obs_proc = make_identity_processors()
-
-    dataset_features = combine_feature_dicts(
-        aggregate_pipeline_dataset_features(
-            pipeline=teleop_proc,
-            initial_features=create_initial_features(action=robot_raw.action_features),
-            use_videos=cfg.dataset.video,
-        ),
-        aggregate_pipeline_dataset_features(
-            pipeline=obs_proc,
-            initial_features=create_initial_features(observation=robot_raw.observation_features),
-            use_videos=cfg.dataset.video,
-        ),
-    )
-
-    dataset = None
-    listener = None
-    shutdown_event = Event()
-    policy_active = Event()
-    rtc_thread = None
-
-    try:
-        if cfg.resume:
-            dataset = LeRobotDataset(
-                cfg.dataset.repo_id,
-                root=cfg.dataset.root,
-                batch_encoding_size=cfg.dataset.video_encoding_batch_size,
-            )
-            if hasattr(robot_raw, "cameras") and robot_raw.cameras:
-                dataset.start_image_writer(
-                    num_processes=cfg.dataset.num_image_writer_processes,
-                    num_threads=cfg.dataset.num_image_writer_threads_per_camera * len(robot_raw.cameras),
-                )
-        else:
-            dataset = LeRobotDataset.create(
-                cfg.dataset.repo_id,
-                cfg.dataset.fps,
-                root=cfg.dataset.root,
-                robot_type=robot_raw.name,
-                features=dataset_features,
-                use_videos=cfg.dataset.video,
-                image_writer_processes=cfg.dataset.num_image_writer_processes,
-                image_writer_threads=cfg.dataset.num_image_writer_threads_per_camera
-                * len(robot_raw.cameras if hasattr(robot_raw, "cameras") else []),
-                batch_encoding_size=cfg.dataset.video_encoding_batch_size,
-            )
-
-        # Load policy
-        logger.info(f"Loading policy from: {cfg.policy.pretrained_path}")
-        policy_class = get_policy_class(cfg.policy.type)
-        policy = policy_class.from_pretrained(cfg.policy.pretrained_path)
-        policy.config.rtc_config = cfg.rtc
-        policy.init_rtc_processor()
-        policy = policy.to(cfg.device)
-        policy.eval()
-        logger.info(f"Policy loaded: {policy.name}")
-
-        # Setup preprocessor/postprocessor
-        hw_features = hw_to_dataset_features(robot_raw.observation_features, "observation")
-        preprocessor, postprocessor = make_pre_post_processors(
-            policy_cfg=cfg.policy,
-            pretrained_path=cfg.policy.pretrained_path,
-            dataset_stats=rename_stats(dataset.meta.stats, cfg.dataset.rename_map),
-            preprocessor_overrides={
-                "device_processor": {"device": cfg.device},
-                "rename_observations_processor": {"rename_map": cfg.dataset.rename_map},
-            },
-        )
-
-        # Connect robot and wrap for thread safety
-        robot_raw.connect()
-        robot = RobotWrapper(robot_raw)
-        
-        teleop.connect()
-        listener, events = init_rac_keyboard_listener()
-
-        # Shared state holders (main loop writes, RTC thread reads)
-        queue_holder = {"queue": ActionQueue(cfg.rtc)}
-        obs_holder = {"obs": None, "robot_type": robot.robot_type}  # Main loop updates obs
-
-        # Start RTC inference thread
-        # NOTE: Thread does NOT access robot directly - reads from obs_holder
-        rtc_thread = Thread(
-            target=rtc_inference_thread,
-            args=(
-                policy,
-                obs_holder,  # Thread reads obs from here (set by main loop)
-                hw_features,
-                preprocessor,
-                postprocessor,
-                queue_holder,
-                shutdown_event,
-                policy_active,
-                cfg,
-            ),
-            daemon=True,
-            name="RTCInference",
-        )
-        rtc_thread.start()
-        logger.info("Started RTC inference thread")
-
-        print("\n" + "=" * 65)
-        print("  RaC Data Collection with RTC")
-        print("=" * 65)
-        print(f"  Policy: {cfg.policy.pretrained_path}")
-        print(f"  Task: {cfg.dataset.single_task}")
-        print(f"  FPS: {cfg.dataset.fps}")
-        print(f"  Interpolation: {cfg.interpolation}")
-        print()
-        print("  Controls:")
-        print("    SPACE  - Pause policy")
-        print("    c      - Take control")
-        print("    →      - End episode")
-        print("    ESC    - Stop and push to hub")
-        print("=" * 65 + "\n")
-
-        with VideoEncodingManager(dataset):
-            recorded = 0
-            while recorded < cfg.dataset.num_episodes and not events["stop_recording"]:
-                log_say(f"RaC episode {dataset.num_episodes}", cfg.play_sounds)
-                
-                # Fresh action queue per episode (update holder so thread sees it)
-                queue_holder["queue"] = ActionQueue(cfg.rtc)
-                
-                logger.info(f"Episode {recorded + 1} / {cfg.dataset.num_episodes}")
-
-                stats = rac_rtc_rollout_loop(
-                    robot=robot,
-                    teleop=teleop,
-                    policy=policy,
-                    preprocessor=preprocessor,
-                    postprocessor=postprocessor,
-                    dataset=dataset,
-                    events=events,
-                    cfg=cfg,
-                    queue_holder=queue_holder,
-                    obs_holder=obs_holder,
-                    policy_active=policy_active,
-                    hw_features=hw_features,
-                )
-
-                logging.info(f"Episode stats: {stats}")
-
-                if events["rerecord_episode"]:
-                    log_say("Re-recording", cfg.play_sounds)
-                    events["rerecord_episode"] = False
-                    events["exit_early"] = False
-                    dataset.clear_episode_buffer()
-                    continue
-
-                dataset.save_episode()
-                recorded += 1
-
-                if recorded < cfg.dataset.num_episodes and not events["stop_recording"]:
-                    reset_loop(robot, teleop, events, cfg.dataset.fps)
-
-    finally:
-        log_say("Stop recording", cfg.play_sounds, blocking=True)
-        
-        shutdown_event.set()
-        policy_active.clear()
-        
-        if rtc_thread and rtc_thread.is_alive():
-            rtc_thread.join(timeout=2.0)
-
-        if dataset:
-            dataset.finalize()
-
-        if robot_raw.is_connected:
-            robot_raw.disconnect()
-        if teleop.is_connected:
-            teleop.disconnect()
-
-        if not is_headless() and listener:
-            listener.stop()
-
-        if cfg.dataset.push_to_hub:
-            dataset.push_to_hub(tags=cfg.dataset.tags, private=cfg.dataset.private)
-
-    return dataset
-
-
-def main():
-    from lerobot.utils.import_utils import register_third_party_plugins
-    register_third_party_plugins()
-    rac_rtc_collect()
-
-
-if __name__ == "__main__":
-    main()

examples/rtc/eval_with_real_robot.py

@@ -94,9 +94,9 @@ from lerobot.rl.process import ProcessSignalHandler
 from lerobot.robots import (  # noqa: F401
     Robot,
     RobotConfig,
+    bi_so_follower,
     koch_follower,
-    so100_follower,
-    so101_follower,
+    so_follower,
 )
 from lerobot.robots.utils import make_robot_from_config
 from lerobot.utils.constants import OBS_IMAGES
@@ -455,7 +455,18 @@ def demo_cli(cfg: RTCDemoConfig):
     if cfg.policy.type == "pi05" or cfg.policy.type == "pi0":
         config.compile_model = cfg.use_torch_compile
 
-    policy = policy_class.from_pretrained(cfg.policy.pretrained_path, config=config)
+    if config.use_peft:
+        from peft import PeftConfig, PeftModel
+
+        peft_pretrained_path = cfg.policy.pretrained_path
+        peft_config = PeftConfig.from_pretrained(peft_pretrained_path)
+
+        policy = policy_class.from_pretrained(
+            pretrained_name_or_path=peft_config.base_model_name_or_path, config=config
+        )
+        policy = PeftModel.from_pretrained(policy, peft_pretrained_path, config=peft_config)
+    else:
+        policy = policy_class.from_pretrained(cfg.policy.pretrained_path, config=config)
 
     # Turn on RTC
     policy.config.rtc_config = cfg.rtc

examples/so100_to_so100_EE/evaluate.py

@@ -34,12 +34,11 @@ from lerobot.processor.converters import (
     transition_to_observation,
     transition_to_robot_action,
 )
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.robot_kinematic_processor import (
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so_follower.robot_kinematic_processor import (
     ForwardKinematicsJointsToEE,
     InverseKinematicsEEToJoints,
 )
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.scripts.lerobot_record import record_loop
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say

examples/so100_to_so100_EE/record.py

@@ -27,16 +27,14 @@ from lerobot.processor.converters import (
     transition_to_observation,
     transition_to_robot_action,
 )
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.robot_kinematic_processor import (
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so_follower.robot_kinematic_processor import (
     EEBoundsAndSafety,
     ForwardKinematicsJointsToEE,
     InverseKinematicsEEToJoints,
 )
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.scripts.lerobot_record import record_loop
-from lerobot.teleoperators.so100_leader.config_so100_leader import SO100LeaderConfig
-from lerobot.teleoperators.so100_leader.so100_leader import SO100Leader
+from lerobot.teleoperators.so_leader import SO100Leader, SO100LeaderConfig
 from lerobot.utils.control_utils import init_keyboard_listener
 from lerobot.utils.utils import log_say
 from lerobot.utils.visualization_utils import init_rerun

examples/so100_to_so100_EE/replay.py

@@ -24,11 +24,10 @@ from lerobot.processor.converters import (
     robot_action_observation_to_transition,
     transition_to_robot_action,
 )
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.robot_kinematic_processor import (
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so_follower.robot_kinematic_processor import (
     InverseKinematicsEEToJoints,
 )
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
 from lerobot.utils.constants import ACTION
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.utils import log_say
@@ -97,7 +96,7 @@ def main():
         # Send action to robot
         _ = robot.send_action(joint_action)
 
-        precise_sleep(1.0 / dataset.fps - (time.perf_counter() - t0))
+        precise_sleep(max(1.0 / dataset.fps - (time.perf_counter() - t0), 0.0))
 
     # Clean up
     robot.disconnect()

examples/so100_to_so100_EE/teleoperate.py

@@ -23,15 +23,13 @@ from lerobot.processor.converters import (
     robot_action_to_transition,
     transition_to_robot_action,
 )
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.robot_kinematic_processor import (
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
+from lerobot.robots.so_follower.robot_kinematic_processor import (
     EEBoundsAndSafety,
     ForwardKinematicsJointsToEE,
     InverseKinematicsEEToJoints,
 )
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
-from lerobot.teleoperators.so100_leader.config_so100_leader import SO100LeaderConfig
-from lerobot.teleoperators.so100_leader.so100_leader import SO100Leader
+from lerobot.teleoperators.so_leader import SO100Leader, SO100LeaderConfig
 from lerobot.utils.robot_utils import precise_sleep
 from lerobot.utils.visualization_utils import init_rerun, log_rerun_data
 

examples/tutorial/act/act_using_example.py

@@ -5,8 +5,7 @@ from lerobot.datasets.lerobot_dataset import LeRobotDatasetMetadata
 from lerobot.policies.act.modeling_act import ACTPolicy
 from lerobot.policies.factory import make_pre_post_processors
 from lerobot.policies.utils import build_inference_frame, make_robot_action
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
 
 MAX_EPISODES = 5
 MAX_STEPS_PER_EPISODE = 20

examples/tutorial/async-inf/robot_client.py

@@ -4,7 +4,7 @@ from lerobot.async_inference.configs import RobotClientConfig
 from lerobot.async_inference.helpers import visualize_action_queue_size
 from lerobot.async_inference.robot_client import RobotClient
 from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
-from lerobot.robots.so100_follower import SO100FollowerConfig
+from lerobot.robots.so_follower import SO100FollowerConfig
 
 
 def main():

examples/tutorial/diffusion/diffusion_using_example.py

@@ -5,8 +5,7 @@ from lerobot.datasets.lerobot_dataset import LeRobotDatasetMetadata
 from lerobot.policies.diffusion.modeling_diffusion import DiffusionPolicy
 from lerobot.policies.factory import make_pre_post_processors
 from lerobot.policies.utils import build_inference_frame, make_robot_action
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
 
 MAX_EPISODES = 5
 MAX_STEPS_PER_EPISODE = 20

examples/tutorial/pi0/using_pi0_example.py

@@ -5,8 +5,7 @@ from lerobot.datasets.utils import hw_to_dataset_features
 from lerobot.policies.factory import make_pre_post_processors
 from lerobot.policies.pi0.modeling_pi0 import PI0Policy
 from lerobot.policies.utils import build_inference_frame, make_robot_action
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
 
 MAX_EPISODES = 5
 MAX_STEPS_PER_EPISODE = 20

examples/tutorial/rl/hilserl_example.py

@@ -14,8 +14,8 @@ from lerobot.policies.sac.modeling_sac import SACPolicy
 from lerobot.policies.sac.reward_model.modeling_classifier import Classifier
 from lerobot.rl.buffer import ReplayBuffer
 from lerobot.rl.gym_manipulator import make_robot_env
-from lerobot.robots.so100_follower import SO100FollowerConfig
-from lerobot.teleoperators.so100_leader import SO100LeaderConfig
+from lerobot.robots.so_follower import SO100FollowerConfig
+from lerobot.teleoperators.so_leader import SO100LeaderConfig
 from lerobot.teleoperators.utils import TeleopEvents
 
 LOG_EVERY = 10

examples/tutorial/smolvla/using_smolvla_example.py

@@ -5,8 +5,7 @@ from lerobot.datasets.utils import hw_to_dataset_features
 from lerobot.policies.factory import make_pre_post_processors
 from lerobot.policies.smolvla.modeling_smolvla import SmolVLAPolicy
 from lerobot.policies.utils import build_inference_frame, make_robot_action
-from lerobot.robots.so100_follower.config_so100_follower import SO100FollowerConfig
-from lerobot.robots.so100_follower.so100_follower import SO100Follower
+from lerobot.robots.so_follower import SO100Follower, SO100FollowerConfig
 
 MAX_EPISODES = 5
 MAX_STEPS_PER_EPISODE = 20

examples/unitree_g1/gr00t_locomotion.py

@@ -13,16 +13,9 @@
 # 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.
-"""
-Example: GR00T Locomotion with Pre-loaded Policies
-
-This example demonstrates the NEW pattern for loading GR00T policies externally
-and passing them to the robot class.
-"""
 
 import argparse
 import logging
-import threading
 import time
 from collections import deque
 
@@ -31,24 +24,26 @@ import onnxruntime as ort
 from huggingface_hub import hf_hub_download
 
 from lerobot.robots.unitree_g1.config_unitree_g1 import UnitreeG1Config
+from lerobot.robots.unitree_g1.g1_utils import G1_29_JointIndex
 from lerobot.robots.unitree_g1.unitree_g1 import UnitreeG1
 
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+
 GROOT_DEFAULT_ANGLES = np.zeros(29, dtype=np.float32)
-GROOT_DEFAULT_ANGLES[[0, 6]] = -0.1  # hip pitch
-GROOT_DEFAULT_ANGLES[[3, 9]] = 0.3  # knee
-GROOT_DEFAULT_ANGLES[[4, 10]] = -0.2  # ankle pitch
+GROOT_DEFAULT_ANGLES[[0, 6]] = -0.1  # Hip pitch
+GROOT_DEFAULT_ANGLES[[3, 9]] = 0.3  # Knee
+GROOT_DEFAULT_ANGLES[[4, 10]] = -0.2  # Ankle pitch
 
 MISSING_JOINTS = []
-G1_MODEL = "g1_23"  # or "g1_29"
+G1_MODEL = "g1_23"  # Or "g1_29"
 if G1_MODEL == "g1_23":
-    MISSING_JOINTS = [12, 14, 20, 21, 27, 28]  # waist yaw/pitch, wrist pitch/yaw
-
-LOCOMOTION_ACTION_SCALE = 0.25
-
-LOCOMOTION_CONTROL_DT = 0.02
+    MISSING_JOINTS = [12, 14, 20, 21, 27, 28]  # Waist yaw/pitch, wrist pitch/yaw
 
+# Control parameters
+ACTION_SCALE = 0.25
+CONTROL_DT = 0.02  # 50Hz
 ANG_VEL_SCALE: float = 0.25
 DOF_POS_SCALE: float = 1.0
 DOF_VEL_SCALE: float = 0.05
@@ -61,12 +56,12 @@ DEFAULT_GROOT_REPO_ID = "nepyope/GR00T-WholeBodyControl_g1"
 def load_groot_policies(
     repo_id: str = DEFAULT_GROOT_REPO_ID,
 ) -> tuple[ort.InferenceSession, ort.InferenceSession]:
-    """Load GR00T dual-policy system (Balance + Walk) from Hugging Face Hub.
+    """Load GR00T dual-policy system (Balance + Walk) from the hub.
 
     Args:
         repo_id: Hugging Face Hub repository ID containing the ONNX policies.
     """
-    logger.info(f"Loading GR00T dual-policy system from Hugging Face Hub ({repo_id})...")
+    logger.info(f"Loading GR00T dual-policy system from the hub ({repo_id})...")
 
     # Download ONNX policies from Hugging Face Hub
     balance_path = hf_hub_download(
@@ -88,15 +83,7 @@ def load_groot_policies(
 
 
 class GrootLocomotionController:
-    """
-    Handles GR00T-style locomotion control for the Unitree G1 robot.
-
-    This controller manages:
-    - Dual-policy system (Balance + Walk)
-    - 29-joint observation processing
-    - 15D action output (legs + waist)
-    - Policy inference and motor command generation
-    """
+    """GR00T lower-body locomotion controller for the Unitree G1."""
 
     def __init__(self, policy_balance, policy_walk, robot, config):
         self.policy_balance = policy_balance
@@ -104,9 +91,9 @@ class GrootLocomotionController:
         self.robot = robot
         self.config = config
 
-        self.locomotion_cmd = np.array([0.0, 0.0, 0.0], dtype=np.float32)  # vx, vy, theta_dot
+        self.cmd = np.array([0.0, 0.0, 0.0], dtype=np.float32)  # vx, vy, theta_dot
 
-        # GR00T-specific state
+        # Robot state
         self.groot_qj_all = np.zeros(29, dtype=np.float32)
         self.groot_dqj_all = np.zeros(29, dtype=np.float32)
         self.groot_action = np.zeros(15, dtype=np.float32)
@@ -116,47 +103,39 @@ class GrootLocomotionController:
         self.groot_height_cmd = 0.74  # Default base height
         self.groot_orientation_cmd = np.array([0.0, 0.0, 0.0], dtype=np.float32)
 
-        # input to gr00t is 6 frames (6*86D=516)
+        # Input to GR00T is 6 frames (6*86D=516)
         for _ in range(6):
             self.groot_obs_history.append(np.zeros(86, dtype=np.float32))
 
-        # Thread management
-        self.locomotion_running = False
-        self.locomotion_thread = None
-
         logger.info("GrootLocomotionController initialized")
 
-    def groot_locomotion_run(self):
-        # get current observation
-        robot_state = self.robot.get_observation()
+    def run_step(self):
+        # Get current observation
+        obs = self.robot.get_observation()
 
-        if robot_state is None:
+        if not obs:
             return
 
-        # get command from remote controller
-        if robot_state.wireless_remote is not None:
-            self.robot.remote_controller.set(robot_state.wireless_remote)
-            if self.robot.remote_controller.button[0]:  # R1 - raise waist
-                self.groot_height_cmd += 0.001
-                self.groot_height_cmd = np.clip(self.groot_height_cmd, 0.50, 1.00)
-            if self.robot.remote_controller.button[4]:  # R2 - lower waist
-                self.groot_height_cmd -= 0.001
-                self.groot_height_cmd = np.clip(self.groot_height_cmd, 0.50, 1.00)
-        else:
-            self.robot.remote_controller.lx = 0.0
-            self.robot.remote_controller.ly = 0.0
-            self.robot.remote_controller.rx = 0.0
-            self.robot.remote_controller.ry = 0.0
+        # Get command from remote controller
+        if obs["remote.buttons"][0]:  # R1 - raise waist
+            self.groot_height_cmd += 0.001
+            self.groot_height_cmd = np.clip(self.groot_height_cmd, 0.50, 1.00)
+        if obs["remote.buttons"][4]:  # R2 - lower waist
+            self.groot_height_cmd -= 0.001
+            self.groot_height_cmd = np.clip(self.groot_height_cmd, 0.50, 1.00)
 
-        self.locomotion_cmd[0] = self.robot.remote_controller.ly  # forward/backward
-        self.locomotion_cmd[1] = self.robot.remote_controller.lx * -1  # left/right
-        self.locomotion_cmd[2] = self.robot.remote_controller.rx * -1  # rotation rate
+        self.cmd[0] = obs["remote.ly"]  # Forward/backward
+        self.cmd[1] = obs["remote.lx"] * -1  # Left/right
+        self.cmd[2] = obs["remote.rx"] * -1  # Rotation rate
 
-        for i in range(29):
-            self.groot_qj_all[i] = robot_state.motor_state[i].q
-            self.groot_dqj_all[i] = robot_state.motor_state[i].dq
+        # Get joint positions and velocities from flat dict
+        for motor in G1_29_JointIndex:
+            name = motor.name
+            idx = motor.value
+            self.groot_qj_all[idx] = obs[f"{name}.q"]
+            self.groot_dqj_all[idx] = obs[f"{name}.dq"]
 
-        # adapt observation for g1_23dof
+        # Adapt observation for g1_23dof
         for idx in MISSING_JOINTS:
             self.groot_qj_all[idx] = 0.0
             self.groot_dqj_all[idx] = 0.0
@@ -165,18 +144,18 @@ class GrootLocomotionController:
         qj_obs = self.groot_qj_all.copy()
         dqj_obs = self.groot_dqj_all.copy()
 
-        # express imu data in gravity frame of reference
-        quat = robot_state.imu_state.quaternion
-        ang_vel = np.array(robot_state.imu_state.gyroscope, dtype=np.float32)
+        # Express IMU data in gravity frame of reference
+        quat = [obs["imu.quat.w"], obs["imu.quat.x"], obs["imu.quat.y"], obs["imu.quat.z"]]
+        ang_vel = np.array([obs["imu.gyro.x"], obs["imu.gyro.y"], obs["imu.gyro.z"]], dtype=np.float32)
         gravity_orientation = self.robot.get_gravity_orientation(quat)
 
-        # scale joint positions and velocities before policy inference
+        # Scale joint positions and velocities before policy inference
         qj_obs = (qj_obs - GROOT_DEFAULT_ANGLES) * DOF_POS_SCALE
         dqj_obs = dqj_obs * DOF_VEL_SCALE
         ang_vel_scaled = ang_vel * ANG_VEL_SCALE
 
-        # build single frame observation
-        self.groot_obs_single[:3] = self.locomotion_cmd * np.array(CMD_SCALE)
+        # Build single frame observation
+        self.groot_obs_single[:3] = self.cmd * np.array(CMD_SCALE)
         self.groot_obs_single[3] = self.groot_height_cmd
         self.groot_obs_single[4:7] = self.groot_orientation_cmd
         self.groot_obs_single[7:10] = ang_vel_scaled
@@ -194,113 +173,76 @@ class GrootLocomotionController:
             end_idx = start_idx + 86
             self.groot_obs_stacked[start_idx:end_idx] = obs_frame
 
-        # Run policy inference (ONNX) with 516D stacked observation
-
-        cmd_magnitude = np.linalg.norm(self.locomotion_cmd)
-
+        cmd_magnitude = np.linalg.norm(self.cmd)
         selected_policy = (
             self.policy_balance if cmd_magnitude < 0.05 else self.policy_walk
-        )  # balance/standing policy for small commands, walking policy for movement commands
+        )  # Balance/standing policy for small commands, walking policy for movement commands
 
-        # run policy inference
+        # Run policy inference
         ort_inputs = {selected_policy.get_inputs()[0].name: np.expand_dims(self.groot_obs_stacked, axis=0)}
         ort_outs = selected_policy.run(None, ort_inputs)
         self.groot_action = ort_outs[0].squeeze()
 
-        # transform action back to target joint positions
-        target_dof_pos_15 = GROOT_DEFAULT_ANGLES[:15] + self.groot_action * LOCOMOTION_ACTION_SCALE
+        # Transform action back to target joint positions
+        target_dof_pos_15 = GROOT_DEFAULT_ANGLES[:15] + self.groot_action * ACTION_SCALE
 
-        # command motors
+        # Build action dict (only first 15 joints for GR00T)
+        action_dict = {}
         for i in range(15):
-            motor_idx = i
-            self.robot.msg.motor_cmd[motor_idx].q = target_dof_pos_15[i]
-            self.robot.msg.motor_cmd[motor_idx].qd = 0
-            self.robot.msg.motor_cmd[motor_idx].kp = self.robot.kp[motor_idx]
-            self.robot.msg.motor_cmd[motor_idx].kd = self.robot.kd[motor_idx]
-            self.robot.msg.motor_cmd[motor_idx].tau = 0
+            motor_name = G1_29_JointIndex(i).name
+            action_dict[f"{motor_name}.q"] = float(target_dof_pos_15[i])
 
-        # adapt action for g1_23dof
+        # Zero out missing joints for g1_23dof
         for joint_idx in MISSING_JOINTS:
-            self.robot.msg.motor_cmd[joint_idx].q = 0.0
-            self.robot.msg.motor_cmd[joint_idx].qd = 0
-            self.robot.msg.motor_cmd[joint_idx].kp = self.robot.kp[joint_idx]
-            self.robot.msg.motor_cmd[joint_idx].kd = self.robot.kd[joint_idx]
-            self.robot.msg.motor_cmd[joint_idx].tau = 0
+            motor_name = G1_29_JointIndex(joint_idx).name
+            action_dict[f"{motor_name}.q"] = 0.0
 
-        # send action to robot
-        self.robot.send_action(self.robot.msg)
+        # Send action to robot
+        self.robot.send_action(action_dict)
 
-    def _locomotion_thread_loop(self):
-        """Background thread that runs the locomotion policy at specified rate."""
-        logger.info("Locomotion thread started")
-        while self.locomotion_running:
+
+def run(repo_id: str = DEFAULT_GROOT_REPO_ID) -> None:
+    """Main function to run the GR00T locomotion controller.
+
+    Args:
+        repo_id: Hugging Face Hub repository ID for GR00T policies.
+    """
+    # Load policies
+    policy_balance, policy_walk = load_groot_policies(repo_id=repo_id)
+
+    # Initialize robot
+    config = UnitreeG1Config()
+    robot = UnitreeG1(config)
+
+    robot.connect()
+
+    # Initialize gr00T locomotion controller
+    groot_controller = GrootLocomotionController(
+        policy_balance=policy_balance,
+        policy_walk=policy_walk,
+        robot=robot,
+        config=config,
+    )
+
+    try:
+        robot.reset(CONTROL_DT, GROOT_DEFAULT_ANGLES)
+
+        logger.info("Use joystick: LY=fwd/back, LX=left/right, RX=rotate, R1=raise waist, R2=lower waist")
+        logger.info("Press Ctrl+C to stop")
+
+        # Run step
+        while not robot._shutdown_event.is_set():
             start_time = time.time()
-            try:
-                self.groot_locomotion_run()
-            except Exception as e:
-                logger.error(f"Error in locomotion loop: {e}")
-
-            # Sleep to maintain control rate
+            groot_controller.run_step()
             elapsed = time.time() - start_time
-            sleep_time = max(0, LOCOMOTION_CONTROL_DT - elapsed)
+            sleep_time = max(0, CONTROL_DT - elapsed)
             time.sleep(sleep_time)
-        logger.info("Locomotion thread stopped")
-
-    def start_locomotion_thread(self):
-        if self.locomotion_running:
-            logger.warning("Locomotion thread already running")
-            return
-
-        logger.info("Starting locomotion control thread...")
-        self.locomotion_running = True
-        self.locomotion_thread = threading.Thread(target=self._locomotion_thread_loop, daemon=True)
-        self.locomotion_thread.start()
-
-        logger.info("Locomotion control thread started!")
-
-    def stop_locomotion_thread(self):
-        if not self.locomotion_running:
-            return
-
-        logger.info("Stopping locomotion control thread...")
-        self.locomotion_running = False
-        if self.locomotion_thread:
-            self.locomotion_thread.join(timeout=2.0)
-        logger.info("Locomotion control thread stopped")
-
-    def reset_robot(self):
-        """Move robot legs to default standing position over 2 seconds (arms are not moved)."""
-        total_time = 3.0
-        num_step = int(total_time / self.robot.control_dt)
-
-        # Only control legs, not arms (first 12 joints)
-        default_pos = GROOT_DEFAULT_ANGLES  # First 12 values are leg angles
-        dof_size = len(default_pos)
-
-        # Get current lowstate
-        robot_state = self.robot.get_observation()
-
-        # Record the current leg positions
-        init_dof_pos = np.zeros(dof_size, dtype=np.float32)
-        for i in range(dof_size):
-            init_dof_pos[i] = robot_state.motor_state[i].q
-
-        # Move legs to default pos
-        for i in range(num_step):
-            alpha = i / num_step
-            for motor_idx in range(dof_size):
-                target_pos = default_pos[motor_idx]
-                self.robot.msg.motor_cmd[motor_idx].q = (
-                    init_dof_pos[motor_idx] * (1 - alpha) + target_pos * alpha
-                )
-                self.robot.msg.motor_cmd[motor_idx].qd = 0
-                self.robot.msg.motor_cmd[motor_idx].kp = self.robot.kp[motor_idx]
-                self.robot.msg.motor_cmd[motor_idx].kd = self.robot.kd[motor_idx]
-                self.robot.msg.motor_cmd[motor_idx].tau = 0
-            self.robot.msg.crc = self.robot.crc.Crc(self.robot.msg)
-            self.robot.lowcmd_publisher.Write(self.robot.msg)
-            time.sleep(self.robot.control_dt)
-        logger.info("Reached default position (legs only)")
+    except KeyboardInterrupt:
+        logger.info("Stopping locomotion...")
+    finally:
+        if robot.is_connected:
+            robot.disconnect()
+        logger.info("Done!")
 
 
 if __name__ == "__main__":
@@ -313,35 +255,4 @@ if __name__ == "__main__":
     )
     args = parser.parse_args()
 
-    # load policies
-    policy_balance, policy_walk = load_groot_policies(repo_id=args.repo_id)
-
-    # initialize robot
-    config = UnitreeG1Config()
-    robot = UnitreeG1(config)
-
-    # initialize gr00t locomotion controller
-    groot_controller = GrootLocomotionController(
-        policy_balance=policy_balance,
-        policy_walk=policy_walk,
-        robot=robot,
-        config=config,
-    )
-
-    # reset legs and start locomotion thread
-    try:
-        groot_controller.reset_robot()
-        groot_controller.start_locomotion_thread()
-
-        # log status
-        logger.info("Robot initialized with GR00T locomotion policies")
-        logger.info("Locomotion controller running in background thread")
-        logger.info("Press Ctrl+C to stop")
-
-        # keep robot alive
-        while True:
-            time.sleep(1.0)
-    except KeyboardInterrupt:
-        print("\nStopping locomotion...")
-        groot_controller.stop_locomotion_thread()
-        print("Done!")
+    run(repo_id=args.repo_id)

examples/unitree_g1/holosoma_locomotion.py

@@ -0,0 +1,264 @@
+#!/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 argparse
+import json
+import logging
+import time
+
+import numpy as np
+import onnx
+import onnxruntime as ort
+from huggingface_hub import hf_hub_download
+
+from lerobot.robots.unitree_g1.config_unitree_g1 import UnitreeG1Config
+from lerobot.robots.unitree_g1.g1_utils import G1_29_JointIndex
+from lerobot.robots.unitree_g1.unitree_g1 import UnitreeG1
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+DEFAULT_ANGLES = np.zeros(29, dtype=np.float32)
+DEFAULT_ANGLES[[0, 6]] = -0.312  # Hip pitch
+DEFAULT_ANGLES[[3, 9]] = 0.669  # Knee
+DEFAULT_ANGLES[[4, 10]] = -0.363  # Ankle pitch
+DEFAULT_ANGLES[[15, 22]] = 0.2  # Shoulder pitch
+DEFAULT_ANGLES[16] = 0.2  # Left shoulder roll
+DEFAULT_ANGLES[23] = -0.2  # Right shoulder roll
+DEFAULT_ANGLES[[18, 25]] = 0.6  # Elbow
+
+MISSING_JOINTS = []
+G1_MODEL = "g1_23"  # Or "g1_29"
+if G1_MODEL == "g1_23":
+    MISSING_JOINTS = [12, 14, 20, 21, 27, 28]  # Waist yaw/pitch, wrist pitch/yaw
+
+# Control parameters
+ACTION_SCALE = 0.25
+CONTROL_DT = 0.02  # 50Hz
+ANG_VEL_SCALE = 0.25
+DOF_POS_SCALE = 1.0
+DOF_VEL_SCALE = 0.05
+GAIT_PERIOD = 1.0
+
+
+DEFAULT_HOLOSOMA_REPO_ID = "nepyope/holosoma_locomotion"
+
+# Policy filename mapping
+POLICY_FILES = {
+    "fastsac": "fastsac_g1_29dof.onnx",
+    "ppo": "ppo_g1_29dof.onnx",
+}
+
+
+def load_policy(
+    repo_id: str = DEFAULT_HOLOSOMA_REPO_ID,
+    policy_type: str = "fastsac",
+) -> tuple[ort.InferenceSession, np.ndarray, np.ndarray]:
+    """Load Holosoma locomotion policy and extract KP/KD from metadata.
+
+    Args:
+        repo_id: Hugging Face Hub repo ID
+        policy_type: Either "fastsac" (default) or "ppo"
+
+    Returns:
+        (policy, kp, kd) tuple
+    """
+    if policy_type not in POLICY_FILES:
+        raise ValueError(f"Unknown policy type: {policy_type}. Choose from: {list(POLICY_FILES.keys())}")
+
+    filename = POLICY_FILES[policy_type]
+    logger.info(f"Loading {policy_type.upper()} policy from: {repo_id}/{filename}")
+    policy_path = hf_hub_download(repo_id=repo_id, filename=filename)
+
+    policy = ort.InferenceSession(policy_path)
+    logger.info(f"Policy loaded: {policy.get_inputs()[0].shape} → {policy.get_outputs()[0].shape}")
+
+    # Extract KP/KD from ONNX metadata
+    model = onnx.load(policy_path)
+    metadata = {prop.key: prop.value for prop in model.metadata_props}
+
+    if "kp" not in metadata or "kd" not in metadata:
+        raise ValueError("ONNX model must contain 'kp' and 'kd' in metadata")
+
+    kp = np.array(json.loads(metadata["kp"]), dtype=np.float32)
+    kd = np.array(json.loads(metadata["kd"]), dtype=np.float32)
+    logger.info(f"Loaded KP/KD from ONNX ({len(kp)} joints)")
+
+    return policy, kp, kd
+
+
+class HolosomaLocomotionController:
+    """Holosoma whole-body locomotion controller for Unitree G1."""
+
+    def __init__(self, policy, robot, kp: np.ndarray, kd: np.ndarray):
+        self.policy = policy
+        self.robot = robot
+
+        # Override robot's PD gains with policy gains
+        self.robot.kp = kp
+        self.robot.kd = kd
+
+        self.cmd = np.zeros(3, dtype=np.float32)
+
+        # Robot state
+        self.qj = np.zeros(29, dtype=np.float32)
+        self.dqj = np.zeros(29, dtype=np.float32)
+        self.obs = np.zeros(100, dtype=np.float32)
+        self.last_action = np.zeros(29, dtype=np.float32)
+
+        # Gait phase
+        self.phase = np.array([[0.0, np.pi]], dtype=np.float32)
+        self.phase_dt = 2 * np.pi / ((1.0 / CONTROL_DT) * GAIT_PERIOD)
+        self.is_standing = True
+
+    def run_step(self):
+        # Get current observation
+        obs = self.robot.get_observation()
+
+        if not obs:
+            return
+
+        # Get command from remote controller
+        ly = obs["remote.ly"] if abs(obs["remote.ly"]) > 0.1 else 0.0
+        lx = obs["remote.lx"] if abs(obs["remote.lx"]) > 0.1 else 0.0
+        rx = obs["remote.rx"] if abs(obs["remote.rx"]) > 0.1 else 0.0
+        self.cmd[:] = [ly, -lx, -rx]
+
+        # Get joint positions and velocities
+        for motor in G1_29_JointIndex:
+            name = motor.name
+            idx = motor.value
+            self.qj[idx] = obs[f"{name}.q"]
+            self.dqj[idx] = obs[f"{name}.dq"]
+
+        # Adapt observation for g1_23dof
+        for idx in MISSING_JOINTS:
+            self.qj[idx] = 0.0
+            self.dqj[idx] = 0.0
+
+        # Express IMU data in gravity frame of reference
+        quat = [obs["imu.quat.w"], obs["imu.quat.x"], obs["imu.quat.y"], obs["imu.quat.z"]]
+        ang_vel = np.array([obs["imu.gyro.x"], obs["imu.gyro.y"], obs["imu.gyro.z"]], dtype=np.float32)
+        gravity = self.robot.get_gravity_orientation(quat)
+
+        # Scale joint positions and velocities before policy inference
+        qj_obs = (self.qj - DEFAULT_ANGLES) * DOF_POS_SCALE
+        dqj_obs = self.dqj * DOF_VEL_SCALE
+        ang_vel_s = ang_vel * ANG_VEL_SCALE
+
+        # Update gait phase
+        if np.linalg.norm(self.cmd[:2]) < 0.01 and abs(self.cmd[2]) < 0.01:
+            self.phase[0, :] = np.pi
+            self.is_standing = True
+        elif self.is_standing:
+            self.phase = np.array([[0.0, np.pi]], dtype=np.float32)
+            self.is_standing = False
+        else:
+            self.phase = np.fmod(self.phase + self.phase_dt + np.pi, 2 * np.pi) - np.pi
+
+        sin_ph = np.sin(self.phase[0])
+        cos_ph = np.cos(self.phase[0])
+
+        # Build observations
+        self.obs[0:29] = self.last_action
+        self.obs[29:32] = ang_vel_s
+        self.obs[32] = self.cmd[2]
+        self.obs[33:35] = self.cmd[:2]
+        self.obs[35:37] = cos_ph
+        self.obs[37:66] = qj_obs
+        self.obs[66:95] = dqj_obs
+        self.obs[95:98] = gravity
+        self.obs[98:100] = sin_ph
+
+        # Run policy inference
+        ort_in = {self.policy.get_inputs()[0].name: self.obs.reshape(1, -1).astype(np.float32)}
+        raw_action = self.policy.run(None, ort_in)[0].squeeze()
+        action = np.clip(raw_action, -100.0, 100.0)
+        self.last_action = action.copy()
+
+        # Transform action back to target joint positions
+        target = DEFAULT_ANGLES + action * ACTION_SCALE
+
+        # Build action dict
+        action_dict = {}
+        for motor in G1_29_JointIndex:
+            action_dict[f"{motor.name}.q"] = float(target[motor.value])
+
+        # Zero out missing joints for g1_23dof
+        for joint_idx in MISSING_JOINTS:
+            motor_name = G1_29_JointIndex(joint_idx).name
+            action_dict[f"{motor_name}.q"] = 0.0
+
+        # Send action to robot
+        self.robot.send_action(action_dict)
+
+
+def run(repo_id: str = DEFAULT_HOLOSOMA_REPO_ID, policy_type: str = "fastsac") -> None:
+    """Main function to run the Holosoma locomotion controller.
+
+    Args:
+        repo_id: Hugging Face Hub repository ID for Holosoma policies.
+        policy_type: Policy type to use ('fastsac' or 'ppo').
+    """
+    # Load policy and gains
+    policy, kp, kd = load_policy(repo_id=repo_id, policy_type=policy_type)
+
+    # Initialize robot
+    config = UnitreeG1Config()
+    robot = UnitreeG1(config)
+    robot.connect()
+
+    holosoma_controller = HolosomaLocomotionController(policy, robot, kp, kd)
+
+    try:
+        robot.reset(CONTROL_DT, DEFAULT_ANGLES)
+
+        logger.info("Use joystick: LY=fwd/back, LX=left/right, RX=rotate")
+        logger.info("Press Ctrl+C to stop")
+
+        # Run step
+        while not robot._shutdown_event.is_set():
+            start_time = time.time()
+            holosoma_controller.run_step()
+            elapsed = time.time() - start_time
+            sleep_time = max(0, CONTROL_DT - elapsed)
+            time.sleep(sleep_time)
+    except KeyboardInterrupt:
+        logger.info("Stopping locomotion...")
+    finally:
+        if robot.is_connected:
+            robot.disconnect()
+        logger.info("Done!")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Holosoma Locomotion Controller for Unitree G1")
+    parser.add_argument(
+        "--repo-id",
+        type=str,
+        default=DEFAULT_HOLOSOMA_REPO_ID,
+        help=f"Hugging Face Hub repo ID for Holosoma policies (default: {DEFAULT_HOLOSOMA_REPO_ID})",
+    )
+    parser.add_argument(
+        "--policy",
+        type=str,
+        choices=["fastsac", "ppo"],
+        default="fastsac",
+        help="Policy type to use: 'fastsac' (default) or 'ppo'",
+    )
+    args = parser.parse_args()
+
+    run(repo_id=args.repo_id, policy_type=args.policy)

loop_datasets.py

@@ -1,10 +0,0 @@
-from huggingface_hub import HfApi, list_datasets
-
-api = HfApi()
-datasets = list_datasets(author="lerobot-data-collection")
-print('"[', end="")
-i=0
-for dataset in datasets:
-    if "three-folds-dataset" in dataset.id:
-        print("'" + dataset.id + "',", end="")
-print(']"',)

pyproject.toml

@@ -27,7 +27,7 @@ discord = "https://discord.gg/s3KuuzsPFb"
 name = "lerobot"
 version = "0.4.3"
 description = "🤗 LeRobot: State-of-the-art Machine Learning for Real-World Robotics in Pytorch"
-readme = "README.md"
+dynamic = ["readme"]
 license = { text = "Apache-2.0" }
 requires-python = ">=3.10"
 authors = [
@@ -74,7 +74,7 @@ dependencies = [
     "packaging>=24.2,<26.0",
     "pynput>=1.7.7,<1.9.0",
     "pyserial>=3.5,<4.0",
-    "wandb>=0.20.0,<0.22.0", # TODO: Bumb dependency (compatible with protobuf)
+    "wandb>=0.24.0,<0.25.0",
 
     "torch>=2.2.1,<2.8.0", # TODO: Bumb dependency
     "torchcodec>=0.2.1,<0.6.0; sys_platform != 'win32' and (sys_platform != 'linux' or (platform_machine != 'aarch64' and platform_machine != 'arm64' and platform_machine != 'armv7l')) and (sys_platform != 'darwin' or platform_machine != 'x86_64')", # TODO: Bumb dependency
@@ -97,7 +97,7 @@ dependencies = [
 pygame-dep = ["pygame>=2.5.1,<2.7.0"]
 placo-dep = ["placo>=0.9.6,<0.10.0"]
 transformers-dep = ["transformers>=4.57.1,<5.0.0"]
-grpcio-dep = ["grpcio==1.73.1", "protobuf==6.31.0"] # TODO: Bumb dependency (compatible with wandb)
+grpcio-dep = ["grpcio==1.73.1", "protobuf>=6.31.1,<6.32.0"]
 
 # Motors
 feetech = ["feetech-servo-sdk>=1.0.0,<2.0.0"]
@@ -109,9 +109,9 @@ hopejr = ["lerobot[feetech]", "lerobot[pygame-dep]"]
 lekiwi = ["lerobot[feetech]", "pyzmq>=26.2.1,<28.0.0"]
 unitree_g1 = [
     "pyzmq>=26.2.1,<28.0.0",
-    "onnxruntime>=1.16.0"
+    "onnxruntime>=1.16.0,<2.0.0"
 ]
-reachy2 = ["reachy2_sdk>=1.0.14,<1.1.0"]
+reachy2 = ["reachy2_sdk>=1.0.15,<1.1.0"]
 kinematics = ["lerobot[placo-dep]"]
 intelrealsense = [
     "pyrealsense2>=2.55.1.6486,<2.57.0 ; sys_platform != 'darwin'",
@@ -127,7 +127,7 @@ wallx = [
     "torchdiffeq==0.2.5",
     "qwen_vl_utils==0.0.11"
 ]
-pi = ["transformers @ git+https://github.com/huggingface/transformers.git@fix/lerobot_openpi"]
+pi = ["transformers @ git+https://github.com/huggingface/transformers.git@fix/lerobot_openpi", "scipy>=1.10.1,<1.15"]
 smolvla = ["lerobot[transformers-dep]", "num2words>=0.5.14,<0.6.0", "accelerate>=1.7.0,<2.0.0", "safetensors>=0.4.3,<1.0.0"]
 groot = [
     "lerobot[transformers-dep]",
@@ -140,12 +140,13 @@ groot = [
     "ninja>=1.11.1,<2.0.0",
     "flash-attn>=2.5.9,<3.0.0 ; sys_platform != 'darwin'"
 ]
-sarm = ["lerobot[transformers-dep]", "faker>=33.0.0,<35.0.0", "matplotlib>=3.10.3,<4.0.0", "qwen-vl-utils>=0.0.14"]
+sarm = ["lerobot[transformers-dep]", "faker>=33.0.0,<35.0.0", "matplotlib>=3.10.3,<4.0.0", "qwen-vl-utils>=0.0.14,<0.1.0"]
 xvla = ["lerobot[transformers-dep]"]
 hilserl = ["lerobot[transformers-dep]", "gym-hil>=0.1.13,<0.2.0", "lerobot[grpcio-dep]", "lerobot[placo-dep]"]
 
 # Features
 async = ["lerobot[grpcio-dep]", "matplotlib>=3.10.3,<4.0.0"]
+peft = ["lerobot[transformers-dep]", "peft>=0.18.0,<1.0.0"]
 
 # Development
 dev = ["pre-commit>=3.7.0,<5.0.0", "debugpy>=1.8.1,<1.9.0", "lerobot[grpcio-dep]", "grpcio-tools==1.73.1", "mypy>=1.19.1"]
@@ -182,7 +183,8 @@ all = [
     "lerobot[phone]",
     "lerobot[libero]",
     "lerobot[metaworld]",
-    "lerobot[sarm]"
+    "lerobot[sarm]",
+    "lerobot[peft]",
 ]
 
 [project.scripts]
@@ -195,6 +197,7 @@ lerobot-setup-motors="lerobot.scripts.lerobot_setup_motors:main"
 lerobot-teleoperate="lerobot.scripts.lerobot_teleoperate:main"
 lerobot-eval="lerobot.scripts.lerobot_eval:main"
 lerobot-train="lerobot.scripts.lerobot_train:main"
+lerobot-train-tokenizer="lerobot.scripts.lerobot_train_tokenizer:main"
 lerobot-dataset-viz="lerobot.scripts.lerobot_dataset_viz:main"
 lerobot-info="lerobot.scripts.lerobot_info:main"
 lerobot-find-joint-limits="lerobot.scripts.lerobot_find_joint_limits:main"
@@ -417,6 +420,10 @@ conflicts = [
         { extra = "wallx" },
         { extra = "libero" },
     ],
+    [
+        { extra = "wallx" },
+        { extra = "peft" },
+    ],
     [
         { extra = "wallx" },
         { extra = "all" },
@@ -450,6 +457,10 @@ conflicts = [
         { extra = "pi" },
         { extra = "libero" },
     ],
+    [
+        { extra = "pi" },
+        { extra = "peft" },
+    ],
     [
         { extra = "pi" },
         { extra = "all" },

setup.py

@@ -0,0 +1,72 @@
+# 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 setuptools import setup
+
+
+def get_version_from_toml() -> str:
+    """Return the project's version string parsed from `pyproject.toml`.
+
+    The function scans `pyproject.toml` line-by-line looking for a line
+    that starts with ``version`` (for example: ``version = "1.2.3"``)
+    and returns the value without surrounding quotes. If no such line is
+    found a :class:`ValueError` is raised.
+
+    Returns:
+        The version string from `pyproject.toml` (e.g. ``"1.2.3"`` ->
+        ``1.2.3``).
+    """
+
+    version = None
+    with open("pyproject.toml", encoding="utf-8") as f:
+        for line in f:
+            if line.strip().startswith("version"):
+                version = line.split("=")[1].strip().strip('"')
+                break
+    if version is None:
+        raise ValueError("Version not found in pyproject.toml")
+    return version
+
+
+def read_long_description() -> str:
+    """Read and return the project's long description for setup.
+
+    This function reads `README.md` and replaces image links that point
+    to the local `./media/` directory with absolute raw GitHub URLs that
+    reference the release tag corresponding to the version parsed from
+    `pyproject.toml` (for example, ``v1.2.3``). The modified README
+    content is returned as a string suitable for passing to
+    ``setuptools.setup(long_description=...)``.
+
+    Returns:
+        The README content with rewritten media links.
+    """
+
+    with open("README.md", encoding="utf-8") as f:
+        content = f.read()
+
+    version = get_version_from_toml()
+    git_tag = f"v{version}"
+
+    base_raw_url = f"https://raw.githubusercontent.com/huggingface/lerobot/{git_tag}/"
+    content = content.replace('src="./media/', f'src="{base_raw_url}media/')
+
+    return content
+
+
+setup(
+    long_description=read_long_description(),
+    long_description_content_type="text/markdown",
+)

src/lerobot/async_inference/constants.py

@@ -26,4 +26,4 @@ DEFAULT_OBS_QUEUE_TIMEOUT = 2
 SUPPORTED_POLICIES = ["act", "smolvla", "diffusion", "tdmpc", "vqbet", "pi0", "pi05"]
 
 # TODO: Add all other robots
-SUPPORTED_ROBOTS = ["so100_follower", "so101_follower", "bi_so100_follower", "omx_follower"]
+SUPPORTED_ROBOTS = ["so100_follower", "so101_follower", "bi_so_follower", "omx_follower"]

src/lerobot/async_inference/robot_client.py

@@ -40,7 +40,6 @@ from collections.abc import Callable
 from dataclasses import asdict
 from pprint import pformat
 from queue import Queue
-from typing import Any
 
 import draccus
 import grpc
@@ -48,15 +47,15 @@ import torch
 
 from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig  # noqa: F401
 from lerobot.cameras.realsense.configuration_realsense import RealSenseCameraConfig  # noqa: F401
+from lerobot.processor import RobotAction
 from lerobot.robots import (  # noqa: F401
     Robot,
     RobotConfig,
-    bi_so100_follower,
+    bi_so_follower,
     koch_follower,
     make_robot_from_config,
     omx_follower,
-    so100_follower,
-    so101_follower,
+    so_follower,
 )
 from lerobot.transport import (
     services_pb2,  # type: ignore
@@ -352,7 +351,7 @@ class RobotClient:
         action = {key: action_tensor[i].item() for i, key in enumerate(self.robot.action_features)}
         return action
 
-    def control_loop_action(self, verbose: bool = False) -> dict[str, Any]:
+    def control_loop_action(self, verbose: bool = False) -> RobotAction:
         """Reading and performing actions in local queue"""
 
         # Lock only for queue operations

src/lerobot/cameras/reachy2_camera/configuration_reachy2_camera.py

@@ -35,18 +35,19 @@ class Reachy2CameraConfig(CameraConfig):
         name="teleop",
         image_type="left",
         ip_address="192.168.0.200",  # IP address of the robot
-        fps=15,
+        port=50065,  # Port of the camera server
         width=640,
         height=480,
+        fps=30,  # Not configurable for Reachy 2 cameras
         color_mode=ColorMode.RGB,
-    )  # Left teleop camera, 640x480 @ 15FPS
+    )  # Left teleop camera, 640x480 @ 30FPS
     ```
 
     Attributes:
         name: Name of the camera device. Can be "teleop" or "depth".
         image_type: Type of image stream. For "teleop" camera, can be "left" or "right".
                     For "depth" camera, can be "rgb" or "depth". (depth is not supported yet)
-        fps: Requested frames per second for the color stream.
+        fps: Requested frames per second for the color stream. Not configurable for Reachy 2 cameras.
         width: Requested frame width in pixels for the color stream.
         height: Requested frame height in pixels for the color stream.
         color_mode: Color mode for image output (RGB or BGR). Defaults to RGB.
@@ -62,7 +63,6 @@ class Reachy2CameraConfig(CameraConfig):
     color_mode: ColorMode = ColorMode.RGB
     ip_address: str | None = "localhost"
     port: int = 50065
-    # use_depth: bool = False
 
     def __post_init__(self) -> None:
         if self.name not in ["teleop", "depth"]:

src/lerobot/cameras/reachy2_camera/reachy2_camera.py

@@ -16,12 +16,13 @@
 Provides the Reachy2Camera class for capturing frames from Reachy 2 cameras using Reachy 2's CameraManager.
 """
 
+from __future__ import annotations
+
 import logging
 import os
 import platform
 import time
-from threading import Event, Lock, Thread
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from numpy.typing import NDArray  # type: ignore  # TODO: add type stubs for numpy.typing
 
@@ -30,10 +31,19 @@ if platform.system() == "Windows" and "OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"
     os.environ["OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS"] = "0"
 import cv2  # type: ignore  # TODO: add type stubs for OpenCV
 import numpy as np  # type: ignore  # TODO: add type stubs for numpy
-from reachy2_sdk.media.camera import CameraView  # type: ignore  # TODO: add type stubs for reachy2_sdk
-from reachy2_sdk.media.camera_manager import (  # type: ignore  # TODO: add type stubs for reachy2_sdk
-    CameraManager,
-)
+
+from lerobot.utils.import_utils import _reachy2_sdk_available
+
+if TYPE_CHECKING or _reachy2_sdk_available:
+    from reachy2_sdk.media.camera import CameraView
+    from reachy2_sdk.media.camera_manager import CameraManager
+else:
+    CameraManager = None
+
+    class CameraView:
+        LEFT = 0
+        RIGHT = 1
+
 
 from lerobot.utils.errors import DeviceNotConnectedError
 
@@ -69,17 +79,10 @@ class Reachy2Camera(Camera):
 
         self.config = config
 
-        self.fps = config.fps
         self.color_mode = config.color_mode
 
         self.cam_manager: CameraManager | None = None
 
-        self.thread: Thread | None = None
-        self.stop_event: Event | None = None
-        self.frame_lock: Lock = Lock()
-        self.latest_frame: NDArray[Any] | None = None
-        self.new_frame_event: Event = Event()
-
     def __str__(self) -> str:
         return f"{self.__class__.__name__}({self.config.name}, {self.config.image_type})"
 
@@ -100,44 +103,23 @@ class Reachy2Camera(Camera):
     def connect(self, warmup: bool = True) -> None:
         """
         Connects to the Reachy2 CameraManager as specified in the configuration.
+
+        Raises:
+            DeviceNotConnectedError: If the camera is not connected.
         """
         self.cam_manager = CameraManager(host=self.config.ip_address, port=self.config.port)
+        if self.cam_manager is None:
+            raise DeviceNotConnectedError(f"Could not connect to {self}.")
         self.cam_manager.initialize_cameras()
 
         logger.info(f"{self} connected.")
 
     @staticmethod
-    def find_cameras(ip_address: str = "localhost", port: int = 50065) -> list[dict[str, Any]]:
+    def find_cameras() -> list[dict[str, Any]]:
         """
-        Detects available Reachy 2 cameras.
-
-        Returns:
-            List[Dict[str, Any]]: A list of dictionaries,
-            where each dictionary contains 'name', 'stereo',
-            and the default profile properties (width, height, fps).
+        Detection not implemented for Reachy2 cameras.
         """
-        initialized_cameras = []
-        camera_manager = CameraManager(host=ip_address, port=port)
-
-        for camera in [camera_manager.teleop, camera_manager.depth]:
-            if camera is None:
-                continue
-
-            height, width, _, _, _, _, _ = camera.get_parameters()
-
-            camera_info = {
-                "name": camera._cam_info.name,
-                "stereo": camera._cam_info.stereo,
-                "default_profile": {
-                    "width": width,
-                    "height": height,
-                    "fps": 30,
-                },
-            }
-            initialized_cameras.append(camera_info)
-
-        camera_manager.disconnect()
-        return initialized_cameras
+        raise NotImplementedError("Camera detection is not implemented for Reachy2 cameras.")
 
     def read(self, color_mode: ColorMode | None = None) -> NDArray[Any]:
         """
@@ -155,95 +137,49 @@ class Reachy2Camera(Camera):
                        (height, width, channels), using the specified or default
                        color mode and applying any configured rotation.
         """
+        start_time = time.perf_counter()
+
         if not self.is_connected:
             raise DeviceNotConnectedError(f"{self} is not connected.")
 
-        start_time = time.perf_counter()
+        if self.cam_manager is None:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
 
         frame: NDArray[Any] = np.empty((0, 0, 3), dtype=np.uint8)
 
-        if self.cam_manager is None:
-            raise DeviceNotConnectedError(f"{self} is not connected.")
+        if self.config.name == "teleop" and hasattr(self.cam_manager, "teleop"):
+            if self.config.image_type == "left":
+                frame = self.cam_manager.teleop.get_frame(
+                    CameraView.LEFT, size=(self.config.width, self.config.height)
+                )[0]
+            elif self.config.image_type == "right":
+                frame = self.cam_manager.teleop.get_frame(
+                    CameraView.RIGHT, size=(self.config.width, self.config.height)
+                )[0]
+        elif self.config.name == "depth" and hasattr(self.cam_manager, "depth"):
+            if self.config.image_type == "depth":
+                frame = self.cam_manager.depth.get_depth_frame()[0]
+            elif self.config.image_type == "rgb":
+                frame = self.cam_manager.depth.get_frame(size=(self.config.width, self.config.height))[0]
         else:
-            if self.config.name == "teleop" and hasattr(self.cam_manager, "teleop"):
-                if self.config.image_type == "left":
-                    frame = self.cam_manager.teleop.get_frame(CameraView.LEFT, size=(640, 480))[0]
-                elif self.config.image_type == "right":
-                    frame = self.cam_manager.teleop.get_frame(CameraView.RIGHT, size=(640, 480))[0]
-            elif self.config.name == "depth" and hasattr(self.cam_manager, "depth"):
-                if self.config.image_type == "depth":
-                    frame = self.cam_manager.depth.get_depth_frame()[0]
-                elif self.config.image_type == "rgb":
-                    frame = self.cam_manager.depth.get_frame(size=(640, 480))[0]
+            raise ValueError(f"Invalid camera name '{self.config.name}'. Expected 'teleop' or 'depth'.")
 
-            if frame is None:
-                return np.empty((0, 0, 3), dtype=np.uint8)
+        if frame is None:
+            return np.empty((0, 0, 3), dtype=np.uint8)
 
-            if self.config.color_mode == "rgb":
-                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        if self.config.color_mode == "rgb":
+            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 
         read_duration_ms = (time.perf_counter() - start_time) * 1e3
         logger.debug(f"{self} read took: {read_duration_ms:.1f}ms")
 
         return frame
 
-    def _read_loop(self) -> None:
-        """
-        Internal loop run by the background thread for asynchronous reading.
-
-        On each iteration:
-        1. Reads a color frame
-        2. Stores result in latest_frame (thread-safe)
-        3. Sets new_frame_event to notify listeners
-
-        Stops on DeviceNotConnectedError, logs other errors and continues.
-        """
-        if self.stop_event is None:
-            raise RuntimeError(f"{self}: stop_event is not initialized before starting read loop.")
-
-        while not self.stop_event.is_set():
-            try:
-                color_image = self.read()
-
-                with self.frame_lock:
-                    self.latest_frame = color_image
-                self.new_frame_event.set()
-
-            except DeviceNotConnectedError:
-                break
-            except Exception as e:
-                logger.warning(f"Error reading frame in background thread for {self}: {e}")
-
-    def _start_read_thread(self) -> None:
-        """Starts or restarts the background read thread if it's not running."""
-        if self.thread is not None and self.thread.is_alive():
-            self.thread.join(timeout=0.1)
-        if self.stop_event is not None:
-            self.stop_event.set()
-
-        self.stop_event = Event()
-        self.thread = Thread(target=self._read_loop, args=(), name=f"{self}_read_loop")
-        self.thread.daemon = True
-        self.thread.start()
-
-    def _stop_read_thread(self) -> None:
-        """Signals the background read thread to stop and waits for it to join."""
-        if self.stop_event is not None:
-            self.stop_event.set()
-
-        if self.thread is not None and self.thread.is_alive():
-            self.thread.join(timeout=2.0)
-
-        self.thread = None
-        self.stop_event = None
-
     def async_read(self, timeout_ms: float = 200) -> NDArray[Any]:
         """
-        Reads the latest available frame asynchronously.
+        Reads the latest available frame.
 
-        This method retrieves the most recent frame captured by the background
-        read thread. It does not block waiting for the camera hardware directly,
-        but may wait up to timeout_ms for the background thread to provide a frame.
+        This method retrieves the most recent frame available in Reachy 2's low-level software.
 
         Args:
             timeout_ms (float): Maximum time in milliseconds to wait for a frame
@@ -261,22 +197,10 @@ class Reachy2Camera(Camera):
         if not self.is_connected:
             raise DeviceNotConnectedError(f"{self} is not connected.")
 
-        if self.thread is None or not self.thread.is_alive():
-            self._start_read_thread()
-
-        if not self.new_frame_event.wait(timeout=timeout_ms / 1000.0):
-            thread_alive = self.thread is not None and self.thread.is_alive()
-            raise TimeoutError(
-                f"Timed out waiting for frame from camera {self} after {timeout_ms} ms. "
-                f"Read thread alive: {thread_alive}."
-            )
-
-        with self.frame_lock:
-            frame = self.latest_frame
-            self.new_frame_event.clear()
+        frame = self.read()
 
         if frame is None:
-            raise RuntimeError(f"Internal error: Event set but no frame available for {self}.")
+            raise RuntimeError(f"Internal error: No frame available for {self}.")
 
         return frame
 
@@ -287,12 +211,9 @@ class Reachy2Camera(Camera):
         Raises:
             DeviceNotConnectedError: If the camera is already disconnected.
         """
-        if not self.is_connected and self.thread is None:
+        if not self.is_connected:
             raise DeviceNotConnectedError(f"{self} not connected.")
 
-        if self.thread is not None:
-            self._stop_read_thread()
-
         if self.cam_manager is not None:
             self.cam_manager.disconnect()
 

src/lerobot/cameras/utils.py

@@ -43,6 +43,11 @@ def make_cameras_from_configs(camera_configs: dict[str, CameraConfig]) -> dict[s
 
             cameras[key] = Reachy2Camera(cfg)
 
+        elif cfg.type == "zmq":
+            from .zmq.camera_zmq import ZMQCamera
+
+            cameras[key] = ZMQCamera(cfg)
+
         else:
             try:
                 cameras[key] = cast(Camera, make_device_from_device_class(cfg))

src/lerobot/cameras/zmq/__init__.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-# Copyright 2025 The HuggingFace Inc. team. All rights reserved.
+# Copyright 2026 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.
@@ -14,5 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .config_so101_follower import SO101FollowerConfig
-from .so101_follower import SO101Follower
+from .camera_zmq import ZMQCamera
+from .configuration_zmq import ZMQCameraConfig
+
+__all__ = ["ZMQCamera", "ZMQCameraConfig"]

src/lerobot/cameras/zmq/camera_zmq.py

@@ -0,0 +1,235 @@
+#!/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.
+
+"""
+ZMQCamera - Captures frames from remote cameras via ZeroMQ using JSON protocol in the
+following format:
+    {
+        "timestamps": {"camera_name": float},
+        "images": {"camera_name": "<base64-jpeg>"}
+    }
+"""
+
+import base64
+import json
+import logging
+import time
+from threading import Event, Lock, Thread
+from typing import Any
+
+import cv2
+import numpy as np
+from numpy.typing import NDArray
+
+from lerobot.utils.errors import DeviceAlreadyConnectedError, DeviceNotConnectedError
+
+from ..camera import Camera
+from ..configs import ColorMode
+from .configuration_zmq import ZMQCameraConfig
+
+logger = logging.getLogger(__name__)
+
+
+class ZMQCamera(Camera):
+    """
+    Example usage:
+        ```python
+        from lerobot.cameras.zmq import ZMQCamera, ZMQCameraConfig
+
+        config = ZMQCameraConfig(server_address="192.168.123.164", port=5555, camera_name="head_camera")
+        camera = ZMQCamera(config)
+        camera.connect()
+        frame = camera.read()
+        camera.disconnect()
+        ```
+    """
+
+    def __init__(self, config: ZMQCameraConfig):
+        super().__init__(config)
+        import zmq
+
+        self.config = config
+        self.server_address = config.server_address
+        self.port = config.port
+        self.camera_name = config.camera_name
+        self.color_mode = config.color_mode
+        self.timeout_ms = config.timeout_ms
+
+        self.context: zmq.Context | None = None
+        self.socket: zmq.Socket | None = None
+        self._connected = False
+
+        self.thread: Thread | None = None
+        self.stop_event: Event | None = None
+        self.frame_lock: Lock = Lock()
+        self.latest_frame: NDArray[Any] | None = None
+        self.new_frame_event: Event = Event()
+
+    def __str__(self) -> str:
+        return f"ZMQCamera({self.camera_name}@{self.server_address}:{self.port})"
+
+    @property
+    def is_connected(self) -> bool:
+        return self._connected and self.context is not None and self.socket is not None
+
+    def connect(self, warmup: bool = True) -> None:
+        """Connect to ZMQ camera server."""
+        if self.is_connected:
+            raise DeviceAlreadyConnectedError(f"{self} is already connected.")
+
+        logger.info(f"Connecting to {self}...")
+
+        try:
+            import zmq
+
+            self.context = zmq.Context()
+            self.socket = self.context.socket(zmq.SUB)
+            self.socket.setsockopt_string(zmq.SUBSCRIBE, "")
+            self.socket.setsockopt(zmq.RCVTIMEO, self.timeout_ms)
+            self.socket.setsockopt(zmq.CONFLATE, True)
+            self.socket.connect(f"tcp://{self.server_address}:{self.port}")
+            self._connected = True
+
+            # Auto-detect resolution
+            if self.width is None or self.height is None:
+                h, w = self.read().shape[:2]
+                self.height = h
+                self.width = w
+                logger.info(f"{self} resolution: {w}x{h}")
+
+            logger.info(f"{self} connected.")
+
+            if warmup:
+                time.sleep(0.1)
+
+        except Exception as e:
+            self._cleanup()
+            raise RuntimeError(f"Failed to connect to {self}: {e}") from e
+
+    def _cleanup(self):
+        """Clean up ZMQ resources."""
+        self._connected = False
+        if self.socket:
+            self.socket.close()
+            self.socket = None
+        if self.context:
+            self.context.term()
+            self.context = None
+
+    @staticmethod
+    def find_cameras() -> list[dict[str, Any]]:
+        """ZMQ cameras require manual configuration (server address/port)."""
+        return []
+
+    def read(self, color_mode: ColorMode | None = None) -> NDArray[Any]:
+        """
+        Read a single frame from the ZMQ camera.
+
+        Returns:
+            np.ndarray: Decoded frame (height, width, 3)
+        """
+        if not self.is_connected or self.socket is None:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+
+        try:
+            message = self.socket.recv_string()
+        except Exception as e:
+            if type(e).__name__ == "Again":
+                raise TimeoutError(f"{self} timeout after {self.timeout_ms}ms") from e
+            raise
+
+        # Decode JSON message
+        data = json.loads(message)
+
+        if "images" not in data:
+            raise RuntimeError(f"{self} invalid message: missing 'images' key")
+
+        images = data["images"]
+
+        # Get image by camera name or first available
+        if self.camera_name in images:
+            img_b64 = images[self.camera_name]
+        elif images:
+            img_b64 = next(iter(images.values()))
+        else:
+            raise RuntimeError(f"{self} no images in message")
+
+        # Decode base64 JPEG
+        img_bytes = base64.b64decode(img_b64)
+        frame = cv2.imdecode(np.frombuffer(img_bytes, np.uint8), cv2.IMREAD_COLOR)
+
+        if frame is None:
+            raise RuntimeError(f"{self} failed to decode image")
+
+        return frame
+
+    def _read_loop(self) -> None:
+        while self.stop_event and not self.stop_event.is_set():
+            try:
+                frame = self.read()
+                with self.frame_lock:
+                    self.latest_frame = frame
+                self.new_frame_event.set()
+            except DeviceNotConnectedError:
+                break
+            except TimeoutError:
+                pass
+            except Exception as e:
+                logger.warning(f"Read error: {e}")
+
+    def _start_read_thread(self) -> None:
+        if self.thread and self.thread.is_alive():
+            return
+        self.stop_event = Event()
+        self.thread = Thread(target=self._read_loop, daemon=True)
+        self.thread.start()
+
+    def _stop_read_thread(self) -> None:
+        if self.stop_event:
+            self.stop_event.set()
+        if self.thread and self.thread.is_alive():
+            self.thread.join(timeout=2.0)
+        self.thread = None
+        self.stop_event = None
+
+    def async_read(self, timeout_ms: float = 10000) -> NDArray[Any]:
+        """Read latest frame asynchronously (non-blocking)."""
+        if not self.is_connected:
+            raise DeviceNotConnectedError(f"{self} is not connected.")
+
+        if not self.thread or not self.thread.is_alive():
+            self._start_read_thread()
+
+        if not self.new_frame_event.wait(timeout=timeout_ms / 1000.0):
+            raise TimeoutError(f"{self} async_read timeout after {timeout_ms}ms")
+
+        with self.frame_lock:
+            frame = self.latest_frame
+            self.new_frame_event.clear()
+
+        if frame is None:
+            raise RuntimeError(f"{self} no frame available")
+
+        return frame
+
+    def disconnect(self) -> None:
+        """Disconnect from ZMQ camera."""
+        if not self.is_connected and not self.thread:
+            raise DeviceNotConnectedError(f"{self} not connected.")
+
+        self._stop_read_thread()
+        self._cleanup()
+        logger.info(f"{self} disconnected.")

src/lerobot/cameras/zmq/configuration_zmq.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+
+# Copyright 2026 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
+
+from ..configs import CameraConfig, ColorMode
+
+__all__ = ["ZMQCameraConfig", "ColorMode"]
+
+
+@CameraConfig.register_subclass("zmq")
+@dataclass
+class ZMQCameraConfig(CameraConfig):
+    server_address: str
+    port: int = 5555
+    camera_name: str = "zmq_camera"
+    color_mode: ColorMode = ColorMode.RGB
+    timeout_ms: int = 5000
+
+    def __post_init__(self) -> None:
+        if self.color_mode not in (ColorMode.RGB, ColorMode.BGR):
+            raise ValueError(
+                f"`color_mode` is expected to be {ColorMode.RGB.value} or {ColorMode.BGR.value}, but {self.color_mode} is provided."
+            )
+
+        if self.timeout_ms <= 0:
+            raise ValueError(f"`timeout_ms` must be positive, but {self.timeout_ms} is provided.")
+
+        if not self.server_address:
+            raise ValueError("`server_address` cannot be empty.")
+
+        if self.port <= 0 or self.port > 65535:
+            raise ValueError(f"`port` must be between 1 and 65535, but {self.port} is provided.")

src/lerobot/cameras/zmq/image_server.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+
+# Copyright 2026 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.
+
+"""
+Streams camera images over ZMQ.
+Uses lerobot's OpenCVCamera for capture, encodes images to base64 and sends them over ZMQ.
+"""
+
+import base64
+import contextlib
+import json
+import logging
+import time
+from collections import deque
+
+import cv2
+import numpy as np
+import zmq
+
+from lerobot.cameras.configs import ColorMode
+from lerobot.cameras.opencv import OpenCVCamera, OpenCVCameraConfig
+
+logger = logging.getLogger(__name__)
+
+
+def encode_image(image: np.ndarray, quality: int = 80) -> str:
+    """Encode RGB image to base64 JPEG string."""
+    _, buffer = cv2.imencode(".jpg", image, [int(cv2.IMWRITE_JPEG_QUALITY), quality])
+    return base64.b64encode(buffer).decode("utf-8")
+
+
+class ImageServer:
+    def __init__(self, config: dict, port: int = 5555):
+        self.fps = config.get("fps", 30)
+        self.cameras: dict[str, OpenCVCamera] = {}
+
+        for name, cfg in config.get("cameras", {}).items():
+            shape = cfg.get("shape", [480, 640])
+            cam_config = OpenCVCameraConfig(
+                index_or_path=cfg.get("device_id", 0),
+                fps=self.fps,
+                width=shape[1],
+                height=shape[0],
+                color_mode=ColorMode.RGB,
+            )
+            camera = OpenCVCamera(cam_config)
+            camera.connect()
+            self.cameras[name] = camera
+            logger.info(f"Camera {name}: {shape[1]}x{shape[0]}")
+
+        # ZMQ PUB socket
+        self.context = zmq.Context()
+        self.socket = self.context.socket(zmq.PUB)
+        self.socket.setsockopt(zmq.SNDHWM, 20)
+        self.socket.setsockopt(zmq.LINGER, 0)
+        self.socket.bind(f"tcp://*:{port}")
+
+        logger.info(f"ImageServer running on port {port}")
+
+    def run(self):
+        frame_count = 0
+        frame_times = deque(maxlen=60)
+
+        try:
+            while True:
+                t0 = time.time()
+
+                # Build message
+                message = {"timestamps": {}, "images": {}}
+                for name, cam in self.cameras.items():
+                    frame = cam.read()  # Returns RGB
+                    message["timestamps"][name] = time.time()
+                    message["images"][name] = encode_image(frame)
+
+                # Send as JSON string (suppress if buffer full)
+                with contextlib.suppress(zmq.Again):
+                    self.socket.send_string(json.dumps(message), zmq.NOBLOCK)
+
+                frame_count += 1
+                frame_times.append(time.time() - t0)
+
+                if frame_count % 60 == 0:
+                    logger.debug(f"FPS: {len(frame_times) / sum(frame_times):.1f}")
+
+                sleep = (1.0 / self.fps) - (time.time() - t0)
+                if sleep > 0:
+                    time.sleep(sleep)
+
+        except KeyboardInterrupt:
+            pass
+        finally:
+            for cam in self.cameras.values():
+                cam.disconnect()
+            self.socket.close()
+            self.context.term()
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    config = {"fps": 30, "cameras": {"head_camera": {"device_id": 4, "shape": [480, 640]}}}
+    ImageServer(config, port=5555).run()

src/lerobot/configs/default.py

@@ -67,3 +67,31 @@ class EvalConfig:
                 f"to increase the number of episodes to match the batch size (e.g. `eval.n_episodes={self.batch_size}`), "
                 f"or lower the batch size (e.g. `eval.batch_size={self.n_episodes}`)."
             )
+
+
+@dataclass
+class PeftConfig:
+    # PEFT offers many fine-tuning methods, layer adapters being the most common and currently also the most
+    # effective methods so we'll focus on those in this high-level config interface.
+
+    # Either a string (module name suffix or 'all-linear'), a list of module name suffixes or a regular expression
+    # describing module names to target with the configured PEFT method. Some policies have a default value for this
+    # so that you don't *have* to choose which layers to adapt but it might still be worthwhile depending on your case.
+    target_modules: list[str] | str | None = None
+
+    # Names/suffixes of modules to fully fine-tune and store alongside adapter weights. Useful for layers that are
+    # not part of a pre-trained model (e.g., action state projections). Depending on the policy this defaults to layers
+    # that are newly created in pre-trained policies. If you're fine-tuning an already trained policy you might want
+    # to set this to `[]`. Corresponds to PEFT's `modules_to_save`.
+    full_training_modules: list[str] | None = None
+
+    # The PEFT (adapter) method to apply to the policy. Needs to be a valid PEFT type.
+    method_type: str = "LORA"
+
+    # Adapter initialization method. Look at the specific PEFT adapter documentation for defaults.
+    init_type: str | None = None
+
+    # We expect that all PEFT adapters are in some way doing rank-decomposition therefore this parameter specifies
+    # the rank used for the adapter. In general a higher rank means more trainable parameters and closer to full
+    # fine-tuning.
+    r: int = 16

src/lerobot/configs/eval.py

@@ -38,6 +38,8 @@ class EvalPipelineConfig:
     seed: int | None = 1000
     # Rename map for the observation to override the image and state keys
     rename_map: dict[str, str] = field(default_factory=dict)
+    # Explicit consent to execute remote code from the Hub (required for hub environments).
+    trust_remote_code: bool = False
 
     def __post_init__(self) -> None:
         # HACK: We parse again the cli args here to get the pretrained path if there was one.

src/lerobot/configs/policies.py

@@ -55,14 +55,18 @@ class PreTrainedConfig(draccus.ChoiceRegistry, HubMixin, abc.ABC):  # type: igno
 
     n_obs_steps: int = 1
 
-    input_features: dict[str, PolicyFeature] = field(default_factory=dict)
-    output_features: dict[str, PolicyFeature] = field(default_factory=dict)
+    # `input_features` can be set to None/null in order to infer those values from the dataset.
+    input_features: dict[str, PolicyFeature] | None = field(default_factory=dict)
+    output_features: dict[str, PolicyFeature] | None = field(default_factory=dict)
 
     device: str | None = None  # e.g. "cuda", "cuda:0", "cpu", or "mps"
     # `use_amp` determines whether to use Automatic Mixed Precision (AMP) for training and evaluation. With AMP,
     # automatic gradient scaling is used.
     use_amp: bool = False
 
+    # Whether the policy employed PEFT for training.
+    use_peft: bool = False
+
     push_to_hub: bool = True  # type: ignore[assignment] # TODO: use a different name to avoid override
     repo_id: str | None = None
 
@@ -125,6 +129,8 @@ class PreTrainedConfig(draccus.ChoiceRegistry, HubMixin, abc.ABC):  # type: igno
 
     @property
     def robot_state_feature(self) -> PolicyFeature | None:
+        if not self.input_features:
+            return None
         for ft_name, ft in self.input_features.items():
             if ft.type is FeatureType.STATE and ft_name == OBS_STATE:
                 return ft
@@ -132,6 +138,8 @@ class PreTrainedConfig(draccus.ChoiceRegistry, HubMixin, abc.ABC):  # type: igno
 
     @property
     def env_state_feature(self) -> PolicyFeature | None:
+        if not self.input_features:
+            return None
         for _, ft in self.input_features.items():
             if ft.type is FeatureType.ENV:
                 return ft
@@ -139,10 +147,14 @@ class PreTrainedConfig(draccus.ChoiceRegistry, HubMixin, abc.ABC):  # type: igno
 
     @property
     def image_features(self) -> dict[str, PolicyFeature]:
+        if not self.input_features:
+            return {}
         return {key: ft for key, ft in self.input_features.items() if ft.type is FeatureType.VISUAL}
 
     @property
     def action_feature(self) -> PolicyFeature | None:
+        if not self.output_features:
+            return None
         for ft_name, ft in self.output_features.items():
             if ft.type is FeatureType.ACTION and ft_name == ACTION:
                 return ft

src/lerobot/configs/train.py

@@ -24,7 +24,7 @@ from huggingface_hub.errors import HfHubHTTPError
 
 from lerobot import envs
 from lerobot.configs import parser
-from lerobot.configs.default import DatasetConfig, EvalConfig, WandBConfig
+from lerobot.configs.default import DatasetConfig, EvalConfig, PeftConfig, WandBConfig
 from lerobot.configs.policies import PreTrainedConfig
 from lerobot.optim import OptimizerConfig
 from lerobot.optim.schedulers import LRSchedulerConfig
@@ -65,6 +65,7 @@ class TrainPipelineConfig(HubMixin):
     scheduler: LRSchedulerConfig | None = None
     eval: EvalConfig = field(default_factory=EvalConfig)
     wandb: WandBConfig = field(default_factory=WandBConfig)
+    peft: PeftConfig | None = None
 
     # RA-BC (Reward-Aligned Behavior Cloning) parameters
     use_rabc: bool = False  # Enable reward-weighted training

src/lerobot/datasets/lerobot_dataset.py

@@ -23,13 +23,11 @@ from pathlib import Path
 
 import datasets
 import numpy as np
-import os
 import packaging.version
 import pandas as pd
 import PIL.Image
 import pyarrow as pa
 import pyarrow.parquet as pq
-from concurrent.futures import ProcessPoolExecutor
 import torch
 import torch.utils
 from huggingface_hub import HfApi, snapshot_download
@@ -80,6 +78,7 @@ from lerobot.datasets.video_utils import (
 from lerobot.utils.constants import HF_LEROBOT_HOME
 
 CODEBASE_VERSION = "v3.0"
+VALID_VIDEO_CODECS = {"h264", "hevc", "libsvtav1"}
 
 
 class LeRobotDatasetMetadata:
@@ -542,11 +541,13 @@ class LeRobotDatasetMetadata:
         return obj
 
 
-def _encode_video_worker(video_key: str, episode_index: int, root: Path, fps: int) -> Path:
+def _encode_video_worker(
+    video_key: str, episode_index: int, root: Path, fps: int, vcodec: str = "libsvtav1"
+) -> Path:
     temp_path = Path(tempfile.mkdtemp(dir=root)) / f"{video_key}_{episode_index:03d}.mp4"
     fpath = DEFAULT_IMAGE_PATH.format(image_key=video_key, episode_index=episode_index, frame_index=0)
     img_dir = (root / fpath).parent
-    encode_video_frames(img_dir, temp_path, fps, overwrite=True)
+    encode_video_frames(img_dir, temp_path, fps, vcodec=vcodec, overwrite=True)
     shutil.rmtree(img_dir)
     return temp_path
 
@@ -565,6 +566,7 @@ class LeRobotDataset(torch.utils.data.Dataset):
         download_videos: bool = True,
         video_backend: str | None = None,
         batch_encoding_size: int = 1,
+        vcodec: str = "libsvtav1",
     ):
         """
         2 modes are available for instantiating this class, depending on 2 different use cases:
@@ -677,8 +679,13 @@ class LeRobotDataset(torch.utils.data.Dataset):
                 You can also use the 'pyav' decoder used by Torchvision, which used to be the default option, or 'video_reader' which is another decoder of Torchvision.
             batch_encoding_size (int, optional): Number of episodes to accumulate before batch encoding videos.
                 Set to 1 for immediate encoding (default), or higher for batched encoding. Defaults to 1.
+            vcodec (str, optional): Video codec for encoding videos during recording. Options: 'h264', 'hevc',
+                'libsvtav1'. Defaults to 'libsvtav1'. Use 'h264' for faster encoding on systems where AV1
+                encoding is CPU-heavy.
         """
         super().__init__()
+        if vcodec not in VALID_VIDEO_CODECS:
+            raise ValueError(f"Invalid vcodec '{vcodec}'. Must be one of: {sorted(VALID_VIDEO_CODECS)}")
         self.repo_id = repo_id
         self.root = Path(root) if root else HF_LEROBOT_HOME / repo_id
         self.image_transforms = image_transforms
@@ -690,6 +697,7 @@ class LeRobotDataset(torch.utils.data.Dataset):
         self.delta_indices = None
         self.batch_encoding_size = batch_encoding_size
         self.episodes_since_last_encoding = 0
+        self.vcodec = vcodec
 
         # Unused attributes
         self.image_writer = None
@@ -1201,9 +1209,41 @@ class LeRobotDataset(torch.utils.data.Dataset):
         use_batched_encoding = self.batch_encoding_size > 1
 
         if has_video_keys and not use_batched_encoding:
-            video_paths = self._encode_multiple_temporary_episode_videos(self.meta.video_keys, episode_index)
-            for video_key, video_path in zip(self.meta.video_keys, video_paths):
-                ep_metadata.update(self._save_episode_video(video_key, episode_index, video_path))
+            num_cameras = len(self.meta.video_keys)
+            if parallel_encoding and num_cameras > 1:
+                # TODO(Steven): Ideally we would like to control the number of threads per encoding such that:
+                # num_cameras * num_threads = (total_cpu -1)
+                with concurrent.futures.ProcessPoolExecutor(max_workers=num_cameras) as executor:
+                    future_to_key = {
+                        executor.submit(
+                            _encode_video_worker,
+                            video_key,
+                            episode_index,
+                            self.root,
+                            self.fps,
+                            self.vcodec,
+                        ): video_key
+                        for video_key in self.meta.video_keys
+                    }
+
+                    results = {}
+                    for future in concurrent.futures.as_completed(future_to_key):
+                        video_key = future_to_key[future]
+                        try:
+                            temp_path = future.result()
+                            results[video_key] = temp_path
+                        except Exception as exc:
+                            logging.error(f"Video encoding failed for {video_key}: {exc}")
+                            raise exc
+
+                for video_key in self.meta.video_keys:
+                    temp_path = results[video_key]
+                    ep_metadata.update(
+                        self._save_episode_video(video_key, episode_index, temp_path=temp_path)
+                    )
+            else:
+                for video_key in self.meta.video_keys:
+                    ep_metadata.update(self._save_episode_video(video_key, episode_index))
 
         # `meta.save_episode` need to be executed after encoding the videos
         self.meta.save_episode(episode_index, episode_length, episode_tasks, ep_stats, ep_metadata)
@@ -1497,23 +1537,7 @@ class LeRobotDataset(torch.utils.data.Dataset):
         Note: `encode_video_frames` is a blocking call. Making it asynchronous shouldn't speedup encoding,
         since video encoding with ffmpeg is already using multithreading.
         """
-        return _encode_video_worker(video_key, episode_index, self.root, self.fps)
-
-    def _encode_multiple_temporary_episode_videos(self, video_keys, episode_index):
-        temp_paths = []
-        img_dirs = []
-        for video_key in video_keys:
-            temp_paths.append(Path(tempfile.mkdtemp(dir=self.root)) / f"{video_key}_{episode_index:03d}.mp4")
-            img_dirs.append(self._get_image_file_dir(episode_index, video_key))
-        fps = [self.fps]*len(video_keys)
-
-        with ProcessPoolExecutor(max_workers=len(video_keys)) as executor:
-            executor.map(encode_video_frames,img_dirs,temp_paths,fps)
-
-        for img_dir in img_dirs:
-            shutil.rmtree(img_dir)
-
-        return temp_paths
+        return _encode_video_worker(video_key, episode_index, self.root, self.fps, self.vcodec)
 
     @classmethod
     def create(
@@ -1529,8 +1553,11 @@ class LeRobotDataset(torch.utils.data.Dataset):
         image_writer_threads: int = 0,
         video_backend: str | None = None,
         batch_encoding_size: int = 1,
+        vcodec: str = "libsvtav1",
     ) -> "LeRobotDataset":
         """Create a LeRobot Dataset from scratch in order to record data."""
+        if vcodec not in VALID_VIDEO_CODECS:
+            raise ValueError(f"Invalid vcodec '{vcodec}'. Must be one of: {sorted(VALID_VIDEO_CODECS)}")
         obj = cls.__new__(cls)
         obj.meta = LeRobotDatasetMetadata.create(
             repo_id=repo_id,
@@ -1547,6 +1574,7 @@ class LeRobotDataset(torch.utils.data.Dataset):
         obj.image_writer = None
         obj.batch_encoding_size = batch_encoding_size
         obj.episodes_since_last_encoding = 0
+        obj.vcodec = vcodec
 
         if image_writer_processes or image_writer_threads:
             obj.start_image_writer(image_writer_processes, image_writer_threads)

src/lerobot/datasets/pipeline_features.py

@@ -18,12 +18,12 @@ from typing import Any
 
 from lerobot.configs.types import PipelineFeatureType
 from lerobot.datasets.utils import hw_to_dataset_features
-from lerobot.processor import DataProcessorPipeline
+from lerobot.processor import DataProcessorPipeline, RobotAction, RobotObservation
 from lerobot.utils.constants import ACTION, OBS_IMAGES, OBS_STATE, OBS_STR
 
 
 def create_initial_features(
-    action: dict[str, Any] | None = None, observation: dict[str, Any] | None = None
+    action: RobotAction | None = None, observation: RobotObservation | None = None
 ) -> dict[PipelineFeatureType, dict[str, Any]]:
     """
     Creates the initial features dict for the dataset from action and observation specs.

src/lerobot/datasets/video_utils.py

@@ -310,7 +310,7 @@ def encode_video_frames(
     crf: int | None = 30,
     fast_decode: int = 0,
     log_level: int | None = av.logging.ERROR,
-    overwrite: bool = True,
+    overwrite: bool = False,
     preset: int | None = None,
 ) -> None:
     """More info on ffmpeg arguments tuning on `benchmark/video/README.md`"""
@@ -355,9 +355,6 @@ def encode_video_frames(
     if crf is not None:
         video_options["crf"] = str(crf)
 
-    #TEMPORARY FIX
-    video_options["preset"] = "12"
-
     if fast_decode:
         key = "svtav1-params" if vcodec == "libsvtav1" else "tune"
         value = f"fast-decode={fast_decode}" if vcodec == "libsvtav1" else "fastdecode"

src/lerobot/envs/__init__.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .configs import AlohaEnv, EnvConfig, PushtEnv  # noqa: F401
+from .configs import AlohaEnv, EnvConfig, HubEnvConfig, PushtEnv  # noqa: F401

src/lerobot/envs/configs.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import abc
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, fields
 from typing import Any
 
 import draccus
@@ -68,6 +68,22 @@ class EnvConfig(draccus.ChoiceRegistry, abc.ABC):
         raise NotImplementedError()
 
 
+@dataclass
+class HubEnvConfig(EnvConfig):
+    """Base class for environments that delegate creation to a hub-hosted make_env.
+
+    Hub environments download and execute remote code from the HF Hub.
+    The hub_path points to a repository containing an env.py with a make_env function.
+    """
+
+    hub_path: str | None = None  # required: e.g., "username/repo" or "username/repo@branch:file.py"
+
+    @property
+    def gym_kwargs(self) -> dict:
+        # Not used for hub environments - the hub's make_env handles everything
+        return {}
+
+
 @EnvConfig.register_subclass("aloha")
 @dataclass
 class AlohaEnv(EnvConfig):
@@ -368,3 +384,71 @@ class MetaworldEnv(EnvConfig):
             "obs_type": self.obs_type,
             "render_mode": self.render_mode,
         }
+
+
+@EnvConfig.register_subclass("isaaclab_arena")
+@dataclass
+class IsaaclabArenaEnv(HubEnvConfig):
+    hub_path: str = "nvidia/isaaclab-arena-envs"
+    episode_length: int = 300
+    num_envs: int = 1
+    embodiment: str | None = "gr1_pink"
+    object: str | None = "power_drill"
+    mimic: bool = False
+    teleop_device: str | None = None
+    seed: int | None = 42
+    device: str | None = "cuda:0"
+    disable_fabric: bool = False
+    enable_cameras: bool = False
+    headless: bool = False
+    enable_pinocchio: bool = True
+    environment: str | None = "gr1_microwave"
+    task: str | None = "Reach out to the microwave and open it."
+    state_dim: int = 54
+    action_dim: int = 36
+    camera_height: int = 512
+    camera_width: int = 512
+    video: bool = False
+    video_length: int = 100
+    video_interval: int = 200
+    # Comma-separated keys, e.g., "robot_joint_pos,left_eef_pos"
+    state_keys: str = "robot_joint_pos"
+    # Comma-separated keys, e.g., "robot_pov_cam_rgb,front_cam_rgb"
+    # Set to None or "" for environments without cameras
+    camera_keys: str | None = None
+    features: dict[str, PolicyFeature] = field(default_factory=dict)
+    features_map: dict[str, str] = field(default_factory=dict)
+    kwargs: dict | None = None
+
+    def __post_init__(self):
+        if self.kwargs:
+            # dynamically convert kwargs to fields in the dataclass
+            # NOTE! the new fields will not bee seen by the dataclass repr
+            field_names = {f.name for f in fields(self)}
+            for key, value in self.kwargs.items():
+                if key not in field_names and key != "kwargs":
+                    setattr(self, key, value)
+            self.kwargs = None
+
+        # Set action feature
+        self.features[ACTION] = PolicyFeature(type=FeatureType.ACTION, shape=(self.action_dim,))
+        self.features_map[ACTION] = ACTION
+
+        # Set state feature
+        self.features[OBS_STATE] = PolicyFeature(type=FeatureType.STATE, shape=(self.state_dim,))
+        self.features_map[OBS_STATE] = OBS_STATE
+
+        # Add camera features for each camera key
+        if self.enable_cameras and self.camera_keys:
+            for cam_key in self.camera_keys.split(","):
+                cam_key = cam_key.strip()
+                if cam_key:
+                    self.features[cam_key] = PolicyFeature(
+                        type=FeatureType.VISUAL,
+                        shape=(self.camera_height, self.camera_width, 3),
+                    )
+                    self.features_map[cam_key] = f"{OBS_IMAGES}.{cam_key}"
+
+    @property
+    def gym_kwargs(self) -> dict:
+        return {}

src/lerobot/envs/factory.py

@@ -20,11 +20,11 @@ import gymnasium as gym
 from gymnasium.envs.registration import registry as gym_registry
 
 from lerobot.configs.policies import PreTrainedConfig
-from lerobot.envs.configs import AlohaEnv, EnvConfig, LiberoEnv, PushtEnv
+from lerobot.envs.configs import AlohaEnv, EnvConfig, HubEnvConfig, IsaaclabArenaEnv, LiberoEnv, PushtEnv
 from lerobot.envs.utils import _call_make_env, _download_hub_file, _import_hub_module, _normalize_hub_result
 from lerobot.policies.xvla.configuration_xvla import XVLAConfig
 from lerobot.processor import ProcessorStep
-from lerobot.processor.env_processor import LiberoProcessorStep
+from lerobot.processor.env_processor import IsaaclabArenaProcessorStep, LiberoProcessorStep
 from lerobot.processor.pipeline import PolicyProcessorPipeline
 
 
@@ -73,6 +73,26 @@ def make_env_pre_post_processors(
     if isinstance(env_cfg, LiberoEnv) or "libero" in env_cfg.type:
         preprocessor_steps.append(LiberoProcessorStep())
 
+    # For Isaaclab Arena environments, add the IsaaclabArenaProcessorStep
+    if isinstance(env_cfg, IsaaclabArenaEnv) or "isaaclab_arena" in env_cfg.type:
+        # Parse comma-separated keys (handle None for state-based policies)
+        if env_cfg.state_keys:
+            state_keys = tuple(k.strip() for k in env_cfg.state_keys.split(",") if k.strip())
+        else:
+            state_keys = ()
+        if env_cfg.camera_keys:
+            camera_keys = tuple(k.strip() for k in env_cfg.camera_keys.split(",") if k.strip())
+        else:
+            camera_keys = ()
+        if not state_keys and not camera_keys:
+            raise ValueError("At least one of state_keys or camera_keys must be specified.")
+        preprocessor_steps.append(
+            IsaaclabArenaProcessorStep(
+                state_keys=state_keys,
+                camera_keys=camera_keys,
+            )
+        )
+
     preprocessor = PolicyProcessorPipeline(steps=preprocessor_steps)
     postprocessor = PolicyProcessorPipeline(steps=postprocessor_steps)
 
@@ -98,7 +118,6 @@ def make_env(
         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
         ModuleNotFoundError: If the requested env package is not installed
@@ -112,19 +131,35 @@ def make_env(
     """
     # if user passed a hub id string (e.g., "username/repo", "username/repo@main:env.py")
     # simplified: only support hub-provided `make_env`
+    # TODO: (jadechoghari): deprecate string API and remove this check
     if isinstance(cfg, str):
+        hub_path: str | None = cfg
+    elif isinstance(cfg, HubEnvConfig):
+        hub_path = cfg.hub_path
+    else:
+        hub_path = None
+
+    # If hub_path is set, download and call hub-provided `make_env`
+    if hub_path:
         # _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)
+        repo_id, file_path, local_file, revision = _download_hub_file(
+            hub_path, 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)
+        env_cfg = None if isinstance(cfg, str) else cfg
+        raw_result = _call_make_env(module, n_envs=n_envs, use_async_envs=use_async_envs, cfg=env_cfg)
 
         # normalize the return into {suite: {task_id: vec_env}}
         return _normalize_hub_result(raw_result)
 
+    # At this point, cfg must be an EnvConfig (not a string) since hub_path would have been set otherwise
+    if isinstance(cfg, str):
+        raise TypeError("cfg should be an EnvConfig at this point")
+
     if n_envs < 1:
         raise ValueError("`n_envs` must be at least 1")
 

src/lerobot/envs/libero.py

@@ -29,6 +29,8 @@ from gymnasium import spaces
 from libero.libero import benchmark, get_libero_path
 from libero.libero.envs import OffScreenRenderEnv
 
+from lerobot.processor import RobotObservation
+
 
 def _parse_camera_names(camera_name: str | Sequence[str]) -> list[str]:
     """Normalize camera_name into a non-empty list of strings."""
@@ -237,7 +239,7 @@ class LiberoEnv(gym.Env):
         env.reset()
         return env
 
-    def _format_raw_obs(self, raw_obs: dict[str, Any]) -> dict[str, Any]:
+    def _format_raw_obs(self, raw_obs: RobotObservation) -> RobotObservation:
         images = {}
         for camera_name in self.camera_name:
             image = raw_obs[camera_name]
@@ -313,7 +315,7 @@ class LiberoEnv(gym.Env):
         info = {"is_success": False}
         return observation, info
 
-    def step(self, action: np.ndarray) -> tuple[dict[str, Any], float, bool, bool, dict[str, Any]]:
+    def step(self, action: np.ndarray) -> tuple[RobotObservation, float, bool, bool, dict[str, Any]]:
         if action.ndim != 1:
             raise ValueError(
                 f"Expected action to be 1-D (shape (action_dim,)), "

src/lerobot/envs/metaworld.py

@@ -25,6 +25,8 @@ import metaworld.policies as policies
 import numpy as np
 from gymnasium import spaces
 
+from lerobot.processor import RobotObservation
+
 # ---- Load configuration data from the external JSON file ----
 CONFIG_PATH = Path(__file__).parent / "metaworld_config.json"
 try:
@@ -161,7 +163,7 @@ class MetaworldEnv(gym.Env):
         env._freeze_rand_vec = False  # otherwise no randomization
         return env
 
-    def _format_raw_obs(self, raw_obs: np.ndarray) -> dict[str, Any]:
+    def _format_raw_obs(self, raw_obs: np.ndarray) -> RobotObservation:
         image = None
         if self._env is not None:
             image = self._env.render()
@@ -196,7 +198,7 @@ class MetaworldEnv(gym.Env):
         self,
         seed: int | None = None,
         **kwargs,
-    ) -> tuple[dict[str, Any], dict[str, Any]]:
+    ) -> tuple[RobotObservation, dict[str, Any]]:
         """
         Reset the environment to its initial state.
 
@@ -204,7 +206,7 @@ class MetaworldEnv(gym.Env):
             seed (Optional[int]): Random seed for environment initialization.
 
         Returns:
-            observation (Dict[str, Any]): The initial formatted observation.
+            observation (RobotObservation): The initial formatted observation.
             info (Dict[str, Any]): Additional info about the reset state.
         """
         super().reset(seed=seed)
@@ -216,7 +218,7 @@ class MetaworldEnv(gym.Env):
         info = {"is_success": False}
         return observation, info
 
-    def step(self, action: np.ndarray) -> tuple[dict[str, Any], float, bool, bool, dict[str, Any]]:
+    def step(self, action: np.ndarray) -> tuple[RobotObservation, float, bool, bool, dict[str, Any]]:
         """
         Perform one environment step.
 
@@ -224,7 +226,7 @@ class MetaworldEnv(gym.Env):
             action (np.ndarray): The action to execute, must be 1-D with shape (action_dim,).
 
         Returns:
-            observation (Dict[str, Any]): The formatted observation after the step.
+            observation (RobotObservation): The formatted observation after the step.
             reward (float): The scalar reward for this step.
             terminated (bool): Whether the episode terminated successfully.
             truncated (bool): Whether the episode was truncated due to a time limit.