LineSensor

Autonomous Line-Following Buggy

An autonomous line-following robot built on an STM32F401RE Nucleo board, combining custom C++/Mbed firmware, a bespoke six-sensor infrared PCB, and two parallel PID loops (steering + wheel speed) for fast, stable line tracking. Built for the EEEN21000 Embedded Systems Project at the University of Manchester and raced in the end-of-year competition.

Heats result: completed the competition track in 10.0 s, finishing 6th in the Heats. Technical demonstrations averaged ~90%, with 100% in TD3.

Contents

• Overview
• Gallery
• How it works
• Repository layout
• Documentation
• Real-time timing budget
• Tuning notes
• What we would do differently
• Team
• Acknowledgements

Overview

The buggy follows a white line on a dark track using a six-sensor infrared array. Sensor voltages are sampled through the STM32's ADCs, converted to a line position with a weighted-average algorithm, and fed into two PID controllers running in parallel — one for steering, one for wheel speed. Motor commands are issued as bipolar PWM to an H-bridge motor-driver board.

Gallery

Final buggy	SolidWorks model

Custom line-sensor PCB (KiCad)	Wiring

How it works

The firmware (firmware/main.cpp) runs the same pipeline every cycle, with no blocking calls:

1. Sense. Six SamplingSensor objects sample the TCRT5000 array on a fixed-frequency Ticker, independently of the main loop.
2. Localise. calculate_lineposition() normalises each reading and takes a weighted average — the weights are the physical sensor offsets — so the result is the buggy's lateral error, with the setpoint at 0.
3. Correct. Two controllers act on that cycle's data in parallel: a steering PID on the line-position error (an equal-and-opposite nudge to the two wheels), and a speed PID per wheel on target − measured RPM from the encoders.
4. Drive. Each wheel command is baseSpeed + speedCorrection ± steeringAdjustment, sent as bipolar PWM to the motor-driver board.

A three-state machine wraps the pipeline — initial (motors off, variables reset), run (PID line-following; exits when every sensor reads low, i.e. the all-black end zone), stop (motors halted). The on-board user button steps between states.

The control system was not originally parallel — see docs/control-system.md for the cascaded → parallel rework, the single change that most improved stability.

Repository layout

esp-buggy/
├── firmware/
│   └── main.cpp                The buggy's control firmware (Mbed / STM32F401RE)
├── docs/
│   ├── hardware.md             Board, pin map, custom PCB, chassis
│   ├── control-system.md       Weighted-average localisation + parallel PID
│   ├── sensor-subsystem.md     Why the TCRT5000 was chosen
│   ├── motor-characterisation.md   Motor constants + gearbox selection
│   └── img/                    Figures
└── hardware/
    ├── wiring-diagram.pdf
    ├── line-sensor-pcb/        KiCad 8 project + PDF / STEP exports
    └── chassis/                Laser-cut DXF

Documentation

Real-time timing budget

The steering loop has a hard deadline, derived from the worst case (buggy at top speed):

This is why the firmware is built entirely from tickers and interrupts and avoids blocking calls.

Tuning notes

• Ki is kept deliberately small. A larger integral term accumulates error over time and delays corrective action; on a curve that reverses direction sharply, that lag makes the buggy overshoot and lose the line.
• The array had a slight left bias. The buggy turned right a fraction late; increasing the left-hand sensor weights re-centred it.

What we would do differently

• Weight. The three-tier chassis was bolted together with metal nuts and bolts. Laser-cut plastic standoffs would have cut mass and improved the uphill and post-slope cornering times.
• Code bloat. Leftover debug printf statements burned MCU cycles and added latency to the control loop; they should have been compiled out for the race build.

Team

Group 31, EEEN21000 Embedded Systems Project, University of Manchester, 2024–25. Tutor: Emad Alsusa.

Charles Lin · Shuocheng Tian · Yefym Lunov · Zain Wilde · Yuncheng Zhang

Acknowledgements

• Arm Mbed OS — https://github.com/ARMmbed/mbed-os
• QEI (quadrature encoder library) — https://os.mbed.com/users/aberk/code/QEI/
• C12832 (on-board LCD library) — https://os.mbed.com/users/askksa12543/code/C12832/