OpenArm Setup Guide: From Unboxing to First Teleoperation

Unboxing Checklist

Inspect every component against the packing list before discarding any packaging. A standard OpenArm kit includes: the follower arm (6-DOF robot arm with servo-driven joints and integrated gripper), the leader arm (passive kinematic replica used by the operator to teleoperate), two USB cameras (wrist-mounted and overhead), the control board and USB hub, a 24V power supply, all required M3 and M4 hardware, a torque screwdriver, and the USB-A to USB-C control cable. Kits that include the compute option also ship with a configured mini-PC with Ubuntu 22.04 and the SVRC software stack pre-installed.

Check the servo cables on both arms for any pinching or kinking that may have occurred during shipping. Gently flex each joint through its range of motion by hand (with power disconnected) to confirm no joints are binding. If any joint feels stiff or notchy rather than smooth and compliant, do not power on — contact SVRC support before proceeding, as a damaged servo should be replaced before first use to avoid striping the gear train.

Lay out the hardware in a clear workspace with at least 1m of clearance around the robot arm in all directions before assembly. OpenArm's maximum reach is 850mm, so plan your table layout accordingly. The leader arm can be placed adjacent to the follower or opposite the operator depending on your preferred working style; most operators find placing the leader arm directly to their dominant hand side the most natural arrangement.

Assembly Steps

If your OpenArm arrived partially disassembled for shipping (most kits ship with the upper arm detached for protection), begin by attaching the upper arm segment to the shoulder joint. Align the mounting holes and use the provided M4 screws with the torque screwdriver set to 0.8 Nm — do not over-torque the servo horn attachments. Thread each servo cable through the arm channel before fully seating the joint, as access is difficult once assembled. The assembly guide in the OpenArm documentation (available through the SVRC platform) includes photographs of each step and a cable routing diagram.

Mount the wrist camera using the printed bracket included in the kit. Route the USB cable through the forearm channel alongside the gripper servo cable. Secure with the provided cable clips every 100mm to prevent the cable from catching on objects during manipulation. The overhead camera mounts on a separate stand (included in full kits) positioned approximately 600mm above and 300mm behind the follower arm base, angled 30–45 degrees downward to capture the full workspace.

Connect the control board to the follower arm's servo chain via the JST connector on the first servo at the base. The control board powers all servos through a daisy-chained power bus; confirm the polarity of each connector before applying power. Connect the 24V power supply to the control board (the barrel jack, not the servo bus connector). Connect the control board to your compute via the included USB-C cable. Finally, connect both cameras to the USB hub, and the hub to compute via USB-A.

Calibration

Calibration establishes the zero position of each joint — the reference point from which all subsequent joint angle measurements are made. Power on the control board and confirm that all servo LEDs illuminate green (amber indicates a communication error; red indicates an overcurrent fault — resolve these before proceeding). Open the SVRC calibration tool, either via the SVRC platform web interface or the command-line tool included in the software stack.

The calibration procedure takes approximately 10 minutes. You will be prompted to move each joint to its defined home position — a fully extended, upright configuration — and confirm. The tool records the encoder offset at each joint and writes it to the servo EEPROM. After calibration, verify by commanding each joint to its documented range limits and observing whether the physical motion matches the commanded range. If any joint reaches a hard limit before the software limit, the calibration offset is incorrect and must be repeated.

Camera calibration is separate. The SVRC platform includes a ChArUco board-based camera calibration workflow that computes intrinsic parameters and the extrinsic transform between the wrist camera, overhead camera, and robot base frame. Print the calibration board at the specified scale (A3 paper, 100% scale), collect 30–50 images at varied orientations, and run the calibration script. Camera calibration is not strictly required to begin collecting demonstrations, but policies trained without calibrated extrinsics generalize less well across hardware copies. Complete it before starting production data collection.

Connecting to the SVRC Platform

The SVRC platform is the software layer for episode recording, dataset management, and policy training. Create or log into your SVRC account, navigate to the Hardware section, and add a new OpenArm device. Enter the serial number printed on the control board label. The platform will generate a device token — paste this into the configuration file at ~/.svrc/config.yaml on your compute, then restart the SVRC agent service with systemctl restart svrc-agent.

Once the agent connects, the device will appear as "Online" in the platform dashboard. You can verify the connection by streaming live joint state and camera feeds from the platform's device view. This live feed is also useful for monitoring data collection sessions remotely and for reviewing episode quality without downloading raw data files. The platform's dataset explorer lets you tag, annotate, and manage episodes directly in the browser.

Your First Teleoperation Session

Enable teleoperation mode in the SVRC platform or via the command-line tool: svrc teleop start --leader /dev/ttyUSB0 --follower /dev/ttyUSB1. The leader arm joints will enter a compliant gravity-compensation mode; the follower arm will mirror every movement in real time with a configurable latency (default 50ms). Move the leader arm slowly through the workspace and confirm that the follower tracks accurately. Check for any joints that lag or overshoot — these indicate a PID tuning issue that can be corrected in the servo configuration file.

For your first recorded episode, choose a simple, repeatable task: picking a cube from a fixed position and placing it on a marked target. Practice the motion with the teleoperation system for 5–10 repetitions without recording to develop muscle memory. When your motions are smooth and consistent, start a recording session in the SVRC platform. Each episode will be tagged with a timestamp, the hardware serial number, and your session ID. After completing a demonstration, review the episode playback in the platform before recording the next one — catching quality issues early saves significant re-collection time later. See our data services guide for best practices on structuring data collection sessions for policy training.

Software Installation: ROS 2 and the OpenArm SDK

If you received the compute option with a pre-configured mini-PC, skip to "Verifying the Software Stack" below. If you are using your own machine, follow these steps.

