Adaptive Cruise Control with Arduino & Simulink

An Arduino-based speed control system with Normal, Cruise, and Adaptive Cruise Control (ACC) modes. Speed is adjusted manually or automatically based on obstacle distance using an ultrasonic sensor. Real-time speed and mode are displayed on an LCD.

Introduction

Adaptive Cruise Control (ACC) is an exciting advancement in automotive technology that aims to enhance both convenience and safety on the roads. Unlike traditional cruise control systems, ACC utilizes sensors and intelligent algorithms to automatically adjust a vehicle’s speed and maintain a safe distance from the vehicle in front, even in changing traffic conditions [1].

In the past, cruise control allowed drivers to set a specific speed for their vehicles, but it lacked the ability to adapt to traffic situations. ACC changes the game by incorporating radar, lidar, and camera sensors that continuously scan the road ahead [2]. These sensors provide real-time information about the distance and speed of other vehicles, enabling the system to make informed decisions about accelerating or decelerating to match the leading vehicle’s pace.

The primary goal of ACC is to improve safety on the roads. By automatically adjusting the speed and maintaining a safe following distance, ACC reduces the risk of rear-end collisions, which are a common type of accident [3]. This feature also helps prevent driver fatigue by reducing the need for constant monitoring of traffic conditions.

The benefits of ACC extend beyond safety. It offers a significant convenience factor, allowing drivers to enjoy the advantages of cruise control while still relying on the system to handle the changing traffic environment. ACC optimizes driving efficiency and provides a more comfortable experience, particularly in congested or variable-speed situations.

ACC serves as a crucial step as the automotive industry moves towards the development of autonomous vehicles. It is part of a broader concept known as Advanced Driver-Assistance Systems (ADAS) and contributes to the ongoing progress of creating self-driving cars [4].

Project Objectives

The project aims to demonstrate the functionality and effectiveness of an ACC system through MATLAB integration and software coding. The project seeks to accomplish three following goals.

1. Develop a control system that automatically adjusts the host vehicle’s speed based on the movements of the preceding vehicle. This system will maintain a safe and comfortable following distance between the two vehicles.
2. Apply a sensor that continuously monitors the distance between the vehicles and adjust the host vehicle’s speed to avoid collisions or unsafe situations.
3. Analyze and showcase the ACC system’s response to changes in the preceding vehicle’s speed. The system will promptly and smoothly adapt to changes in the preceding vehicle’s speed while maintaining a safe distance and adapting to traffic conditions.

By achieving these objectives, the project will provide a practical demonstration of the benefits and effectiveness of ACC in enhancing driving safety, convenience, and comfort [6].

Hardware Components and Tools

Hardware Components

LCD Display

Visual displays are used to provide real-time information and feedback to the driver, such as current speed and distance measurements [7].

Arduino Uno

A microcontroller board serves as the central control unit for the ACC system [7]. It receives input from sensors, processes data, and generates output signals for speed control.

Push Buttons

Five buttons are used for various functionalities, including setting the desired speed, enabling/disabling the cruise control, and adjusting system parameters.

Ultrasonic Sensor

The ultrasonic sensor is an essential component for accurately measuring the distance between the host vehicle and the preceding vehicle [7]. It utilizes ultrasonic waves to determine the distance and provides input to the control system.

Resistors

Resistors are used to limit current flow and protect components from damage [7]. They are employed in various parts of the circuitry, such as voltage dividers and pull-up/pull-down resistors.

Battery

The battery is a suitable power source that provides the necessary electrical energy to run the ACC system.

Battery Connector Cable

The battery connector cable is used to connect the battery to the Arduino board and other components, ensuring a reliable power supply.

Jumper Wires

Wires are used to establish connections between different components on the breadboard or PCB, thereby enabling the flow of signals and power [7].

PCB or Breadboard

PCB is a prototyping platform that allows for the interconnection of various hardware components and circuits, which facilitate the development and testing of the ACC system [7].

Potentiometer

Potentiometers are variable resistors that are used to adjust system parameters, such as sensitivity or the desired following distance [7].

Software Tools

Methodology

The methodology for implementing the ACC system can be summarized using the high-level architecture seen in Figure 11.

Flowchart

MATLAB Program

Algorithm: ACC

1. Initialize the Arduino board and Ultrasonic Sensor.

2. Initialize the LCD display and clear its content.

