Robotic arm controller

🦾 6-Axis Robotic Arm Controller — RP2040

A high-performance embedded controller for 6-axis robotic arms featuring PIO-based jitter-free PWM, per-channel current sensing, real-time torque estimation, and hardware-level collision detection — no external sensors required.

📸 PCB Renders

3D Render	PCB Layout	Schematic

⚡ Key Specs

🧠 Core Concept

Traditional servo controllers simply send PWM signals. This board goes further:

MEASURE  →  ANALYZE  →  REACT

Every servo channel has a dedicated current sense amplifier. The RP2040 reads all six channels through a 74HC4051 analog multiplexer, continuously estimating torque, detecting collisions, and triggering per-channel shutdowns — all in real time.

🔩 Hardware & Components

Processing Unit

• RP2040 — Dual-core ARM Cortex-M0+ @ 133 MHz, 264KB SRAM, 8 PIO state machines
• W25Q16JV55 — 16MB QSPI Flash for firmware and data logging
• 12 MHz Crystal — Stable PLL reference for USB timing and precise PWM periods

Power Management

• Integrated 5V Buck Converter — Logic supply and low-power servo rail
• AMS1117-3.3 — Clean LDO for MCU and all analog circuitry
• Auto power-path — Seamless switching between USB-C (5V) and external VIN (6–24V)

Servo Driver Block (×6 channels)

• AO3401A P-MOSFET — High-side switch per channel. Enables software-controlled power sequencing and instant per-joint emergency stops
• INA180A1 — Current sense amplifier, gain ×20. Amplifies shunt voltage for ADC reading
• 10 mΩ Shunt Resistor — In-series with each servo rail for current measurement

Analog Signal Chain

• 74HC4051 — 8:1 CMOS analog multiplexer. Funnels all 6 current sense signals into a single ADC pin using only 3 GPIO select lines
• JP1–JP6 Jumpers — Per-channel voltage selection: position A = 5V buck, position B = direct VIN

User Interface

• RV1, RV2 — 10kΩ potentiometers mapped to Joint 1 & 2 for manual testing
• D3 — User-programmable LED
• Reset button — Hardware reset
• SWD header — ARM Serial Wire Debug (J-Link / DAPLink / OpenOCD)

🔌 GPIO Pin Mapping

GPIO 0–5 → Servo Enable (P-MOS high-side switches)
GPIO 6–11 → Servo PWM (PIO state machine outputs)

🏗️ PCB — 4-Layer Stackup

A 4-layer design is essential here — with 6 servo channels switching simultaneously and up to 10A peak current, a 2-layer board would suffer from unacceptable EMI coupling and resistive heating.

📐 Physics — How It Works

Motor Torque from Current

The fundamental relationship exploited by this board:

τ = Kₜ × I

A DC motor's torque is directly proportional to its armature current. Kₜ is the motor's torque constant (Nm/A). By measuring current through the INA180 shunt amplifiers, we measure torque — without any mechanical sensor.

Current Sensing Chain

