SIMULATION ARCHITECTURE TELEMETRY DOCS

Vehicle Dynamics and Autonomous Driving

Explore the dynamic behavior of a '69 Ford Mustang (1500 kg) managed entirely by an autonomous driving system in a simulated environment. The chassis uses Ackermann geometry coupled with an innovative 4-Wheel Steering (4WS) system.

The control unit automatically adjusts the rear wheel steering between in-phase and counter-phase based on speed conditions established by the Velocity Planning system, maximizing maneuverability and ensuring absolute stability at high speeds.

DISCOVER THE SYSTEM REPORT

THE SIMULATION WILL BE LOADED SOON

Control Architecture & Analysis

1. Control Algorithms (PID)

Mustang's movement and steering are managed by applying forces calculated by full PID controllers, structured to dynamically handle position and speed:

  • Proportional (P): Ensures a fast reaction proportional to the detected error.
  • Integral (I): Eliminates steady-state error, counteracting constant resistances like ground friction.
  • Derivative (D): Dampens oscillations induced by vehicle inertia, optimizing stability.

2. Saturation & Anti-Windup

Since Godot physics and real motors have force limits, the system implements Saturation. To prevent instability due to error accumulation, we integrated an Anti-Windup logic: when the system enters saturation, the integrator action is suspended to avoid excessive overshoots when returning to the target.

3. Workflow

  1. Sensing: Reading current telemetry data from Godot's internal sensors.
  2. Processing: Error calculation (Desired Target - Actual measured value).
  3. Control: Generation of the correction signal (Force/Torque) from the PID regulator.
  4. Action: Application of force within the physics engine to correct the trajectory.
controllers.py (PID_Controller Extract) 
class PID_Controller:
    def compute(self, setpoint, measured, dt):
        error = setpoint - measured
        self.integral += error * dt
        derivative = (error - self.prev_error) / dt
        
        # Calcolo output PID
        out = (self.kp * error) + (self.ki * self.integral) + (self.kd * derivative)
        
        # Logica Anti-windup e Saturazione
        if abs(out) > self.max_out:
            out = math.copysign(self.max_out, out)
            self.integral -= error * dt  # Sospende l'integrale
            
        self.prev_error = error
        return out

Concept: Feedback Loop

Target
Error
PID
Control
Godot

PID Internal Structure

e(t)
Kp
Ki ∫ dt
Kd d/dt
Σ
u(t)

System Block Diagram

Control Algorithm (PID) + - + + + KP KI ∫ KD d/dt Physical System Speed Sensor v̄ error = v̄ - v F v p v

Telemetry Data Visualization

Grafici Telemetria

Comprehensive Analysis: Position Error, Velocity Planning, and 4WS Steering (In-Phase/Counter-Phase)