How to Control a Robotic Arm with OpenClaw on Raspberry Pi

A typical Raspberry Pi robotic arm project works like this: you write a Python script that sends PWM signals to servo motors through a PCA9685 driver board. Each movement is a function call with hardcoded angle values. The arm moves to position A, closes the gripper, moves to position B, opens the gripper. If the object shifts two centimeters to the left, the script fails.

OpenClaw sits between your natural language instructions and the hardware control layer. Instead of writing move_to(x=120, y=45, z=90) for every position, you describe what you want: "pick up the red block and place it in the left bin." The agent breaks that instruction into a sequence of servo commands, executes them through shell commands on the Pi, and can adjust if something goes wrong.

The Hackster.io project by psmooij demonstrates this with an Arduino Braccio arm connected to a Raspberry Pi 5 running OpenClaw. The Pi handles the AI reasoning while an Arduino UNO R4 WiFi manages the actual servo signals. OpenClaw generates Python scripts that call the arm's SDK, translating high-level intent into joint angles and gripper positions.

This matters for three practical reasons. First, you can change the task without rewriting code. Second, the agent can chain operations together, sorting a tray of parts by color or size without a separate script for each combination. Third, every command and result gets logged, which means you can review what happened, debug failures, and store motion data for later analysis.

The build splits into four groups: the Pi, the arm, the servo driver, and optional vision hardware.

Raspberry Pi:

• Raspberry Pi 5 (4 GB or 8 GB) for best performance
• Raspberry Pi 4 (4 GB minimum) works but runs the LLM API calls and servo control with less headroom
• 32 GB high-endurance microSD card or USB SSD for reliability
• USB-C power supply rated at 5V/5A for Pi 5

Robotic arm options:

• Hiwonder ArmPi FPV: a 6DOF arm designed for Pi 5 with integrated camera mount and ROS 2 support, priced around $300 for the advanced kit
• Arduino Braccio: a 6DOF arm that pairs with an Arduino UNO R4 as the motor controller, communicating with the Pi over USB or WiFi
• DIY 6DOF aluminum arm kits (ROT3U style): budget option around $40 to $60, requires your own servo driver and mounting

PCA9685 servo driver:

The PCA9685 is a 16-channel, 12-bit PWM driver that communicates over I2C. It controls up to 16 servos using just two GPIO pins (SDA and SCL) on the Pi. Popular boards include the Adafruit 16-Channel Servo Driver, the Waveshare Servo Driver HAT, and the Onyehn PCA9685 module (available in multi-packs for under $10).

The 12-bit resolution gives you 4,096 steps per channel, which translates to roughly 0.05-degree positioning accuracy on a standard 180-degree servo. That is more than enough for pick-and-place work.

Optional vision hardware:

• Raspberry Pi Camera Module 3 for visual feedback
• Raspberry Pi AI HAT+ with Hailo-8L for real-time object detection
• Microsoft Kinect (used in the Hackster.io budget build as a depth sensor)

Total cost ranges from about $100 for a DIY arm with a Pi 4 and PCA9685 board to $400+ for a Hiwonder ArmPi FPV kit with camera and AI HAT+.

The PCA9685 connects to the Pi over I2C. If you are using a HAT-style board like the Waveshare Servo Driver HAT, it plugs directly onto the 40-pin GPIO header. For standalone PCA9685 breakout boards, the wiring is four connections.

I2C wiring:

• SDA on the PCA9685 to GPIO 2 (pin 3) on the Pi
• SCL on the PCA9685 to GPIO 3 (pin 5) on the Pi
• VCC to 3.3V (pin 1) for the logic side
• GND to any ground pin (pin 6, 9, 14, 20, 25, 30, 34, or 39)

Servo power: Connect the V+ terminal on the PCA9685 board to an external 5V or 6V power supply rated for your servo draw. A 6DOF arm with MG996R servos can pull 2A to 3A under load. Do not power servos from the Pi's 5V rail. That rail supplies about 1A total, and a servo stall will brown out the Pi and corrupt the SD card.

Enable I2C:

Run sudo raspi-config, navigate to Interface Options, and enable I2C. Verify with i2cdetect -y 1. The PCA9685 should appear at address 0x40 (or 0x41 if the A0 solder jumper is bridged).

Install the Python library:

pip install adafruit-circuitpython-servokit

Calibrate each servo:

Every servo has slightly different pulse width ranges. The default range (1000 to 2000 microseconds) works for most SG90 and MG90S servos, but higher-torque servos like the MG996R often need 500 to 2500 microseconds. Test each joint individually before running full arm movements.

from adafruit_servokit import ServoKit

kit = ServoKit(channels=16)
kit.servo[0].actuation_range = 180
kit.servo[0].set_pulse_width_range(500, 2500)
kit.servo[0].angle = 90  # center position

Run this for each channel (0 through 5 for a 6DOF arm) and note the safe angle ranges. Some joints will bind mechanically before reaching 0 or 180 degrees. Record these limits because you will need them when configuring the agent's safety boundaries.

Store your arm's calibration data and motion logs in one searchable workspace

generous storage, no credit card, with built-in AI search across your servo configs, captured images, and run logs. Agents and humans share the same workspace.

Start 14-Day Trial

OpenClaw installs on Raspberry Pi OS Lite (64-bit) with a single command.

curl -fsSL https://openclaw.ai/install.sh | bash

