Build your first integrations.

🛒 What you need

• Pollen Robotics Reachy Mini (assembled — from huggingface.co/reachy-mini)
• A computer on the same Wi-Fi or Ethernet as the robot (Raspberry Pi 5, Jetson, or laptop)
• Python 3.10+ with OpenCastor installed
• USB-C cable for initial firmware check (optional)

Step 1 — Install OpenCastor with the Reachy extra

The [reachy] extra installs reachy2-sdk and zeroconf for mDNS discovery.

# In a virtual environment (required on Pi OS / Debian)
python3 -m venv ~/opencastor-venv --system-site-packages
source ~/opencastor-venv/bin/activate

pip install opencastor[reachy]

# Verify
castor scan --preset-only

Expected output: reachy_mini (high): Reachy Mini detected via mDNS

Step 2 — Power on Reachy Mini and verify mDNS

Reachy Mini advertises itself on your local network as reachy-mini.local using mDNS.

# Test connectivity from your computer
ping reachy-mini.local

# Or use the OpenCastor hardware scanner
castor scan
# Should show: reachy: true, host: reachy-mini.local

If mDNS doesn't resolve, check that both devices are on the same network segment. Fallback: use the robot's IP directly in your config.

Step 3 — Generate an RCAN config for Reachy Mini

OpenCastor's wizard auto-populates a config based on detected hardware.

castor wizard --preset reachy_mini --output ~/reachy-mini.rcan.yaml

The generated config will look like:

robot_uuid: "your-uuid-here"
robot_name: "reachy-mini"

hardware:
  - driver: reachy
    host: auto        # mDNS auto-discovery: reachy-mini.local
    joints:
      - name: head_roll
      - name: head_pitch
      - name: head_yaw
      - name: l_antenna
      - name: r_antenna

interpreter:
  backend: auto       # local CLIP → Gemini if GOOGLE_API_KEY is set
  mode: non_blocking

Step 4 — Start the gateway and dashboard

castor gateway --config ~/reachy-mini.rcan.yaml &
castor dashboard &

# Check the API
curl http://localhost:8000/api/status
# → {"version": "2026.3.12.0", "status": "ok", "hardware": ["reachy"]}

Step 5 — Control head movement

Send movement commands via the REST API or Python SDK:

import requests

# Nod the head
requests.post("http://localhost:8000/api/move", json={
    "joint": "head_pitch",
    "position": 0.3,    # radians
    "duration": 1.0
})

# Wave the antennas
for joint in ["l_antenna", "r_antenna"]:
    requests.post("http://localhost:8000/api/move", json={
        "joint": joint,
        "position": 0.5,
        "duration": 0.5
    })

Step 6 — Behavior scripting with RCAN behaviors

Add named behaviors to your config to make Reachy Mini react to events:

behaviors:
  - name: greet
    trigger: on_event("hello")
    actions:
      - move: {joint: head_yaw, position: 0.0, duration: 0.3}
      - move: {joint: l_antenna, position: 0.8, duration: 0.5}
      - move: {joint: r_antenna, position: 0.8, duration: 0.5}
      - wait: 0.5
      - move: {joint: l_antenna, position: 0.0, duration: 0.5}
      - move: {joint: r_antenna, position: 0.0, duration: 0.5}

  - name: look_around
    trigger: on_schedule("*/30 * * * * *")   # every 30s
    actions:
      - move: {joint: head_yaw, position: 0.4, duration: 1.0}
      - wait: 0.8
      - move: {joint: head_yaw, position: -0.4, duration: 1.5}
      - wait: 0.8
      - move: {joint: head_yaw, position: 0.0, duration: 1.0}

Step 7 — (Optional) Scene embeddings for reactive behaviors

If you attach a USB camera, OpenCastor can generate CLIP embeddings and trigger behaviors based on what the robot sees:

interpreter:
  backend: auto
  camera: /dev/video0     # USB camera attached to your compute node
  similarity_threshold: 0.78

behaviors:
  - name: react_to_person
    trigger: on_embedding_match("a person in the scene", threshold: 0.82)
    actions:
      - move: {joint: head_pitch, position: 0.0, duration: 0.5}  # look up
      - emit_event: "hello"

This runs entirely on-device with CLIP (Tier 0). No cloud API key required.

✅ You're done

Reachy Mini is now fully integrated with OpenCastor. Next steps: add a Raspberry Pi 5 compute node for local ML inference, or wire up an HLabs ACB motor controller to add a custom arm.

🛒 Full parts list

• Compute: Raspberry Pi 5 (8GB) + active cooler, OR Nvidia Jetson Orin Nano developer kit
• Motor controllers: 2–6× HLabs ACB v2.0
• Motors: BLDC outrunners (T-Motor, GL, etc.) sized for your robot
• Power: 4S LiPo (14.8V) + power distribution board, or 24V bench supply
• USB-CAN adapter: Canable, Waveshare USB-CAN-A, or Pi 5 CAN HAT
• Camera: USB webcam or Pi Camera Module 3 (for visual embeddings)
• OAK-D SR (optional): For stereo depth + RGB capture
• Frame: 3D printed, aluminum extrusion, or MDF — your design
• MicroSD (Pi 5) or NVMe SSD (Jetson): 64GB+ for OS + models
• 120Ω termination resistors: 2× for CAN Bus ends