Step 1 -- Install Ubuntu 22.04 LTS. OpenArm's software stack targets Ubuntu 22.04 exclusively. Other distributions and versions may work but are not tested or supported. Use a clean installation, not a dual-boot or VM -- real-time servo communication requires consistent USB latency that virtualized environments cannot guarantee.

Step 2 -- Install ROS 2 Humble. ROS 2 Humble Hawksbill is the LTS release that the OpenArm packages target. Install using the official Debian packages:

sudo apt update && sudo apt install software-properties-common
sudo add-apt-repository universe
sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key \
  -o /usr/share/keyrings/ros-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] \
  http://packages.ros.org/ros2/ubuntu $(. /etc/os-release && echo $UBUNTU_CODENAME) main" \
  | sudo tee /etc/apt/sources.list.d/ros2.list > /dev/null
sudo apt update && sudo apt install ros-humble-desktop python3-colcon-common-extensions

Source the ROS 2 setup in your shell profile: echo "source /opt/ros/humble/setup.bash" >> ~/.bashrc. Verify with ros2 topic list -- you should see /rosout and /parameter_events.

Step 3 -- Install the OpenArm Python SDK. The SDK provides the low-level servo communication layer, calibration utilities, and the teleoperation controller:

pip install openarm-sdk
# Or from source for development:
git clone https://github.com/svrc-robotics/openarm-sdk.git
cd openarm-sdk && pip install -e ".[dev]"

Step 4 -- Install the SVRC Agent. The SVRC agent connects your OpenArm to the SVRC platform for remote monitoring, episode recording, and dataset management:

pip install svrc-agent
svrc-agent init  # Creates ~/.svrc/config.yaml

Verifying the Software Stack. Run the built-in diagnostic tool to confirm everything is working:

openarm diagnose --all
# Expected output:
# [OK] USB servo chain detected (6 servos on /dev/ttyUSB0)
# [OK] Leader arm detected (6 joints on /dev/ttyUSB1)
# [OK] Camera 0: /dev/video0 (640x480 @ 30fps)
# [OK] Camera 1: /dev/video2 (640x480 @ 30fps)
# [OK] ROS 2 Humble: active
# [OK] SVRC Agent: connected to platform

First Motion: Joint Position Control

Before running teleoperation, verify that you can command individual joints programmatically. This confirms the servo chain, calibration offsets, and communication bus are all working correctly.

from openarm import OpenArm
import time

arm = OpenArm(port="/dev/ttyUSB0")
arm.connect()

# Read current joint positions (radians)
print("Current positions:", arm.get_joint_positions())

# Move joint 1 (shoulder) to 0.5 rad at 30% speed
arm.move_joint(joint_id=1, position=0.5, speed=0.3)
time.sleep(2)

# Move to a named home pose
arm.move_to_home()
time.sleep(2)

# Move through a sequence of waypoints
waypoints = [
    [0.0, -0.5, 1.0, 0.0, 0.5, 0.0],   # approach
    [0.0, -0.3, 0.8, 0.0, 0.3, 0.5],    # pre-grasp
    [0.0, -0.3, 0.8, 0.0, 0.3, 1.0],    # close gripper
]
for wp in waypoints:
    arm.move_joints(wp, speed=0.2)
    time.sleep(1.5)

arm.disconnect()

If any joint does not respond or moves to an unexpected position, re-run calibration for that joint before proceeding. The most common issue is a servo ID conflict -- two servos assigned the same ID on the bus. Use openarm scan-servos to list all detected servo IDs and resolve conflicts.

Common Issues and Fixes

Next Steps After Setup

Once your OpenArm is assembled, calibrated, connected to the platform, and you have verified joint control and teleoperation, here is the recommended progression:

1. Practice teleoperation (2-4 hours). Spend time developing muscle memory with the leader arm. Start with large motions (moving to positions in the workspace) before attempting fine manipulation (grasping small objects). Most operators need 4-8 hours before their demonstrations are production-quality.
2. Collect a calibration dataset (50 episodes). Record 50 demonstrations of a simple pick-and-place task. Review every episode in the platform. This dataset validates your entire pipeline from hardware to storage and lets you catch any remaining issues before investing in larger collection campaigns.
3. Train a test policy. Use the 50-episode dataset to train an ACT or Diffusion Policy using LeRobot. If the policy achieves 40-60% success on the simple task, your hardware and data pipeline are working correctly. If it achieves less than 30%, review your data quality using the data quality framework.
4. Scale to production collection. Once the pipeline is validated, scale up to your target dataset size. For most single-task manipulation policies, 200-500 demonstrations is the typical range. For multi-task or foundation model fine-tuning, plan for 1,000-5,000 demonstrations. SVRC's managed collection service can accelerate this phase with trained operators and structured QA.

OpenArm Specifications at a Glance

Data Collection Tips

Maintain consistent speed throughout demonstrations. Abrupt speed changes — fast approach, sudden slow grasp — make it harder for policies to learn smooth behavior. Aim for a tempo that feels deliberate but not painstaking: as if demonstrating a task to a colleague who needs to see each step clearly. If you are collecting for Diffusion Policy or ACT, systematic variation in object position is more valuable than additional demonstrations with objects in the same place. After every 20 episodes, move the target object to a new position within the expected deployment range.

Take breaks every 30–45 minutes. Operator fatigue produces subtle changes in demonstration quality — hesitations, asymmetric grasps, incomplete placements — that are difficult to detect in individual episodes but degrade policy training at scale. The SVRC platform's session analytics flag episodes where the demonstration duration is an outlier (too fast or too slow compared to the session median), providing an automated quality signal. Use these flags as a starting point for manual review, not as a complete substitute for it. For scaling beyond what a single operator can produce, SVRC's managed collection service provides teams of trained operators with structured QA protocols. Contact us to learn more.