Add bundled OpenArm URDF and meshes for UMI evaluation

- Copy openarm_bimanual_pybullet.urdf and all referenced STL/DAE meshes
  into src/lerobot/robots/openarms/urdf/
- Update openarms_follower.py to prefer the bundled URDF over the
  external ~/Documents/openarm_description path
- Includes visual and collision meshes for arm, body, and end-effector
- Force-add .stl and .urdf files past .gitignore

.gitignore

@@ -173,4 +173,7 @@ outputs/
 
 # Dev folders
 .cache/*
+*.stl
+*.urdf
+*.xml
 *.part

examples/openarms/convert_joints_to_ee.py

@@ -1,257 +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.
-
-"""
-Convert a joint-space OpenArms dataset to end-effector space.
-
-For each frame, converts joint positions to EE poses (x, y, z, wx, wy, wz) using FK.
-Grippers are kept as-is. Applies to both observation.state and action.
-
-Example usage:
-    python examples/openarms/convert_joints_to_ee.py \
-        --input-dataset lerobot-data-collection/rac_blackf0 \
-        --output-repo-id my_user/rac_blackf0_ee \
-        --output-dir ./outputs/rac_blackf0_ee
-"""
-
-import argparse
-import shutil
-from pathlib import Path
-
-import numpy as np
-import pandas as pd
-from tqdm import tqdm
-
-from lerobot.datasets.compute_stats import get_feature_stats
-from lerobot.datasets.lerobot_dataset import LeRobotDataset, LeRobotDatasetMetadata
-from lerobot.datasets.utils import write_info, write_stats
-from lerobot.model.kinematics import RobotKinematics
-from lerobot.utils.rotation import Rotation
-
-DEFAULT_URDF = "src/lerobot/robots/openarms/urdf/openarm_bimanual_pybullet.urdf"
-DEFAULT_LEFT_EE_FRAME = "openarm_left_hand_tcp"
-DEFAULT_RIGHT_EE_FRAME = "openarm_right_hand_tcp"
-
-LEFT_URDF_JOINTS = [f"openarm_left_joint{i}" for i in range(1, 8)]
-RIGHT_URDF_JOINTS = [f"openarm_right_joint{i}" for i in range(1, 8)]
-
-JOINT_NAMES = [f"joint_{i}" for i in range(1, 8)]
-EE_COMPONENTS = ["x", "y", "z", "wx", "wy", "wz"]
-
-
-def compute_fk_for_arm(kinematics: RobotKinematics, joint_values: np.ndarray) -> dict[str, float]:
-    """Compute FK for one arm, returns EE pose as dict."""
-    t = kinematics.forward_kinematics(joint_values)
-    pos = t[:3, 3]
-    rotvec = Rotation.from_matrix(t[:3, :3]).as_rotvec()
-    return {
-        "x": float(pos[0]),
-        "y": float(pos[1]),
-        "z": float(pos[2]),
-        "wx": float(rotvec[0]),
-        "wy": float(rotvec[1]),
-        "wz": float(rotvec[2]),
-    }
-
-
-def convert_joints_to_ee(
-    values: np.ndarray,
-    names: list[str],
-    left_kin: RobotKinematics,
-    right_kin: RobotKinematics,
-) -> tuple[np.ndarray, list[str]]:
-    """
-    Convert joint values to EE values.
-    
-    Args:
-        values: Array of shape (N,) with joint values for one frame
-        names: List of feature names corresponding to values
-        left_kin: Left arm kinematics solver
-        right_kin: Right arm kinematics solver
-    
-    Returns:
-        (new_values, new_names) with joints replaced by EE poses
-    """
-    name_to_idx = {n: i for i, n in enumerate(names)}
-    
-    new_values = []
-    new_names = []
-    
-    for prefix, kinematics in [("right", right_kin), ("left", left_kin)]:
-        joint_vals = []
-        for jname in JOINT_NAMES:
-            key = f"{prefix}_{jname}.pos"
-            if key in name_to_idx:
-                joint_vals.append(values[name_to_idx[key]])
-        
-        if len(joint_vals) == 7:
-            ee_pose = compute_fk_for_arm(kinematics, np.array(joint_vals, dtype=float))
-            for comp in EE_COMPONENTS:
-                new_names.append(f"{prefix}_ee.{comp}")
-                new_values.append(ee_pose[comp])
-        
-        gripper_key = f"{prefix}_gripper.pos"
-        if gripper_key in name_to_idx:
-            new_names.append(f"{prefix}_ee.gripper_pos")
-            new_values.append(values[name_to_idx[gripper_key]])
-    
-    return np.array(new_values, dtype=np.float32), new_names
-
-
-def transform_feature_info(old_info: dict, new_names: list[str]) -> dict:
-    """Create new feature info with EE names instead of joint names."""
-    return {
-        "dtype": old_info.get("dtype", "float32"),
-        "shape": (len(new_names),),
-        "names": new_names,
-    }
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Convert joint-space dataset to EE-space")
-    parser.add_argument("--input-dataset", type=str, required=True, help="Input dataset repo ID")
-    parser.add_argument("--output-repo-id", type=str, required=True, help="Output dataset repo ID")
-    parser.add_argument("--output-dir", type=str, required=True, help="Output directory")
-    parser.add_argument("--urdf", type=str, default=DEFAULT_URDF, help="Path to URDF file")
-    parser.add_argument("--left-ee-frame", type=str, default=DEFAULT_LEFT_EE_FRAME)
-    parser.add_argument("--right-ee-frame", type=str, default=DEFAULT_RIGHT_EE_FRAME)
-    parser.add_argument("--push-to-hub", action="store_true", help="Push converted dataset to HF Hub")
-    args = parser.parse_args()
-
-    output_dir = Path(args.output_dir)
-    if output_dir.exists():
-        shutil.rmtree(output_dir)
-
-    urdf_path = args.urdf
-    if not Path(urdf_path).is_absolute():
-        urdf_path = str(Path(__file__).parent.parent.parent / urdf_path)
-
-    print(f"Loading dataset: {args.input_dataset}")
-    dataset = LeRobotDataset(args.input_dataset)
-    
-    print(f"Initializing kinematics from {urdf_path}")
-    left_kin = RobotKinematics(urdf_path, args.left_ee_frame, LEFT_URDF_JOINTS)
-    right_kin = RobotKinematics(urdf_path, args.right_ee_frame, RIGHT_URDF_JOINTS)
-
-    action_info = dataset.meta.features.get("action", {})
-    state_info = dataset.meta.features.get("observation.state", {})
-    action_names = action_info.get("names", [])
-    state_names = state_info.get("names", [])
-
-    print(f"Original action names ({len(action_names)}): {action_names[:8]}...")
-    print(f"Original state names ({len(state_names)}): {state_names[:8]}...")
-
-    sample_action = np.zeros(len(action_names), dtype=np.float32)
-    _, new_action_names = convert_joints_to_ee(sample_action, action_names, left_kin, right_kin)
-    sample_state = np.zeros(len(state_names), dtype=np.float32)
-    _, new_state_names = convert_joints_to_ee(sample_state, state_names, left_kin, right_kin)
-
-    print(f"New action names ({len(new_action_names)}): {new_action_names}")
-    print(f"New state names ({len(new_state_names)}): {new_state_names}")
-
-    new_features = dataset.meta.features.copy()
-    new_features["action"] = transform_feature_info(action_info, new_action_names)
-    new_features["observation.state"] = transform_feature_info(state_info, new_state_names)
-
-    new_meta = LeRobotDatasetMetadata.create(
-        repo_id=args.output_repo_id,
-        fps=dataset.meta.fps,
-        features=new_features,
-        robot_type=dataset.meta.robot_type,
-        root=output_dir,
-        use_videos=len(dataset.meta.video_keys) > 0,
-    )
-
-    data_dir = dataset.root / "data"
-    parquet_files = sorted(data_dir.glob("*/*.parquet"))
-    print(f"Processing {len(parquet_files)} parquet files...")
-
-    all_actions = []
-    all_states = []
-
-    for src_path in tqdm(parquet_files, desc="Converting"):
-        df = pd.read_parquet(src_path).reset_index(drop=True)
-        
-        new_actions = []
-        new_states = []
-        
-        for idx in range(len(df)):
-            action_vals = np.array(df.iloc[idx]["action"], dtype=np.float32)
-            state_vals = np.array(df.iloc[idx]["observation.state"], dtype=np.float32)
-            
-            new_action, _ = convert_joints_to_ee(action_vals, action_names, left_kin, right_kin)
-            new_state, _ = convert_joints_to_ee(state_vals, state_names, left_kin, right_kin)
-            
-            new_actions.append(new_action.tolist())
-            new_states.append(new_state.tolist())
-            all_actions.append(new_action)
-            all_states.append(new_state)
-        
-        df["action"] = new_actions
-        df["observation.state"] = new_states
-        
-        relative_path = src_path.relative_to(dataset.root)
-        out_path = output_dir / relative_path
-        out_path.parent.mkdir(parents=True, exist_ok=True)
-        df.to_parquet(out_path)
-
-    print("Computing statistics...")
-    all_actions_arr = np.stack(all_actions)
-    all_states_arr = np.stack(all_states)
-    
-    stats = {}
-    stats["action"] = get_feature_stats(all_actions_arr, axis=0, keepdims=True)
-    stats["observation.state"] = get_feature_stats(all_states_arr, axis=0, keepdims=True)
-    write_stats(stats, output_dir)
-
-    print("Updating metadata...")
-    new_meta.info["total_episodes"] = dataset.meta.total_episodes
-    new_meta.info["total_frames"] = dataset.meta.total_frames
-    new_meta.info["total_tasks"] = dataset.meta.total_tasks
-    write_info(new_meta.info, output_dir)
-
-    print("Copying episode metadata...")
-    src_episodes_dir = dataset.root / "meta" / "episodes"
-    dst_episodes_dir = output_dir / "meta" / "episodes"
-    if src_episodes_dir.exists():
-        shutil.copytree(src_episodes_dir, dst_episodes_dir, dirs_exist_ok=True)
-
-    print("Copying tasks metadata...")
-    src_tasks = dataset.root / "meta" / "tasks.parquet"
-    dst_tasks = output_dir / "meta" / "tasks.parquet"
-    if src_tasks.exists():
-        shutil.copy2(src_tasks, dst_tasks)
-
-    if dataset.meta.video_keys:
-        print("Copying videos...")
-        src_videos = dataset.root / "videos"
-        dst_videos = output_dir / "videos"
-        if src_videos.exists():
-            shutil.copytree(src_videos, dst_videos, dirs_exist_ok=True)
-
-    print(f"\nDone! Dataset saved to: {output_dir}")
-    print(f"Repo ID: {args.output_repo_id}")
-
-    if args.push_to_hub:
-        print("\nPushing to Hub...")
-        output_dataset = LeRobotDataset(args.output_repo_id, root=output_dir)
-        output_dataset.push_to_hub()
-        print(f"Pushed to: https://huggingface.co/datasets/{args.output_repo_id}")
-
-
-if __name__ == "__main__":
-    main()
-

examples/openarms/evaluate_ee.py

@@ -1,650 +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 End-Effector Policy Evaluation
-
-Evaluates a policy trained on end-effector (EE) space by:
-1. Converting robot joint observations to EE poses (FK)
-2. Running policy inference with EE state
-3. Converting EE action output back to joint positions (IK)
-4. Sending joint commands to robot
-
-Example usage:
-    python examples/openarms/evaluate_ee.py
-    python examples/openarms/evaluate_ee.py --model lerobot/my-ee-policy
-"""
-
-import time
-from pathlib import Path
-
-import numpy as np
-import torch
-
-from lerobot.cameras.opencv.configuration_opencv import OpenCVCameraConfig
-from lerobot.configs.policies import PreTrainedConfig
-from lerobot.configs.train import TrainPipelineConfig
-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.model.kinematics import RobotKinematics
-from lerobot.policies.factory import make_policy, make_pre_post_processors
-from lerobot.processor import RobotAction, RobotObservation, RobotProcessorPipeline, make_default_processors
-from lerobot.utils.constants import ACTION, OBS_STR
-from lerobot.utils.control_utils import predict_action
-from lerobot.utils.relative_actions import (
-    convert_state_to_relative,
-    convert_from_relative_actions,
-    PerTimestepNormalizer,
-)
-from lerobot.utils.utils import get_safe_torch_device
-from lerobot.utils.visualization_utils import init_rerun, log_rerun_data
-from lerobot.processor.converters import (
-    robot_action_observation_to_transition,
-    robot_action_to_transition,
-    transition_to_robot_action,
-)
-from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
-from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
-from lerobot.robots.openarms.robot_kinematic_processor import (
-    BimanualEEBoundsAndSafety,
-    BimanualForwardKinematicsJointsToEE,
-    BimanualInverseKinematicsEEToJoints,
-)
-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.robot_utils import precise_sleep
-from lerobot.utils.utils import log_say
-
-# Configuration
-HF_MODEL_ID = "lerobot-data-collection/pi0_ee"  # TODO: Replace with your EE-trained model
-HF_EVAL_DATASET_ID = "your-org/your-ee-eval-dataset"  # TODO: Replace with your eval dataset
-TASK_DESCRIPTION = "ee-policy-task"  # TODO: Replace with your task
-
-NUM_EPISODES = 1
-FPS = 30
-EPISODE_TIME_SEC = 1000
-RESET_TIME_SEC = 60
-
-# Robot CAN interfaces
-FOLLOWER_LEFT_PORT = "can0"
-FOLLOWER_RIGHT_PORT = "can1"
-
-# Leader for manual resets (disabled by default)
-USE_LEADER_FOR_RESETS = False
-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),
-}
-
-# Kinematics configuration
-DEFAULT_URDF = "src/lerobot/robots/openarms/urdf/openarm_bimanual_pybullet.urdf"
-DEFAULT_LEFT_EE_FRAME = "openarm_left_hand_tcp"
-DEFAULT_RIGHT_EE_FRAME = "openarm_right_hand_tcp"
-
-MOTOR_NAMES = ["joint_1", "joint_2", "joint_3", "joint_4", "joint_5", "joint_6", "joint_7", "gripper"]
-LEFT_URDF_JOINTS = [f"openarm_left_joint{i}" for i in range(1, 8)]
-RIGHT_URDF_JOINTS = [f"openarm_right_joint{i}" for i in range(1, 8)]
-
-
-def load_relative_config(model_path: Path | str) -> tuple[PerTimestepNormalizer | None, bool, bool]:
-    """Auto-detect relative action/state settings and load normalizer from checkpoint."""
-    model_path = Path(model_path) if isinstance(model_path, str) else model_path
-    normalizer = None
-    use_relative_actions = False
-    use_relative_state = False
-    
-    # Try local path first
-    if model_path.exists():
-        stats_path = model_path / "relative_stats.pt"
-        if stats_path.exists():
-            normalizer = PerTimestepNormalizer.load(stats_path)
-            use_relative_actions = True
-            print(f"  Loaded per-timestep stats from: {stats_path}")
-        
-        config_path = model_path / "train_config.json"
-        if config_path.exists():
-            cfg = TrainPipelineConfig.from_pretrained(model_path)
-            use_relative_actions = getattr(cfg, "use_relative_actions", use_relative_actions)
-            use_relative_state = getattr(cfg, "use_relative_state", False)
-    else:
-        # Try hub
-        try:
-            from huggingface_hub import hf_hub_download
-            try:
-                stats_file = hf_hub_download(repo_id=str(model_path), filename="relative_stats.pt")
-                normalizer = PerTimestepNormalizer.load(stats_file)
-                use_relative_actions = True
-                print("  Loaded per-timestep stats from hub")
-            except Exception:
-                pass  # No stats file means no relative actions
-            
-            try:
-                config_file = hf_hub_download(repo_id=str(model_path), filename="train_config.json")
-                cfg = TrainPipelineConfig.from_pretrained(Path(config_file).parent)
-                use_relative_actions = getattr(cfg, "use_relative_actions", use_relative_actions)
-                use_relative_state = getattr(cfg, "use_relative_state", False)
-            except Exception:
-                pass
-        except Exception as e:
-            print(f"  Warning: Could not load relative config: {e}")
-    
-    return normalizer, use_relative_actions, use_relative_state
-
-
-def build_kinematics_pipelines(urdf_path: str, left_ee_frame: str, right_ee_frame: str):
-    """Build FK and IK pipelines for bimanual robot."""
-    left_kinematics = RobotKinematics(
-        urdf_path=urdf_path,
-        target_frame_name=left_ee_frame,
-        joint_names=LEFT_URDF_JOINTS,
-    )
-    right_kinematics = RobotKinematics(
-        urdf_path=urdf_path,
-        target_frame_name=right_ee_frame,
-        joint_names=RIGHT_URDF_JOINTS,
-    )
-
-    # Joints -> EE (Forward Kinematics)
-    joints_to_ee = RobotProcessorPipeline[RobotAction, RobotAction](
-        steps=[
-            BimanualForwardKinematicsJointsToEE(
-                left_kinematics=left_kinematics,
-                right_kinematics=right_kinematics,
-                motor_names=MOTOR_NAMES,
-            ),
-        ],
-        to_transition=robot_action_to_transition,
-        to_output=transition_to_robot_action,
-    )
-
-    # EE -> Joints (Inverse Kinematics)
-    ee_to_joints = RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction](
-        steps=[
-            BimanualEEBoundsAndSafety(
-                end_effector_bounds={"min": [-1.0, -1.0, -1.0], "max": [1.0, 1.0, 1.0]},
-                max_ee_step_m=0.10,
-            ),
-            BimanualInverseKinematicsEEToJoints(
-                left_kinematics=left_kinematics,
-                right_kinematics=right_kinematics,
-                motor_names=MOTOR_NAMES,
-                initial_guess_current_joints=True,
-            ),
-        ],
-        to_transition=robot_action_observation_to_transition,
-        to_output=transition_to_robot_action,
-    )
-
-    return joints_to_ee, ee_to_joints
-
-
-def convert_obs_joints_to_ee(obs: dict, joints_to_ee_pipeline) -> dict:
-    """Convert joint observations to EE space."""
-    # Extract joint positions from observation
-    joint_positions = {}
-    for key, value in obs.items():
-        if key.startswith("observation.state.") and key.endswith(".pos"):
-            # e.g., observation.state.left_joint_1.pos -> left_joint_1.pos
-            motor_key = key.replace("observation.state.", "")
-            joint_positions[motor_key] = value
-    
-    if not joint_positions:
-        return obs
-    
-    # Apply FK to get EE poses
-    ee_poses = joints_to_ee_pipeline(joint_positions)
-    
-    # Build new observation with EE state
-    new_obs = {}
-    for key, value in obs.items():
-        if not (key.startswith("observation.state.") and key.endswith(".pos")):
-            new_obs[key] = value
-    
-    # Add EE poses as state
-    for key, value in ee_poses.items():
-        new_obs[f"observation.state.{key}"] = value
-    
-    return new_obs
-
-
-def convert_action_ee_to_joints(
-    ee_action: dict,
-    current_obs: dict,
-    ee_to_joints_pipeline,
-) -> dict:
-    """Convert EE action to joint positions using IK."""
-    # Extract EE components from action
-    ee_action_dict = {}
-    for key, value in ee_action.items():
-        if "ee." in key:
-            # e.g., action.left_ee.x -> left_ee.x
-            ee_key = key.replace("action.", "")
-            ee_action_dict[ee_key] = value
-    
-    if not ee_action_dict:
-        return ee_action
-    
-    # Build current observation for IK (joint positions)
-    current_joints = {}
-    for key, value in current_obs.items():
-        if key.startswith("observation.state.") and "joint" in key and key.endswith(".pos"):
-            motor_key = key.replace("observation.state.", "")
-            current_joints[motor_key] = value
-    
-    # Apply IK
-    joint_action = ee_to_joints_pipeline((ee_action_dict, current_joints))
-    
-    # Format as action dict
-    result = {}
-    for key, value in joint_action.items():
-        result[f"action.{key}"] = value
-    
-    return result
-
-
-def run_ee_inference_loop(
-    robot: OpenArmsFollower,
-    policy,
-    preprocessor,
-    postprocessor,
-    joints_to_ee,
-    ee_to_joints,
-    dataset: LeRobotDataset,
-    fps: int,
-    duration_s: float,
-    events: dict,
-    task: str,
-    use_relative_actions: bool = False,
-    use_relative_state: bool = False,
-    relative_normalizer: PerTimestepNormalizer | None = None,
-    display_data: bool = True,
-):
-    """Run inference loop with EE conversion and optional UMI-style relative actions."""
-    device = get_safe_torch_device(policy.config.device)
-    
-    # Reset policy and processors
-    policy.reset()
-    preprocessor.reset()
-    postprocessor.reset()
-    
-    dt = 1.0 / fps
-    timestamp = 0
-    start_time = time.perf_counter()
-    step = 0
-    
-    mode_str = ""
-    if use_relative_actions:
-        mode_str += " [relative actions]"
-    if use_relative_state:
-        mode_str += " [relative state]"
-    print(f"\nRunning EE inference for {duration_s}s...{mode_str}")
-    
-    while timestamp < duration_s:
-        loop_start = time.perf_counter()
-        
-        if events.get("exit_early"):
-            events["exit_early"] = False
-            break
-        
-        # 1. Get robot observation (joint positions)
-        robot_obs = robot.get_observation()
-        
-        # 2. Convert joint observation to EE space using FK
-        joint_state = {}
-        for key, value in robot_obs.items():
-            if key.endswith(".pos"):
-                joint_state[key] = value
-        
-        ee_state = joints_to_ee(joint_state.copy())
-        
-        # 3. Build observation frame with EE state for policy input
-        # Filter to only EE keys (FK may include other keys in output)
-        # Expected: left_ee.{x,y,z,wx,wy,wz,gripper_pos}, right_ee.{...} = 14 total
-        ee_keys = sorted([k for k in ee_state.keys() if "_ee." in k])
-        ee_values = [ee_state[k] for k in ee_keys]
-        
-        # Debug: print on first step
-        if step == 0:
-            print(f"  FK output keys ({len(ee_keys)}): {ee_keys}")
-            state_feature = policy.config.input_features.get("observation.state")
-            if state_feature:
-                print(f"  Policy expects state dim: {state_feature.shape[0]}")
-        
-        # Store current EE position for relative action conversion (using same order)
-        current_ee_pos = torch.tensor(ee_values)
-        
-        # Convert to relative state if enabled (UMI-style)
-        if use_relative_state:
-            ee_state_tensor = torch.tensor(ee_values)
-            relative_state = convert_state_to_relative(ee_state_tensor.unsqueeze(0))
-            ee_values = [float(relative_state[0, i]) for i in range(len(ee_values))]
-        
-        # Build observation dict for policy (images + state as numpy arrays)
-        observation_frame = {}
-        
-        # Add images - robot.cameras contains camera names as keys
-        for cam_name in robot.cameras:
-            if cam_name in robot_obs:
-                observation_frame[f"observation.images.{cam_name}"] = robot_obs[cam_name]
-        
-        # Add state as numpy array
-        observation_frame["observation.state"] = np.array(ee_values, dtype=np.float32)
-        
-        # 4. Run policy inference using predict_action
-        action_tensor = predict_action(
-            observation=observation_frame,
-            policy=policy,
-            device=device,
-            preprocessor=preprocessor,
-            postprocessor=postprocessor,
-            use_amp=policy.config.use_amp,
-            task=task,
-            robot_type=robot.robot_type,
-        )
-        
-        # 5. Convert action tensor to dict using EE keys (not joint keys from eval dataset)
-        action_tensor = action_tensor.squeeze(0).cpu()
-        while action_tensor.dim() > 1:
-            action_tensor = action_tensor[0]
-        # Use the same EE keys we used for state (truncated to match policy's action dim)
-        ee_action = {ee_keys[i]: float(action_tensor[i]) for i in range(len(action_tensor))}
-        
-        # 6. Convert relative action back to absolute if needed
-        if use_relative_actions:
-            action_keys = sorted(ee_action.keys())
-            action_vals = torch.tensor([ee_action[k] for k in action_keys])
-            
-            # Unnormalize if we have a normalizer
-            if relative_normalizer is not None:
-                action_vals = relative_normalizer.unnormalize(action_vals.unsqueeze(0).unsqueeze(0))
-                action_vals = action_vals.squeeze(0).squeeze(0)
-            
-            # Convert from relative to absolute
-            absolute_action = convert_from_relative_actions(action_vals.unsqueeze(0), current_ee_pos)
-            
-            # Convert back to dict
-            ee_action = {k: float(absolute_action[0, i]) for i, k in enumerate(action_keys)}
-        
-        # 7. Convert EE action to joint positions using IK
-        joint_action = ee_to_joints((ee_action.copy(), joint_state.copy()))
-        
-        # 8. Send joint commands to robot
-        robot.send_action(joint_action)
-        
-        # 9. Save frame to dataset (save original robot obs + joint action)
-        if dataset is not None:
-            obs_frame = build_dataset_frame(dataset.features, robot_obs, prefix=OBS_STR)
-            act_frame = build_dataset_frame(dataset.features, joint_action, prefix=ACTION)
-            frame = {**obs_frame, **act_frame, "task": task}
-            dataset.add_frame(frame)
-        
-        # 10. Visualization
-        if display_data:
-            log_rerun_data(observation=robot_obs, action=joint_action)
-        
-        # Progress logging
-        step += 1
-        if step % (fps * 5) == 0:
-            elapsed = time.perf_counter() - start_time
-            print(f"  Step {step}, elapsed: {elapsed:.1f}s")
-        
-        # Maintain loop rate
-        loop_duration = time.perf_counter() - loop_start
-        sleep_time = dt - loop_duration
-        if sleep_time > 0:
-            precise_sleep(sleep_time)
-        
-        timestamp = time.perf_counter() - start_time
-    
-    print(f"  Completed {step} steps")
-
-
-def main():
-    """Main evaluation function for EE policies."""
-    print("=" * 70)
-    print("OpenArms End-Effector Policy Evaluation")
-    print("=" * 70)
-    print(f"\nModel: {HF_MODEL_ID}")
-    print(f"Dataset: {HF_EVAL_DATASET_ID}")
-    print(f"Task: {TASK_DESCRIPTION}")
-    print(f"Episodes: {NUM_EPISODES}")
-    print(f"Episode Duration: {EPISODE_TIME_SEC}s")
-    print("=" * 70)
-    
-    # Resolve URDF path
-    urdf_path = Path(__file__).parent.parent.parent / DEFAULT_URDF
-    if not urdf_path.exists():
-        raise FileNotFoundError(f"URDF not found: {urdf_path}")
-    urdf_path = str(urdf_path)
-    
-    # Build kinematics pipelines
-    print("\n[1/5] Building kinematics pipelines...")
-    joints_to_ee, ee_to_joints = build_kinematics_pipelines(
-        urdf_path, DEFAULT_LEFT_EE_FRAME, DEFAULT_RIGHT_EE_FRAME
-    )
-    print("  FK and IK pipelines ready")
-    
-    # Initialize robot
-    print("\n[2/5] Connecting to robot...")
-    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("Robot failed to connect!")
-    print("  Robot connected")
-    
-    # Initialize leader for resets
-    leader = None
-    if USE_LEADER_FOR_RESETS:
-        print("\n  Connecting 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,
-        )
-        leader = OpenArmsLeader(leader_config)
-        leader.connect(calibrate=False)
-        
-        if leader.is_connected and leader.pin_robot is not None:
-            leader.bus_right.enable_torque()
-            leader.bus_left.enable_torque()
-            print("  Leader connected with gravity compensation")
-    
-    # Create dataset for saving evaluation data
-    print(f"\n[3/5] Creating evaluation dataset...")
-    teleop_action_processor, robot_action_processor, robot_observation_processor = make_default_processors()
-    action_features_hw = {k: v for k, v in follower.action_features.items() if k.endswith(".pos")}
-    
-    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,
-        ),
-    )
-    
-    dataset_path = Path.home() / ".cache" / "huggingface" / "lerobot" / HF_EVAL_DATASET_ID
-    if dataset_path.exists():
-        print(f"  Dataset exists at: {dataset_path}")
-        if input("  Continue and overwrite? (y/n): ").strip().lower() != 'y':
-            follower.disconnect()
-            return
-    
-    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,
-    )
-    print("  Dataset created")
-    
-    # Load policy directly using from_pretrained to preserve original EE features
-    # (make_policy would overwrite output_features with joint features from eval dataset)
-    print(f"\n[4/5] Loading policy from {HF_MODEL_ID}...")
-    from lerobot.policies.factory import get_policy_class
-    
-    policy_config = PreTrainedConfig.from_pretrained(HF_MODEL_ID)
-    policy_cls = get_policy_class(policy_config.type)
-    policy = policy_cls.from_pretrained(HF_MODEL_ID)
-    
-    # Load preprocessor/postprocessor from pretrained model
-    # (uses the trained EE features, not joint features from eval dataset)
-    preprocessor, postprocessor = make_pre_post_processors(
-        policy_cfg=policy.config,
-        pretrained_path=HF_MODEL_ID,
-        preprocessor_overrides={
-            "device_processor": {"device": str(policy.config.device)}
-        },
-    )
-    print("  Policy loaded")
-    print(f"  State dim: {policy.config.input_features['observation.state'].shape[0]}")
-    print(f"  Action dim: {policy.config.output_features['action'].shape[0]}")
-    
-    # Auto-detect relative action/state settings from checkpoint
-    relative_normalizer, use_relative_actions, use_relative_state = load_relative_config(HF_MODEL_ID)
-    
-    mode = "absolute"
-    if use_relative_actions:
-        mode = "relative actions + state" if use_relative_state else "relative actions only"
-    print(f"  Mode: {mode}")
-    
-    # Initialize keyboard listener and visualization
-    print("\n[5/5] Starting evaluation...")
-    listener, events = init_keyboard_listener()
-    init_rerun(session_name="openarms_eval_ee")
-    
-    print("\nControls: ESC=stop, →=next episode, ←=rerecord")
-    episode_idx = 0
-    
-    try:
-        while episode_idx < NUM_EPISODES and not events.get("stop_recording"):
-            log_say(f"Episode {episode_idx + 1} of {NUM_EPISODES}")
-            print(f"\n{'='*50}")
-            print(f"Episode {episode_idx + 1}/{NUM_EPISODES}")
-            print(f"{'='*50}")
-            
-            input("\nPress ENTER to start episode...")
-            events["exit_early"] = False
-            
-            # Run inference with EE conversion
-            run_ee_inference_loop(
-                robot=follower,
-                policy=policy,
-                preprocessor=preprocessor,
-                postprocessor=postprocessor,
-                joints_to_ee=joints_to_ee,
-                ee_to_joints=ee_to_joints,
-                dataset=dataset,
-                fps=FPS,
-                duration_s=EPISODE_TIME_SEC,
-                events=events,
-                task=TASK_DESCRIPTION,
-                use_relative_actions=use_relative_actions,
-                use_relative_state=use_relative_state,
-                relative_normalizer=relative_normalizer,
-            )
-            
-            # Handle re-recording
-            if events.get("rerecord_episode", False):
-                log_say("Re-recording episode")
-                events["rerecord_episode"] = False
-                events["exit_early"] = False
-                dataset.clear_episode_buffer()
-                continue
-            
-            # Save episode if we have data
-            if dataset.episode_buffer is not None and dataset.episode_buffer.get("size", 0) > 0:
-                print(f"  Saving episode {episode_idx + 1}...")
-                dataset.save_episode()
-                episode_idx += 1
-            
-            events["exit_early"] = False
-            
-            # Reset between episodes
-            if episode_idx < NUM_EPISODES and not events.get("stop_recording"):
-                if USE_LEADER_FOR_RESETS and leader and leader.is_connected:
-                    log_say("Reset environment using leader arms")
-                    print(f"\nManual reset ({RESET_TIME_SEC}s) - use leader arms...")
-                    
-                    reset_start = time.perf_counter()
-                    while time.perf_counter() - reset_start < RESET_TIME_SEC:
-                        if events.get("exit_early") or events.get("stop_recording"):
-                            break
-                        
-                        leader_action = leader.get_action()
-                        follower_action = {k: v for k, v in leader_action.items() if k.endswith(".pos")}
-                        if follower_action:
-                            follower.send_action(follower_action)
-                        time.sleep(1/FPS)
-                else:
-                    input("\nReset environment and press ENTER...")
-        
-        print(f"\n✓ Evaluation complete! {episode_idx} episodes recorded")
-        log_say("Evaluation complete", blocking=True)
-    
-    except KeyboardInterrupt:
-        print("\n\nEvaluation interrupted")
-    
-    finally:
-        if leader:
-            if hasattr(leader, 'bus_right'):
-                leader.bus_right.disable_torque()
-            if hasattr(leader, 'bus_left'):
-                leader.bus_left.disable_torque()
-            leader.disconnect()
-        
-        follower.disconnect()
-        
-        if listener is not None:
-            listener.stop()
-        
-        # Finalize and push dataset
-        dataset.finalize()
-        print("Uploading to Hub...")
-        dataset.push_to_hub(private=True)
-        
-        print("✓ Done!")
-
-
-if __name__ == "__main__":
-    main()
-

examples/openarms/evaluate_relative.py

@@ -26,13 +26,14 @@ 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.policies.factory import make_policy, make_pre_post_processors
+from lerobot.policies.utils import predict_action
 from lerobot.processor import make_default_processors
+from lerobot.processor.core import RobotAction
 from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
 from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
 from lerobot.utils.constants import ACTION, OBS_STR
-from lerobot.utils.control_utils import init_keyboard_listener, predict_action
-from lerobot.utils.robot_utils import precise_sleep
-from lerobot.utils.utils import get_safe_torch_device
+from lerobot.utils.control_utils import init_keyboard_listener, precise_sleep
+from lerobot.utils.device_utils import get_safe_torch_device
 from lerobot.utils.relative_actions import (
     convert_from_relative_actions_dict,
     convert_state_to_relative,
@@ -49,7 +50,7 @@ TASK_DESCRIPTION = "your task description"
 
 NUM_EPISODES = 1
 FPS = 30
-EPISODE_TIME_SEC = 1000
+EPISODE_TIME_SEC = 300
 
 FOLLOWER_LEFT_PORT = "can0"
 FOLLOWER_RIGHT_PORT = "can1"
@@ -61,6 +62,16 @@ CAMERA_CONFIG = {
 }
 
 
+def make_robot_action(action_values: dict, features: dict) -> RobotAction:
+    robot_action = {}
+    for key in features:
+        if key.startswith(ACTION + "."):
+            action_key = key.removeprefix(ACTION + ".")
+            if action_key in action_values:
+                robot_action[action_key] = action_values[action_key]
+    return robot_action
+
+
 def load_relative_config(model_path: Path | str) -> tuple[PerTimestepNormalizer | None, bool]:
     """Load normalizer and relative_state setting from checkpoint."""
     model_path = Path(model_path) if isinstance(model_path, str) else model_path
@@ -135,8 +146,8 @@ def inference_loop_relative(
             if isinstance(state_tensor, torch.Tensor):
                 observation_frame[state_key] = convert_state_to_relative(state_tensor)
         
-        # Policy inference (outputs action tensor)
-        action_tensor = predict_action(
+        # Policy inference (outputs normalized relative actions)
+        action_values = predict_action(
             observation=observation_frame,
             policy=policy,
             device=device,
@@ -147,24 +158,17 @@ def inference_loop_relative(
             robot_type=robot.robot_type,
         )
         
-        # Unnormalize relative actions if normalizer exists
+        # Unnormalize actions
         if relative_normalizer is not None:
-            # action_tensor shape: [1, action_dim] or [action_dim]
-            if action_tensor.dim() == 1:
-                action_tensor = action_tensor.unsqueeze(0).unsqueeze(0)  # [1, 1, action_dim]
-            elif action_tensor.dim() == 2:
-                action_tensor = action_tensor.unsqueeze(1)  # [batch, 1, action_dim]
-            action_tensor = relative_normalizer.unnormalize(action_tensor)
+            action_keys = [k for k in action_values.keys() if not k.startswith("task")]
+            action_tensor = torch.tensor([[action_values[k] for k in action_keys]])
+            action_tensor = action_tensor.unsqueeze(1)
+            action_unnorm = relative_normalizer.unnormalize(action_tensor)
+            for i, k in enumerate(action_keys):
+                action_values[k] = action_unnorm[0, 0, i].item()
         
-        # Flatten to 1D: take first timestep if chunks, squeeze batch dims
-        while action_tensor.dim() > 1:
-            action_tensor = action_tensor[0]
-        
-        # Manually convert to dict (tensor_to_robot_action expects specific shape)
-        action_names = dataset.features[ACTION]["names"]
-        relative_action = {name: float(action_tensor[i]) for i, name in enumerate(action_names)}
-        
-        # Convert relative to absolute
+        # Convert to absolute
+        relative_action = make_robot_action(action_values, dataset.features)
         absolute_action = convert_from_relative_actions_dict(relative_action, current_pos)
         
         robot.send_action(absolute_action)

examples/openarms/replay_ee.py

@@ -1,403 +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 End-Effector Replay Example with Visualization
-
-Replays a dataset recorded with absolute joint positions by:
-1. Converting joint positions to EE poses using FK
-2. Converting EE poses back to joint positions using IK
-3. Sending joint commands to the robot OR visualizing in simulation
-
-Supports three modes:
-- real: Send commands to physical robot
-- sim: Visualize in simulation only (no robot required)
-- both: Real robot + visualization
-
-Example usage:
-    python examples/openarms/replay_ee.py --mode sim
-    python examples/openarms/replay_ee.py --mode real
-    python examples/openarms/replay_ee.py --mode both --visualizer meshcat
-"""
-
-import argparse
-import time
-from os.path import dirname, expanduser
-
-import numpy as np
-
-from lerobot.datasets.lerobot_dataset import LeRobotDataset
-from lerobot.model.kinematics import RobotKinematics
-from lerobot.processor import RobotAction, RobotObservation, RobotProcessorPipeline
-from lerobot.processor.converters import (
-    robot_action_observation_to_transition,
-    robot_action_to_transition,
-    transition_to_robot_action,
-)
-from lerobot.robots.openarms.robot_kinematic_processor import (
-    BimanualEEBoundsAndSafety,
-    BimanualForwardKinematicsJointsToEE,
-    BimanualInverseKinematicsEEToJoints,
-)
-from lerobot.utils.constants import ACTION
-from lerobot.utils.robot_utils import precise_sleep
-
-
-# Default configuration
-DEFAULT_EPISODE_IDX = 0
-DEFAULT_DATASET = "lerobot-data-collection/rac_blackf0"
-DEFAULT_URDF = "src/lerobot/robots/openarms/urdf/openarm_bimanual_pybullet.urdf"
-DEFAULT_LEFT_EE_FRAME = "openarm_left_hand_tcp"
-DEFAULT_RIGHT_EE_FRAME = "openarm_right_hand_tcp"
-
-# Motor names as used in the dataset actions (e.g., left_joint_1.pos)
-MOTOR_NAMES = ["joint_1", "joint_2", "joint_3", "joint_4", "joint_5", "joint_6", "joint_7", "gripper"]
-
-# URDF joint names (no underscore between "joint" and number)
-LEFT_URDF_JOINTS = [f"openarm_left_joint{i}" for i in range(1, 8)]
-RIGHT_URDF_JOINTS = [f"openarm_right_joint{i}" for i in range(1, 8)]
-
-
-class MeshcatVisualizer:
-    """Lightweight URDF visualizer using pinocchio + meshcat."""
-    
-    def __init__(self, urdf_path: str):
-        import pinocchio as pin
-        from pinocchio.visualize import MeshcatVisualizer as PinMeshcat
-        
-        urdf_dir = dirname(urdf_path)
-        self.model, self.collision_model, self.visual_model = pin.buildModelsFromUrdf(
-            urdf_path, urdf_dir, pin.JointModelFreeFlyer()
-        )
-        self.data = self.model.createData()
-        
-        self.viz = PinMeshcat(self.model, self.collision_model, self.visual_model)
-        self.viz.initViewer(open=True)
-        self.viz.loadViewerModel()
-        
-        # Build joint name mapping: dataset name -> pinocchio joint index
-        # Dataset uses: left_joint_1, right_joint_2, etc.
-        # URDF uses: openarm_left_joint1, openarm_right_joint2, etc.
-        self.joint_map = {}
-        for jid in range(1, self.model.njoints):
-            urdf_name = self.model.names[jid]  # e.g., "openarm_left_joint1"
-            # Extract side and number
-            if "left_joint" in urdf_name:
-                num = urdf_name.split("joint")[-1]  # "1"
-                dataset_name = f"left_joint_{num}"
-                self.joint_map[dataset_name] = jid
-            elif "right_joint" in urdf_name:
-                num = urdf_name.split("joint")[-1]
-                dataset_name = f"right_joint_{num}"
-                self.joint_map[dataset_name] = jid
-        
-        print(f"  Meshcat viewer opened (mapped {len(self.joint_map)} joints)")
-        print(f"  Joint map: {list(self.joint_map.keys())[:4]}...")
-        print("  Waiting for meshcat to load...")
-        time.sleep(3)  # Give meshcat time to load meshes
-        self._first_update = True
-    
-    def update(self, joint_positions: dict[str, float]):
-        """Update visualization with new joint positions."""
-        if self._first_update:
-            pos_keys = [k for k in joint_positions.keys() if k.endswith(".pos")]
-            print(f"  First update keys: {pos_keys[:4]}...")
-            # Print sample values
-            for k in pos_keys[:2]:
-                print(f"    {k} = {joint_positions[k]:.2f}")
-        
-        # Build configuration vector (base pose + joints)
-        # Free flyer base: [x, y, z, qx, qy, qz, qw]
-        q = np.zeros(self.model.nq)
-        q[3:7] = [0, 0, 0, 1]  # Identity quaternion
-        
-        matched = 0
-        # Map joint positions using pre-built mapping
-        for name, pos in joint_positions.items():
-            if not name.endswith(".pos"):
-                continue
-            joint_name = name.removesuffix(".pos")  # e.g., "left_joint_1"
-            
-            jid = self.joint_map.get(joint_name)
-            if jid is not None:
-                idx = self.model.idx_qs[jid]
-                if idx < len(q):
-                    q[idx] = np.deg2rad(pos)
-                    matched += 1
-        
-        if self._first_update:
-            print(f"  Matched {matched} joints, q[7:14] = {q[7:14]}")
-            self._first_update = False
-        
-        self.viz.display(q)
-
-
-class RerunVisualizer:
-    """Rerun-based visualizer for plots and EE trajectories."""
-    
-    def __init__(self, urdf_path: str = None, session_name: str = "openarms_replay"):
-        import rerun as rr
-        self.rr = rr
-        rr.init(session_name)
-        rr.spawn(memory_limit="10%")
-        print("  Rerun viewer spawned (plots only, use --visualizer meshcat for 3D robot)")
-    
-    def update(self, joint_positions: dict[str, float], ee_poses: dict[str, float], frame_idx: int):
-        """Log joint positions and EE poses."""
-        self.rr.set_time("frame", sequence=frame_idx)
-        
-        # Log EE positions as colored spheres
-        for prefix, color in [("left", [255, 100, 100]), ("right", [100, 100, 255])]:
-            x, y, z = ee_poses.get(f"{prefix}_ee.x"), ee_poses.get(f"{prefix}_ee.y"), ee_poses.get(f"{prefix}_ee.z")
-            if None not in (x, y, z):
-                self.rr.log(f"ee/{prefix}", self.rr.Points3D([[x, y, z]], colors=[color], radii=[0.02]))
-        
-        # Log joint positions as time series
-        for name, pos in joint_positions.items():
-            if name.endswith(".pos"):
-                self.rr.log(f"joints/{name}", self.rr.Scalars(pos))
-        
-        # Log EE poses as time series
-        for name, val in ee_poses.items():
-            self.rr.log(f"ee_plots/{name}", self.rr.Scalars(val))
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="OpenArms EE Replay with Visualization")
-    parser.add_argument("--mode", choices=["real", "sim", "both"], default="sim",
-                        help="Execution mode: real (robot), sim (visualization), both")
-    parser.add_argument("--visualizer", choices=["meshcat", "rerun", "none"], default="meshcat",
-                        help="Visualization backend (meshcat shows 3D robot, rerun shows plots)")
-    parser.add_argument("--dataset", type=str, default=DEFAULT_DATASET,
-                        help="Dataset repo ID")
-    parser.add_argument("--episode", type=int, default=DEFAULT_EPISODE_IDX,
-                        help="Episode index to replay")
-    parser.add_argument("--urdf", type=str, default=DEFAULT_URDF,
-                        help="Path to URDF file")
-    parser.add_argument("--left-ee-frame", type=str, default=DEFAULT_LEFT_EE_FRAME,
-                        help="Left arm end-effector frame name in URDF")
-    parser.add_argument("--right-ee-frame", type=str, default=DEFAULT_RIGHT_EE_FRAME,
-                        help="Right arm end-effector frame name in URDF")
-    parser.add_argument("--port-left", type=str, default="can2",
-                        help="CAN port for left arm")
-    parser.add_argument("--port-right", type=str, default="can3",
-                        help="CAN port for right arm")
-    parser.add_argument("--speed", type=float, default=1.0,
-                        help="Playback speed multiplier")
-    return parser.parse_args()
-
-
-def main():
-    args = parse_args()
-    use_robot = args.mode in ["real", "both"]
-    use_viz = args.mode in ["sim", "both"] and args.visualizer != "none"
-    
-    print("=" * 70)
-    print("OpenArms EE Replay (FK -> IK Pipeline)")
-    print("=" * 70)
-    print(f"\nMode: {args.mode}")
-    print(f"Visualizer: {args.visualizer}")
-    print(f"Dataset: {args.dataset}")
-    print(f"Episode: {args.episode}")
-    print(f"Speed: {args.speed}x")
-    print("=" * 70)
-
-    robot = None
-    viz = None
-    
-    # Resolve URDF path (handle relative and ~ paths)
-    from pathlib import Path
-    urdf_path = args.urdf
-    if urdf_path.startswith("~"):
-        urdf_path = expanduser(urdf_path)
-    elif not Path(urdf_path).is_absolute():
-        # Relative to workspace root
-        urdf_path = str(Path(__file__).parent.parent.parent / urdf_path)
-    
-    # Initialize robot if needed
-    if use_robot:
-        from lerobot.robots.openarms.config_openarms_follower import OpenArmsFollowerConfig
-        from lerobot.robots.openarms.openarms_follower import OpenArmsFollower
-        
-        print("\n[1/5] Initializing robot...")
-        robot_config = OpenArmsFollowerConfig(
-            port_left=args.port_left,
-            port_right=args.port_right,
-            can_interface="socketcan",
-            id="openarms_follower",
-            disable_torque_on_disconnect=True,
-            max_relative_target=10.0,
-        )
-        robot = OpenArmsFollower(robot_config)
-    else:
-        print("\n[1/5] Skipping robot (sim mode)")
-
-    # Initialize visualizer if needed
-    if use_viz:
-        print(f"\n[2/5] Initializing {args.visualizer} visualizer...")
-        if args.visualizer == "meshcat":
-            viz = MeshcatVisualizer(urdf_path)
-        elif args.visualizer == "rerun":
-            viz = RerunVisualizer(urdf_path)
-    else:
-        print("\n[2/5] Skipping visualization")
-
-    # Initialize kinematics with URDF joint names
-    print("\n[3/5] Initializing kinematics solvers...")
-    
-    left_kinematics = RobotKinematics(
-        urdf_path=urdf_path,
-        target_frame_name=args.left_ee_frame,
-        joint_names=LEFT_URDF_JOINTS,
-    )
-    right_kinematics = RobotKinematics(
-        urdf_path=urdf_path,
-        target_frame_name=args.right_ee_frame,
-        joint_names=RIGHT_URDF_JOINTS,
-    )
-
-    # Build pipelines - use motor names without gripper for the processor
-    motor_names_no_gripper = [n for n in MOTOR_NAMES if n != "gripper"]
-    
-    joints_to_ee = RobotProcessorPipeline[RobotAction, RobotAction](
-        steps=[
-            BimanualForwardKinematicsJointsToEE(
-                left_kinematics=left_kinematics,
-                right_kinematics=right_kinematics,
-                motor_names=MOTOR_NAMES,
-            ),
-        ],
-        to_transition=robot_action_to_transition,
-        to_output=transition_to_robot_action,
-    )
-
-    ee_to_joints = RobotProcessorPipeline[tuple[RobotAction, RobotObservation], RobotAction](
-        steps=[
-            BimanualEEBoundsAndSafety(
-                end_effector_bounds={"min": [-1.0, -1.0, -1.0], "max": [1.0, 1.0, 1.0]},
-                max_ee_step_m=0.10,
-            ),
-            BimanualInverseKinematicsEEToJoints(
-                left_kinematics=left_kinematics,
-                right_kinematics=right_kinematics,
-                motor_names=MOTOR_NAMES,
-                initial_guess_current_joints=False,
-            ),
-        ],
-        to_transition=robot_action_observation_to_transition,
-        to_output=transition_to_robot_action,
-    )
-
-    # Load dataset
-    print(f"\n[4/5] Loading dataset '{args.dataset}'...")
-    dataset = LeRobotDataset(args.dataset, episodes=[args.episode])
-    episode_frames = dataset.hf_dataset.filter(lambda x: x["episode_index"] == args.episode)
-    
-    if len(episode_frames) == 0:
-        raise ValueError(f"No frames found for episode {args.episode}")
-    
-    print(f"  Found {len(episode_frames)} frames at {dataset.fps} FPS")
-    
-    action_features = dataset.features.get(ACTION, {})
-    action_names = action_features.get("names", [])
-    actions = episode_frames.select_columns(ACTION)
-
-    # Connect robot if needed
-    if use_robot:
-        print("\n[5/5] Connecting to robot...")
-        robot.connect(calibrate=False)
-        if not robot.is_connected:
-            raise RuntimeError("Robot failed to connect!")
-    else:
-        print("\n[5/5] Skipping robot connection (sim mode)")
-
-    print("\n" + "=" * 70)
-    print(f"Ready to replay! Mode: {args.mode}")
-    print("=" * 70)
-    
-    if use_robot:
-        input("\nPress ENTER to start...")
-    else:
-        print("\nStarting visualization playback...")
-        time.sleep(1)
-
-    # Simulated observation for sim-only mode
-    sim_obs = {f"{prefix}_{motor}.pos": 0.0 
-               for prefix in ["left", "right"] 
-               for motor in MOTOR_NAMES}
-
-    try:
-        for idx in range(len(episode_frames)):
-            loop_start = time.perf_counter()
-
-            # Get observation
-            if use_robot:
-                robot_obs = robot.get_observation()
-            else:
-                robot_obs = sim_obs.copy()
-
-            # Build joint action from dataset
-            action_array = actions[idx][ACTION]
-            joint_action = {}
-            for i, name in enumerate(action_names):
-                if name.endswith(".pos"):
-                    joint_action[name] = float(action_array[i])
-
-            # Convert: joints -> EE (FK)
-            ee_action = joints_to_ee(joint_action.copy())
-
-            # Convert: EE -> joints (IK)
-            final_joint_action = ee_to_joints((ee_action.copy(), robot_obs))
-
-            # Update simulated observation for next iteration
-            if not use_robot:
-                sim_obs.update(final_joint_action)
-
-            # Send to robot
-            if use_robot:
-                robot.send_action(final_joint_action)
-
-            # Update visualization with ORIGINAL dataset trajectory
-            if viz:
-                if isinstance(viz, MeshcatVisualizer):
-                    viz.update(joint_action)  # Use original, not FK->IK reconstructed
-                elif isinstance(viz, RerunVisualizer):
-                    viz.update(joint_action, ee_action, idx)
-
-            # Maintain replay rate
-            loop_duration = time.perf_counter() - loop_start
-            dt_s = (1.0 / dataset.fps / args.speed) - loop_duration
-            if dt_s > 0:
-                precise_sleep(dt_s)
-
-            if (idx + 1) % 100 == 0:
-                progress = (idx + 1) / len(episode_frames) * 100
-                print(f"Progress: {idx + 1}/{len(episode_frames)} ({progress:.1f}%)")
-
-        print(f"\n✓ Replayed {len(episode_frames)} frames")
-
-    except KeyboardInterrupt:
-        print("\n\nReplay interrupted")
-    finally:
-        if use_robot and robot:
-            print("\nDisconnecting robot...")
-            robot.disconnect()
-        print("✓ Done!")
-
-
-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()