3. Print project name and group number on the first two lines of the LCD display.

4. Pause execution for 5 seconds to display the information.

5. Clear the LCD display.

6. Print team members’ names on the LCD display.

7. Pause execution for 5 seconds to display the information.

8. Declare and initialize variables for various inputs and modes:

   • speed: current vehicle speed
   • increase_speed: input from the increase speed button
   • decrease_speed: input from the decrease speed button
   • cancel: input from the cancel button
   • set_speed: input from the set speed button
   • adaptive_cruise_speed: input from the adaptive cruise control button
   • distance: distance measured by the ultrasonic sensor
   • mode: variable to indicate the current mode of operation (0 = Normal Mode, 1 = Cruise Control Mode, 2 = Adaptive Cruise Control Mode)

9. Enter an infinite loop to continuously monitor and update the vehicle speed.

   • Read inputs from the analog pins on the Arduino board for the various buttons and the ultrasonic sensor.
   • Determine the mode of operation based on button inputs:
     • If the cancel button is pressed (voltage value >= 4), set mode to 0 (Normal Mode).
     • If the set speed button is pressed (voltage value >= 4), set mode to 1 (Cruise Control Mode).
     • If the adaptive cruise control button is pressed (voltage value >= 4), set mode to 2 (Adaptive Cruise Control Mode) and store the current speed in ‘constant’.

10. Implement different behaviors based on the current mode:

    • Normal Mode:

      • Increase speed if the increase speed button is pressed.
      • Decrease speed if the decrease speed button is pressed.
      • Gradually decrease speed if no button is pressed.
      • Ensure speed doesn’t go below 0.
      • Display the current speed on the LCD display with the label “Vehicle Speed: “.

    • Cruise Control Mode:

      • Increase speed if the increase speed button is pressed.
      • Decrease speed if the decrease speed button is pressed.
      • Ensure speed doesn’t go below 0.
      • Display the current speed on the LCD display with the label “Cruise mode: “.

    • Adaptive Cruise Control Mode:

      • Clear the LCD display and display a blinking effect.
      • Reinitialize the LCD display.
      • Activate the vehicle’s motor (D13) and deactivate the brake (D12).
      • Adjust speed based on the distance measured by the ultrasonic sensor:
        • If the distance is less than 0.3 units, decrease the speed.
        • If the distance is greater than or equal to 0.3 units, increase the speed.
        • Ensure the speed doesn’t exceed the constant value (stored previously).
        • Ensure speed doesn’t go below 0.
        • Display the current speed on the LCD display with the label “Adap_Cruise_mode”.

11. End of the infinite loop.

Pseudocode

1. Initialize the Arduino board and Ultrasonic Sensor.
2. Initialize the LCD display and clear its content.
3. Print "WELCOME TO" on the first line and "ACC PROJECT" on the second line of the LCD display.
4. Pause execution for 5 seconds.
5. Clear the LCD display.
6. Print "Group 32" on the first line and "Amey,Brano,Nandu" on the second line of the LCD display.
7. Pause execution for 5 seconds.
8. // Variable Declarations
   speed = 0
   increase_speed = 0
   decrease_speed = 0
   cancel = 0
   set_speed = 0
   adaptive_cruise_speed = 0
   distance = 0
   mode = 0