The installer sets up Node.js, configures a systemd service, and runs an onboarding wizard where you provide your LLM API key. OpenClaw supports cloud models (Gemini, Claude, GPT-4) and local models through Ollama. On a Pi 5 with 8 GB RAM, running a small local model like Qwen 2.5 is feasible for basic commands, but cloud models give better results for complex multi-step sequences.

The official docs recommend a minimum of 1 GB RAM and 500 MB disk, but for robotic arm work you want at least 2 GB RAM and an SSD. Servo control scripts, camera feeds, and agent reasoning all compete for resources.

Two architecture patterns:

The simplest setup runs everything on the Pi. OpenClaw executes Python scripts that import the ServoKit library and move servos directly. This works when the Pi handles both the agent logic and the hardware.

The second pattern splits the work. The Pi runs OpenClaw and handles reasoning. An Arduino UNO R4 WiFi (or similar microcontroller) handles the real-time servo control. OpenClaw sends commands to the Arduino over USB serial or WiFi API endpoints. This is the pattern used in the Hackster.io Braccio arm project, and it is better for arms that need precise timing or run ROS 2 firmware.

Direct control example:

OpenClaw's robot skill (available on ClawHub) provides structured guidance for motor control, sensor integration, and safety checks. When you give the agent a natural language command, it generates and executes a Python script. For a direct-control setup, that script calls ServoKit methods.

A command like "move the arm to the home position" produces a script that sets all six servos to their calibrated center angles. "Pick up the object at the front of the workspace" generates a sequence: lower the arm, close the gripper, raise the arm, rotate to the drop position, lower, open the gripper. The agent handles the sequencing. You describe the outcome.

Arduino bridge example:

For the split architecture, OpenClaw sends serial commands or HTTP requests to the Arduino. The Arduino firmware translates those into PWM signals. This adds a layer of abstraction but gives you hardware-level timing guarantees that Python on Linux cannot match.

A sorting workflow demonstrates where the agent approach pays off compared to scripted control. Say you have a tray of colored blocks and three bins. A hardcoded script needs a function for every block-color-to-bin mapping and a detection routine that identifies colors at fixed coordinates. Move one bin and the script breaks.

With OpenClaw and a camera, the workflow becomes adaptive. The camera captures the workspace, the agent identifies objects by color and position, plans a sequence, and executes it. If a block is not where expected, the agent can re-scan and adjust.

Practical steps for a sorting task:

1. Mount the camera above or beside the arm's workspace, angled to see the pickup and drop zones
2. Write a Python helper that captures a frame and runs basic color detection (HSV filtering with OpenCV works for solid-colored objects)
3. Give OpenClaw access to that helper as a shell command
4. Instruct the agent: "Sort the blocks in the tray by color. Red blocks go to the left bin, blue to the center, green to the right."

The agent calls the camera helper, parses the output, generates servo commands for each pick-and-place cycle, and runs them in sequence. If you add a yellow block later, you update the instruction, not the code.

Safety boundaries matter. Robotic arms can damage themselves, the workspace, and anything in reach. Define hard limits for each joint angle in your servo calibration script and enforce them in the helper functions. OpenClaw's robot skill emphasizes simulation-first workflows and speed limits for exactly this reason. Set maximum angular velocity so the arm does not whip between positions, and add a soft home position the agent returns to between tasks.

Logging and review:

Every command the agent runs gets logged. For physical automation, this log becomes your audit trail. You can review what the arm did, when it did it, and whether the result matched the intent. Storing these logs alongside captured images creates a complete record of each sorting run.

For teams running multiple arms or sharing results across shifts, Fastio workspaces provide a central place to collect motion logs, captured images, and configuration files. The free tier includes 50 GB of storage and included credits per month with no credit card required. Enable Intelligence Mode on the workspace and the logs become searchable: you can ask "show me all failed pick attempts from last Tuesday" and get cited results from the indexed files.

A robotic arm project generates more data than the arm movements themselves. Calibration profiles for each servo, camera snapshots of the workspace before and after tasks, motion logs, error reports when a pick fails, and configuration files that define joint limits and speed curves. On a single Pi this data lives on the SD card and is one corruption event away from disappearing.

Local storage options:

• SD card: convenient but unreliable for write-heavy workloads. Servo logging can produce thousands of small writes per hour
• USB SSD: more durable, faster, and recommended for any production use
• Network share (NFS/SMB): keeps data off the Pi entirely, but requires a server on the local network

Cloud storage for collaboration:

When multiple people work on the same arm, or when you run several arms across different locations, local storage creates silos. Cloud storage solves this, but most options (S3, Google Drive) require custom sync scripts and offer no way to query the files after upload.

Fastio handles both the storage and the query layer. Upload calibration files, motion logs, and workspace photos through the MCP server or the REST API. Once Intelligence Mode is enabled, every file gets indexed automatically. You can search logs by content, ask questions about past runs, and get answers with citations pointing to the specific files.

The ownership transfer feature fits robotics projects well. An agent or contractor builds the arm configuration, calibrates servos, tests the workflow, and stores everything in a Fastio workspace. When the project is ready, they transfer ownership to the client or operations team. The builder keeps admin access for support, the new owner gets full control. No zip files, no manual handoffs, no lost documentation.

Alternatives worth considering:

• GitHub repos work well for code and configuration but are awkward for binary files like images and large logs
• Google Drive is accessible but has no built-in search over file contents
• Self-hosted Nextcloud gives you full control but requires server maintenance

For a single arm on your desk, any of these works. For a classroom with ten arms, a factory floor with sorting stations, or a distributed team iterating on arm configurations, the searchable workspace model saves time finding the calibration profile that actually works or the log that shows why the gripper missed.