Technical Retrospective: The Evolution of a Tracked Robotic Fleet

Introduction & Historical Context

Consumer and educational robotics between the early 2000s and 2010s went through a fundamental transition — away from rigid, proprietary logic controllers and toward open, bare-metal programmable platforms. At the center of that shift was a rugged, rubber-tracked tank chassis, originally released by Conrad Electronic as the Robby RP5 (Conrad CCRP5). When Arexx Engineering later developed the RP6 and RP6v2, they kept the same dependable mechanical layout and completely re-engineered the electronics inside it.

This fleet — one baseline RP5 and three differently configured RP6v2 units — documents that architectural evolution directly.

The Architectural Shift

The mechanical continuity between the RP5 and RP6v2 reflects a simple engineering principle: when a chassis works, don't touch it — upgrade the electronics instead. Both share the same dual-DC-motor drivetrain; what changed completely is what's driving it.

Same tracked chassis and dual DC gearboxes on both sides — the mechanics stayed constant.

The Fleet Breakdown

Four physical units, each representing a step in the same progression.

3.1 Unit 1 — The Baseline Conrad Robby RP5

The original Motorola-driven C-Control module, running timed open-loop execution blocks. Serves as the historical control model against which the closed-loop RP6v2 units are contrasted.

3.2 Unit 2 — The RP6v2 Base Sensor Specialist

An Atmel ATmega32 8-bit RISC processor delivering 8 MIPS at 8 MHz, managing real-time tasks through its native out-of-box sensor suite:

• Optical encoders: dual high-resolution infrared interrupters tracking gearbox rotation to calculate velocity
• Infrared Anti-Collision System (ACS): modulated IR emitters/receivers detecting obstacles before impact
• Ambient telemetry: dual LDRs for phototaxis, plus micro-switch bumper feedback

3.3 Unit 3 — The I²C Modular Expansion Build

Steps past the physical I/O pin limits of the 40-pin ATmega32 by using the integrated I²C bus (via the hardware TWI lines, SDA and SCL). An expansion board acts as an infrastructure layer, letting the master board offload tasks or read peripheral sensors without disrupting the high-frequency interrupt loops driving the motors.

3.4 Unit 4 — The Multi-Processor Master Setup (M128 Configuration)

The most advanced unit in the fleet. Mounting the official RP6 CONTROL M128 expansion module relegates the base ATmega32 board to an I²C motor/sensor slave, while a secondary ATmega128 becomes the master brain — handling higher-level state machines and expanded memory.

Both branches hang off the ATmega32 master core (8 MHz / 8 MIPS) via the I²C / TWI bus.

Generational Contrast — Open-Loop vs. Closed-Loop

4.1 The RP5's "blind" navigation (open-loop)

The RP5 had no hardware mechanism to measure actual track rotation or wheel slip. Driving straight required hardcoded calibration values inside the CCBASIC script to balance left/right motor voltages — and as battery voltage degraded over a session, those ratios drifted, and so did the robot's path.

4.2 The RP6v2's active feedback (closed-loop)

The RP6v2 resolved this with integrated optical encoders: hardware interrupts continuously monitor wheel velocity, and a software PID loop adjusts motor power in real time. Hit an obstacle or lose traction, and the loop corrects power delivery immediately to hold the intended path.

The Software Toolchain Transition

5.1 The RP5 execution model

Programmed inside the proprietary Conrad C-Control IDE using CCBASIC, compiled to compressed bytecode and transmitted over an RS-232 serial cable. The onboard microcontroller ran a permanent interpreter loop, fetching tokens from an external EEPROM — a real computational overhead that capped execution speed.

5.2 The RP6v2 execution model

A shift to compiled, native C/C++ via the open-source WinAVR toolchain (or Atmel Studio) and the AVR-GCC cross-compiler, with Makefiles tuned for size (-Os) to fit the ATmega32's 32KB flash limit. Direct hardware register access pushed execution to a deterministic 8 MIPS.

5.3 Flashing and telemetry via RP6Loader v2

The old DB9 serial link gave way to a USB-to-UART bridge (FTDI). Code was uploaded with RP6Loader, a cross-platform Java tool that triggers the bootloader via the DTR line — and since the Arexx library redirects standard C printf() output straight to UART, live sensor telemetry streams directly back to a PC terminal.

Code Architecture Showcase — Multi-Tasking on Bare Metal

With no OS or threading available, the ATmega32 relies on cooperative multitasking driven by hardware interrupts and non-blocking software timers. The example below runs real-time safety telemetry and a navigation state machine concurrently, without either one blocking the other.

#include "RP6RobotBaseLib.h"
#include <avr/pgmspace.h>

#define TELEMETRY_INTERVAL  500

typedef enum {
    STATE_FORWARD,
    STATE_EVADING,
    STATE_STOPPED
} RobotState;

RobotState currentState = STATE_FORWARD;
uint32_t lastTelemetryTime = 0;

// Callback fired when the Anti-Collision System detects an obstacle
void acsStateChangedHandler(void) {
    if (obstacle_left || obstacle_right) {
        currentState = STATE_EVADING;
        moveAtSpeed(0, 0); // halt immediately
    } else {
        currentState = STATE_FORWARD;
    }
}

// Non-blocking task: streams motor telemetry over UART
void runTelemetryTask(void) {
    if (getTimerTicks() - lastTelemetryTime >= TELEMETRY_INTERVAL) {
        lastTelemetryTime = getTimerTicks();
        writeString_P(PSTR("[TELEMETRY] Left Speed: "));
        writeInteger(getLeftSpeed(), DEC);
        writeString_P(PSTR(" | Right Speed: "));
        writeInteger(getRightSpeed(), DEC);
        writeString_P(PSTR(" | Battery mV: "));
        writeInteger(adcBattery, DEC);
        writeChar('\n');
    }
}