I (servo current)
  → V_shunt = I × R_shunt          (Ohm's Law across 10mΩ shunt)
  → V_out = V_shunt × 20           (INA180 ×20 amplification)
  → ADC = (V_out / 3.3V) × 65535  (RP2040 12-bit ADC)
  → I = (ADC / 65535 × 3.3) / (20 × 0.01)

At 2.5A (overload threshold): V_shunt = 25mV → V_out = 500mV — well within ADC range.

Resolution: ~0.25 mA per LSB → ~0.02 mNm torque resolution per LSB.

Servo PWM Position Encoding

θ° = (t_pulse − 500µs) / 2000µs × 180°

The RP2040's PIO state machines generate these pulses in hardware — completely independent of the CPU clock, eliminating software-induced jitter that corrupts positional accuracy.

Why PIO Instead of Hardware PWM?

Hardware PWM slices share a clock divider. Reprogramming multiple channels simultaneously causes brief glitches. PIO state machines run from dedicated instruction memory, each executing its PWM loop independently — giving 6 perfectly phase-stable signals while freeing both CPU cores for inverse kinematics or vision tasks.

Collision Detection — Torque Spike

When the arm hits an obstacle, the motor stalls. A stalled motor draws its locked-rotor current — far above normal running current:

Normal:  I ≈ 0.3–0.8 A  →  τ ≈ 0.025–0.068 Nm
Stall:   I → 2–4 A      →  τ → 0.17–0.34 Nm  ← triggers shutdown

The ADC scans all 6 channels continuously. A torque spike is detected within one scan cycle (~1 ms). The P-MOSFET cuts power within a single GPIO toggle (~10 ns).

🛡️ Safety System

💻 Firmware

# robotic_arm_controller.py
# GPIO 0-5  → Servo ENABLE (P-MOS high-side switches)
# GPIO 6-11 → Servo PWM    (PIO state machines)
import rp2, machine, time

SERVO_EN_PINS  = [0, 1, 2, 3, 4, 5]
SERVO_PWM_PINS = [6, 7, 8, 9, 10, 11]
MUX_SEL_PINS   = [12, 13, 14]
ADC_ISNS_PIN   = 29
POT1_PIN, POT2_PIN = 18, 19

SERVO_MIN_US = 500
SERVO_MAX_US = 2500
ISNS_GAIN    = 20
SHUNT_R      = 0.010
OVERLOAD_A   = 2.5
KT_NM_PER_A  = 0.085
COLLISION_NM = 0.20

@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW)
def servo_pwm_pio():
    pull(block)          .side(0)
    mov(x, osr)
    label("high_loop")

🚀 Getting Started

1. Power the board Connect VIN (6–24V) to the screw terminal. Set jumpers JP1–JP6:

• Position A → 5V internal buck (standard hobby servos)
• Position B → Direct VIN (high-torque servos above 7.4V)

2. Flash firmware Hold BOOT on the back, press RESET. A drive named RPI-RP2 appears. Drag your .uf2 file onto it. Board reboots and runs automatically.

3. Test with potentiometers RV1 and RV2 control Joint 1 and Joint 2 by default. Rotate to verify servo response before connecting the full arm.

4. Monitor over serial Open any terminal at 115200 baud on the USB-C port. arm.status() prints a live table of angle, current, torque, and fault state for all 6 joints.

5. Tune collision thresholds Run the arm freely and log status() output. Set COLLISION_NM to ~1.5–2× the maximum torque observed during normal free movement.

6. Extend with C++ for performance Run motion control on Core 0 and current sensing on Core 1 for fully parallel deterministic operation. Core 1 can achieve scan rates exceeding 10 kHz — enabling sub-millisecond collision response.

✅ Capabilities

• 6 independent PIO-generated PWM channels — sub-microsecond jitter
• Real-time torque estimation on every joint — no mechanical sensors
• Per-channel collision detection with configurable threshold
• Individual high-side MOSFET shutdown per channel
• Emergency stop — all 6 channels cut within a single GPIO toggle
• Smooth interpolated motion with mid-move collision check
• Staggered power-up to prevent inrush brownout
• Manual joint control via onboard potentiometers
• USB-C UF2 flashing — no external programmer required
• SWD debug header — J-Link / DAPLink / OpenOCD compatible
• Dual-core execution: motion on Core 0, sensing on Core 1
• MicroPython and C++ Pico SDK fully supported
• Per-servo independent voltage selection via JP1–JP6
• Live status table: angle, current, torque, fault per joint
• Latching fault system with software reset
• CERN Open Hardware License — free to modify and manufacture

📄 License

Released under the CERN Open Hardware Licence Version 2 — Strongly Reciprocal (CERN-OHL-S v2).
Free to study, modify, manufacture, and distribute — derivatives must remain open source.