LiDAR-Based Autonomous Driving

Overview

The main purpose of this university project, documented in its technical report, was to reproduce the organization and scheduling concerns of a real-time application through multiple prioritized periodic tasks. The software ran on a standard, non-real-time Linux system, so it did not claim hard real-time guarantees. Instead, explicit task priorities, periods, relative deadlines, absolute-time activation, shared-resource protocols, and deadline-miss counters made scheduling behaviour observable while the autonomous-driving simulation supplied a realistic concurrent workload.

A defining constraint was that the complete application—including the reinforcement-learning algorithm—was implemented directly in pure C. The Q-learning and Q-velocity matrices, epsilon-greedy policy, reward calculation, state encoding, task utilities, timing functions, vehicle model, collision logic, telemetry, and persistence were all written from scratch without an external AI, robotics, numerical, or vehicle-dynamics library. Apart from the standard C and POSIX system facilities, Allegro was the only external dependency, and its role was limited to window management, bitmap access, and rendering.

Environmental perception uses a deliberately compact LiDAR model. One forward ray and two rays angled at ±45° measure the distance to the track boundary, up to 100 m, by scanning pixel colours in the rendered map. The lateral difference and forward range are quantized into seven levels each, reducing three raw measurements to 49 discrete states. Collision detection follows a similar graphical approach by testing the edges of the car footprint against the black boundary pixels.

An epsilon-greedy Q-learning agent maps those states to driving actions. In steering-only mode, speed remains fixed and the policy chooses one of 17 steering angles from −40° to +40°. In the more ambitious steering-and-acceleration mode, a second quality matrix learns longitudinal commands alongside steering. The reward combines a strong crash penalty with smaller terms for survival time, distance covered, steering smoothness, valid acceleration, and proximity to the track centre. Learned matrices can be saved, loaded, and reused in inference mode.

The simulated car follows the rear-axle kinematic bicycle model shown in the report. Its reference point lies at the rear axle; L is the axle distance, v is longitudinal speed, θ is vehicle heading, and δ is the commanded front-wheel steering angle. The instantaneous turning radius is R = L / tan(δ), producing the implemented yaw rate θ̇ = v tan(δ) / L.

The bicycle representation collapses each physical axle into one equivalent wheel at its centre. The rear blue wheel remains aligned with the vehicle body and is the position reference. The front blue wheel is rotated by the steering command δ. Both wheels are mathematical abstractions: together they replace the four contact patches while preserving the geometry needed to calculate curvature and heading change.

Every 20 ms, the old velocity advances x, y, and heading; acceleration then produces the velocity for the next step. The C implementation uses ẋ = v cos(θ), ẏ = v sin(θ), and θ̇ = v tan(δ) / L. Speed is clamped between zero and the configured maximum, reverse motion is disabled to simplify learning, and heading is wrapped into [0, 2π). This deterministic model couples steering, speed, pose, LiDAR measurements, and the next reinforcement-learning state.

Around the model, the multi-task configuration separates rendering, keyboard commands, LiDAR updates, and agent/model updates into periodic pthread tasks. The implementation requests explicit SCHED_RR priorities: commands run at priority 40, sensing and agent updates at priority 10, and rendering at priority 5. Shared vehicle, sensor, velocity, and Q-learning data are guarded by mutexes configured with priority inheritance. A single-task mode combines the loop for faster debugging and training, while multi-task mode exposes scheduling interactions and deadline misses directly in the interface.

The report records the strongest results in steering-only mode: useful behaviour emerged after roughly 8,000 episodes, with training at 5 m/s and successful tests up to approximately 15 m/s. Joint steering and acceleration learning did not converge as completely; pre-training steering before enabling acceleration improved it, but also highlighted the limits of the tabular state representation and reward design. That contrast was an important result of the project, showing both where a compact Q-learning controller works and where the problem needs a richer state or learning strategy.