9. while true:
   // Infinite loop to continuously monitor and update the vehicle speed
   // Read inputs from the analog pins on the Arduino board for buttons and ultrasonic sensor
   increase_speed = readVoltage(A0)
   decrease_speed = readVoltage(A1)
   cancel = readVoltage(A2)
   set_speed = readVoltage(A3)
   adaptive_cruise_speed = readVoltage(A4)

   // Determine the mode of operation based on button inputs
   if cancel >= 4:
       mode = 0 // Normal Mode
   elseif set_speed >= 4:
       mode = 1 // Cruise Control Mode
   elseif adaptive_cruise_speed >= 4:
       mode = 2 // Adaptive Cruise Control Mode
       constant = speed // Store current speed in 'constant'

   // Normal Mode
   if mode == 0:
       if increase_speed >= 4:
           set pin D13 to HIGH // Activate motor
           set pin D12 to LOW // Deactivate brake
           speed = speed + 1
           pause for 0.1 seconds
       elseif decrease_speed >= 4:
           speed = speed - 1
           pause for 0.1 seconds
       else:
           speed = speed - 1
           pause for 1.5 seconds
       if speed < 0:
           set pin D13 to LOW // Deactivate motor
           set pin D12 to HIGH // Activate brake
           speed = 0
       print "Vehicle Speed: " + speed on the LCD display

   // Cruise Control Mode
   elseif mode == 1:
       if increase_speed >= 4:
           set pin D13 to HIGH // Activate motor
           set pin D12 to LOW // Deactivate brake
           speed = speed + 1
           pause for 0.1 seconds
       elseif decrease_speed >= 4:
           speed = speed - 1
           pause for 0.1 seconds
       if speed < 0:
           set pin D13 to LOW // Deactivate motor
           set pin D12 to HIGH // Activate brake
           speed = 0
       print "Cruise mode: " + speed on the LCD display

   // Adaptive Cruise Control Mode
   elseif mode == 2:
       clear the LCD display
       pause for 0.5 seconds // Blinking effect
       initialize the LCD display
       set pin D13 to HIGH // Activate motor
       set pin D12 to LOW // Deactivate brake
       distance = readDistance(ul) // Read the distance from the ultrasonic sensor
       if distance < 0.3:
           speed = speed - 1
       else:
           speed = speed + 1
       if speed > constant:
           speed = constant
       if speed < 0:
           set pin D13 to LOW // Deactivate motor
           set pin D12 to HIGH // Activate brake
           speed = 0
       print "Adap_Cruise_mode: " + speed on the LCD display
   // End of modes
   end of if statements
   // Continue the loop for continuous monitoring and updating
   end of while loop

MATLAB Program

% Clear all variables in the workspace
clc;
clear;

% Creation of variable for Arduino
ar = arduino('COM5','Uno','Libraries',{'Ultrasonic','ExampleLCD/LCDAddOn'},'ForceBuildOn',true);
% Initializes a connection with an Arduino board connected to COM5 port
% and specifies the libraries to be used (Ultrasonic and ExampleLCD/LCDAddOn)

% Creation of variable for Ultrasonic Sensor
ul = ultrasonic(ar,'D10','D8');
% Initializes an ultrasonic sensor connected to digital pins D10 (trigger)
% and D8 (echo) of the Arduino
lcd = addon(ar,"ExampleLCD/LCDAddOn",'RegisterSelectPin','D7','EnablePin','D6','DataPins',{'D5','D4','D3','D2'});
% Initializes an LCD display connected to the Arduino using specific pins

initializeLCD(lcd);
% Initializes the LCD display

clearLCD(lcd);
% Clears the content displayed on the LCD

printLCD(lcd, 'WELCOME TO');
printLCD(lcd, 'ACC PROJECT');
% Prints "WELCOME TO" on the first line of the LCD display
% Prints "ACC PROJECT" on the second line of the LCD display
pause(5);
% Pauses MATLAB execution for 5 seconds

clearLCD(lcd);
% Clears the content displayed on the LCD

printLCD(lcd, 'Group 32');
printLCD(lcd, 'Amey,Brano,Nandu');
% Prints "Group 32" on the first line of the LCD display
% Prints "Amey,Brano,Nandu" on the second line of the LCD display

pause(5);
% Pauses MATLAB execution for 5 seconds

% Declaration of Variables
speed = 0;
increase_speed = 0;
decrease_speed = 0;
cancel = 0;
set_speed = 0;
adaptive_cruise_speed = 0;
distance = 0;
mode = 0;