// Navigation state transitions, without stalling execution
void runNavigationStateMachine(void) {
    switch (currentState) {
        case STATE_FORWARD:
            changeDirection(FORWARD);
            moveAtSpeed(60, 60); // regulated via closed-loop PID
            break;
        case STATE_EVADING:
            changeDirection(LEFT);
            moveAtSpeed(40, 40);
            break;
        case STATE_STOPPED:
        default:
            moveAtSpeed(0, 0);
            break;
    }
}

int main(void) {
    initRobotBase();
    ACS_setStateChangedHandler(acsStateChangedHandler);
    setLEDs(0b001001);
    powerON();
    writeString_P(PSTR("\n--- RP6v2 Firmware Initialized ---\n"));

    while(1) {
        task_RP6System();          // background library routines
        runTelemetryTask();        // decoupled, non-blocking
        runNavigationStateMachine();
    }
    return 0;
}

Ecosystem Retrospective — Legacy vs. Modern Edge AI

Contrasting this platform with something like a Raspberry Pi 5 or NVIDIA Jetson running ROS 2 shows how far the paradigm has moved.

7.1 Resource scarcity vs. abundance

Working on the RP6 meant a constant resource-optimization puzzle — 32KB of flash and 2KB of SRAM forced minimal variable sizes, bitmask packing, and storing text in flash via PROGMEM. Modern platforms abstract memory constraints away almost entirely.

7.2 Monolithic super-loops vs. distributed nodes

The RP6v2 runs one sequential loop — an I²C bus fault or a hung routine freezes the whole system, a real physical collision risk. ROS 2 instead splits logic into independent Nodes communicating via publish-subscribe; if a high-level mapping node crashes, the motor driver node keeps running its own safe-stop procedure.

7.3 Thresholds vs. dense spatial awareness

The RP5/RP6 read the world through simple numeric thresholds — binary bumper triggers, analog IR spikes. Modern platforms build rich 3D point clouds via LiDAR or depth cameras and use SLAM to map and localize down to millimeter accuracy.

7.4 The enduring value of legacy systems

Despite the huge processing gap, a full Linux OS is fundamentally non-deterministic — it can pause application code at any millisecond for background tasks. That's exactly why the RP6v2's design principles still matter: modern robotics architectures are hybrids, pairing a high-level computer for vision/planning with an independent, real-time microcontroller — doing exactly what the ATmega32 did — dedicated to deterministic, microsecond-accurate motor control and emergency interrupt handling.

Appendix A: Odometry Calculations

Firmware translates raw encoder counts into linear distance using fixed constants derived from the chassis geometry.

• Encoder resolution (R): 120 interrupts per full drive-sprocket rotation
• Drive sprocket diameter (D): 4.0 cm (40 mm)
• Circumference: C = π × D = 3.14159 × 4.0 cm ≈ 12.566 cm
• Distance per tick: C ÷ R = 12.566 cm ÷ 120 ≈ 0.1047 cm (1.047 mm)

Engineering guideline: roughly 9.55 encoder ticks correspond to exactly 1.0 cm of travel.

Because the 8-bit ATmega32 has no hardware floating-point unit, real-time speed-control loops use fixed-point integer arithmetic instead of floats to avoid processing bottlenecks:

// Converts raw encoder ticks to millimeters without float variables.
// Multiplies by 1047 and divides by 1000 to keep high cycle efficiency.
uint32_t calculateDistanceInMM(uint32_t rawEncoderTicks) {
    return (rawEncoderTicks * 1047) / 1000;
}

Appendix B: Glossary

ACS (Anti-Collision System)

Optical proximity setup pulsing an IR emitter and monitoring reflections to detect obstacles before contact.

ATmega32

8-bit, low-power RISC microcontroller from Atmel (Microchip), the main processor of the RP6 base platform.

AVR-GCC

Open-source GNU cross-compiler translating C/C++ into machine code for the AVR architecture.

C-Control

Legacy Conrad Electronic microcontroller board series; the original Robby RP5 used the C-Control I module.

CCBASIC

Token-based BASIC dialect used to program early Conrad hardware.

Closed-loop system

A control structure that monitors its own output via sensor feedback to adjust dynamically.

Dead reckoning

Estimating current position from prior position, elapsed time, and wheel rotation counts.

I²C (Inter-Integrated Circuit)

Synchronous serial bus enabling master/slave communication over two wires (SDA, SCL).

ISR (Interrupt Service Routine)

Code block that pauses the main loop instantly when triggered by a hardware event.

MIPS

Million instructions per second — the 8 MHz ATmega32 delivers a deterministic 8 MIPS.

Odometry

Using sensor data from wheels/tracks to calculate relative change in position over time.

Open-loop system

A control structure that outputs power without verifying the mechanical result.

PID controller

Proportional-Integral-Derivative feedback loop that regulates motor speed and trajectory smoothly.

PROGMEM

AVR-GCC keyword storing static data in flash memory rather than scarce SRAM.

RISC

Reduced Instruction Set Computer — simple instructions optimized to execute in a single clock cycle.

ROS / ROS 2

Open-source robotics middleware providing hardware abstraction and message-passing infrastructure.

SLAM

Simultaneous Localization and Mapping — algorithms letting a vehicle map an unknown space while tracking its own position in it.

TWI (Two-Wire Interface)

Atmel's hardware naming for its I²C-compatible peripheral.

WinAVR

Legacy open-source Windows toolchain containing AVR-GCC, used to build software for Arexx robots.