src/lerobot/robots/openarms/__init__.py

@@ -16,16 +16,5 @@
 
 from .config_openarms_follower import OpenArmsFollowerConfig
 from .openarms_follower import OpenArmsFollower
-from .robot_kinematic_processor import (
-    BimanualEEBoundsAndSafety,
-    BimanualForwardKinematicsJointsToEE,
-    BimanualInverseKinematicsEEToJoints,
-)
 
-__all__ = [
-    "OpenArmsFollower",
-    "OpenArmsFollowerConfig",
-    "BimanualForwardKinematicsJointsToEE",
-    "BimanualInverseKinematicsEEToJoints",
-    "BimanualEEBoundsAndSafety",
-]
+__all__ = ["OpenArmsFollower", "OpenArmsFollowerConfig"]

src/lerobot/robots/openarms/openarms_follower.py

@@ -96,16 +96,26 @@ class OpenArmsFollower(Robot):
         # Initialize Pinocchio robot model for dynamics (optional)
         self.pin_robot = None
         try:
-            # Load URDF - try external path first (with meshes), then repository
             import os
-            from os.path import expanduser, dirname
-            
-            # Try external URDF with meshes first
-            external_urdf_path = expanduser("~/Documents/openarm_description/openarm_bimanual_pybullet.urdf")
-            if os.path.exists(external_urdf_path):
+            from os.path import dirname
+
+            # Prefer the URDF bundled in the repository
+            repo_urdf_path = os.path.join(
+                dirname(__file__), "urdf", "openarm_bimanual_pybullet.urdf"
+            )
+            external_urdf_path = os.path.expanduser(
+                "~/Documents/openarm_description/openarm_bimanual_pybullet.urdf"
+            )
+
+            if os.path.exists(repo_urdf_path):
+                urdf_path = repo_urdf_path
+            elif os.path.exists(external_urdf_path):
                 urdf_path = external_urdf_path
+            else:
+                urdf_path = None
+
+            if urdf_path is not None:
                 urdf_dir = dirname(urdf_path)
-            
                 self.pin_robot = pin.RobotWrapper.BuildFromURDF(urdf_path, urdf_dir)
                 self.pin_robot.data = self.pin_robot.model.createData()
                 logger.info(f"Loaded OpenArms URDF for dynamics computation from {urdf_path}")

src/lerobot/robots/openarms/robot_kinematic_processor.py

@@ -1,245 +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.
-
-"""
-Kinematic processor steps for bimanual OpenArms robot.
-
-Provides FK/IK conversions for both left and right arms.
-"""
-
-from dataclasses import dataclass, field
-from typing import Any
-
-import numpy as np
-
-from lerobot.configs.types import FeatureType, PipelineFeatureType, PolicyFeature
-from lerobot.model.kinematics import RobotKinematics
-from lerobot.processor import (
-    ProcessorStep,
-    ProcessorStepRegistry,
-    RobotAction,
-    RobotActionProcessorStep,
-    TransitionKey,
-)
-from lerobot.utils.rotation import Rotation
-
-
-def compute_bimanual_fk(
-    joints: dict[str, Any],
-    left_kinematics: RobotKinematics,
-    right_kinematics: RobotKinematics,
-    motor_names: list[str],
-) -> dict[str, Any]:
-    """Compute FK for both arms, converting joint positions to EE poses."""
-    result = {}
-    
-    for prefix, kinematics in [("left", left_kinematics), ("right", right_kinematics)]:
-        motor_joint_values = []
-        for name in motor_names:
-            key = f"{prefix}_{name}.pos"
-            if key in joints:
-                motor_joint_values.append(joints[key])
-        
-        if not motor_joint_values:
-            continue
-            
-        q = np.array(motor_joint_values, dtype=float)
-        t = kinematics.forward_kinematics(q)
-        pos = t[:3, 3]
-        tw = Rotation.from_matrix(t[:3, :3]).as_rotvec()
-        
-        gripper_key = f"{prefix}_gripper.pos"
-        gripper_pos = joints.get(gripper_key, 0.0)
-        
-        result[f"{prefix}_ee.x"] = float(pos[0])
-        result[f"{prefix}_ee.y"] = float(pos[1])
-        result[f"{prefix}_ee.z"] = float(pos[2])
-        result[f"{prefix}_ee.wx"] = float(tw[0])
-        result[f"{prefix}_ee.wy"] = float(tw[1])
-        result[f"{prefix}_ee.wz"] = float(tw[2])
-        result[f"{prefix}_ee.gripper_pos"] = float(gripper_pos)
-    
-    return result
-
-
-@ProcessorStepRegistry.register("bimanual_forward_kinematics_joints_to_ee")
-@dataclass
-class BimanualForwardKinematicsJointsToEE(RobotActionProcessorStep):
-    """
-    Converts joint positions to end-effector poses for both arms using FK.
-    
-    Input action keys: {prefix}_{motor}.pos (e.g., "right_joint_1.pos", "left_joint_2.pos")
-    Output action keys: {prefix}_ee.{x,y,z,wx,wy,wz,gripper_pos}
-    """
-    left_kinematics: RobotKinematics
-    right_kinematics: RobotKinematics
-    motor_names: list[str]  # e.g., ["joint_1", "joint_2", ..., "joint_7", "gripper"]
-
-    def action(self, action: RobotAction) -> RobotAction:
-        ee_poses = compute_bimanual_fk(
-            action, self.left_kinematics, self.right_kinematics, self.motor_names
-        )
-        
-        # Remove joint positions, keep EE poses
-        for prefix in ["left", "right"]:
-            for name in self.motor_names:
-                action.pop(f"{prefix}_{name}.pos", None)
-        
-        action.update(ee_poses)
-        return action
-
-    def transform_features(
-        self, features: dict[PipelineFeatureType, dict[str, PolicyFeature]]
-    ) -> dict[PipelineFeatureType, dict[str, PolicyFeature]]:
-        for prefix in ["left", "right"]:
-            for name in self.motor_names:
-                features[PipelineFeatureType.ACTION].pop(f"{prefix}_{name}.pos", None)
-            for k in ["x", "y", "z", "wx", "wy", "wz", "gripper_pos"]:
-                features[PipelineFeatureType.ACTION][f"{prefix}_ee.{k}"] = PolicyFeature(
-                    type=FeatureType.ACTION, shape=(1,)
-                )
-        return features
-
-
-@ProcessorStepRegistry.register("bimanual_inverse_kinematics_ee_to_joints")
-@dataclass
-class BimanualInverseKinematicsEEToJoints(RobotActionProcessorStep):
-    """
-    Converts EE poses to joint positions for both arms using IK.
-    
-    Input action keys: {prefix}_ee.{x,y,z,wx,wy,wz,gripper_pos}
-    Output action keys: {prefix}_{motor}.pos
-    """
-    left_kinematics: RobotKinematics
-    right_kinematics: RobotKinematics
-    motor_names: list[str]
-    initial_guess_current_joints: bool = True
-    
-    q_curr_left: np.ndarray | None = field(default=None, init=False, repr=False)
-    q_curr_right: np.ndarray | None = field(default=None, init=False, repr=False)
-
-    def action(self, action: RobotAction) -> RobotAction:
-        observation = self.transition.get(TransitionKey.OBSERVATION)
-        if observation is None:
-            raise ValueError("Observation required for IK")
-        observation = observation.copy()
-        
-        for prefix, kinematics in [("left", self.left_kinematics), ("right", self.right_kinematics)]:
-            x = action.pop(f"{prefix}_ee.x", None)
-            y = action.pop(f"{prefix}_ee.y", None)
-            z = action.pop(f"{prefix}_ee.z", None)
-            wx = action.pop(f"{prefix}_ee.wx", None)
-            wy = action.pop(f"{prefix}_ee.wy", None)
-            wz = action.pop(f"{prefix}_ee.wz", None)
-            gripper_pos = action.pop(f"{prefix}_ee.gripper_pos", None)
-            
-            if None in (x, y, z, wx, wy, wz, gripper_pos):
-                continue
-            
-            # Get current joint positions from observation
-            q_raw = np.array([
-                float(observation.get(f"{prefix}_{name}.pos", 0.0))
-                for name in self.motor_names if name != "gripper"
-            ], dtype=float)
-            
-            q_curr_attr = f"q_curr_{prefix}"
-            if self.initial_guess_current_joints:
-                setattr(self, q_curr_attr, q_raw)
-            else:
-                if getattr(self, q_curr_attr) is None:
-                    setattr(self, q_curr_attr, q_raw)
-            
-            t_des = np.eye(4, dtype=float)
-            t_des[:3, :3] = Rotation.from_rotvec([wx, wy, wz]).as_matrix()
-            t_des[:3, 3] = [x, y, z]
-            
-            q_target = kinematics.inverse_kinematics(getattr(self, q_curr_attr), t_des)
-            setattr(self, q_curr_attr, q_target)
-            
-            for i, name in enumerate(self.motor_names):
-                if name != "gripper":
-                    action[f"{prefix}_{name}.pos"] = float(q_target[i])
-                else:
-                    action[f"{prefix}_gripper.pos"] = float(gripper_pos)
-        
-        return action
-
-    def transform_features(
-        self, features: dict[PipelineFeatureType, dict[str, PolicyFeature]]
-    ) -> dict[PipelineFeatureType, dict[str, PolicyFeature]]:
-        for prefix in ["left", "right"]:
-            for k in ["x", "y", "z", "wx", "wy", "wz", "gripper_pos"]:
-                features[PipelineFeatureType.ACTION].pop(f"{prefix}_ee.{k}", None)
-            for name in self.motor_names:
-                features[PipelineFeatureType.ACTION][f"{prefix}_{name}.pos"] = PolicyFeature(
-                    type=FeatureType.ACTION, shape=(1,)
-                )
-        return features
-
-    def reset(self):
-        self.q_curr_left = None
-        self.q_curr_right = None
-
-
-@ProcessorStepRegistry.register("bimanual_ee_bounds_and_safety")
-@dataclass
-class BimanualEEBoundsAndSafety(RobotActionProcessorStep):
-    """
-    Clips EE poses to bounds and limits step size for both arms.
-    """
-    end_effector_bounds: dict  # {"min": [x,y,z], "max": [x,y,z]}
-    max_ee_step_m: float = 0.05
-    
-    _last_pos_left: np.ndarray | None = field(default=None, init=False, repr=False)
-    _last_pos_right: np.ndarray | None = field(default=None, init=False, repr=False)
-
-    def action(self, action: RobotAction) -> RobotAction:
-        for prefix in ["left", "right"]:
-            x = action.get(f"{prefix}_ee.x")
-            y = action.get(f"{prefix}_ee.y")
-            z = action.get(f"{prefix}_ee.z")
-            
-            if None in (x, y, z):
-                continue
-            
-            pos = np.array([x, y, z], dtype=float)
-            pos = np.clip(pos, self.end_effector_bounds["min"], self.end_effector_bounds["max"])
-            
-            last_pos_attr = f"_last_pos_{prefix}"
-            last_pos = getattr(self, last_pos_attr)
-            if last_pos is not None:
-                dpos = pos - last_pos
-                n = float(np.linalg.norm(dpos))
-                if n > self.max_ee_step_m and n > 0:
-                    pos = last_pos + dpos * (self.max_ee_step_m / n)
-            
-            setattr(self, last_pos_attr, pos)
-            
-            action[f"{prefix}_ee.x"] = float(pos[0])
-            action[f"{prefix}_ee.y"] = float(pos[1])
-            action[f"{prefix}_ee.z"] = float(pos[2])
-        
-        return action
-
-    def reset(self):
-        self._last_pos_left = None
-        self._last_pos_right = None
-
-    def transform_features(
-        self, features: dict[PipelineFeatureType, dict[str, PolicyFeature]]
-    ) -> dict[PipelineFeatureType, dict[str, PolicyFeature]]:
-        return features
-

src/lerobot/robots/openarms/urdf/.gitattributes

@@ -1,74 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
-meshes/arm/v10/collision/link3_symp.stl filter=lfs diff=lfs merge=lfs -text
-meshes/arm/v10/collision/link4_symp.stl filter=lfs diff=lfs merge=lfs -text
-meshes/arm/v10/collision/link5_symp.stl filter=lfs diff=lfs merge=lfs -text
-meshes/arm/v10/visual/link0.stl filter=lfs diff=lfs merge=lfs -text
-meshes/arm/v10/visual/link1.stl filter=lfs diff=lfs merge=lfs -text
-meshes/arm/v10/visual/link2.stl filter=lfs diff=lfs merge=lfs -text
-meshes/arm/v10/visual/link3.stl filter=lfs diff=lfs merge=lfs -text
-meshes/arm/v10/visual/link4.stl filter=lfs diff=lfs merge=lfs -text
-meshes/arm/v10/visual/link5.stl filter=lfs diff=lfs merge=lfs -text
-meshes/arm/v10/visual/link6.stl filter=lfs diff=lfs merge=lfs -text
-meshes/arm/v10/visual/link7.stl filter=lfs diff=lfs merge=lfs -text
-meshes/body/v10/collision/body_link0_symp.stl filter=lfs diff=lfs merge=lfs -text
-meshes/body/v10/visual/body_link0.dae filter=lfs diff=lfs merge=lfs -text
-meshes/body/v10/visual/body_link0.stl filter=lfs diff=lfs merge=lfs -text
-meshes/ee/openarm_hand/visual/finger.stl filter=lfs diff=lfs merge=lfs -text

src/lerobot/robots/openarms/urdf/CMakeLists.txt

@@ -1,35 +0,0 @@
-# Copyright 2025 Enactic, Inc.
-#
-# 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.
-
-cmake_minimum_required(VERSION 3.8)
-project(openarm_description)
-
-find_package(ament_cmake REQUIRED)
-
-if(BUILD_TESTING)
-  find_package(ament_lint_auto REQUIRED)
-  # the following line skips the linter which checks for copyrights
-  # comment the line when a copyright and license is added to all source files
-  set(ament_cmake_copyright_FOUND TRUE)
-  # the following line skips cpplint (only works in a git repo)
-  # comment the line when this package is in a git repo and when
-  # a copyright and license is added to all source files
-  set(ament_cmake_cpplint_FOUND TRUE)
-  ament_lint_auto_find_test_dependencies()
-endif()
-
-install(DIRECTORY launch meshes rviz urdf config
-        DESTINATION share/${PROJECT_NAME})
-
-ament_package()

src/lerobot/robots/openarms/urdf/CODE_OF_CONDUCT.md