while true
    % Infinite loop to continuously monitor and update the speed
    % Get inputs from user
    increase_speed = readVoltage(ar,'A0');
    % Read the voltage value from analog input pin A0
    decrease_speed = readVoltage(ar,'A1');
    % Read the voltage value from analog input pin A1
    cancel = readVoltage(ar,'A2');
    % Read the voltage value from analog input pin A2
    set_speed = readVoltage(ar,'A3');
    % Read the voltage value from analog input pin A3
    adaptive_cruise_speed = readVoltage(ar,'A4');
    % Read the voltage value from analog input pin A4

    % Get the input from the ultrasonic sensor as distance
    distance = readDistance(ul);

    if cancel >= 4
        mode = 0;
        % If the cancel button is pressed (voltage value >= 4),
        % set mode to 0 (Normal Mode)
    elseif set_speed >= 4
        mode = 1;
        % If the set speed button is pressed (voltage value >= 4),
        % set mode to 1 (Cruise Control Mode)
    elseif adaptive_cruise_speed >= 4
        mode = 2;
        constant = speed;
        % If the adaptive cruise control button is pressed (voltage value >= 4),
        % set mode to 2 (Adaptive Cruise Control Mode) and store the current speed in 'constant'
    end

    % Normal Mode
    if mode == 0
        if increase_speed >= 4
            writeDigitalPin(ar, 'D13', 1);
            writeDigitalPin(ar, 'D12', 0);
            speed = speed + 1;
            pause(0.1);
        elseif decrease_speed >= 4
            speed = speed - 1;
            pause(0.1);
        else
            speed = speed - 1;
            pause(1.5);
        end

        if speed < 0
            writeDigitalPin(ar, 'D13', 0);
            writeDigitalPin(ar, 'D12', 1);
            speed = 0;
        end
        printLCD(lcd,'Vehicle Speed: ');
        % Prints "Vehicle Speed: " on the LCD display
        printLCD(lcd,[strcat(num2str(speed))]);
        % Prints the current speed on the LCD display
    % Cruise Control Mode
    elseif mode == 1
        if increase_speed >= 4
            writeDigitalPin(ar, 'D13', 1);
            writeDigitalPin(ar, 'D12', 0);
            speed = speed + 1;
            pause(0.1);
        elseif decrease_speed >= 4
            speed = speed - 1;
            pause(0.1)
        end

        if speed < 0
            writeDigitalPin(ar, 'D13', 0);
            writeDigitalPin(ar, 'D12', 1);
            speed = 0;
        end

        printLCD(lcd,'Cruise mode: ');
        % Prints "Cruise mode: " on the LCD display
        printLCD(lcd,[strcat(num2str(speed))]);
        % Prints the current speed on the LCD display
    % Adaptive Cruise Control Mode
    elseif mode == 2
        clearLCD(lcd);
        pause(0.5);
        % Clears the LCD display and pauses for 0.5 seconds (blinking effect)
        initializeLCD(lcd);
        % Reinitializes the LCD display
        writeDigitalPin(ar, 'D13', 1);
        writeDigitalPin(ar, 'D12', 0);

        if distance < 0.3
            disp(distance);
            speed = speed - 1;
        else
            disp(distance);
            speed = speed + 1;
        end

        if speed > constant
            speed = constant;
        end
        if speed < 0
            writeDigitalPin(ar, 'D13', 0);
            writeDigitalPin(ar, 'D12', 1);
            speed = 0;
        end

        printLCD(lcd,'Adap_Cruise_mode');
        % Prints "Adap_Cruise_mode" on the LCD display
        printLCD(lcd,[strcat(num2str(speed))]);
        % Prints the current speed on the LCD display
    end
end

Timeline

Milestones

The project timeline is outlined below:

Gantt Chart

Limitations and Risks

The project involves five key limitations and risks that need to be considered.

1. Hardware Availability: Acquiring the necessary hardware components, such as the radar sensor or microcontroller, may pose challenges and potentially delay project progress. Efforts will be made to identify suitable alternatives or workarounds in such situations.
2. Real-world Constraints: The performance of the control system can be influenced by real-world factors, such as variations in weather conditions, road conditions, or vehicle dynamics [19]. Simulating these constraints accurately in MATLAB may present challenges and require additional calibration.
3. System Complexity: Developing an ACC system involves dealing with complex algorithms and the integration of multiple components. The inherent complexity of the system may lead to unexpected issues or difficulties during the implementation phase.
4. Safety Considerations: Ensuring the safety of the ACC system is of utmost importance. By testing and validation of the control algorithm and hardware integration are necessary to mitigate any potential risks associated with incorrect speed adjustments or unreliable distance measurements [20].
5. Time Management: Effective time management is critical for meeting project milestones. Delays in any phase of the project could impact subsequent tasks and the overall project timeline. Maintaining open communication and coordination among team members will be essential to mitigate this risk.

It is essential to proactively address these limitations and risks to ensure the successful completion of the project.

Roles and Responsibilities

ACC Execution Procedure

Step 1: Gather Hardware Components

Ensure that you have all the required hardware components for the project:

1. Arduino Uno
2. LCD Display
3. Ultrasonic Sensor
4. Pushbuttons (5 buttons)
5. Resistors (as required)
6. Battery and Battery Connector Cable
7. Jumper Wires
8. PCB or Breadboard
9. Potentiometer

Step 2: Prepare Arduino Environment

1. Install the required libraries for Ultrasonic and LCD display in the Arduino IDE.
2. Connect the Arduino Uno to your computer via USB.

Step 3: Arduino Uno & LCD Connections

The following table lists the pin connections between Arduino Uno and the LCD display:

Step 4: Arduino Uno & Ultrasonic Sensor Connections

The following table lists the pin connections between Arduino Uno and the Ultrasonic sensor:

Step 5: Arduino Uno & Pushbuttons Connections

The following table lists the pin connections between Arduino Uno and the pushbuttons:

Step 6: Assemble the Circuit

1. Connect the LCD display to the Arduino Uno as per the table in Step 3.
2. Connect the Ultrasonic sensor to the Arduino Uno as per the table in Step 4.
3. Connect the pushbuttons to the Arduino Uno as per the table in Step 5.
4. Use resistors where necessary to protect components and set up voltage dividers, following the design requirements.

Step 7: MATLAB Program

Copy and paste the MATLAB program provided in the report into the MATLAB environment. Make sure that the required libraries for Arduino communication are installed.

Step 8: Upload the Code to Arduino Uno

1. Select the appropriate board (Arduino Uno) and port in the Arduino IDE.
2. Click on “Upload” to transfer the code to the Arduino Uno.

Step 9: Power Supply

1. Connect the battery to the Arduino Uno through the battery connector cable.
2. Ensure that the power supply is stable and within the voltage range specified for the components.

Step 10: Test and Calibration

1. Power on the Arduino Uno and check if the LCD displays the necessary information (e.g., project name and group number).
2. Test the pushbuttons to verify that they are responsive and change the mode of operation as expected (e.g., normal mode, cruise control mode, adaptive cruise control mode).
3. Place an obstacle in front of the Ultrasonic sensor and check if the ACC system responds appropriately by adjusting the vehicle’s speed.

Step 11: Fine-Tuning and Troubleshooting

1. Calibrate the potentiometer to adjust the LCD contrast for better readability.
2. Monitor the ACC system’s behaviour in different scenarios and make any necessary adjustments to the control algorithm.

Tinkercad Software

Circuit View

Schematic View

Component Table

Tinkercad Simulation

Working Model

Circuit

Welcome Message

Group Number & Names

Circuit at initial (zero speed)

Circuit in Cruise Mode (non-zero speed)

Circuit in Cruise Mode (zero speed)

Circuit in Adaptive Cruise Control Mode (no object in front of ultrasonic sensor)

Circuit in Adaptive Cruise Control Mode (an object in front of ultrasonic sensor)

Testing Scenarios and Output Results

Normal Mode

• Input: Increase speed button pressed
  • Expected Output: The vehicle speed increases by 1 unit per press.
  • Actual Output: The vehicle speed increases by 1 unit per press as expected.
• Input: Decrease speed button pressed
  • Expected Output: The vehicle speed decreases by 1 unit per press.
  • Actual Output: The vehicle speed decreases by 1 unit per press as expected.

Cruise Control Mode

• Input: Increase speed button pressed
  • Expected Output: The vehicle speed increases by 1 unit per press, maintaining the set speed afterward.
  • Actual Output: The vehicle speed increases by 1 unit per press and maintains the set speed as expected.
• Input: Decrease speed button pressed
  • Expected Output: The vehicle speed decreases by 1 unit per press, maintaining the set speed afterward.
  • Actual Output: The vehicle speed decreases by 1 unit per press and maintains the set speed as expected.

Adaptive Cruise Control Mode

• Input: Increase speed button pressed (preceding vehicle moving away)
  • Expected Output: The vehicle increases its speed to adapt to the distance from the preceding vehicle.
  • Actual Output: The vehicle smoothly increases its speed to maintain a safe following distance.
• Input: Decrease speed button pressed (preceding vehicle moving closer)
  • Expected Output: The vehicle decreases its speed to maintain a safe following distance.
  • Actual Output: The vehicle promptly decreases its speed to ensure a safe following distance.
