Motor Controller Interface

name: motor-controller-interface description: 'Interface with motor controllers (RoboClaw, ODrive). Use when configuring packet serial, velocity PID, or encoder feedback.'

Interfacing with Motor Controllers in ROS 2

Motor Controller Landscape

RoboClaw: Packet Serial Protocol

Serial Modes

• Simple serial: Single-byte speed commands (0-127 per motor). No feedback. Avoid.
• Packet serial: Structured commands with address byte and CRC-16 checksum. Use this.

Packet format:

[Address] [Command] [Data bytes...] [CRC16-MSB] [CRC16-LSB]

Default address: 0x80 (128). Configurable for multi-controller setups (0x80-0x87).

CRC-16 Calculation

def roboclaw_crc16(packet: bytes) -> int:
    crc = 0
    for byte in packet:
        crc ^= byte << 8
        for _ in range(8):
            if crc & 0x8000:
                crc = (crc << 1) ^ 0x1021
            else:
                crc <<= 1
            crc &= 0xFFFF
    return crc

Common Commands

Python RoboClaw Driver

import serial
import struct

class RoboClawDriver:
    def __init__(self, port: str, address: int = 0x80, baud: int = 115200):
        self.ser = serial.Serial(port, baud, timeout=0.1)
        self.addr = address

    def _send_command(self, cmd: int, data: bytes = b'') -> bool:
        packet = bytes([self.addr, cmd]) + data
        crc = self._crc16(packet)
        self.ser.write(packet + struct.pack('>H', crc))
        return True

    def _read_response(self, size: int) -> bytes:
        data = self.ser.read(size + 2)  # data + 2 byte CRC
        if len(data) < size + 2:
            raise TimeoutError("RoboClaw response timeout")
        payload, recv_crc = data[:size], struct.unpack('>H', data[size:])[0]
        calc_crc = self._crc16(bytes([self.addr]) + payload)  # verify
        if recv_crc != calc_crc:
            raise ValueError("CRC mismatch")
        return payload

    def _crc16(self, data: bytes) -> int:
        crc = 0
        for b in data:
            crc ^= b << 8
            for _ in range(8):
                if crc & 0x8000:
                    crc = (crc << 1) ^ 0x1021
                else:
                    crc <<= 1
                crc &= 0xFFFF
        return crc

    def set_speeds(self, m1_speed: int, m2_speed: int):
        """Set motor speeds in encoder counts/second."""
        data = struct.pack('>ii', m1_speed, m2_speed)
        self._send_command(37, data)

    def read_encoders(self) -> tuple:
        """Returns (m1_counts, m2_counts)."""
        self._send_command(16)
        m1_data = self._read_response(5)
        m1_counts = struct.unpack('>i', m1_data[:4])[0]

        self._send_command(17)
        m2_data = self._read_response(5)
        m2_counts = struct.unpack('>i', m2_data[:4])[0]
        return m1_counts, m2_counts

    def read_battery_voltage(self) -> float:
        """Returns battery voltage in volts."""
        self._send_command(24)
        data = self._read_response(2)
        raw = struct.unpack('>H', data)[0]
        return raw / 10.0

    def read_motor_currents(self) -> tuple:
        """Returns (m1_amps, m2_amps)."""
        self._send_command(49)
        data = self._read_response(4)
        m1, m2 = struct.unpack('>HH', data)
        return m1 / 100.0, m2 / 100.0

Velocity PID Tuning on RoboClaw

The RoboClaw runs its own PID loop on-board at ~300 Hz. You send target velocity in counts/sec, and the controller tracks it using encoder feedback.

PID parameters: P, I, D, QPPS (max speed in quadrature pulses per second).

Tuning procedure:

1. Set I = 0, D = 0. Start with P low (e.g., P = 1.0).
2. Command a step velocity (e.g., 1000 counts/sec). Observe motor response.
3. Increase P until the motor responds quickly but doesn't oscillate.
4. Add I (start at P/10) to eliminate steady-state error.
5. Add small D only if there is overshoot.
6. Set QPPS to the maximum speed the motor can physically achieve (measure it by driving at 100% duty and reading the encoder rate).

Watchdog/Timeout

The RoboClaw has a configurable serial timeout. If no valid command is received within the timeout period, both motors stop. This is a critical safety feature.

# Command 14: Set serial timeout
# Value is in units of 100ms. So 10 = 1 second timeout.
# Set to 0 to disable (dangerous!).
self._send_command(14, struct.pack('>B', 5))  # 500ms timeout

Always configure a timeout. If the ROS 2 node crashes or the serial cable disconnects, the motors will stop automatically.

ODrive Interface (CAN Bus)

ODrive uses CAN bus with a well-defined protocol. Each axis has a CAN node ID. Commands:

CAN ID = (node_id << 5) | command_id

Set_Input_Vel:  command_id = 0x00D, data = [float vel, float torque_ff]
Set_Input_Pos:  command_id = 0x00C, data = [float pos, int16 vel_ff, int16 torque_ff]
Get_Encoder_Estimates: command_id = 0x009, returns [float pos, float vel]

ODrive advantages: brushless motor support, FOC control, high bandwidth (8 kHz PID loop), integrated encoder interface, web-based configuration tool.

Pololu Motor Drivers

For simple applications where the MCU handles PID:

// PWM + Direction pin control
const int DIR_PIN = 6;
const int PWM_PIN = 7;

void setMotor(int speed) {  // speed: -255 to 255
    digitalWrite(DIR_PIN, speed >= 0 ? HIGH : LOW);
    analogWrite(PWM_PIN, abs(speed));
}

No protocol overhead, no CRC, no serial bus contention. The MCU must run its own PID loop using encoder feedback. This gives the most control but requires more firmware development.

Choosing a Controller

• RoboClaw: Best for differential drive robots. Dual motor with built-in PID, encoder inputs, and battery monitoring. One device handles both motors. Packet serial is well-documented.
• ODrive: Best when you need brushless motors or very high performance. CAN bus allows long cable runs. More complex setup.
• Pololu / bare H-bridge: Best for simple projects, educational robots, or when the MCU already runs PID. Lowest cost and complexity.