High-Speed Line Follower: PID Control Loops & Kinematics

1. The Bang-Bang Oscillation Paradox

Novice roboticists begin line following with naive binary logic: "If left sensor sees black, turn left; if right sensor sees black, turn right."

At speeds below $0.2 \text{ m/s}$, this "bang-bang" controller appears functional. However, as chassis velocity increases, the system encounters the fundamental limits of discrete switching control:

1. Violent Limit Cycle Oscillations: The robot repeatedly overshoots the line trajectory, creating high-frequency physical oscillations that bleed mechanical energy and destabilize the caster wheel.
2. Inertial Momentum Disconnect: Because motor torque switching is instantaneous ($100\%$ to $0\%$), the robot’s angular momentum carries it clean off the course at 90-degree acute intersections or high-radius hairpins.

Transitioning from hobbyist toy to precision high-speed competitive racer requires continuous feedback control via Proportional-Integral-Derivative (PID) regulation coupled with high-frequency analog reflectance interpolation.

2. Differential Drive Kinematics & Curvature

The robot utilizes two independent coaxial drive wheels separated by track width $L$, with a passive low-friction ball caster. Let $v_L$ and $v_R$ represent the linear velocities of the left and right wheels:

$$v_{\text{robot}} = \frac{v_R + v_L}{2}, \quad \omega = \frac{v_R - v_L}{L}$$

$$R_{\text{turn}} = \frac{v}{\omega} = \frac{L}{2} \cdot \frac{v_R + v_L}{v_R - v_L}$$

Where $\omega$ is the robot's angular yaw velocity in radians per second, and $R_{\text{turn}}$ is the instantaneous radius of curvature. To follow a curved line without slipping, the control system must modulate the differential speed $(v_R - v_L)$ proportionally to the track’s instantaneous curvature.

3. 8-Channel Reflectance Weighted Centroid Calculation

Using digital HIGH/LOW inputs limits spatial resolution to the physical spacing of the IR diodes (~9 mm). To achieve sub-millimeter precision, we read raw 10-bit analog values from an 8-channel infrared reflectance array (Pololu QTR-8A):

Let $S_i \in [0, 1000]$ denote the normalized reflectance value of sensor $i \in \{0, 1, \dots, 7\}$ (calibrated such that 0 = pure white surface, 1000 = pure black line). We compute the line's center-of-mass Weighted Centroid Position:

$$\text{Position} = \frac{\sum_{i=0}^{7} (i \times 1000) \cdot S_i}{\sum_{i=0}^{7} S_i}$$

$$\text{Error } e(t) = \text{Position} - 3500$$

Where $3500$ represents the perfect physical center between sensor 3 and sensor 4. The resulting error signal $e(t) \in [-3500, +3500]$ provides an analog position measurement with a resolution of ±0.1 millimeters.

4. Mathematical Derivation: Discrete PID with Anti-Windup

The continuous-time PID control equation operates on instantaneous error $e(t)$:

$$u(t) = K_p \cdot e(t) + K_i \int_0^t e(\tau) d\tau + K_d \frac{de(t)}{dt}$$

To execute on an 8-bit or 32-bit embedded microcontroller with fixed sampling period $\Delta t = 1 \text{ ms}$, we discretize the equations using backward rectangular Euler integration:

$$P[k] = K_p \cdot e[k]$$

$$I[k] = \text{clamp}\left( I[k-1] + K_i \cdot e[k] \cdot \Delta t, \ -I_{\max}, \ +I_{\max} \right)$$

$$D[k] = K_d \cdot \frac{e[k] - e[k-1]}{\Delta t}$$

$$u[k] = P[k] + I[k] + D[k]$$

5. Production Implementation: Hardware Timer Interrupt Loop

#include <Arduino.h>

// Hardware Pin Definitions
#define PIN_PWMA    5   // Left Motor PWM (Timer3)
#define PIN_PWMB    6   // Right Motor PWM (Timer4)
#define PIN_AIN1    7   // Left Motor Direction
#define PIN_AIN2    8
#define PIN_BIN1    9   // Right Motor Direction
#define PIN_BIN2    10

// Control Parameters
const float Kp = 0.082f;
const float Ki = 0.0004f;
const float Kd = 1.450f;
const float I_MAX = 80.0f;
const int BASE_PWM = 200;

volatile int last_error = 0;
volatile float integral_sum = 0.0f;

void configure_ultrasonic_pwm() {
    // Reconfigure Timer3 and Timer4 for 20 kHz ultrasonic PWM
    // Eliminates audible coil whine and enhances motor torque linearity
    TCCR3B = (TCCR3B & 0xF8) | 0x02; // Prescaler = 8
    TCCR4B = (TCCR4B & 0xF8) | 0x02;
}

int read_calibrated_centroid() {
    long numerator = 0;
    long denominator = 0;

    for (uint8_t i = 0; i < 8; i++) {
        int raw = analogRead(A0 + i);
        // Normalize against white/black calibration bounds
        int val = map(raw, 120, 920, 0, 1000);
        val = constrain(val, 0, 1000);

        numerator += (long)i * 1000L * val;
        denominator += val;
    }

    if (denominator < 200) {
        // Line lost condition: maintain last known heading
        return (last_error > 0) ? 7000 : 0;
    }

    return (int)(numerator / denominator);
}

void execute_pid_step() {
    int position = read_calibrated_centroid();
    int error = position - 3500;

    // 1. Proportional Term
    float P = Kp * (float)error;

    // 2. Integral Term with Anti-Windup Clamping
    integral_sum += (float)error;
    integral_sum = constrain(integral_sum, -I_MAX / Ki, I_MAX / Ki);
    float I = Ki * integral_sum;

    // 3. Derivative Term with Backward Difference
    float D = Kd * (float)(error - last_error);
    last_error = error;

    // Compute PID Correction Output
    int correction = (int)(P + I + D);

    // Differential Motor Speed Allocation
    int left_speed = constrain(BASE_PWM - correction, -255, 255);
    int right_speed = constrain(BASE_PWM + correction, -255, 255);

    // Apply Motor Drive Signals
    set_motor_speeds(left_speed, right_speed);
}

void set_motor_speeds(int left, int right) {
    // Left Motor Direction & PWM
    digitalWrite(PIN_AIN1, left >= 0 ? HIGH : LOW);
    digitalWrite(PIN_AIN2, left >= 0 ? LOW : HIGH);
    analogWrite(PIN_PWMA, abs(left));

    // Right Motor Direction & PWM
    digitalWrite(PIN_BIN1, right >= 0 ? HIGH : LOW);
    digitalWrite(PIN_BIN2, right >= 0 ? LOW : HIGH);
    analogWrite(PIN_PWMB, abs(right));
}

6. Empirical Lap & Tuning Benchmarks

We benchmarked controller performance across a standard 18-meter international competition track featuring 45° slants, 90° acute corners, and high-curvature S-curves:

7. Critical Hardware Failure Modes: Back-EMF & Slip

High-speed physical robotics projects fail more frequently due to analog and mechanical oversights than algorithmic bugs: