Devlog – Pure Pursuit Controller Improvements

One of the biggest improvements I made during this stage of the project was upgrading the Pure Pursuit controller. While the original implementation could follow the racing line, it wasn’t reliable enough once the car started driving faster. It would oversteer in corners, make unnecessary steering corrections, and sometimes struggle to recover after obstacle avoidance or localization drift.

The first thing I focused on was waypoint tracking. The previous controller would occasionally target waypoints that were too close or even behind the vehicle, causing unstable steering behavior. I improved the waypoint selection logic so the controller consistently looks farther ahead on the racing line, resulting in much smoother and more predictable steering.

I also refined how the controller handles corners. Instead of making aggressive steering inputs when approaching a turn, the updated controller transitions into corners much more naturally. This allows the car to maintain higher speeds while staying much closer to the ideal racing line.

Recovery was another major area of improvement. Previously, if the car drifted off the planned path because of localization error or obstacle avoidance, it could take several seconds to find the racing line again. I redesigned the path reacquisition logic so the controller intelligently finds the best point to merge back onto the path instead of simply driving toward the nearest waypoint. This made recovery significantly faster and reduced unnecessary crashes.

I spent a considerable amount of time tuning controller parameters, including lookahead behavior, steering gain, waypoint progression, and cornering performance. Most of this work involved iterative testing, making small adjustments, and analyzing the car’s behavior until it drove consistently across the entire track.

Results

After these improvements, the difference was immediately noticeable:

• Much smoother steering with fewer oscillations
• Cleaner cornering at higher speeds
• More accurate tracking of the racing line
• Faster recovery after localization drift or obstacle avoidance
• More stable autonomous driving overall
• Better foundation for future high-speed racing improvements

These Pure Pursuit upgrades made the car feel significantly more polished and reliable. With a much stronger path-following system in place, the project is now ready for future improvements such as adaptive lookahead, curvature-based speed control, and more advanced racing algorithms.

Autonomous Self-Driving RC Race Car

For my project, I spent 12 hours turning my RC car from something that constantly crashed into a fully autonomous racing platform. At the start, localization drifted, steering was unstable, obstacle avoidance made poor decisions, and the car could barely complete a lap. By the end, it could localize itself, follow an optimized racing line, slow down for corners, avoid obstacles, and drive around the map completely on its own.

Hardware

• NVIDIA Jetson Orin Nano
• ROS 2 Humble
• RPLidar C1
• Yahboom 10-Axis IMU
• VESC motor controller with wheel odometry
• Brushless RC platform

What I Built

I developed a complete autonomous driving stack that combines localization, path planning, obstacle avoidance, speed control, and vehicle control. Every system runs in real time on the Jetson Orin Nano.

Problems I Solved

Localization Drift: The car slowly lost track of where it was, causing missed turns and crashes. I rebuilt the localization system using AMCL, improved scan matching, and tuned the parameters until the pose stayed stable.

Localization Delay: The LiDAR alone couldn’t keep up at higher speeds, so the car reacted too late. I integrated IMU data and wheel odometry to predict motion between LiDAR scans, making localization much smoother.

Steering Instability: Small localization errors caused the steering to constantly twitch. I improved the Pure Pursuit controller with better lookahead calculations, steering smoothing, and waypoint selection so the car follows the track naturally.

Cornering: The car entered corners too fast and couldn’t recover if it started understeering. I added adaptive braking that slows the car before sharp turns and accelerates again on straights, making high-speed driving much more reliable.

Obstacle Avoidance: Originally the car drove straight into obstacles. I built a new occupancy grid based obstacle avoidance system that detects blocked paths, plans a safe route around obstacles, and smoothly reconnects to the original racing line. If no safe path exists, the car stops instead of crashing.

Wall Detection: The obstacle detector often thought nearby walls were obstacles. After improving the detection logic, the car could correctly distinguish walls from actual obstacles and stopped making unnecessary avoidance maneuvers.

Biggest Accomplishments

• Built a complete autonomous driving system from scratch
• Improved localization accuracy and stability
• Added IMU and wheel odometry for smoother pose estimation
• Reduced localization delay
• Stabilized TF transforms
• Improved Pure Pursuit path following
• Added adaptive speed control for corners
• Built intelligent obstacle avoidance
• Generated smoother racing lines
• Achieved reliable autonomous driving without human control

Results

At the beginning of the hackathon, the car struggled to drive across a room without hitting a wall. Twelve hours later, it could build and use maps, localize itself in real time, follow a racing line, slow down for corners, avoid obstacles, reconnect to its path, and complete laps completely autonomously.

This project showed me that autonomous driving is all about combining many smaller systems into one reliable solution. Every improvement to localization, planning, and control made the entire car perform better, and by the end I had built a solid foundation for a true self-driving RC race car.