@@ -1,133 +0,0 @@
-
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, caste, color, religion, or sexual
-identity and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our
-community include:
-
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the overall
-  community
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or advances of
-  any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email address,
-  without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official email address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-hi_public@reazon.jp.
-All complaints will be reviewed and investigated promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series of
-actions.
-
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or permanent
-ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior, harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within the
-community.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.1, available at
-[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
-
-Community Impact Guidelines were inspired by
-[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
-
-For answers to common questions about this code of conduct, see the FAQ at
-[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
-[https://www.contributor-covenant.org/translations][translations].
-
-[homepage]: https://www.contributor-covenant.org
-[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
-[Mozilla CoC]: https://github.com/mozilla/diversity
-[FAQ]: https://www.contributor-covenant.org/faq
-[translations]: https://www.contributor-covenant.org/translations

src/lerobot/robots/openarms/urdf/CONTRIBUTING.md

@@ -1,19 +0,0 @@
-# How to contribute
-
-## Did you find a bug?
-
-Please report it to [GitHub Issues](https://github.com/enactic/openarm_description/issues/new?template=1-bug-report.yml)!
-
-## Did you have a feature request?
-
-Please share it to [GitHub Issues](https://github.com/enactic/openarm_description/issues/new?template=2-feature-request.yml)!
-
-## Did you write a patch?
-
-Please open a pull request with it!
-
-Please make sure to review [our license](https://github.com/enactic/openarm_description/blob/main/LICENSE.txt) before you open a pull request.
-
-## Others?
-
-Please share it on [Discord](https://discord.gg/FsZaZ4z3We) or [GitHub Discussions](https://github.com/enactic/openarm_description/discussions)!

src/lerobot/robots/openarms/urdf/LICENSE.txt

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   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.

src/lerobot/robots/openarms/urdf/README.md

@@ -1,20 +0,0 @@
-# Robot Description files for OpenArm
-
-This package contains description files to generate OpenArm URDFs (Universal Robot Description Files). See [documentation](https://docs.openarm.dev/software/description) for details.
-
-## Related links
-
-- 📚 Read the [documentation](https://docs.openarm.dev/software/description)
-- 💬 Join the community on [Discord](https://discord.gg/FsZaZ4z3We)
-- 📬 Contact us through <openarm@enactic.ai>
-
-## License
-
-[Apache License 2.0](LICENSE.txt)
-
-Copyright 2025 Enactic, Inc.
-
-## Code of Conduct
-
-All participation in the OpenArm project is governed by our
-[Code of Conduct](CODE_OF_CONDUCT.md).

src/lerobot/robots/openarms/urdf/config/arm/v10/inertials.yaml

@@ -1,135 +0,0 @@
-link0:
-  origin:
-    x: -0.0009483362816297526
-    y: 0.0001580207020448382
-    z: 0.03076860287587199
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-  mass: 1.1432284943239561
-  inertia:
-    xx: 0.001128
-    xy: -4.0e-06
-    xz: -3.3e-05
-    yy: 0.000962
-    yz: -7.0e-06
-    zz: 0.00147
-
-link1:
-  origin:
-    x: 0.0011467657911800769
-    y: 3.319987657026362e-05
-    z: 0.05395284380736254
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-  mass: 1.1416684646202298
-  inertia:
-    xx: 0.001567
-    xy: -1.0e-06
-    xz: -2.9e-05
-    yy: 0.001273
-    yz: 1e-06
-    zz: 0.001016
-
-link2:
-  origin:
-    x: 0.00839629182351943
-    y: -2.0145102027597523e-08
-    z: 0.03256649300522363
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-  mass: 0.2775092746011571
-  inertia:
-    xx: 0.000359
-    xy: 1e-06
-    xz: -0.000109
-    yy: 0.000376
-    yz: 1e-06
-    zz: 0.000232
-
-link3:
-  origin:
-    x: -0.002104752099628911
-    y: 0.0005549085042607548
-    z: 0.09047470545721961
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-  mass: 1.073863338202347
-  inertia:
-    xx: 0.004372
-    xy: 1e-06
-    xz: 1.1e-05
-    yy: 0.004319
-    yz: -3.6e-05
-    zz: 0.000661
-
-link4:
-  origin:
-    x: -0.0029006831074562967
-    y: -0.03030575826634669
-    z: 0.06339637422196209
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-  mass: 0.6348534566833373
-  inertia:
-    xx: 0.000623
-    xy: -1.0e-06
-    xz: -1.9e-05
-    yy: 0.000511
-    yz: 3.8e-05
-    zz: 0.000334
-
-link5:
-  origin:
-    x: -0.003049665024221911
-    y: 0.0008866902457326625
-    z: 0.043079803024980934
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-  mass: 0.6156588026168502
-  inertia:
-    xx: 0.000423
-    xy: -8.0e-06
-    xz: 6.0e-06
-    yy: 0.000445
-    yz: -6.0e-06
-    zz: 0.000324
-
-link6:
-  origin:
-    x: -0.037136587005447405
-    y: 0.00033230528343419053
-    z: -9.498374522309838e-05
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-  mass: 0.475202773187987
-  inertia:
-    xx: 0.000143
-    xy: 1e-06
-    xz: 1e-06
-    yy: 0.000157
-    yz: 1e-06
-    zz: 0.000159
-
-link7:
-  origin:
-    x: 6.875510271106056e-05
-    y: 0.01266175250761268
-    z: 0.06951945409987448
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-  mass: 0.4659771327380578
-  inertia:
-    xx: 0.000639
-    xy: 1e-06
-    xz: 1e-06
-    yy: 0.000497
-    yz: 8.9e-05
-    zz: 0.000342

src/lerobot/robots/openarms/urdf/config/arm/v10/joint_limits.yaml

@@ -1,62 +0,0 @@
-joint1:
-  limit:
-    lower: -1.396263
-    upper: 3.490659
-    velocity: 16.754666
-    effort: 40
-
-joint2:
-  limit:
-    lower: -1.745329
-    upper: 1.745329
-    velocity: 16.754666
-    effort: 40
-
-joint3:
-  limit:
-    lower: -1.570796
-    upper: 1.570796
-    velocity: 5.445426
-    effort: 27
-
-joint4:
-  limit:
-    lower: 0.0
-    upper: 2.443461
-    velocity: 5.445426
-    effort: 27
-
-joint5:
-  limit:
-    lower: -1.570796
-    upper: 1.570796
-    velocity: 20.943946
-    effort: 7
-
-joint6:
-  limit:
-    lower: -0.785398
-    upper: 0.785398
-    velocity: 20.943946
-    effort: 7
-
-joint7:
-  limit:
-    lower: -1.570796
-    upper: 1.570796
-    velocity: 20.943946
-    effort: 7
-
-# joint_gripper1:
-#   limit:
-#     lower: 0.0
-#     upper: 0.043
-#     velocity: 100
-#     effort: 100
-
-# joint_gripper2:
-#   limit:
-#     lower: 0.0
-#     upper: 0.043
-#     velocity: 100
-#     effort: 100

src/lerobot/robots/openarms/urdf/config/arm/v10/kinematics.yaml

@@ -1,89 +0,0 @@
-joint1:
-  kinematic:
-    x: 0.0
-    y: 0.0
-    z: 0.0625
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-joint2:
-  kinematic:
-    x: -0.0301
-    y: 0.0
-    z: 0.06
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-joint3:
-  kinematic:
-    x: 0.0301
-    y: 0.0
-    z: 0.06625
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-joint4:
-  kinematic:
-    x: 0.0
-    y: 0.0315
-    z: 0.20375
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-joint5:
-  kinematic:
-    x: 0.0
-    y: -0.0315
-    z: 0.0955
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-joint6:
-  kinematic:
-    x: 0.0375
-    y: 0.0
-    z: 0.1205
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-# joint7:
-#   kinematic:
-#     x: -0.0375
-#     y: 0.0205
-#     z: 0.0
-#     roll: 0
-#     pitch: 0
-#     yaw: 0
-
-joint7:
-  kinematic:
-    x: -0.0375
-    y: 0.0
-    z: 0.0
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-# joint8:
-#   kinematic:
-#     x: 1e-06
-#     y: -0.098
-#     z: 0.114501
-#     roll: 0
-#     pitch: 0
-#     yaw: 0
-
-joint8:
-  kinematic:
-    x: 1e-6
-    y: 0.0205
-    z: 0.0
-    roll: 0
-    pitch: 0
-    yaw: 0

src/lerobot/robots/openarms/urdf/config/arm/v10/kinematics_link.yaml

@@ -1,80 +0,0 @@
-link0:
-  kinematic:
-    x: 0.0
-    y: 0.0
-    z: 0.0
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-
-link1:
-  kinematic:
-    x: -0.0
-    y: 0.0
-    z: -0.0625
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-
-link2:
-  kinematic:
-    x: 0.0301
-    y: 0.0
-    z: -0.1225
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-
-link3:
-  kinematic:
-    x: -0.0
-    y: -0.0
-    z: -0.18875
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-
-link4:
-  kinematic:
-    x: 0.0
-    y: -0.0315
-    z: -0.3425
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-
-link5:
-  kinematic:
-    x: -0.0
-    y: -0.0
-    z: -0.438
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-
-link6:
-  kinematic:
-    x: -0.0375
-    y: -0.0
-    z: -0.5585
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-    
-# link7:
-#   kinematic:
-#     x: 0.0
-#     y: -0.0205
-#     z: -0.5585
-#     roll: 0.0
-#     pitch: 0.0
-#     yaw: 0.0
-
-link7:
-  kinematic:
-    x: 0.0
-    y: -0.0
-    z: -0.5585
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0

src/lerobot/robots/openarms/urdf/config/arm/v10/kinematics_offset.yaml

@@ -1,71 +0,0 @@
-joint1:
-  kinematic_offset:
-    x: 0.0
-    y: 0.0
-    z: 0.0
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-joint2:
-  kinematic_offset:
-    x: 0.0
-    y: 0.0
-    z: 0.0
-    roll: 1.57079632679
-    pitch: 0
-    yaw: 0
-
-joint3:
-  kinematic_offset:
-    x: 0.0
-    y: 0.0
-    z: 0.0
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-joint4:
-  kinematic_offset:
-    x: -0.0
-    y: 0.0
-    z: 0.0
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-joint5:
-  kinematic_offset:
-    x: 0.0
-    y: -0.0
-    z: 0.0
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-joint6:
-  kinematic_offset:
-    x: 0.0
-    y: 0.0
-    z: 0.0
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-joint7:
-  kinematic_offset:
-    x: -0.0
-    y: 0.0
-    z: 0.0
-    roll: 0
-    pitch: 0
-    yaw: 0
-
-joint8:
-  kinematic_offset:
-    x: 0.0
-    y: -0.0
-    z: 0.0
-    roll: 0
-    pitch: 0
-    yaw: 0

src/lerobot/robots/openarms/urdf/config/body/v10/inertials.yaml

@@ -1,14 +0,0 @@
-body_link0:
-  origin:
-    xyz: 0.0 0.0 0.0
-    rpy: 0.0 0.0 0.0
-  mass: 13.89
-  inertia:
-    xx: 1.653
-    xy: 0.0
-    xz: 0.0
-    yy: 1.653
-    yz: 0.0
-    zz: 0.051
-
-    

src/lerobot/robots/openarms/urdf/config/body/v10/kinematics.yaml

@@ -1,8 +0,0 @@
-body_link0:
-  kinematic:
-    x: 0.0
-    y: 0.0
-    z: 0.0
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0

src/lerobot/robots/openarms/urdf/config/body/v10/kinematics_link.yaml

@@ -1,8 +0,0 @@
-body_link0:
-  kinematic:
-    x: 0.0
-    y: 0.0
-    z: 0.0
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0

src/lerobot/robots/openarms/urdf/config/hand/openarm_hand/inertials.yaml

@@ -1,70 +0,0 @@
-hand:
-  origin:
-    x: 0.0
-    y: 0.002
-    z: 0.03
-    roll: 0
-    pitch: 0
-    yaw: 0
-  mass: 0.35
-  inertia:
-    xx: 0.0002473
-    yy: 1.763e-05
-    zz: 0.0002521
-    xy: 1e-06
-    xz: 1e-06
-    yz: 1e-06
-
-left_finger:
-  origin:
-    x: 0.0064528
-    y: 0.017020
-    z: 0.0219685
-    roll: 0
-    pitch: 0
-    yaw: 0
-  mass: 0.03602545343277134
-  inertia:
-    xx: 2.3749999999999997e-06
-    yy: 2.3749999999999997e-06
-    zz: 7.5e-07
-    xy: 1e-06
-    xz: 1e-06
-    yz: 1e-06
-
-right_finger:
-  origin:
-    x: 0.0064528
-    y: -0.017020
-    z: 0.0219685
-    roll: 0
-    pitch: 0
-    yaw: 0
-  mass: 0.03602545343277134
-  inertia:
-    xx: 2.3749999999999997e-06
-    yy: 2.3749999999999997e-06
-    zz: 7.5e-07
-    xy: 1e-06
-    xz: 1e-06
-    yz: 1e-06
-
-# left_finger: &finger
-#   origin:
-#     x: 00064528
-#     y: 0.017020
-#     z: 0.0219685
-#     roll: 0
-#     pitch: 0
-#     yaw: 0
-#   mass: 0.03602545343277134
-#   inertia:
-#     xx: 2.3749999999999997e-06
-#     yy: 2.3749999999999997e-06
-#     zz: 7.5e-07
-#     xy: 0
-#     xz: 0
-#     yz: 0
-# right_finger: *finger
-
-

src/lerobot/robots/openarms/urdf/config/hand/openarm_hand/kinematics_link.yaml

@@ -1,62 +0,0 @@
-# hand:
-#   kinematic:
-#     x: 0.0
-#     y: -0.0205
-#     z: -0.5585
-#     roll: 0.0
-#     pitch: 0.0
-#     yaw: 0.0
-
-hand:
-  kinematic:
-    x: 0.0
-    y: 0.00
-    z: -0.6585
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-
-# left_finger:
-#   kinematic:
-#     x: 0.0
-#     y: 0.0775
-#     z: -0.673001
-#     roll: 0.0
-#     pitch: 0.0
-#     yaw: 0.0
-
-# left_finger:
-#   kinematic:
-#     x: 0.0
-#     y: 0.053
-#     z: -0.673001
-#     roll: 0.0
-#     pitch: 0.0
-#     yaw: 0.0
-
-# right_finger:
-#   kinematic:
-#     x: 0.0
-#     y: 0.143
-#     z: -0.673001
-#     roll: 0.0
-#     pitch: 0.0
-#     yaw: 0.0
-
-left_finger:
-  kinematic:
-    x: 0.0
-    y: -0.05
-    z: -0.673001
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0
-
-right_finger:
-  kinematic:
-    x: 0.0
-    y: 0.05
-    z: -0.673001
-    roll: 0.0
-    pitch: 0.0
-    yaw: 0.0

src/lerobot/robots/openarms/urdf/dev/README.md

@@ -1,9 +0,0 @@
-# Development
-
-## How to release
-
-```bash
-git clone git@github.com:enactic/openarm_description.git
-cd openarm_description
-dev/release.sh ${VERSION} # e.g. dev/release.sh 1.0.0
-```

src/lerobot/robots/openarms/urdf/dev/release.sh

@@ -1,50 +0,0 @@
-#!/bin/bash
-#
-# Copyright 2025 Enactic, Inc.
-#
-# 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.
-
-set -eu
-
-if [ $# -ne 1 ]; then
-    echo "Usage: $0 version"
-    echo " e.g.: $0 1.0.0"
-    exit 0
-fi
-
-version="$1"
-
-base_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-cd "${base_dir}"
-
-if [ "${RELEASE_CHECK_ORIGIN:-yes}" = "yes" ]; then
-    git_origin_url="$(git remote get-url origin)"
-    if [ "${git_origin_url}" != "git@github.com:enactic/openarm_description.git" ]; then
-        echo "This script must be ran with working copy of enactic/openarm_description."
-        echo "The origin's URL: ${git_origin_url}"
-        exit 1
-    fi
-fi
-
-if [ "${RELEASE_PULL:-yes}" = "yes" ]; then
-    echo "Ensure using the latest commit"
-    git checkout main
-    git pull --ff-only
-fi
-
-if [ "${RELEASE_TAG:-yes}" = "yes" ]; then
-    echo "Tag"
-    git tag -a -m "OpenArm Description ${version}" "${version}"
-    git push origin "${version}"
-fi

src/lerobot/robots/openarms/urdf/launch/display_openarm.launch.py

@@ -1,120 +0,0 @@
-# Copyright 2025 Enactic, Inc.
-#
-# 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 os
-import xacro
-
-from ament_index_python.packages import get_package_share_directory
-
-from launch import LaunchDescription, LaunchContext
-from launch.actions import DeclareLaunchArgument, OpaqueFunction
-from launch.substitutions import LaunchConfiguration
-
-from launch_ros.actions import Node
-
-
-def robot_state_publisher_spawner(context: LaunchContext, arm_type, ee_type, bimanual):
-    arm_type_str = context.perform_substitution(arm_type)
-    ee_type_str = context.perform_substitution(ee_type)
-    bimanual_str = context.perform_substitution(bimanual)
-
-    xacro_path = os.path.join(
-        get_package_share_directory("openarm_description"),
-        "urdf", "robot", f"{arm_type_str}.urdf.xacro"
-    )
-
-    robot_description = xacro.process_file(
-        xacro_path,
-        mappings={
-            "arm_type": arm_type_str,
-            "ee_type": ee_type_str,
-            "bimanual": bimanual_str,
-        }
-    ).toprettyxml(indent="  ")
-
-    return [
-        Node(
-            package="robot_state_publisher",
-            executable="robot_state_publisher",
-            name="robot_state_publisher",
-            output="screen",
-            parameters=[{"robot_description": robot_description}],
-        )
-    ]
-
-
-def rviz_spawner(context: LaunchContext, bimanual):
-    bimanual_str = context.perform_substitution(bimanual)
-
-    rviz_config_file = "bimanual.rviz" if bimanual_str.lower() == "true" else "arm_only.rviz"
-    rviz_config_path = os.path.join(
-        get_package_share_directory("openarm_description"),
-        "rviz", rviz_config_file
-    )
-
-    return [
-        Node(
-            package="rviz2",
-            executable="rviz2",
-            name="rviz2",
-            arguments=["--display-config", rviz_config_path],
-            output="screen"
-        ),
-    ]
-
-
-def generate_launch_description():
-    arm_type_arg = DeclareLaunchArgument(
-        "arm_type",
-        description="Type of arm to visualize (e.g., v10)"
-    )
-
-    ee_type_arg = DeclareLaunchArgument(
-        "ee_type",
-        default_value="openarm_hand",
-        description="Type of end-effector to attach (e.g., openarm_hand or none)"
-    )
-
-    bimanual_arg = DeclareLaunchArgument(
-        "bimanual",
-        default_value="false",
-        description="Whether to use bimanual configuration"
-    )
-
-    arm_type = LaunchConfiguration("arm_type")
-    ee_type = LaunchConfiguration("ee_type")
-    bimanual = LaunchConfiguration("bimanual")
-
-    robot_state_publisher_loader = OpaqueFunction(
-        function=robot_state_publisher_spawner,
-        args=[arm_type, ee_type, bimanual]
-    )
-
-    rviz_loader = OpaqueFunction(
-        function=rviz_spawner,
-        args=[bimanual]
-    )
-
-    return LaunchDescription([
-        arm_type_arg,
-        ee_type_arg,
-        bimanual_arg,
-        robot_state_publisher_loader,
-        Node(
-            package="joint_state_publisher_gui",
-            executable="joint_state_publisher_gui",
-            name="joint_state_publisher_gui"
-        ),
-        rviz_loader,
-    ])

src/lerobot/robots/openarms/urdf/openarm_bimanual.urdf

@@ -1,649 +0,0 @@
-<?xml version="1.0" ?>
-<!-- =================================================================================== -->
-<!-- |    This document was autogenerated by xacro from urdf/robot/v10.urdf.xacro      | -->
-<!-- |    EDITING THIS FILE BY HAND IS NOT RECOMMENDED                                 | -->
-<!-- =================================================================================== -->
-<robot name="openarm">
-  <!-- Is the robot being simulated in gazebo? -->
-  <!-- <xacro:arg name="gazebo" default="false" /> -->
-  <link name="world"/>
-  <joint name="openarm_body_world_joint" type="fixed">
-    <parent link="world"/>
-    <child link="openarm_body_link0"/>
-    <origin rpy="0 0 0" xyz="0 0 0"/>
-  </joint>
-  <link name="openarm_body_link0">
-    <visual name="openarm_body_link0_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0"/>
-      <geometry>
-        <mesh filename="./meshes/body/v10/visual/body_link0.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_body_link0_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0"/>
-      <geometry>
-        <mesh filename="./meshes/body/v10/collision/body_link0_symp.stl" scale="0.001 0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0"/>
-      <mass value="13.89"/>
-      <inertia ixx="1.653" ixy="0.0" ixz="0.0" iyy="1.653" iyz="0.0" izz="0.051"/>
-    </inertial>
-  </link>
-  <joint name="openarm_left_openarm_body_link0_joint" type="fixed">
-    <parent link="openarm_body_link0"/>
-    <child link="openarm_left_link0"/>
-    <origin rpy="-1.5708 0 0" xyz="0.0 0.031 0.698"/>
-  </joint>
-  <link name="openarm_left_link0">
-    <visual name="openarm_left_link0_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link0.dae" scale="0.001 -0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link0_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link0_symp.stl" scale="0.001 -0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0009483362816297526 -0.0001580207020448382 0.03076860287587199"/>
-      <mass value="1.1432284943239561"/>
-      <inertia ixx="0.001128" ixy="-4e-06" ixz="-3.3e-05" iyy="0.000962" iyz="-7e-06" izz="0.00147"/>
-    </inertial>
-  </link>
-  <link name="openarm_left_link1">
-    <visual name="openarm_left_link1_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 0.0 -0.0625"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link1.dae" scale="0.001 -0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link1_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 0.0 -0.0625"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link1_symp.stl" scale="0.001 -0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="0.0011467657911800769 -3.319987657026362e-05 0.05395284380736254"/>
-      <mass value="1.1416684646202298"/>
-      <inertia ixx="0.001567" ixy="-1e-06" ixz="-2.9e-05" iyy="0.001273" iyz="1e-06" izz="0.001016"/>
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint1" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0 0.0 0.0625"/>
-    <parent link="openarm_left_link0"/>
-    <child link="openarm_left_link1"/>
-    <axis xyz="0 0 1"/>
-    <limit effort="40" lower="-3.490659" upper="1.3962629999999998" velocity="16.754666"/>
-  </joint>
-  <link name="openarm_left_link2">
-    <visual name="openarm_left_link2_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0301 0.0 -0.1225"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link2.dae" scale="0.001 -0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link2_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0301 0.0 -0.1225"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link2_symp.stl" scale="0.001 -0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="0.00839629182351943 2.0145102027597523e-08 0.03256649300522363"/>
-      <mass value="0.2775092746011571"/>
-      <inertia ixx="0.000359" ixy="1e-06" ixz="-0.000109" iyy="0.000376" iyz="1e-06" izz="0.000232"/>
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint2" type="revolute">
-    <origin rpy="-1.57079632679 0 0" xyz="-0.0301 0.0 0.06"/>
-    <parent link="openarm_left_link1"/>
-    <child link="openarm_left_link2"/>
-    <axis xyz="-1 0 0"/>
-    <limit effort="40" lower="-3.3161253267948965" upper="0.17453267320510335" velocity="16.754666"/>
-  </joint>
-  <link name="openarm_left_link3">
-    <visual name="openarm_left_link3_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.18875"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link3.dae" scale="0.001 -0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link3_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.18875"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link3_symp.stl" scale="0.001 -0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.002104752099628911 -0.0005549085042607548 0.09047470545721961"/>
-      <mass value="1.073863338202347"/>
-      <inertia ixx="0.004372" ixy="1e-06" ixz="1.1e-05" iyy="0.004319" iyz="-3.6e-05" izz="0.000661"/>
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint3" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0301 0.0 0.06625"/>
-    <parent link="openarm_left_link2"/>
-    <child link="openarm_left_link3"/>
-    <axis xyz="0 0 1"/>
-    <limit effort="27" lower="-1.570796" upper="1.570796" velocity="5.445426"/>
-  </joint>
-  <link name="openarm_left_link4">
-    <visual name="openarm_left_link4_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0315 -0.3425"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link4.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link4_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0315 -0.3425"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link4_symp.stl" scale="0.001 0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0029006831074562967 -0.03030575826634669 0.06339637422196209"/>
-      <mass value="0.6348534566833373"/>
-      <inertia ixx="0.000623" ixy="-1e-06" ixz="-1.9e-05" iyy="0.000511" iyz="3.8e-05" izz="0.000334"/>
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint4" type="revolute">
-    <origin rpy="0 0 0" xyz="-0.0 0.0315 0.20375"/>
-    <parent link="openarm_left_link3"/>
-    <child link="openarm_left_link4"/>
-    <axis xyz="0 1 0"/>
-    <limit effort="27" lower="0.0" upper="2.443461" velocity="5.445426"/>
-  </joint>
-  <link name="openarm_left_link5">
-    <visual name="openarm_left_link5_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.438"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link5.dae" scale="0.001 -0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link5_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.438"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link5_symp.stl" scale="0.001 -0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.003049665024221911 -0.0008866902457326625 0.043079803024980934"/>
-      <mass value="0.6156588026168502"/>
-      <inertia ixx="0.000423" ixy="-8e-06" ixz="6e-06" iyy="0.000445" iyz="-6e-06" izz="0.000324"/>
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint5" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0 -0.0315 0.0955"/>
-    <parent link="openarm_left_link4"/>
-    <child link="openarm_left_link5"/>
-    <axis xyz="0 0 1"/>
-    <limit effort="7" lower="-1.570796" upper="1.570796" velocity="20.943946"/>
-  </joint>
-  <link name="openarm_left_link6">
-    <visual name="openarm_left_link6_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0375 -0.0 -0.5585"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link6.dae" scale="0.001 -0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link6_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0375 -0.0 -0.5585"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link6_symp.stl" scale="0.001 -0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.037136587005447405 -0.00033230528343419053 -9.498374522309838e-05"/>
-      <mass value="0.475202773187987"/>
-      <inertia ixx="0.000143" ixy="1e-06" ixz="1e-06" iyy="0.000157" iyz="1e-06" izz="0.000159"/>
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint6" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0375 0.0 0.1205"/>
-    <parent link="openarm_left_link5"/>
-    <child link="openarm_left_link6"/>
-    <axis xyz="1 0 0"/>
-    <limit effort="7" lower="-0.785398" upper="0.785398" velocity="20.943946"/>
-  </joint>
-  <link name="openarm_left_link7">
-    <visual name="openarm_left_link7_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0 -0.5585"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link7.dae" scale="0.001 -0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_left_link7_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0 -0.5585"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link7_symp.stl" scale="0.001 -0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="6.875510271106056e-05 -0.01266175250761268 0.06951945409987448"/>
-      <mass value="0.4659771327380578"/>
-      <inertia ixx="0.000639" ixy="1e-06" ixz="1e-06" iyy="0.000497" iyz="8.9e-05" izz="0.000342"/>
-    </inertial>
-  </link>
-  <joint name="openarm_left_joint7" type="revolute">
-    <origin rpy="0 0 0" xyz="-0.0375 0.0 0.0"/>
-    <parent link="openarm_left_link6"/>
-    <child link="openarm_left_link7"/>
-    <axis xyz="0 -1 0"/>
-    <limit effort="7" lower="-1.570796" upper="1.570796" velocity="20.943946"/>
-  </joint>
-  <!-- <link name="${prefix}link8"/>
-
-    <joint name="${prefix}joint8" type="fixed">
-      <xacro:openarm-kinematics name="joint8" config="${kinematics}" />
-      <parent link="${prefix}link7" />
-      <child link="${prefix}link8" />
-    </joint> -->
-  <joint name="openarm_right_openarm_body_link0_joint" type="fixed">
-    <parent link="openarm_body_link0"/>
-    <child link="openarm_right_link0"/>
-    <origin rpy="1.5708 0 0" xyz="0.0 -0.031 0.698"/>
-  </joint>
-  <link name="openarm_right_link0">
-    <visual name="openarm_right_link0_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link0.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link0_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 0.0"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link0_symp.stl" scale="0.001 0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0009483362816297526 0.0001580207020448382 0.03076860287587199"/>
-      <mass value="1.1432284943239561"/>
-      <inertia ixx="0.001128" ixy="-4e-06" ixz="-3.3e-05" iyy="0.000962" iyz="-7e-06" izz="0.00147"/>
-    </inertial>
-  </link>
-  <link name="openarm_right_link1">
-    <visual name="openarm_right_link1_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 0.0 -0.0625"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link1.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link1_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 0.0 -0.0625"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link1_symp.stl" scale="0.001 0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="0.0011467657911800769 3.319987657026362e-05 0.05395284380736254"/>
-      <mass value="1.1416684646202298"/>
-      <inertia ixx="0.001567" ixy="-1e-06" ixz="-2.9e-05" iyy="0.001273" iyz="1e-06" izz="0.001016"/>
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint1" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0 0.0 0.0625"/>
-    <parent link="openarm_right_link0"/>
-    <child link="openarm_right_link1"/>
-    <axis xyz="0 0 1"/>
-    <limit effort="40" lower="-1.396263" upper="3.490659" velocity="16.754666"/>
-  </joint>
-  <link name="openarm_right_link2">
-    <visual name="openarm_right_link2_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0301 0.0 -0.1225"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link2.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link2_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0301 0.0 -0.1225"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link2_symp.stl" scale="0.001 0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="0.00839629182351943 -2.0145102027597523e-08 0.03256649300522363"/>
-      <mass value="0.2775092746011571"/>
-      <inertia ixx="0.000359" ixy="1e-06" ixz="-0.000109" iyy="0.000376" iyz="1e-06" izz="0.000232"/>
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint2" type="revolute">
-    <origin rpy="1.57079632679 0 0" xyz="-0.0301 0.0 0.06"/>
-    <parent link="openarm_right_link1"/>
-    <child link="openarm_right_link2"/>
-    <axis xyz="-1 0 0"/>
-    <limit effort="40" lower="-0.17453267320510335" upper="3.3161253267948965" velocity="16.754666"/>
-  </joint>
-  <link name="openarm_right_link3">
-    <visual name="openarm_right_link3_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.18875"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link3.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link3_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.18875"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link3_symp.stl" scale="0.001 0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.002104752099628911 0.0005549085042607548 0.09047470545721961"/>
-      <mass value="1.073863338202347"/>
-      <inertia ixx="0.004372" ixy="1e-06" ixz="1.1e-05" iyy="0.004319" iyz="-3.6e-05" izz="0.000661"/>
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint3" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0301 0.0 0.06625"/>
-    <parent link="openarm_right_link2"/>
-    <child link="openarm_right_link3"/>
-    <axis xyz="0 0 1"/>
-    <limit effort="27" lower="-1.570796" upper="1.570796" velocity="5.445426"/>
-  </joint>
-  <link name="openarm_right_link4">
-    <visual name="openarm_right_link4_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0315 -0.3425"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link4.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link4_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0315 -0.3425"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link4_symp.stl" scale="0.001 0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0029006831074562967 -0.03030575826634669 0.06339637422196209"/>
-      <mass value="0.6348534566833373"/>
-      <inertia ixx="0.000623" ixy="-1e-06" ixz="-1.9e-05" iyy="0.000511" iyz="3.8e-05" izz="0.000334"/>
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint4" type="revolute">
-    <origin rpy="0 0 0" xyz="-0.0 0.0315 0.20375"/>
-    <parent link="openarm_right_link3"/>
-    <child link="openarm_right_link4"/>
-    <axis xyz="0 1 0"/>
-    <limit effort="27" lower="0.0" upper="2.443461" velocity="5.445426"/>
-  </joint>
-  <link name="openarm_right_link5">
-    <visual name="openarm_right_link5_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.438"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link5.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link5_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0 -0.0 -0.438"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link5_symp.stl" scale="0.001 0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.003049665024221911 0.0008866902457326625 0.043079803024980934"/>
-      <mass value="0.6156588026168502"/>
-      <inertia ixx="0.000423" ixy="-8e-06" ixz="6e-06" iyy="0.000445" iyz="-6e-06" izz="0.000324"/>
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint5" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0 -0.0315 0.0955"/>
-    <parent link="openarm_right_link4"/>
-    <child link="openarm_right_link5"/>
-    <axis xyz="0 0 1"/>
-    <limit effort="7" lower="-1.570796" upper="1.570796" velocity="20.943946"/>
-  </joint>
-  <link name="openarm_right_link6">
-    <visual name="openarm_right_link6_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0375 -0.0 -0.5585"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link6.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link6_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="-0.0375 -0.0 -0.5585"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link6_symp.stl" scale="0.001 0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="-0.037136587005447405 0.00033230528343419053 -9.498374522309838e-05"/>
-      <mass value="0.475202773187987"/>
-      <inertia ixx="0.000143" ixy="1e-06" ixz="1e-06" iyy="0.000157" iyz="1e-06" izz="0.000159"/>
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint6" type="revolute">
-    <origin rpy="0 0 0" xyz="0.0375 0.0 0.1205"/>
-    <parent link="openarm_right_link5"/>
-    <child link="openarm_right_link6"/>
-    <axis xyz="1 0 0"/>
-    <limit effort="7" lower="-0.785398" upper="0.785398" velocity="20.943946"/>
-  </joint>
-  <link name="openarm_right_link7">
-    <visual name="openarm_right_link7_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0 -0.5585"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/visual/link7.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_right_link7_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.0 -0.5585"/>
-      <geometry>
-        <mesh filename="./meshes/arm/v10/collision/link7_symp.stl" scale="0.001 0.001 0.001"/>
-        <!-- <mesh filename="./meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0.0 0.0 0.0" xyz="6.875510271106056e-05 0.01266175250761268 0.06951945409987448"/>
-      <mass value="0.4659771327380578"/>
-      <inertia ixx="0.000639" ixy="1e-06" ixz="1e-06" iyy="0.000497" iyz="8.9e-05" izz="0.000342"/>
-    </inertial>
-  </link>
-  <joint name="openarm_right_joint7" type="revolute">
-    <origin rpy="0 0 0" xyz="-0.0375 0.0 0.0"/>
-    <parent link="openarm_right_link6"/>
-    <child link="openarm_right_link7"/>
-    <axis xyz="0 1 0"/>
-    <limit effort="7" lower="-1.570796" upper="1.570796" velocity="20.943946"/>
-  </joint>
-  <!-- <link name="${prefix}link8"/>
-
-    <joint name="${prefix}joint8" type="fixed">
-      <xacro:openarm-kinematics name="joint8" config="${kinematics}" />
-      <parent link="${prefix}link7" />
-      <child link="${prefix}link8" />
-    </joint> -->
-  <link name="openarm_left_hand">
-    <visual name="openarm_left_hand_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 -0.6585"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/hand.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_left_hand_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 -0.6585"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/hand.stl" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0 0.002 0.03"/>
-      <mass value="0.35"/>
-      <inertia ixx="0.0002473" ixy="1e-06" ixz="1e-06" iyy="1.763e-05" iyz="1e-06" izz="0.0002521"/>
-    </inertial>
-  </link>
-  <!-- <link name="${ee_prefix}hand"/> -->
-  <!-- <joint name="${ee_prefix}hand_joint" type="fixed"> -->
-  <joint name="left_openarm_hand_joint" type="fixed">
-    <parent link="openarm_left_link7"/>
-    <child link="openarm_left_hand"/>
-    <origin rpy="0 0 0" xyz="0 -0.0 0.1001"/>
-  </joint>
-  <!-- Define the hand_tcp frame -->
-  <link name="openarm_left_hand_tcp"/>
-  <joint name="openarm_left_hand_tcp_joint" type="fixed">
-    <origin rpy="0 0 0" xyz="0 -0.0 0.08"/>
-    <parent link="openarm_left_hand"/>
-    <child link="openarm_left_hand_tcp"/>
-  </joint>
-  <link name="openarm_left_left_finger">
-    <visual name="openarm_left_left_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.723001"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/finger.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_left_left_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.723001"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0064528 0.01702 0.0219685"/>
-      <mass value="0.03602545343277134"/>
-      <inertia ixx="2.3749999999999997e-06" ixy="1e-06" ixz="1e-06" iyy="2.3749999999999997e-06" iyz="1e-06" izz="7.5e-07"/>
-    </inertial>
-  </link>
-  <link name="openarm_left_right_finger">
-    <visual name="openarm_left_right_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.723001"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/finger.dae" scale="0.001 -0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_left_right_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.723001"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 -0.001 0.001"/>
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0064528 -0.01702 0.0219685"/>
-      <mass value="0.03602545343277134"/>
-      <inertia ixx="2.3749999999999997e-06" ixy="1e-06" ixz="1e-06" iyy="2.3749999999999997e-06" iyz="1e-06" izz="7.5e-07"/>
-    </inertial>
-  </link>
-  <joint name="openarm_left_finger_joint1" type="prismatic">
-    <parent link="openarm_left_hand"/>
-    <child link="openarm_left_right_finger"/>
-    <origin rpy="0 0 0" xyz="0 -0.006 0.015"/>
-    <axis xyz="0 -1 0"/>
-    <limit effort="333" lower="0.0" upper="0.044" velocity="10.0"/>
-  </joint>
-  <joint name="openarm_left_finger_joint2" type="prismatic">
-    <parent link="openarm_left_hand"/>
-    <child link="openarm_left_left_finger"/>
-    <origin rpy="0 0 0" xyz="0 0.006 0.015"/>
-    <axis xyz="0 1 0"/>
-    <limit effort="333" lower="0.0" upper="0.044" velocity="10.0"/>
-    <mimic joint="openarm_left_finger_joint1"/>
-  </joint>
-  <link name="openarm_right_hand">
-    <visual name="openarm_right_hand_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 -0.6585"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/hand.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_right_hand_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.0 -0.6585"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/hand.stl" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0 0.002 0.03"/>
-      <mass value="0.35"/>
-      <inertia ixx="0.0002473" ixy="1e-06" ixz="1e-06" iyy="1.763e-05" iyz="1e-06" izz="0.0002521"/>
-    </inertial>
-  </link>
-  <!-- <link name="${ee_prefix}hand"/> -->
-  <!-- <joint name="${ee_prefix}hand_joint" type="fixed"> -->
-  <joint name="right_openarm_hand_joint" type="fixed">
-    <parent link="openarm_right_link7"/>
-    <child link="openarm_right_hand"/>
-    <origin rpy="0 0 0" xyz="0 -0.0 0.1001"/>
-  </joint>
-  <!-- Define the hand_tcp frame -->
-  <link name="openarm_right_hand_tcp"/>
-  <joint name="openarm_right_hand_tcp_joint" type="fixed">
-    <origin rpy="0 0 0" xyz="0 -0.0 0.08"/>
-    <parent link="openarm_right_hand"/>
-    <child link="openarm_right_hand_tcp"/>
-  </joint>
-  <link name="openarm_right_left_finger">
-    <visual name="openarm_right_left_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.723001"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/finger.dae" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_right_left_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.723001"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 0.001 0.001"/>
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0064528 0.01702 0.0219685"/>
-      <mass value="0.03602545343277134"/>
-      <inertia ixx="2.3749999999999997e-06" ixy="1e-06" ixz="1e-06" iyy="2.3749999999999997e-06" iyz="1e-06" izz="7.5e-07"/>
-    </inertial>
-  </link>
-  <link name="openarm_right_right_finger">
-    <visual name="openarm_right_right_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.723001"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/visual/finger.dae" scale="0.001 -0.001 0.001"/>
-      </geometry>
-    </visual>
-    <collision name="openarm_right_right_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.723001"/>
-      <geometry>
-        <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 -0.001 0.001"/>
-      </geometry>
-    </collision>
-    <inertial>
-      <origin rpy="0 0 0" xyz="0.0064528 -0.01702 0.0219685"/>
-      <mass value="0.03602545343277134"/>
-      <inertia ixx="2.3749999999999997e-06" ixy="1e-06" ixz="1e-06" iyy="2.3749999999999997e-06" iyz="1e-06" izz="7.5e-07"/>
-    </inertial>
-  </link>
-  <joint name="openarm_right_finger_joint1" type="prismatic">
-    <parent link="openarm_right_hand"/>
-    <child link="openarm_right_right_finger"/>
-    <origin rpy="0 0 0" xyz="0 -0.006 0.015"/>
-    <axis xyz="0 -1 0"/>
-    <limit effort="333" lower="0.0" upper="0.044" velocity="10.0"/>
-  </joint>
-  <joint name="openarm_right_finger_joint2" type="prismatic">
-    <parent link="openarm_right_hand"/>
-    <child link="openarm_right_left_finger"/>
-    <origin rpy="0 0 0" xyz="0 0.006 0.015"/>
-    <axis xyz="0 1 0"/>
-    <limit effort="333" lower="0.0" upper="0.044" velocity="10.0"/>
-    <mimic joint="openarm_right_finger_joint1"/>
-  </joint>
-</robot>

src/lerobot/robots/openarms/urdf/openarm_bimanual_pybullet.urdf

@@ -147,7 +147,7 @@
     </inertial>
   </link>
   <joint name="openarm_left_joint4" type="revolute">
-    <origin rpy="0 0 0" xyz="-0.0 0.0315 0.20375" />
+    <origin rpy="0 0 0" xyz="-0.0 0.0315 0.15375" />
     <parent link="openarm_left_link3" />
     <child link="openarm_left_link4" />
     <axis xyz="0 1 0" />
@@ -353,7 +353,7 @@
     </inertial>
   </link>
   <joint name="openarm_right_joint4" type="revolute">
-    <origin rpy="0 0 0" xyz="-0.0 0.0315 0.20375" />
+    <origin rpy="0 0 0" xyz="-0.0 0.0315 0.15375" />
     <parent link="openarm_right_link3" />
     <child link="openarm_right_link4" />
     <axis xyz="0 1 0" />
@@ -475,13 +475,13 @@
   </joint>
   <link name="openarm_left_left_finger">
     <visual name="openarm_left_left_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.723001" />
+      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.673001" />
       <geometry>
         <mesh filename="./meshes/ee/openarm_hand/visual/finger.stl" scale="0.001 0.001 0.001" />
       </geometry>
     </visual>
     <collision name="openarm_left_left_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.723001" />
+      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.673001" />
       <geometry>
         <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 0.001 0.001" />
       </geometry>
@@ -494,13 +494,13 @@
   </link>
   <link name="openarm_left_right_finger">
     <visual name="openarm_left_right_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.723001" />
+      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.673001" />
       <geometry>
         <mesh filename="./meshes/ee/openarm_hand/visual/finger.stl" scale="0.001 -0.001 0.001" />
       </geometry>
     </visual>
     <collision name="openarm_left_right_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.723001" />
+      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.673001" />
       <geometry>
         <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 -0.001 0.001" />
       </geometry>
@@ -564,13 +564,13 @@
   </joint>
   <link name="openarm_right_left_finger">
     <visual name="openarm_right_left_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.723001" />
+      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.673001" />
       <geometry>
         <mesh filename="./meshes/ee/openarm_hand/visual/finger.stl" scale="0.001 0.001 0.001" />
       </geometry>
     </visual>
     <collision name="openarm_right_left_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.723001" />
+      <origin rpy="0.0 0.0 0.0" xyz="0.0 -0.05 -0.673001" />
       <geometry>
         <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 0.001 0.001" />
       </geometry>
@@ -583,13 +583,13 @@
   </link>
   <link name="openarm_right_right_finger">
     <visual name="openarm_right_right_finger_visual">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.723001" />
+      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.673001" />
       <geometry>
         <mesh filename="./meshes/ee/openarm_hand/visual/finger.stl" scale="0.001 -0.001 0.001" />
       </geometry>
     </visual>
     <collision name="openarm_right_right_finger_collision">
-      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.723001" />
+      <origin rpy="0.0 0.0 0.0" xyz="0.0 0.05 -0.673001" />
       <geometry>
         <mesh filename="./meshes/ee/openarm_hand/collision/finger.stl" scale="0.001 -0.001 0.001" />
       </geometry>

src/lerobot/robots/openarms/urdf/package.xml

@@ -1,40 +0,0 @@
-<?xml version="1.0"?>
-<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
-<!--
-　Copyright 2025 Enactic, Inc.
-
-　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.
--->
-<package format="3">
-  <name>openarm_description</name>
-  <version>1.0.0</version>
-  <description>URDF with optional configuration parameters for OpenArm</description>
-  <maintainer email="openarm_dev@enactic.ai">Enactic, Inc.</maintainer>
-  <license>Apache-2.0</license>
-
-  <buildtool_depend>ament_cmake</buildtool_depend>
-
-  <test_depend>ament_lint_auto</test_depend>
-  <test_depend>ament_lint_common</test_depend>
-  <test_depend>ament_cmake_pytest</test_depend>
-
-  <depend>joint_state_publisher_gui</depend>
-  <depend>ros_gz</depend>
-  <depend>realsense2_description</depend>
-  <exec_depend>xacro</exec_depend>
-  <exec_depend>rviz2</exec_depend>
-
-  <export>
-    <build_type>ament_cmake</build_type>
-  </export>
-</package>

src/lerobot/robots/openarms/urdf/rviz/arm_only.rviz

@@ -1,185 +0,0 @@
-Panels:
-  - Class: rviz_common/Displays
-    Help Height: 138
-    Name: Displays
-    Property Tree Widget:
-      Expanded:
-        - /Global Options1
-      Splitter Ratio: 0.5
-    Tree Height: 758
-  - Class: rviz_common/Views
-    Expanded:
-      - /Current View1
-    Name: Views
-    Splitter Ratio: 0.5
-Visualization Manager:
-  Class: ""
-  Displays:
-    - Alpha: 0.5
-      Cell Size: 1
-      Class: rviz_default_plugins/Grid
-      Color: 160; 160; 164
-      Enabled: true
-      Line Style:
-        Line Width: 0.029999999329447746
-        Value: Lines
-      Name: Grid
-      Normal Cell Count: 0
-      Offset:
-        X: 0
-        Y: 0
-        Z: 0
-      Plane: XY
-      Plane Cell Count: 10
-      Reference Frame: <Fixed Frame>
-      Value: true
-    - Alpha: 1
-      Class: rviz_default_plugins/RobotModel
-      Collision Enabled: false
-      Description File: ""
-      Description Source: Topic
-      Description Topic:
-        Depth: 5
-        Durability Policy: Volatile
-        History Policy: Keep Last
-        Reliability Policy: Reliable
-        Value: /robot_description
-      Enabled: true
-      Links:
-        All Links Enabled: true
-        Expand Joint Details: false
-        Expand Link Details: false
-        Expand Tree: false
-        Link Tree Style: Links in Alphabetic Order
-        openarm_hand:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_hand_tcp:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-        openarm_left_finger:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_link0:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_link1:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_link2:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_link3:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_link4:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_link5:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_link6:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_link7:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_link8:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-        openarm_right_finger:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-      Mass Properties:
-        Inertia: false
-        Mass: false
-      Name: RobotModel
-      TF Prefix: ""
-      Update Interval: 0
-      Value: true
-      Visual Enabled: true
-    - Class: rviz_default_plugins/TF
-      Enabled: false
-      Frame Timeout: 15
-      Frames:
-        All Enabled: true
-      Marker Scale: 1
-      Name: TF
-      Show Arrows: true
-      Show Axes: true
-      Show Names: false
-      Tree:
-        {}
-      Update Interval: 0
-      Value: false
-  Enabled: true
-  Global Options:
-    Background Color: 48; 48; 48
-    Fixed Frame: openarm_link0
-    Frame Rate: 30
-  Name: root
-  Tools:
-    - Class: rviz_default_plugins/MoveCamera
-  Transformation:
-    Current:
-      Class: rviz_default_plugins/TF
-  Value: true
-  Views:
-    Current:
-      Class: rviz_default_plugins/Orbit
-      Distance: 2.424237012863159
-      Enable Stereo Rendering:
-        Stereo Eye Separation: 0.05999999865889549
-        Stereo Focal Distance: 1
-        Swap Stereo Eyes: false
-        Value: false
-      Focal Point:
-        X: 0
-        Y: 0
-        Z: 0
-      Focal Shape Fixed Size: true
-      Focal Shape Size: 0.05000000074505806
-      Invert Z Axis: false
-      Name: Current View
-      Near Clip Distance: 0.009999999776482582
-      Pitch: 0.33000001311302185
-      Target Frame: <Fixed Frame>
-      Value: Orbit (rviz)
-      Yaw: 5.5
-    Saved: ~
-Window Geometry:
-  Displays:
-    collapsed: false
-  Height: 1922
-  Hide Left Dock: false
-  Hide Right Dock: false
-  QMainWindow State: 000000ff00000000fd0000000100000000000001da000006f0fc0200000002fb000000100044006900730070006c0061007900730100000069000003e40000017800fffffffb0000000a005600690065007700730100000459000003000000012300ffffff00000afa000006f000000004000000040000000800000008fc0000000100000002000000010000000a0054006f006f006c00730100000000ffffffff0000000000000000
-  Views:
-    collapsed: false
-  Width: 3296
-  X: 0
-  Y: 64

src/lerobot/robots/openarms/urdf/rviz/bimanual.rviz

@@ -1,257 +0,0 @@
-Panels:
-  - Class: rviz_common/Displays
-    Help Height: 138
-    Name: Displays
-    Property Tree Widget:
-      Expanded:
-        - /Global Options1
-      Splitter Ratio: 0.5
-    Tree Height: 139
-  - Class: rviz_common/Views
-    Expanded:
-      - /Current View1
-    Name: Views
-    Splitter Ratio: 0.5
-Visualization Manager:
-  Class: ""
-  Displays:
-    - Alpha: 0.5
-      Cell Size: 1
-      Class: rviz_default_plugins/Grid
-      Color: 160; 160; 164
-      Enabled: true
-      Line Style:
-        Line Width: 0.029999999329447746
-        Value: Lines
-      Name: Grid
-      Normal Cell Count: 0
-      Offset:
-        X: 0
-        Y: 0
-        Z: 0
-      Plane: XY
-      Plane Cell Count: 10
-      Reference Frame: <Fixed Frame>
-      Value: true
-    - Alpha: 1
-      Class: rviz_default_plugins/RobotModel
-      Collision Enabled: false
-      Description File: ""
-      Description Source: Topic
-      Description Topic:
-        Depth: 5
-        Durability Policy: Volatile
-        History Policy: Keep Last
-        Reliability Policy: Reliable
-        Value: /robot_description
-      Enabled: true
-      Links:
-        All Links Enabled: true
-        Expand Joint Details: false
-        Expand Link Details: false
-        Expand Tree: false
-        Link Tree Style: Links in Alphabetic Order
-        openarm_left_hand:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_left_hand_tcp:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-        openarm_left_left_finger:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_left_link0:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_left_link1:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_left_link2:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_left_link3:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_left_link4:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_left_link5:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_left_link6:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_left_link7:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_left_link8:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-        openarm_left_right_finger:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_right_hand:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_right_hand_tcp:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-        openarm_right_left_finger:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_right_link0:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_right_link1:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_right_link2:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_right_link3:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_right_link4:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_right_link5:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_right_link6:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_right_link7:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        openarm_right_link8:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-        openarm_right_right_finger:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        v10_body_link0:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-          Value: true
-        world:
-          Alpha: 1
-          Show Axes: false
-          Show Trail: false
-      Mass Properties:
-        Inertia: false
-        Mass: false
-      Name: RobotModel
-      TF Prefix: ""
-      Update Interval: 0
-      Value: true
-      Visual Enabled: true
-    - Class: rviz_default_plugins/TF
-      Enabled: false
-      Frame Timeout: 15
-      Frames:
-        All Enabled: true
-      Marker Scale: 1
-      Name: TF
-      Show Arrows: true
-      Show Axes: true
-      Show Names: false
-      Tree:
-        {}
-      Update Interval: 0
-      Value: false
-  Enabled: true
-  Global Options:
-    Background Color: 48; 48; 48
-    Fixed Frame: world
-    Frame Rate: 30
-  Name: root
-  Tools:
-    - Class: rviz_default_plugins/MoveCamera
-  Transformation:
-    Current:
-      Class: rviz_default_plugins/TF
-  Value: true
-  Views:
-    Current:
-      Class: rviz_default_plugins/Orbit
-      Distance: 5
-      Enable Stereo Rendering:
-        Stereo Eye Separation: 0.05999999865889549
-        Stereo Focal Distance: 1
-        Swap Stereo Eyes: false
-        Value: false
-      Focal Point:
-        X: 0
-        Y: 0
-        Z: 0
-      Focal Shape Fixed Size: true
-      Focal Shape Size: 0.05000000074505806
-      Invert Z Axis: false
-      Name: Current View
-      Near Clip Distance: 0.009999999776482582
-      Pitch: 0.33000001311302185
-      Target Frame: <Fixed Frame>
-      Value: Orbit (rviz)
-      Yaw: 5.5
-    Saved: ~
-Window Geometry:
-  Displays:
-    collapsed: false
-  Height: 826
-  Hide Left Dock: false
-  Hide Right Dock: false
-  QMainWindow State: 000000ff00000000fd0000000100000000000001da000002a8fc0200000002fb000000100044006900730070006c0061007900730100000069000001790000017800fffffffb0000000a0056006900650077007301000001ee000001230000012300ffffff000002ca000002a800000004000000040000000800000008fc0000000100000002000000010000000a0054006f006f006c00730100000000ffffffff0000000000000000
-  Views:
-    collapsed: false
-  Width: 1200
-  X: 42
-  Y: 64

src/lerobot/robots/openarms/urdf/urdf/arm/openarm_arm.xacro

@@ -1,118 +0,0 @@
-<?xml version='1.0' encoding='utf-8'?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro" name="openarm">
-
-  <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/arm/openarm_macro.xacro" />
-
-  <xacro:macro name="openarm_arm" params="arm_type arm_prefix:='' no_prefix:=false description_pkg:='openarm_description' connected_to:='base' xyz:='0 0 0' rpy:='0 0 0' joint_limits inertials kinematics kinematics_link kinematics_offset:=none " >
-
-    <xacro:property name="prefix" value="${'' if no_prefix else 'openarm' + '_' + arm_prefix}" />
-
-    <xacro:if value="${arm_prefix == 'right_'}">
-      <xacro:property name="reflect" value="1" />
-    </xacro:if>
-
-    <xacro:unless value="${arm_prefix == 'right_'}">
-      <xacro:property name="reflect" value="-1" />
-    </xacro:unless>
-
-    <xacro:unless value="${connected_to == ''}">
-      <joint name="${prefix}${connected_to}_joint" type="fixed">
-        <parent link="${connected_to}"/>
-        <child link="${prefix}link0"/>
-        <origin rpy="${rpy}" xyz="${xyz}"/>
-      </joint>
-    </xacro:unless>
-
-    <xacro:link_with_sc no_prefix="${no_prefix}" name="link0" kinematics_link="${kinematics_link}" inertials="${inertials}" reflect="${reflect}"/>
-
-    <xacro:link_with_sc no_prefix="${no_prefix}" name="link1" kinematics_link="${kinematics_link}" inertials="${inertials}" reflect="${reflect}"/>
-
-    <joint name="${prefix}joint1" type="revolute">
-      <xacro:openarm-kinematics name="joint1" config="${kinematics}" reflect="${reflect}"/>
-      <parent link="${prefix}link0" />
-      <child link="${prefix}link1" />
-      <axis xyz="0 0 1" />
-      <xacro:openarm-limits name="joint1" config="${joint_limits}" offset="${-2.094396 if arm_prefix=='left_' else 0}"/>
-    </joint>
-
-    <!-- for bimanual offset -->
-    <xacro:link_with_sc no_prefix="${no_prefix}" name="link2" kinematics_link="${kinematics_link}" inertials="${inertials}" reflect="${reflect}"/>
-
-    <xacro:property name="limit_offset_joint2" value="0" />
-
-    <xacro:if value="${prefix.find('right_') != -1}">
-      <xacro:property name="limit_offset_joint2" value="${pi/2}" />
-    </xacro:if>
-    
-    <xacro:if value="${prefix.find('left_') != -1}">
-      <xacro:property name="limit_offset_joint2" value="${-pi/2}" />
-    </xacro:if>
-
-    <joint name="${prefix}joint2" type="revolute">
-      <xacro:openarm-kinematics name="joint2" config="${kinematics}" offset="${kinematics_offset}" reflect="${reflect}"/>
-      <parent link="${prefix}link1" />
-      <child link="${prefix}link2" />
-      <axis xyz="-1 0 0" />
-      <xacro:openarm-limits name="joint2" config="${joint_limits}" reflect="${reflect}" offset="${limit_offset_joint2}"/>
-    </joint>
-    
-    <xacro:link_with_sc no_prefix="${no_prefix}" name="link3" kinematics_link="${kinematics_link}" inertials="${inertials}" reflect="${reflect}"/>
-
-    <joint name="${prefix}joint3" type="revolute">
-      <xacro:openarm-kinematics name="joint3" config="${kinematics}" />
-      <parent link="${prefix}link2" />
-      <child link="${prefix}link3" />
-      <axis xyz="0 0 1" />
-      <xacro:openarm-limits name="joint3" config="${joint_limits}" />
-    </joint>
-
-    <xacro:link_with_sc no_prefix="${no_prefix}" name="link4" kinematics_link="${kinematics_link}" />
-
-    <joint name="${prefix}joint4" type="revolute">
-      <xacro:openarm-kinematics name="joint4" config="${kinematics}" />
-      <parent link="${prefix}link3" />
-      <child link="${prefix}link4" />
-      <axis xyz="0 1 0" />
-      <xacro:openarm-limits name="joint4" config="${joint_limits}" />
-    </joint>
-
-    <xacro:link_with_sc no_prefix="${no_prefix}" name="link5" kinematics_link="${kinematics_link}" inertials="${inertials}" reflect="${reflect}" />
-
-    <joint name="${prefix}joint5" type="revolute">
-      <xacro:openarm-kinematics name="joint5" config="${kinematics}" />
-      <parent link="${prefix}link4" />
-      <child link="${prefix}link5" />
-      <axis xyz="0 0 1" />
-      <xacro:openarm-limits name="joint5" config="${joint_limits}" />
-    </joint>
-
-    <xacro:link_with_sc no_prefix="${no_prefix}" name="link6" kinematics_link="${kinematics_link}" inertials="${inertials}" reflect="${reflect}"/>
-
-    <joint name="${prefix}joint6" type="revolute">
-      <xacro:openarm-kinematics name="joint6" config="${kinematics}" />
-      <parent link="${prefix}link5" />
-      <child link="${prefix}link6" />
-      <axis xyz="1 0 0" />
-      <xacro:openarm-limits name="joint6" config="${joint_limits}" />
-    </joint>
-
-    <xacro:link_with_sc no_prefix="${no_prefix}" name="link7" kinematics_link="${kinematics_link}" inertials="${inertials}" reflect="${reflect}"/>
-
-    <joint name="${prefix}joint7" type="revolute">
-      <xacro:openarm-kinematics name="joint7" config="${kinematics}" />
-      <parent link="${prefix}link6"/>
-      <child link="${prefix}link7"/>
-      <axis xyz="0 ${reflect} 0"/>
-      <xacro:openarm-limits name="joint7" config="${joint_limits}" />
-    </joint>
-
-    <!-- <link name="${prefix}link8"/>
-
-    <joint name="${prefix}joint8" type="fixed">
-      <xacro:openarm-kinematics name="joint8" config="${kinematics}" />
-      <parent link="${prefix}link7" />
-      <child link="${prefix}link8" />
-    </joint> -->
-
-  </xacro:macro>
-</robot>

src/lerobot/robots/openarms/urdf/urdf/arm/openarm_macro.xacro

@@ -1,137 +0,0 @@
-<?xml version="1.0"?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro">
-
-  <xacro:macro name="openarm-inertials" params="name inertials:=^ reflect:=1">
-    <xacro:unless value="${name in inertials}">
-      ${xacro.warning('No inertia properties defined for: ' + name)}
-    </xacro:unless>
-    <xacro:if value="${name in inertials}">
-      <xacro:property name="I" value="${inertials[name]}" lazy_eval="false" />
-      <inertial>
-        <origin
-          xyz="${I.origin.x} ${reflect * I.origin.y} ${I.origin.z}"
-          rpy="${I.origin.roll} ${I.origin.pitch} ${I.origin.yaw}" />
-        <mass value="${I.mass}" />
-        <xacro:if value="${'inertia' in I}">
-          <xacro:property name="inert" value="${I.inertia}" />
-          <inertia ixx="${inert.xx}" ixy="${inert.xy}" ixz="${inert.xz}"
-                   iyy="${inert.yy}" iyz="${inert.yz}" izz="${inert.zz}" />
-        </xacro:if>
-      </inertial>
-    </xacro:if>
-  </xacro:macro>
-  
-  <xacro:macro name="link_with_sc" params="name no_prefix:='false' rpy:='0 0 0' kinematics_link:='' reflect:=1 inertials:=^">
-    <!-- <xacro:property name="prefix" value="${'' if no_prefix else arm_prefix + arm_type + '_'}" /> -->
-    <xacro:property name="prefix" value="${'' if no_prefix else 'openarm' + '_' +  arm_prefix}" />
-    <link name="${prefix}${name}">
-      <visual name="${prefix}${name}_visual">
-        <xacro:openarm-kinematics-link config="${kinematics_link}" name="${name}" />
-        <geometry>
-          <mesh filename="package://${description_pkg}/meshes/arm/${arm_type}/visual/${name}.dae" scale="0.001 ${0.001*reflect} 0.001" />
-        </geometry>
-      </visual>
-      <collision name="${prefix}${name}_collision">
-        <xacro:openarm-kinematics-link config="${kinematics_link}" name="${name}" />
-        <geometry>
-          <mesh filename="package://openarm_description/meshes/arm/${arm_type}/collision/${name}_symp.stl" scale="0.001 ${0.001*reflect} 0.001" />
-          <!-- <mesh filename="package://openarm_description/meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-        </geometry>
-      </collision>
-      <xacro:openarm-inertials name="${name}" inertials="${inertials}" reflect="${reflect}" />
-    </link>
-  </xacro:macro>
-  
-  <xacro:macro name="transmission-openarm-state" params="arm_type:=fer">
-    <transmission name="${arm_prefix}${arm_type}_openarm_state">
-      <type>openarm_hw/openarmStateInterface</type>
-      <joint name="${arm_prefix}${arm_type}_joint1"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></joint>
-      <joint name="${arm_prefix}${arm_type}_joint2"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></joint>
-      <joint name="${arm_prefix}${arm_type}_joint3"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></joint>
-      <joint name="${arm_prefix}${arm_type}_joint4"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></joint>
-      <joint name="${arm_prefix}${arm_type}_joint5"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></joint>
-      <joint name="${arm_prefix}${arm_type}_joint6"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></joint>
-      <joint name="${arm_prefix}${arm_type}_joint7"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></joint>
-
-      <actuator name="${arm_prefix}${arm_type}_motor1"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></actuator>
-      <actuator name="${arm_prefix}${arm_type}_motor2"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></actuator>
-      <actuator name="${arm_prefix}${arm_type}_motor3"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></actuator>
-      <actuator name="${arm_prefix}${arm_type}_motor4"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></actuator>
-      <actuator name="${arm_prefix}${arm_type}_motor5"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></actuator>
-      <actuator name="${arm_prefix}${arm_type}_motor6"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></actuator>
-      <actuator name="${arm_prefix}${arm_type}_motor7"><hardwareInterface>openarm_hw/openarmStateInterface</hardwareInterface></actuator>
-    </transmission>
-  </xacro:macro>
-
-  <xacro:macro name="transmission-openarm-model" params="arm_type:=v10 root:=v10_joint1 tip:=v10_joint7">
-    <transmission name="${arm_prefix}${arm_type}_openarm_model">
-      <type>openarm_hw/openarmModelInterface</type>
-      <joint name="${root}">
-        <role>root</role>
-        <hardwareInterface>openarm_hw/openarmModelInterface</hardwareInterface>
-      </joint>
-      <joint name="${tip}">
-        <role>tip</role>
-        <hardwareInterface>openarm_hw/openarmModelInterface</hardwareInterface>
-      </joint>
-      <actuator name="${root}_motor_root"><hardwareInterface>openarm_hw/openarmModelInterface</hardwareInterface></actuator>
-      <actuator name="${tip}_motor_tip"  ><hardwareInterface>openarm_hw/openarmModelInterface</hardwareInterface></actuator>
-    </transmission>
-  </xacro:macro>
-  <xacro:macro name="inertia-cylinder" params="mass radius h">
-    <inertial>
-      <mass value="${mass}" />
-      <inertia ixx="${1./12 * mass * (3 * radius**2 + h**2)}" ixy = "0" ixz = "0"
-               iyy="${1./12 * mass * (3 * radius**2 + h**2)}" iyz = "0"
-               izz="${1./2  * mass * radius**2}" />
-    </inertial>
-  </xacro:macro>
-
-
-  <xacro:macro name="openarm-limits" params="name config reflect:=1 offset:=0">
-    <xacro:property name="limits" value="${config[name]['limit']}"/>
-    <xacro:property name="raw_lower" value="${limits.lower * reflect + offset}" />
-    <xacro:property name="raw_upper" value="${limits.upper * reflect + offset}" />
-  
-    <xacro:property name="lower" value="0.0" />
-    <xacro:property name="upper" value="0.0" />
-  
-    <xacro:if value="${raw_lower &lt; raw_upper}">
-      <xacro:property name="lower" value="${raw_lower}" />
-      <xacro:property name="upper" value="${raw_upper}" />
-    </xacro:if>
-  
-    <xacro:unless value="${raw_lower &lt; raw_upper}">
-      <xacro:property name="lower" value="${raw_upper}" />
-      <xacro:property name="upper" value="${raw_lower}" />
-    </xacro:unless>
-  
-    <limit
-      lower="${lower}"
-      upper="${upper}"
-      effort="${limits.effort}"
-      velocity="${limits.velocity}" />
-  </xacro:macro>
-  
-  <xacro:macro name="openarm-kinematics" params="name config offset:=none reflect:=1">
-    <xacro:property name="kinematics" value="${config[name]['kinematic']}" lazy_eval="false" />
-    <xacro:if value="${offset != 'none'}">
-      <xacro:property name="offset" value="${offset[name]['kinematic_offset']}" lazy_eval="false" />
-      <origin
-        xyz="${kinematics.x + offset.x} ${kinematics.y + offset.y} ${kinematics.z + offset.z}"
-        rpy="${reflect*(kinematics.roll + offset.roll)} ${reflect*(kinematics.pitch + offset.pitch)} ${reflect*(kinematics.yaw + offset.yaw)}" />
-    </xacro:if>
-    <xacro:unless value="${offset != 'none'}">
-      <origin
-        xyz="${kinematics.x} ${kinematics.y} ${kinematics.z}"
-        rpy="${reflect*kinematics.roll} ${reflect*kinematics.pitch} ${reflect*kinematics.yaw}" />
-    </xacro:unless>
-  </xacro:macro>
-
-  <xacro:macro name="openarm-kinematics-link" params="config name">
-    <xacro:property name="kinematics_link" value="${config[name]['kinematic']}" lazy_eval="false" />
-    <origin rpy="${kinematics_link.roll} ${kinematics_link.pitch} ${kinematics_link.yaw}"
-            xyz="${kinematics_link.x} ${kinematics_link.y} ${kinematics_link.z}" />
-  </xacro:macro>
-
-</robot>

src/lerobot/robots/openarms/urdf/urdf/body/openarm_body.xacro

@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro" name="openarm_body">
-
-
-  <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/body/openarm_body_macro.xacro" />
-
-      <xacro:macro name="openarm_body"
-      params="body_type
-              body_prefix:=''
-              no_prefix:=false
-              description_pkg:='openarm_description'
-              connected_to:='world'
-              xyz:='0 0 0'
-              rpy:='0 0 0'
-              inertials
-              kinematics
-              kinematics_link">
-
-    <!-- <xacro:property name="prefix" value="${'' if no_prefix else body_prefix + 'body_'}" /> -->
-    <xacro:property name="prefix" value="${'' if no_prefix else 'openarm_' + 'body_'}" />
-
-    <xacro:unless value="${not connected_to}">
-    <link name="${connected_to}" />
-    <joint name="${prefix}${connected_to}_joint" type="fixed">
-    <parent link="${connected_to}" />
-    <child link="${prefix}link0" />
-    <origin xyz="${xyz}" rpy="${rpy}" />
-    </joint>
-    </xacro:unless>
-
-    <xacro:body_link_with_sc
-    name="body_link0"
-    no_prefix="${no_prefix}"
-    kinematics_link="${kinematics_link}" />
-    </xacro:macro>
-
-</robot>

src/lerobot/robots/openarms/urdf/urdf/body/openarm_body_macro.xacro

@@ -1,55 +0,0 @@
-<?xml version="1.0"?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro">
-
-  <xacro:macro name="openarm-body-inertials" params="name inertials:=^">
-      <xacro:unless value="${name in inertials}">${xacro.warning('No inertia properties defined for: ' + name)}</xacro:unless>
-      <xacro:if value="${name in inertials}">
-        <!-- Access inertia properties of link 'name' -->
-        <xacro:property name="link_inertials" value="${inertials[name]}" lazy_eval="false" />
-        <inertial>
-          <origin rpy="${link_inertials.origin.rpy}" xyz="${link_inertials.origin.xyz}" />
-          <mass value="${link_inertials.mass}" />
-          <xacro:if value="${'inertia' in link_inertials}">
-            <xacro:property name="I" value="${link_inertials.inertia}" />
-            <inertia ixx="${I.xx}" ixy="${I.xy}" ixz="${I.xz}" iyy="${I.yy}" iyz="${I.yz}" izz="${I.zz}" />
-          </xacro:if>
-        </inertial>
-      </xacro:if>
-  </xacro:macro>
-
-
-  <xacro:macro name="body_link_with_sc" params="name no_prefix:='false' rpy:='0 0 0' kinematics_link">
-    <!-- <xacro:property name="prefix" value="${'' if no_prefix else body_prefix + body_type + '_'}" /> -->
-    <xacro:property name="prefix" value="${'' if no_prefix else 'openarm' + '_' + body_prefix}" /> 
-    <link name="${prefix}${name}">
-      <visual name="${prefix}${name}_visual">
-        <xacro:openarm-body-kinematics config="${kinematics_link}" name="${name}" />
-        <geometry>
-          <mesh filename="package://${description_pkg}/meshes/body/${body_type}/visual/${name}.dae" scale="0.001 0.001 0.001" />
-        </geometry>
-      </visual>
-      <collision name="${prefix}${name}_collision">
-        <xacro:openarm-body-kinematics config="${kinematics_link}" name="${name}" />
-        <geometry>
-          <mesh filename="package://openarm_description/meshes/body/${body_type}/collision/${name}_symp.stl" scale="0.001 0.001 0.001" />
-          <!-- <mesh filename="package://openarm_description/meshes/arm/${arm_type}/collision/${name}.stl" scale="0.001 0.001 0.001" /> -->
-        </geometry>
-      </collision>
-      <xacro:openarm-body-inertials name="${name}" />
-    </link>
-  </xacro:macro>
-
-  <xacro:macro name="openarm-body-kinematics" params="config name">
-    <xacro:property name="kinematics" value="${config[name]['kinematic']}" lazy_eval="false" />
-    <origin rpy="${kinematics.roll} ${kinematics.pitch} ${kinematics.yaw}"
-          xyz="${kinematics.x} ${kinematics.y} ${kinematics.z}" />
-</xacro:macro>
-
-<xacro:macro name="openarm-body-kinematics-link" params="config name">
-  <xacro:property name="kinematics_link" value="${config[name]['kinematic']}" lazy_eval="false" />
-  <origin rpy="${kinematics_link.roll} ${kinematics_link.pitch} ${kinematics_link.yaw}"
-          xyz="${kinematics_link.x} ${kinematics_link.y} ${kinematics_link.z}" />
-</xacro:macro>
-
-
-</robot>

src/lerobot/robots/openarms/urdf/urdf/ee/ee_with_one_link.xacro

@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro" name="ee_with_one_link">
-  <!-- safety_distance: Minimum safety distance in [m] by which the collision volumes are expanded and which is enforced during robot motions -->
-  <xacro:macro name="ee_with_one_link" params="connected_to:='' arm_type arm_prefix:='' ee_type ee_inertials rpy_ee:='0 0 0' xyz_ee:='0 0 0' tcp_xyz:='0 0 0' tcp_rpy:='0 0 0' description_pkg:=openarm_description with_sc:=false">
-    <xacro:property name="ee_prefix" default="robot_"/>
-    <xacro:unless value="${arm_type == ''}">
-      <xacro:property name="ee_prefix" value="openarm_${arm_prefix}" />
-    </xacro:unless>
-    <xacro:unless value="${connected_to == ''}">
-      <joint name="${ee_prefix}${ee_type}_joint" type="fixed">
-        <parent link="${connected_to}" />
-        <child link="${ee_prefix}${ee_type}" />
-        <origin xyz="${xyz_ee}" rpy="${rpy_ee}" />
-      </joint>
-    </xacro:unless>
-
-    <xacro:ee_link_with_sc name="${ee_type}"/>
-
-    <!-- Define the ${ee_type}_tcp frame -->
-    <link name="${ee_prefix}${ee_type}_tcp" />
-
-    <joint name="${ee_prefix}${ee_type}_tcp_joint" type="fixed">
-      <origin xyz="${tcp_xyz}" rpy="${tcp_rpy}" />
-      <parent link="${ee_prefix}${ee_type}" />
-      <child link="${ee_prefix}${ee_type}_tcp" />
-    </joint>
-
-  </xacro:macro>
-</robot>

src/lerobot/robots/openarms/urdf/urdf/ee/openarm_hand.xacro

@@ -1,85 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro" name="hand">
-  <!-- safety_distance: Minimum safety distance in [m] by which the collision volumes are expanded and which is enforced during robot motions -->
-  <xacro:macro name="openarm_hand" params="connected_to:='' arm_type arm_prefix:='' ee_type ee_inertials ee_kinematics_link rpy_ee:='0 0 0' xyz_ee:='0 0 0' tcp_xyz:='0 0 0' tcp_rpy:='0 0 0' description_pkg:=openarm_description">
-
-    <xacro:property name="ee_prefix" default=""/>
-
-    <xacro:unless value="${arm_type == ''}">
-      <!-- <xacro:property name="ee_prefix" value="${arm_prefix}${arm_type}_" /> -->
-      <xacro:property name="ee_prefix" value="openarm_${arm_prefix}" />
-    </xacro:unless>
-
-
-    <xacro:ee_link_with_sc name="hand" prefix="${ee_prefix}" ee_kinematics_link="${ee_kinematics_link}"/>
-    <!-- <link name="${ee_prefix}hand"/> -->
-
-    <xacro:unless value="${connected_to == ''}">
-      <!-- <joint name="${ee_prefix}hand_joint" type="fixed"> -->
-      <joint name="${arm_prefix}openarm_hand_joint" type="fixed">
-        <parent link="${connected_to}" />
-        <child link="${ee_prefix}hand" />
-        <origin xyz="${xyz_ee}" rpy="${rpy_ee}" />
-      </joint>
-    </xacro:unless>
-
-    <!-- Define the hand_tcp frame -->
-    <link name="${ee_prefix}hand_tcp" />
-
-    <joint name="${ee_prefix}hand_tcp_joint" type="fixed">
-      <origin xyz="${tcp_xyz}" rpy="${tcp_rpy}" />
-      <parent link="${ee_prefix}hand" />
-      <child link="${ee_prefix}hand_tcp" />
-    </joint>
-
-    <link name="${ee_prefix}left_finger">
-      <visual name="${ee_prefix}left_finger_visual">
-        <xacro:openarm-ee-kinematics-link config="${ee_kinematics_link}" name="left_finger" />
-        <geometry>
-          <mesh filename="package://${description_pkg}/meshes/ee/${ee_type}/visual/finger.dae" scale="0.001 0.001 0.001"/>
-        </geometry>
-      </visual>
-      <collision name="${ee_prefix}left_finger_collision">
-        <xacro:openarm-ee-kinematics-link config="${ee_kinematics_link}" name="left_finger" />
-        <geometry>
-          <mesh filename="package://${description_pkg}/meshes/ee/${ee_type}/collision/finger.stl" scale="0.001 0.001 0.001" />
-        </geometry>
-      </collision>
-      <xacro:ee-inertials name="left_finger"/>
-    </link>
-
-    <link name="${ee_prefix}right_finger">
-      <visual name="${ee_prefix}right_finger_visual">
-        <xacro:openarm-ee-kinematics-link config="${ee_kinematics_link}" name="right_finger" />
-        <geometry>
-          <mesh filename="package://${description_pkg}/meshes/ee/${ee_type}/visual/finger.dae" scale="0.001 -0.001 0.001"/>
-        </geometry>
-      </visual>
-      <collision name="${ee_prefix}right_finger_collision">
-        <xacro:openarm-ee-kinematics-link config="${ee_kinematics_link}" name="right_finger" />
-        <geometry>
-          <mesh filename="package://${description_pkg}/meshes/ee/${ee_type}/collision/finger.stl" scale="0.001 -0.001 0.001" />
-        </geometry>
-      </collision>
-      <xacro:ee-inertials name="right_finger"/>
-    </link>
-
-    <joint name="${ee_prefix}finger_joint1" type="prismatic">
-      <parent link="${ee_prefix}hand" />
-      <child link="${ee_prefix}right_finger" />
-      <origin xyz="0 -0.006 0.015" rpy="0 0 0" />
-      <axis xyz="0 -1 0" />
-      <limit effort="333" lower="0.0" upper="0.044" velocity="10.0" />
-    </joint>
-
-    <joint name="${ee_prefix}finger_joint2" type="prismatic">
-      <parent link="${ee_prefix}hand" />
-      <child link="${ee_prefix}left_finger" />
-      <origin xyz="0 0.006 0.015" rpy="0 0 0" />
-      <axis xyz="0 1 0" />
-      <limit effort="333" lower="0.0" upper="0.044" velocity="10.0" />
-      <mimic joint="${ee_prefix}finger_joint1" />
-    </joint>
-
-  </xacro:macro>
-</robot>

src/lerobot/robots/openarms/urdf/urdf/ee/openarm_hand_arguments.xacro

@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro">
-
-  <!-- Where is the end-effector connected to, if different from the robot flange?  -->
-  <xacro:arg name="special_connection" default="" />
-
-  <!-- Position offset between ee and parent frame -->
-  <xacro:arg name="xyz_ee" default="0 -0.0 0.1001" />
-
-  <!-- Rotation offset between ee and parent frame -->
-  <xacro:arg name="rpy_ee" default= "0 0 0" />
-
-  <!-- Position offset between ee frame and tcp frame -->
-  <xacro:arg name="tcp_xyz" default="0 -0.0 0.08" />
-
-  <!-- Rotation offset between ee frame and tcp frame -->
-  <xacro:arg name="tcp_rpy" default="0 0 0" />
-
-  <!-- Is the robot being simulated in gazebo? -->
-  <!-- <xacro:arg name="gazebo" default="false" /> -->
-
-  <!-- Name of the description package -->
-  <xacro:arg name="description_pkg" default="openarm_description" />
-
-</robot>

src/lerobot/robots/openarms/urdf/urdf/ee/openarm_hand_macro.xacro

@@ -1,55 +0,0 @@
-<?xml version="1.0"?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro">
-
-
-  <xacro:macro name="ee-inertials" params="name ee_inertials:=^">
-    <xacro:unless value="${name in ee_inertials}">
-      ${xacro.warning('No inertia properties defined for: ' + name)}
-    </xacro:unless>
-    <xacro:if value="${name in ee_inertials}">
-      <xacro:property name="link_inertials" value="${ee_inertials[name]}" lazy_eval="false" />
-      <xacro:property name="xyz" value="${link_inertials.origin.x} ${link_inertials.origin.y} ${link_inertials.origin.z}" />
-      <xacro:property name="rpy" value="${link_inertials.origin.roll} ${link_inertials.origin.pitch} ${link_inertials.origin.yaw}" />
-      <inertial>
-        <origin xyz="${xyz}" rpy="${rpy}" />
-        <mass value="${link_inertials.mass}" />
-        <xacro:if value="${'inertia' in link_inertials}">
-          <xacro:property name="I" value="${link_inertials.inertia}" />
-          <inertia ixx="${I.xx}" ixy="${I.xy}" ixz="${I.xz}"
-                   iyy="${I.yy}" iyz="${I.yz}" izz="${I.zz}" />
-        </xacro:if>
-      </inertial>
-    </xacro:if>
-  </xacro:macro>
-  
-  <xacro:macro name="ee_link_with_sc" params="name prefix rpy:='0 0 0' ee_kinematics_link">
-    <link name="${prefix}${name}">
-      <visual name="${prefix}${name}_visual">
-        <xacro:openarm-ee-kinematics-link config="${ee_kinematics_link}" name="${name}" />
-        <geometry>
-          <mesh filename="package://${description_pkg}/meshes/ee/${ee_type}/visual/${name}.dae" scale="0.001 0.001 0.001" />
-        </geometry>
-      </visual>
-      <collision name="${prefix}${name}_collision">
-        <xacro:openarm-ee-kinematics-link config="${ee_kinematics_link}" name="${name}" />
-        <geometry>
-          <mesh filename="package://openarm_description/meshes/ee/${ee_type}/collision/${name}.stl" scale="0.001 0.001 0.001" />
-        </geometry>
-      </collision>
-      <xacro:ee-inertials name="${name}" />
-    </link>
-  </xacro:macro>
-
-  <xacro:macro name="openarm-ee-kinematics" params="config name">
-      <xacro:property name="kinematics" value="${config[name]['kinematic']}" lazy_eval="false" />
-      <origin rpy="${kinematics.roll} ${kinematics.pitch} ${kinematics.yaw}"
-            xyz="${kinematics.x} ${kinematics.y} ${kinematics.z}" />
-  </xacro:macro>
-
-  <xacro:macro name="openarm-ee-kinematics-link" params="config name">
-    <xacro:property name="kinematics_link" value="${config[name]['kinematic']}" lazy_eval="false" />
-    <origin rpy="${kinematics_link.roll} ${kinematics_link.pitch} ${kinematics_link.yaw}"
-            xyz="${kinematics_link.x} ${kinematics_link.y} ${kinematics_link.z}" />
-  </xacro:macro>
-
-</robot>

src/lerobot/robots/openarms/urdf/urdf/robot/openarm_robot.xacro

@@ -1,197 +0,0 @@
-<?xml version='1.0' encoding='utf-8'?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro">
-    <xacro:macro name="openarm_robot"
-    params="arm_type
-            joint_limits
-            kinematics
-            kinematics_link
-            kinematics_offset
-            inertials
-            body_type
-            body_inertials
-            body_kinematics
-            body_kinematics_link
-            ee_kinematics_link
-            parent:='world'
-            xyz:='0 0 0'
-            rpy:='0 0 0'
-            hand:='false'
-            ee_type:=''
-            ros2_control:=false
-            can_interface:=''
-            use_fake_hardware:=false
-            fake_sensor_commands:=false
-            no_prefix:='false'
-            arm_prefix:=''
-            body_prefix:=''
-            arm_connected_to='base'
-            body_connected_to='world'
-            bimanual:=false
-            right_arm_base_xyz='0 0 0'
-            left_arm_base_xyz='0 0 0'
-            right_arm_base_rpy='0 0 0'
-            left_arm_base_rpy='0 0 0'
-            left_can_interface:='can1'
-            right_can_interface:='can0'
-            left_arm_prefix:='left_'
-            right_arm_prefix:='right_'
-            can_fd:='true'
-            "
-            >
-
-    <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/arm/openarm_macro.xacro" />
-    <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/arm/openarm_arm.xacro" />
-    <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/body/openarm_body_macro.xacro" />
-    <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/body/openarm_body.xacro" />
-    <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/ee/openarm_hand.xacro" />
-    <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/ee/openarm_hand_macro.xacro" />
-    <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/ros2_control/openarm.ros2_control.xacro" />
-    <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/ros2_control/openarm.bimanual.ros2_control.xacro" />
-    <xacro:if value="${ee_type != 'none'}">
-        <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/ee/${ee_type}_arguments.xacro" />
-    </xacro:if>
-
-    <xacro:property name="arm_prefix_modified" value="${'' if arm_prefix == '' else arm_prefix + '_'}" />
-    <xacro:property name="body_prefix_modified" value="${'' if body_prefix == '' else body_prefix + '_'}" />
-
-    <xacro:if value="${bimanual}">
-
-        <xacro:openarm_body
-        body_type="${body_type}"
-        body_prefix="${body_prefix_modified}"
-        no_prefix="${no_prefix}"
-        description_pkg="openarm_description"
-        connected_to="${body_connected_to}"
-        xyz="${xyz}"
-        rpy="${rpy}"
-        inertials="${body_inertials}"
-        kinematics="${body_kinematics}"
-        kinematics_link="${body_kinematics_link}" />
-
-        <!-- left arm -->
-        <xacro:openarm_arm
-        arm_type="${arm_type}"
-        arm_prefix="left_"
-        no_prefix="false"
-        description_pkg="openarm_description"
-        connected_to="openarm_body_link0"
-        xyz="${left_arm_base_xyz}"
-        rpy="${left_arm_base_rpy}"
-        joint_limits="${joint_limits}"
-        inertials="${inertials}"
-        kinematics="${kinematics}"
-        kinematics_link="${kinematics_link}"
-        kinematics_offset="${kinematics_offset}" />
-
-        <!-- right arm -->
-        <xacro:openarm_arm
-        arm_type="${arm_type}"
-        arm_prefix="right_"
-        no_prefix="false"
-        description_pkg="openarm_description"
-        connected_to="openarm_body_link0"
-        xyz="${right_arm_base_xyz}"
-        rpy="${right_arm_base_rpy}"
-        joint_limits="${joint_limits}"
-        inertials="${inertials}"
-        kinematics="${kinematics}"
-        kinematics_link="${kinematics_link}"
-        kinematics_offset="${kinematics_offset}" />
-
-        <!-- ros2_control hardware interfaces for bimanual setup -->
-        <xacro:if value="${ros2_control}">
-            <xacro:openarm_bimanual_ros2_control
-            arm_type="${arm_type}"
-            left_can_interface="${left_can_interface}"
-            right_can_interface="${right_can_interface}"
-            use_fake_hardware="${use_fake_hardware}"
-            fake_sensor_commands="${fake_sensor_commands}"
-            left_arm_prefix="${left_arm_prefix}"
-            right_arm_prefix="${right_arm_prefix}"
-            hand="${hand}"/>
-        </xacro:if>
-
-        <xacro:if value="$(eval hand and ee_type == 'openarm_hand')">
-            <xacro:openarm_hand
-                connected_to="openarm_left_link7"
-                arm_type="${arm_type}"
-                arm_prefix="left_"
-                ee_type="${ee_type}"
-                ee_kinematics_link="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/hand/openarm_hand/kinematics_link.yaml')}"
-                ee_inertials="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/hand/openarm_hand/inertials.yaml')}"
-                rpy_ee="$(arg rpy_ee)"
-                xyz_ee="$(arg xyz_ee)"
-                tcp_xyz="$(arg tcp_xyz)"
-                tcp_rpy="$(arg tcp_rpy)"
-                description_pkg="$(arg description_pkg)"
-            />
-            <xacro:openarm_hand
-                connected_to="openarm_right_link7"
-                arm_type="${arm_type}"
-                arm_prefix="right_"
-                ee_type="${ee_type}"
-                ee_kinematics_link="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/hand/openarm_hand/kinematics_link.yaml')}"
-                ee_inertials="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/hand/openarm_hand/inertials.yaml')}"
-                rpy_ee="$(arg rpy_ee)"
-                xyz_ee="$(arg xyz_ee)"
-                tcp_xyz="$(arg tcp_xyz)"
-                tcp_rpy="$(arg tcp_rpy)"
-                description_pkg="$(arg description_pkg)"
-            />
-          </xacro:if>
-    </xacro:if>
-
-    <xacro:if value="${not bimanual}">
-
-        <xacro:openarm_arm
-        arm_type="${arm_type}"
-        arm_prefix="${arm_prefix_modified}"
-        no_prefix="${no_prefix}"
-        xyz="${xyz}"
-        rpy="${rpy}"
-        joint_limits="${joint_limits}"
-        kinematics="${kinematics}"
-        kinematics_link="${kinematics_link}"
-        inertials="${inertials}"
-        connected_to=""
-        />
-
-        <xacro:if value="${ros2_control}">
-
-        <xacro:openarm_arm_ros2_control
-            arm_type="${arm_type}"
-            arm_prefix="${arm_prefix_modified}"
-            can_interface="${can_interface}"
-            use_fake_hardware="${use_fake_hardware}"
-            fake_sensor_commands="${fake_sensor_commands}"
-            hand="${hand}"
-            bimanual="false"
-            can_fd="${can_fd}"/>
-        </xacro:if>
-
-        <xacro:if value="${hand and ee_type == 'openarm_hand'}">
-
-        <xacro:property name="special_connection" value="$(arg special_connection)" />
-        <!-- <xacro:property name="connection" value="${special_connection if special_connection != '' else arm_type + '_link7'}" /> -->
-        <xacro:property name="connection" value="${special_connection if special_connection != '' else 'openarm' + '_link7'}" />
-
-        <xacro:if value="$(eval hand and ee_type == 'openarm_hand')">
-        <xacro:openarm_hand
-            connected_to="${arm_prefix_modified}${connection}"
-            arm_type="${arm_type}"
-            arm_prefix="${arm_prefix_modified}"
-            ee_type="${ee_type}"
-            ee_kinematics_link="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/hand/openarm_hand/kinematics_link.yaml')}"
-            ee_inertials="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/hand/openarm_hand/inertials.yaml')}"
-            rpy_ee="$(arg rpy_ee)"
-            xyz_ee="$(arg xyz_ee)"
-            tcp_xyz="$(arg tcp_xyz)"
-            tcp_rpy="$(arg tcp_rpy)"
-            description_pkg="$(arg description_pkg)"/>
-        </xacro:if>
-        </xacro:if>
-
-        </xacro:if>
-
-  </xacro:macro>
-</robot>

src/lerobot/robots/openarms/urdf/urdf/robot/v10.urdf.xacro

@@ -1,87 +0,0 @@
-<?xml version='1.0' encoding='utf-8'?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro" name="openarm">
-
-  <xacro:include filename="/Users/michel_aractingi/code/openarm_description/urdf/robot/openarm_robot.xacro"/>
-
-  <xacro:arg name="arm_type" default="v10" />
-
-  <xacro:arg name="body_type" default="v10" />
-
-  <xacro:arg name="ee_type" default="openarm_hand" />
-
-  <xacro:arg name="no_prefix" default="false"/>
-
-  <xacro:arg name="hand" default="true" />
-
-  <xacro:if value="$(eval ee_type == 'none')">
-    <xacro:property name="hand" value="false"/>
-  </xacro:if>
-
-  <xacro:arg name="parent" default="world" />
-
-  <xacro:arg name="xyz" default="0 0 0" />
-
-  <xacro:arg name="rpy" default="0 0 0" />
-
-  <xacro:arg name="ros2_control" default="false" />
-
-  <xacro:arg name="can_interface" default="can0" />
-
-  <xacro:arg name="left_can_interface" default="can1" />
-
-  <xacro:arg name="right_can_interface" default="can0" />
-
-  <xacro:arg name="left_arm_prefix" default="left_" />
-
-  <xacro:arg name="right_arm_prefix" default="right_" />
-
-  <xacro:arg name="use_fake_hardware" default="false" />
-
-  <xacro:arg name="fake_sensor_commands" default="false" />
-
-  <xacro:arg name="bimanual" default="true" />
-
-  <xacro:arg name="right_arm_base_xyz" default="0.0 -0.031 0.698" />
-  <xacro:arg name="right_arm_base_rpy" default="1.5708 0 0" />
-
-  <xacro:arg name="left_arm_base_xyz" default="0.0 0.031 0.698" />
-  <xacro:arg name="left_arm_base_rpy" default="-1.5708 0 0" />
-
-  <xacro:arg name="can_fd" default="true" />
-
-  <xacro:openarm_robot
-  arm_type="v10"
-  body_type="v10"
-  joint_limits="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config//arm/v10/joint_limits.yaml')}"
-  inertials="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/arm/v10/inertials.yaml')}"
-  kinematics="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/arm/v10/kinematics.yaml')}"
-  kinematics_link="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/arm/v10/kinematics_link.yaml')}"
-  kinematics_offset="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/arm/v10/kinematics_offset.yaml')}"
-  body_inertials="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/body/v10/inertials.yaml')}"
-  body_kinematics="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/body/v10/kinematics.yaml')}"
-  body_kinematics_link="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/body/v10/kinematics.yaml')}"
-  ee_kinematics_link="${xacro.load_yaml('/Users/michel_aractingi/code/openarm_description/config/hand/openarm_hand/kinematics_link.yaml')}"
-  hand="$(arg hand)"
-  ee_type="$(arg ee_type)"
-  ros2_control="$(arg ros2_control)"
-  can_interface="$(arg can_interface)"
-  left_can_interface="$(arg left_can_interface)"
-  right_can_interface="$(arg right_can_interface)"
-  left_arm_prefix="$(arg left_arm_prefix)"
-  right_arm_prefix="$(arg right_arm_prefix)"
-  use_fake_hardware="$(arg use_fake_hardware)"
-  fake_sensor_commands="$(arg fake_sensor_commands)"
-  no_prefix="$(arg no_prefix)"
-  arm_prefix=""
-  body_prefix=""
-  arm_connected_to="base"
-  body_connected_to="world"
-  bimanual="$(arg bimanual)"
-  right_arm_base_xyz="$(arg right_arm_base_xyz)"
-  left_arm_base_xyz="$(arg left_arm_base_xyz)"
-  right_arm_base_rpy="$(arg right_arm_base_rpy)"
-  left_arm_base_rpy="$(arg left_arm_base_rpy)"
-  can_fd="$(arg can_fd)"
-  />
-
-</robot>

src/lerobot/robots/openarms/urdf/urdf/ros2_control/openarm.bimanual.ros2_control.xacro

@@ -1,99 +0,0 @@
-<?xml version="1.0"?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro">
-
-<xacro:macro name="openarm_bimanual_ros2_control"
-         params="arm_type
-             left_can_interface:=^|can1
-             right_can_interface:=^|can0
-             use_fake_hardware:=^|false
-             fake_sensor_commands:=^|false
-             hand:=^|false
-             left_arm_prefix:=^|left_
-             right_arm_prefix:=^|right_
-             can_fd:=^|true">
-
-    <!-- Left Arm Hardware Interface -->
-    <ros2_control name="openarm_left_hardware_interface" type="system">
-        <hardware>
-          <param name="arm_type">${arm_type}</param>
-          <xacro:if value="${use_fake_hardware}">
-            <plugin>fake_components/GenericSystem</plugin>
-            <param name="fake_sensor_commands">${fake_sensor_commands}</param>
-            <param name="state_following_offset">0.0</param>
-          </xacro:if>
-          <xacro:unless value="${use_fake_hardware}">
-            <plugin>openarm_hardware/OpenArm_v10HW</plugin>
-            <param name="can_interface">${left_can_interface}</param>
-            <param name="arm_prefix">${left_arm_prefix}</param>
-            <param name="hand">${hand}</param>
-            <param name="can_fd">${can_fd}</param>
-          </xacro:unless>
-        </hardware>
-
-      <xacro:macro name="configure_joint" params="joint_name initial_position">
-        <joint name="${joint_name}">
-          <command_interface name="position"/>
-          <command_interface name="velocity"/>
-          <command_interface name="effort"/>
-
-          <state_interface name="position">
-            <param name="initial_value">${initial_position}</param>
-          </state_interface>
-
-          <state_interface name="velocity">
-            <param name="initial_value">0.0</param>
-          </state_interface>
-
-          <state_interface name="effort">
-            <param name="initial_value">0.0</param>
-          </state_interface>
-        </joint>
-      </xacro:macro>
-
-      <xacro:configure_joint joint_name="openarm_${left_arm_prefix}joint1" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${left_arm_prefix}joint2" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${left_arm_prefix}joint3" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${left_arm_prefix}joint4" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${left_arm_prefix}joint5" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${left_arm_prefix}joint6" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${left_arm_prefix}joint7" initial_position="0.0"/>
-
-      <xacro:if value="${hand}">
-        <xacro:configure_joint joint_name="openarm_${left_arm_prefix}finger_joint1" initial_position="0.0" />
-      </xacro:if>
-    </ros2_control>
-
-    <!-- Right Arm Hardware Interface -->
-    <ros2_control name="openarm_right_hardware_interface" type="system">
-        <hardware>
-          <param name="arm_type">${arm_type}</param>
-          <xacro:if value="${use_fake_hardware}">
-            <plugin>fake_components/GenericSystem</plugin>
-            <param name="fake_sensor_commands">${fake_sensor_commands}</param>
-            <param name="state_following_offset">0.0</param>
-          </xacro:if>
-          <xacro:unless value="${use_fake_hardware}">
-            <plugin>openarm_hardware/OpenArm_v10HW</plugin>
-            <param name="can_interface">${right_can_interface}</param>
-            <param name="arm_prefix">${right_arm_prefix}</param>
-            <param name="hand">${hand}</param>
-            <param name="can_fd">${can_fd}</param>
-          </xacro:unless>
-        </hardware>
-
-      <xacro:configure_joint joint_name="openarm_${right_arm_prefix}joint1" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${right_arm_prefix}joint2" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${right_arm_prefix}joint3" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${right_arm_prefix}joint4" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${right_arm_prefix}joint5" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${right_arm_prefix}joint6" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${right_arm_prefix}joint7" initial_position="0.0"/>
-
-      <xacro:if value="${hand}">
-        <xacro:configure_joint joint_name="openarm_${right_arm_prefix}finger_joint1" initial_position="0.0" />
-      </xacro:if>
-    </ros2_control>
-
-  </xacro:macro>
-
-</robot>

src/lerobot/robots/openarms/urdf/urdf/ros2_control/openarm.ros2_control.xacro

@@ -1,77 +0,0 @@
-<?xml version="1.0"?>
-<robot xmlns:xacro="http://www.ros.org/wiki/xacro">
-
-<xacro:macro name="openarm_arm_ros2_control"
-         params="arm_type
-             can_interface
-             use_fake_hardware:=^|false
-             fake_sensor_commands:=^|false
-             hand:=^|false
-             gazebo_effort:=^|false
-             arm_prefix:=''
-             bimanual:=false
-             can_fd:=^|true">
-
-    <ros2_control name="openarm_hardware_interface" type="system">
-        <hardware>
-          <param name="arm_type">${arm_type}</param>
-          <param name="prefix">${arm_prefix}</param>
-          <xacro:if value="${use_fake_hardware}">
-            <plugin>fake_components/GenericSystem</plugin>
-            <param name="fake_sensor_commands">${fake_sensor_commands}</param>
-            <param name="state_following_offset">0.0</param>
-          </xacro:if>
-          <xacro:if value="${use_fake_hardware == 0}">
-            <plugin>openarm_hardware/OpenArm_${arm_type}HW</plugin>
-            <param name="can_interface">${can_interface}</param>
-            <param name="arm_prefix">${arm_prefix}</param>
-            <param name="hand">${hand}</param>
-            <param name="can_fd">${can_fd}</param>
-          </xacro:if>
-        </hardware>
-
-      <xacro:macro name="configure_joint" params="joint_name initial_position">
-        <joint name="${joint_name}">
-          <!--
-            deactivated for gazebo velocity and position interface due to a bug
-            https://github.com/ros-controls/gz_ros2_control/issues/343
-
-            Command Interfaces -->
-            <command_interface name="position"/>
-            <command_interface name="velocity"/>
-            <command_interface name="effort"/>
-
-          <!-- State Interfaces -->
-          <state_interface name="position">
-            <param name="initial_value">${initial_position}</param>
-          </state_interface>
-
-          <state_interface name="velocity">
-            <param name="initial_value">0.0</param>
-          </state_interface>
-
-          <state_interface name="effort">
-            <param name="initial_value">0.0</param>
-          </state_interface>
-
-        </joint>
-      </xacro:macro>
-
-      <xacro:configure_joint joint_name="openarm_${arm_prefix}joint1" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${arm_prefix}joint2" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${arm_prefix}joint3" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${arm_prefix}joint4" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${arm_prefix}joint5" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${arm_prefix}joint6" initial_position="0.0"/>
-      <xacro:configure_joint joint_name="openarm_${arm_prefix}joint7" initial_position="0.0"/>
-
-      <xacro:if value="${hand}">
-        <xacro:configure_joint joint_name="openarm_${arm_prefix}finger_joint1" initial_position="0.0" />
-      </xacro:if>
-
-    </ros2_control>
-
-  </xacro:macro>
-
-
-</robot>

src/lerobot/scripts/lerobot_train.py

@@ -49,8 +49,7 @@ from lerobot.utils.train_utils import (
 )
 from lerobot.utils.relative_actions import (
     convert_to_relative_actions,
-    compute_relative_action_stats,
-    PerTimestepNormalizer,
+    compute_global_relative_stats,
 )
 from lerobot.utils.utils import (
     format_big_number,
@@ -304,40 +303,60 @@ def train(cfg: TrainPipelineConfig, accelerator: Accelerator | None = None):
             device=device,
         )
 
-    # Compute per-timestep normalizer for relative actions
-    relative_normalizer = None
+    # Compute relative action/state stats and hotswap them into the normalizer
+    raw_state_key = None
     if cfg.use_relative_actions:
+        from lerobot.processor.normalize_processor import hotswap_stats
+
         mode = "actions + state" if cfg.use_relative_state else "actions only"
         cfg.output_dir.mkdir(parents=True, exist_ok=True)
         stats_path = cfg.output_dir / "relative_stats.pt"
-        
+
+        reverse_rename = {v: k for k, v in cfg.rename_map.items()} if cfg.rename_map else {}
+        raw_state_key = reverse_rename.get("observation.state", "observation.state")
+
         if is_main_process:
             logging.info(colored(f"Relative mode: {mode}", "cyan", attrs=["bold"]))
-            
+
             if stats_path.exists():
-                logging.info(f"Loading pre-computed stats from: {stats_path}")
+                logging.info(f"Loading pre-computed relative stats from: {stats_path}")
             else:
-                logging.info("Computing per-timestep stats (first 1000 batches)...")
-                logging.info("Using fresh dataset to avoid video decoder state issues...")
-                # Create separate dataset instance to avoid corrupting main dataset's video decoders
+                logging.info("Computing global relative stats (first 1000 batches)...")
                 stats_dataset = make_dataset(cfg)
                 temp_loader = torch.utils.data.DataLoader(
                     stats_dataset, batch_size=cfg.batch_size, shuffle=False, num_workers=0
                 )
-                mean, std = compute_relative_action_stats(temp_loader, num_batches=1000)
+                rel_stats = compute_global_relative_stats(
+                    temp_loader, state_key=raw_state_key,
+                    convert_state=cfg.use_relative_state, num_batches=1000,
+                )
                 del temp_loader, stats_dataset
                 gc.collect()
-                torch.save({"mean": mean, "std": std}, stats_path)
-                logging.info(f"Saved stats to: {stats_path}")
-        
-        # Poll for stats file instead of using NCCL barrier (avoids timeout during long computation)
+                torch.save(rel_stats, stats_path)
+                logging.info(f"Saved relative stats to: {stats_path}")
+
         if not is_main_process:
             while not stats_path.exists():
                 time.sleep(5)
-        
-        data = torch.load(stats_path, weights_only=True, map_location="cpu")
-        relative_normalizer = PerTimestepNormalizer(data["mean"], data["std"])
-        accelerator.wait_for_everyone()  # Sync after everyone has loaded
+
+        rel_stats = torch.load(stats_path, weights_only=True, map_location="cpu")
+
+        # Replace absolute stats with relative stats in the normalizer
+        updated_stats = dict(dataset.meta.stats)
+        updated_stats["action"] = {
+            **updated_stats["action"],
+            "mean": rel_stats["action_mean"].numpy(),
+            "std": rel_stats["action_std"].numpy(),
+        }
+        if cfg.use_relative_state and "state_mean" in rel_stats:
+            updated_stats[raw_state_key] = {
+                **updated_stats.get(raw_state_key, {}),
+                "mean": rel_stats["state_mean"].numpy(),
+                "std": rel_stats["state_std"].numpy(),
+            }
+        preprocessor = hotswap_stats(preprocessor, updated_stats)
+        logging.info("Hotswapped normalizer stats with relative stats")
+        accelerator.wait_for_everyone()
 
     step = 0  # number of policy updates (forward + backward + optim)
 
@@ -425,13 +444,14 @@ def train(cfg: TrainPipelineConfig, accelerator: Accelerator | None = None):
     for _ in range(step, cfg.steps):
         start_time = time.perf_counter()
         batch = next(dl_iter)
-        batch = preprocessor(batch)
-        
-        # Convert to relative actions (and optionally state) if enabled
+
+        # Convert to relative on raw data BEFORE normalization
         if cfg.use_relative_actions:
-            batch = convert_to_relative_actions(batch, convert_state=cfg.use_relative_state)
-            if relative_normalizer is not None:
-                batch["action"] = relative_normalizer.normalize(batch["action"])
+            batch = convert_to_relative_actions(
+                batch, state_key=raw_state_key, convert_state=cfg.use_relative_state,
+            )
+
+        batch = preprocessor(batch)
         
         train_tracker.dataloading_s = time.perf_counter() - start_time
 
@@ -487,9 +507,6 @@ def train(cfg: TrainPipelineConfig, accelerator: Accelerator | None = None):
                     preprocessor=preprocessor,
                     postprocessor=postprocessor,
                 )
-                # Save relative action stats with checkpoint
-                if relative_normalizer is not None:
-                    relative_normalizer.save(checkpoint_dir / "relative_stats.pt")
                 update_last_checkpoint(checkpoint_dir)
                 if wandb_logger:
                     wandb_logger.log_policy(checkpoint_dir)

src/lerobot/utils/relative_actions.py

@@ -74,11 +74,53 @@ def compute_relative_action_stats(
         rel = action.clone()
         rel[..., :min_dim] -= current_pos[:, None, :min_dim]
         all_rel.append(rel)
-    
+
     all_rel = torch.cat(all_rel, dim=0)
     return all_rel.mean(dim=0), all_rel.std(dim=0).clamp(min=1e-6)
 
 
+def compute_global_relative_stats(
+    dataloader,
+    state_key: str = "observation.state",
+    convert_state: bool = True,
+    num_batches: int | None = None,
+) -> dict[str, torch.Tensor]:
+    """Compute global mean/std for relative actions (and state) across all timesteps.
+
+    Returns stats compatible with the standard MEAN_STD normalizer (shape = action_dim).
+    """
+    all_rel_actions = []
+    all_rel_states = []
+    for i, batch in enumerate(dataloader):
+        if num_batches is not None and i >= num_batches:
+            break
+        action, state = batch["action"], batch[state_key]
+        current_pos = state[:, -1, :] if state.dim() == 3 else state
+
+        min_dim = min(action.shape[-1], current_pos.shape[-1])
+        rel = action.clone()
+        rel[..., :min_dim] -= current_pos[:, None, :min_dim]
+        all_rel_actions.append(rel.reshape(-1, rel.shape[-1]))
+
+        if convert_state:
+            if state.dim() == 3:
+                rel_state = state - current_pos[:, None, :]
+            else:
+                rel_state = torch.zeros_like(state)
+            all_rel_states.append(rel_state.reshape(-1, rel_state.shape[-1]))
+
+    all_rel_actions = torch.cat(all_rel_actions, dim=0)
+    result = {
+        "action_mean": all_rel_actions.mean(dim=0),
+        "action_std": all_rel_actions.std(dim=0).clamp(min=1e-6),
+    }
+    if convert_state and all_rel_states:
+        all_rel_states = torch.cat(all_rel_states, dim=0)
+        result["state_mean"] = all_rel_states.mean(dim=0)
+        result["state_std"] = all_rel_states.std(dim=0).clamp(min=1e-6)
+    return result
+
+
 def convert_to_relative(
     batch: dict,
     state_key: str = "observation.state",

tests/test_cli.py

@@ -1,229 +0,0 @@
-import importlib
-import os
-from unittest.mock import MagicMock, patch
-
-import pytest
-from safetensors.torch import load_file
-
-from .utils import require_package
-
-
-def run_command(cmd, module, args):
-    module = importlib.import_module(f"lerobot.scripts.{module}")
-    with patch("sys.argv", [cmd] + args):
-        module.main()
-
-
-def lerobot_train(args):
-    return run_command(cmd="lerobot-train", module="lerobot_train", args=args)
-
-
-def lerobot_record(args):
-    return run_command(cmd="lerobot-record", module="lerobot_record", args=args)
-
-
-def resolve_model_id_for_peft_training(policy_type):
-    """PEFT training needs pretrained models, this finds the pretrained model of a policy type for PEFT training."""
-    if policy_type == "smolvla":
-        return "lerobot/smolvla_base"
-
-    raise ValueError(f"No pretrained model known for {policy_type}. PEFT training will not work.")
-
-
-@pytest.mark.parametrize("policy_type", ["smolvla"])
-@require_package("peft")
-def test_peft_training_push_to_hub_works(policy_type, tmp_path):
-    """Ensure that push to hub stores PEFT only the adapter, not the full model weights."""
-    output_dir = tmp_path / f"output_{policy_type}"
-    upload_folder_contents = set()
-
-    model_id = resolve_model_id_for_peft_training(policy_type)
-
-    def mock_upload_folder(*args, **kwargs):
-        folder_path = kwargs["folder_path"]
-        # we include more than is actually uploaded since we ignore {allow,ignore}_patterns of upload_folders()
-        upload_folder_contents.update(os.listdir(folder_path))
-        return MagicMock()
-
-    with (
-        patch("huggingface_hub.HfApi.create_repo"),
-        patch("huggingface_hub.HfApi.upload_folder", mock_upload_folder),
-    ):
-        lerobot_train(
-            [
-                f"--policy.path={model_id}",
-                "--policy.push_to_hub=true",
-                "--policy.repo_id=foo/bar",
-                "--policy.input_features=null",
-                "--policy.output_features=null",
-                "--peft.method=LORA",
-                "--dataset.repo_id=lerobot/pusht",
-                "--dataset.episodes=[0, 1]",
-                "--steps=1",
-                f"--output_dir={output_dir}",
-            ]
-        )
-
-        assert "adapter_model.safetensors" in upload_folder_contents
-        assert "config.json" in upload_folder_contents
-        assert "adapter_config.json" in upload_folder_contents
-
-
-@pytest.mark.parametrize("policy_type", ["smolvla"])
-@require_package("peft")
-def test_peft_training_works(policy_type, tmp_path):
-    """Check whether the standard case of fine-tuning a (partially) pre-trained policy with PEFT works."""
-    output_dir = tmp_path / f"output_{policy_type}"
-    model_id = resolve_model_id_for_peft_training(policy_type)
-
-    lerobot_train(
-        [
-            f"--policy.path={model_id}",
-            "--policy.push_to_hub=false",
-            "--policy.input_features=null",
-            "--policy.output_features=null",
-            "--peft.method=LORA",
-            "--dataset.repo_id=lerobot/pusht",
-            "--dataset.episodes=[0, 1]",
-            "--steps=1",
-            f"--output_dir={output_dir}",
-        ]
-    )
-
-    policy_dir = output_dir / "checkpoints" / "last" / "pretrained_model"
-
-    for file in ["adapter_config.json", "adapter_model.safetensors", "config.json"]:
-        assert (policy_dir / file).exists()
-
-    # This is the default case where we train a pre-trained policy from scratch with new data.
-    # We assume that we target policy-specific modules but fully fine-tune action and state projections
-    # so these must be part of the trained state dict.
-    state_dict = load_file(policy_dir / "adapter_model.safetensors")
-
-    adapted_keys = [
-        "state_proj",
-        "action_in_proj",
-        "action_out_proj",
-        "action_time_mlp_in",
-        "action_time_mlp_out",
-    ]
-
-    found_keys = [
-        module_key
-        for module_key in adapted_keys
-        for state_dict_key in state_dict
-        if f".{module_key}." in state_dict_key
-    ]
-
-    assert set(found_keys) == set(adapted_keys)
-
-
-@pytest.mark.parametrize("policy_type", ["smolvla"])
-@require_package("peft")
-def test_peft_training_params_are_fewer(policy_type, tmp_path):
-    """Check whether the standard case of fine-tuning a (partially) pre-trained policy with PEFT works."""
-    output_dir = tmp_path / f"output_{policy_type}"
-    model_id = resolve_model_id_for_peft_training(policy_type)
-
-    def dummy_update_policy(
-        train_metrics, policy, batch, optimizer, grad_clip_norm: float, accelerator, **kwargs
-    ):
-        params_total = sum(p.numel() for p in policy.parameters())
-        params_trainable = sum(p.numel() for p in policy.parameters() if p.requires_grad)
-
-        assert params_total > params_trainable
-
-        return train_metrics, {}
-
-    with patch("lerobot.scripts.lerobot_train.update_policy", dummy_update_policy):
-        lerobot_train(
-            [
-                f"--policy.path={model_id}",
-                "--policy.push_to_hub=false",
-                "--policy.input_features=null",
-                "--policy.output_features=null",
-                "--peft.method=LORA",
-                "--dataset.repo_id=lerobot/pusht",
-                "--dataset.episodes=[0, 1]",
-                "--steps=1",
-                f"--output_dir={output_dir}",
-            ]
-        )
-
-
-class DummyRobot:
-    name = "dummy"
-    cameras = []
-    action_features = {"foo": 1.0, "bar": 2.0}
-    observation_features = {"obs1": 1.0, "obs2": 2.0}
-    is_connected = True
-
-    def connect(self, *args):
-        pass
-
-    def disconnect(self):
-        pass
-
-
-def dummy_make_robot_from_config(*args, **kwargs):
-    return DummyRobot()
-
-
-@pytest.mark.parametrize("policy_type", ["smolvla"])
-@require_package("peft")
-def test_peft_record_loads_policy(policy_type, tmp_path):
-    """Train a policy with PEFT and attempt to load it with `lerobot-record`."""
-    from peft import PeftModel
-
-    output_dir = tmp_path / f"output_{policy_type}"
-    model_id = resolve_model_id_for_peft_training(policy_type)
-
-    lerobot_train(
-        [
-            f"--policy.path={model_id}",
-            "--policy.push_to_hub=false",
-            "--policy.input_features=null",
-            "--policy.output_features=null",
-            "--peft.method=LORA",
-            "--dataset.repo_id=lerobot/pusht",
-            "--dataset.episodes=[0, 1]",
-            "--steps=1",
-            f"--output_dir={output_dir}",
-        ]
-    )
-
-    policy_dir = output_dir / "checkpoints" / "last" / "pretrained_model"
-    dataset_dir = tmp_path / "eval_pusht"
-    single_task = "move the table"
-    loaded_policy = None
-
-    def dummy_record_loop(*args, **kwargs):
-        nonlocal loaded_policy
-
-        if "dataset" not in kwargs:
-            return
-
-        dataset = kwargs["dataset"]
-        dataset.add_frame({"task": single_task})
-        loaded_policy = kwargs["policy"]
-
-    with (
-        patch("lerobot.scripts.lerobot_record.make_robot_from_config", dummy_make_robot_from_config),
-        # disable record loop since we're only interested in successful loading of the policy.
-        patch("lerobot.scripts.lerobot_record.record_loop", dummy_record_loop),
-        # disable speech output
-        patch("lerobot.utils.utils.say"),
-    ):
-        lerobot_record(
-            [
-                f"--policy.path={policy_dir}",
-                "--robot.type=so101_follower",
-                "--robot.port=/dev/null",
-                "--dataset.repo_id=lerobot/eval_pusht",
-                f'--dataset.single_task="{single_task}"',
-                f"--dataset.root={dataset_dir}",
-                "--dataset.push_to_hub=false",
-            ]
-        )
-
-        assert isinstance(loaded_policy, PeftModel)