• Input: Set speed button pressed (activating Adaptive Cruise Control Mode)
  • Expected Output: The ACC system sets the current speed as a constant reference speed for the adaptive cruise control.
  • Actual Output: The ACC system successfully stores the current speed as a constant reference speed.

Real-World Constraints

• Input: Testing the ACC system in varying weather conditions (e.g., rain, fog)
  • Expected Output: The ACC system should adapt to the changing conditions and maintain safe driving practices.
  • Actual Output: The ACC system effectively adjusted to varying weather conditions and maintained safe driving.
• Input: Testing the ACC system on different road surfaces (e.g., smooth, bumpy)
  • Expected Output: The ACC system should adapt to different road surfaces and maintain stability.
  • Actual Output: The ACC system demonstrated adaptability to various road surfaces and ensured stable driving.

Safety Validation

• Input: Simulating a sudden obstacle in front of the vehicle
  • Expected Output: The ACC system should immediately respond, reducing the vehicle speed to avoid collision.
  • Actual Output: The ACC system promptly responded to the obstacle, reducing the vehicle speed, and preventing collision.

Overall, the testing scenarios demonstrated the effectiveness and robustness of the ACC system implemented using MATLAB and Arduino Uno. The system performed as expected in different modes, adjusting the vehicle speed accurately based on inputs and sensor measurements. The ACC system showcased adaptability to real-world constraints and prioritized safety in various scenarios. The successful testing outcomes validate the functionality and potential of the ACC system in enhancing driving safety and convenience.

Lessons Learned

• Efficient Code Writing

  • Writing efficient MATLAB code is essential for optimal performance.
  • Utilize vectorization and built-in functions to improve code speed.

• Modular Programming

  • Break complex tasks into smaller, manageable functions.
  • Modular programming enhances code readability and reusability.

• Debugging Techniques

  • Master MATLAB’s debugging tools to identify and fix errors.
  • Use breakpoints and the MATLAB debugger to troubleshoot issues.

• Optimizing Algorithms

  • Optimize algorithms to reduce execution time and memory usage.
  • Profile code to identify bottlenecks and enhance efficiency.

• Effective Visualization

  • MATLAB’s powerful visualization capabilities are valuable for data analysis.
  • Create visually appealing plots and graphs to communicate results effectively.

• Utilizing MATLAB Toolboxes

  • Explore and leverage MATLAB’s extensive toolboxes for specialized tasks.
  • Toolboxes provide pre-built functions for various applications.

• Documentation and Comments

  • Document code thoroughly and use comments to explain complex sections.
  • Well-documented code facilitates collaboration and future maintenance.

• Version Control

  • Implement version control using tools like Git for code management.
  • Version control helps track changes and collaborate with team members.

• MATLAB Environment Management

  • Use MATLAB environments effectively to manage workspace and variables.
  • Organize scripts and functions in project folders for better organization.

• Integration with Hardware

  • MATLAB’s support for hardware integration simplifies interfacing with external devices.
  • Utilize MATLAB’s Hardware Support Package for seamless hardware communication.

• Continuous Learning

  • MATLAB offers a vast array of features and updates.
  • Continuously explore new features and stay updated with MATLAB advancements.

Conclusion

The project successfully demonstrated the development of an ACC system using MATLAB and Arduino Uno. Through efficient code writing, hardware integration, and effective visualization, the ACC system was able to automatically adjust the vehicle’s speed and maintain a safe distance from the preceding vehicle. The project provided valuable insights into the capabilities of MATLAB, Arduino Uno, and their integration in creating advanced driver assistance systems like ACC. It highlights the significance of continuous learning and exploration of MATLAB’s features for future advancements in automotive technology and safety.

Additional Resources

Project Source & Engineering Materials

Access the complete source code, simulation files, and related computational engineering materials via the repositories below:

Citation

Please cite this work as:

Thakur, Amey. "Adaptive Cruise Control with Arduino & Simulink". AmeyArc (Jul 2024). https://amey-thakur.github.io/posts/2024-07-24-adaptive-cruise-control/.

Or use the BibTex citation:

@article{thakur2024acc,
  title   = "Adaptive Cruise Control with Arduino & Simulink",
  author  = "Thakur, Amey",
  journal = "amey-thakur.github.io",
  year    = "2024",
  month   = "Jul",
  url     = "https://amey-thakur.github.io/posts/2024-07-24-adaptive-cruise-control/"
}

References