Development of a Vehicle Platooning System with lateral planning capabilities. The follower vehicle autonomously adapts its lateral reference to mimic the leader's maneuvers while ensuring safety constraints, powered by Adaptive LQR. Built on SCANeR Studio and MATLAB/Simulink.
Fig 1. Simulation of cooperative lateral maneuver in vehicle platooning. |
Fig 2. Illustration of truck platooning. Source: rapp.ch |
Fig 3. NAHSC platoon demo (San Diego, 1997). Source: tech-faq.com |
This project was developed and validated using the SCANeR Studio co-simulation middleware.
Since the simulation environment is proprietary, the .slx files provided here (if still present) are for algorithmic review and architectural demonstration. They cannot be executed without the specific SCANeR Studio licenses and interfaces.
This project implements a collaborative Vehicle Platooning system focusing on autonomous lateral planning and control. The goal here is to dynamically adapt the lateral reference to track a Leader Vehicle and execute cooperative overtaking maneuvers. The control strategy relies on the robust Adaptive Linear Quadratic Regulator (LQR) developed in my previous work, applied to a dynamic bicycle model.
The system was validated on a dynamic driving simulator to assess performance and realism. The setup includes:
- Immersive Display: A triple-screen configuration for a wide field of view.
- Motion Platform: A dynamic seat actuated by cylinders to simulate longitudinal forces (acceleration/braking) and physical feedback.
- Physical hardware setup : real steering wheel, pedals, and gearbox.
In the SCANeR Studio simulation environment, the road geometry is standardized with the central median at 0. From there, we map the exact coordinates of the two usable lanes:
- Left Lane: Ends at
-1.25/-4.25(Center: -2.5) - Right Lane: Ends at
-4.25/-7.25(Center: -6.0)
Why does this positioning matter?
You might be wondering why I map the lanes so precisely instead of just recording the leader's trajectory. That is a great question, and the answer lies in stability.
My goal was to adapt the Lateral Control system I previously developed to handle platooning. However, simply mimicking the leader's exact path is risky. If the leader swerves slightly to avoid a pothole or a rabbit, we don't want the follower to blindly copy that erratic movement.
The Solution: "Snap-to-Lane" Logic
Instead of following the leader's exact coordinates, the system acts smarter:
- It detects the leader's position at every sampling step.
- It determines which lane the leader is currently in.
- It forces the follower's lateral setpoint to the center of that specific lane (either
-2.5or-6.0).
This ensures the follower stays perfectly centered, even if the leader drives a bit off-center.
The figure below illustrates the actual Simulink implementation of this logic:
Fig 4. Simulink implementation of the lane decision logic.
The Problem: Abrupt Dynamics
During the initial testing phase, I noticed that feeding the raw decision output (a sudden step signal) directly to the controller was problematic. The command was too brutal: the vehicle tried to "jump" instantly from one lane center to the other, causing significant oscillations and jerky steering behavior.
The Solution: Rate Limiter
To solve this, I integrated a Rate Limiter block to filter the signal.
Fig 5. Simulink implementation: Integration of the Rate Limiter block.
- How it works: It acts similarly to a 2nd-order discrete filter, transforming the sharp "step" command into a progressive "ramp."
- The Result: This simple addition ensures the lateral trajectory is smooth and realistic, guaranteeing passenger comfort and keeping the vehicle stable during maneuvers.
To validate this approach, I simulated a stress test where a virtual leader (calculated in code but invisible in the rendering) switches lanes every 4 seconds. The video below demonstrates the stabilizing effect of the Rate Limiter: the follower executes seamless transitions without any overshoot or oscillation.
BMW.mov |
Fig 6. Evolution of vehicle lateral position relative to the input.
At this stage, you might think the job is done. But in reality, we have to deal with some annoying (and dangerous) scenarios.
For example:
- The "Cut-in" Risk: The leader (V1) moves to the left lane and barely squeezes in. However, a fast car is approaching from behind, making it impossible for the follower (V2) to join safely.
- The "Blocked Merge" Risk: The leader (V1) merges back to the right after overtaking, but another vehicle is right next to the follower, blocking the merge.
To handle these situations, I leveraged SCANeR Studio’s data (positions and speeds of surrounding traffic) to build a Safety Check Algorithm. The follower is only allowed to change lanes if the specific lane is free and safe, regardless of what the leader does.
(See the logic diagram below)