Step 1 — OS setup

Raspberry Pi 5:

# Flash Pi OS (64-bit) via Raspberry Pi Imager
# Enable SSH, set hostname, configure Wi-Fi during flash

# After first boot, update
sudo apt update && sudo apt upgrade -y
sudo apt install -y python3-venv python3-pip can-utils git

Nvidia Jetson Orin:

# Flash JetPack 6 via SDK Manager on a host Ubuntu machine
# Then on Jetson:
sudo apt update && sudo apt upgrade -y
sudo apt install -y python3-venv python3-pip can-utils git

# Verify CUDA
nvcc --version
# → Cuda compilation tools, release 12.x

Step 2 — Enable CAN Bus interface

With USB-CAN adapter (works on both Pi 5 and Jetson):

# Bring up CAN interface
sudo ip link set can0 up type can bitrate 1000000
sudo ip link set can0 txqueuelen 1000

# Make persistent via /etc/network/interfaces.d/can0
echo "auto can0
iface can0 inet manual
    pre-up /sbin/ip link set can0 up type can bitrate 1000000
    post-down /sbin/ip link set can0 down" | sudo tee /etc/network/interfaces.d/can0

# Test — plug in ACB and check
candump can0

With Pi 5 CAN HAT (MCP2515-based):

# Add to /boot/config.txt:
dtparam=spi=on
dtoverlay=mcp2515-can0,oscillator=12000000,interrupt=25
dtoverlay=spi-bcm2835-overlay

# Then reboot and bring up:
sudo ip link set can0 up type can bitrate 1000000

Step 3 — Install OpenCastor

# Create venv (required on Pi OS/Ubuntu — PEP 668)
python3 -m venv ~/opencastor-venv --system-site-packages
source ~/opencastor-venv/bin/activate

# Install with HLabs support
# (also add [reachy] if connecting Reachy Mini via this compute node)
pip install opencastor[hlabs]

# Scan detected hardware
castor scan
# Pi 5 output:
# platform: rpi · acb: true (2 nodes) · cameras: 1
# Jetson output:
# platform: jetson · acb: true (2 nodes) · cameras: 1 · hailo: false

Step 4 — Full RCAN config for your robot

robot_uuid: "diy-robot-uuid"
robot_name: "my-diy-robot"

hardware:
  - driver: hlabs_acb
    interface: can0
    bitrate: 1000000
    joints:
      - name: base_rotation
        node_id: 1
        gear_ratio: 10.0
      - name: arm_shoulder
        node_id: 2
        gear_ratio: 6.0
      - name: arm_elbow
        node_id: 3
        gear_ratio: 4.0

interpreter:
  backend: auto          # CLIP on Pi 5, ImageBind on Jetson (if GPU available)
  camera: /dev/video0
  mode: non_blocking

telemetry:
  enabled: true
  rate_hz: 50
  prometheus_port: 9090

Step 5 — Jetson: enable GPU-accelerated inference (optional)

On Jetson, the auto backend will detect CUDA and use the local_extended tier (ImageBind) for richer multimodal embeddings:

# Install CUDA-compatible torch (Jetson ships its own torch wheel)
pip install torch torchvision --index-url https://developer.download.nvidia.com/compute/redist/jp/v60/pytorch/

# Verify GPU is visible to OpenCastor
castor doctor
# → embedding_backend: local_extended (GPU) ✅
# → cuda_available: true ✅

# ImageBind runs on GPU — ~15ms per frame vs ~200ms CPU on Pi 5

Note: ImageBind is CC BY-NC 4.0. For commercial use, set backend: gemini with a GOOGLE_API_KEY.

Step 6 — Run as a systemd service (auto-start on boot)

# Generate and install systemd service files
castor service install --config ~/my-diy-robot.rcan.yaml

# Enable on boot
systemctl --user enable opencastor.service
systemctl --user enable opencastor-dashboard.service

# Start now
systemctl --user start opencastor.service

# Check status
systemctl --user status opencastor.service
castor doctor   # verify everything is healthy

Step 7 — (Optional) Add OAK-D SR for stereo depth

Plug in a Luxonis OAK-D SR (USB 3) for stereo RGB+Depth capture:

pip install depthai

# OAK-D is auto-detected by castor scan
castor scan
# → oakd: true, model: Luxonis OAK-D SR, usb3: true

# Add to RCAN config:
hardware:
  - driver: oakd
    model: auto             # auto-detected
    streams: [rgb, stereo_depth]
    fps: 30

✅ Robot is live

Your DIY robot is running with HLabs ACB motor control, on-device ML inference, and full OpenCastor observability. Dashboard at http://<your-robot-ip>:8501. Next steps:

• Add a Reachy Mini head for a full humanoid upper body
• Enable behavior scripting for autonomous task execution
• Explore community presets for your robot type