Project 2 Adaptive Cruise Control
Main Project – Adaptive Cruise Control (ACC)
General Overview:
Adaptive Cruise Control Feature for passenger cars allows the host vehicle to adapt to the speed in line with the flow of traffic. Driving in heavy traffic or keeping a safe distance to the preceding vehicle calls for a high level of concentration. The Adaptive Cruise Control feature can reduce the stress on the driver by automatically controlling the vehicle speed & maintaining a predefined minimum distance to the preceding vehicle. As a consequence, the driver enjoys more comfort & can concentrate on the road little better.
A radar sensor is usually at the core of the Adaptive Cruise Control. Installed at the front of the vehicle, the system permanently monitors the road ahead. As long as the road ahead is clear, the cruise control feature maintains the speed set by the driver. If the system spots a slower vehicle within its detection range, it gently reduces speed by releasing the accelerator or actively engaging the brake control system. If the vehicle ahead speeds up or changes lanes, the cruise control automatically accelerates to the driver’s desired speed.
Standard Adaptive Cruise Control can be activated from speeds of around 30 km/h (20 mph) upwards and supports the driver, primarily on cross-country journeys or on freeways. The cruise control stops & go variant is also active at speeds below 30 km/h (20 mph). It can maintain the set distance to the preceding vehicle even at very low speeds and can decelerate to a complete standstill. When the vehicle remains stopped longer, the driver needs only to reactivate the system, for example by briefly stepping on the gas pedal to return to cruise control mode. In this way, cruise control stops & go supports the driver even in heavy traffic and traffic jams.
Since Adaptive Cruise Control is a comfort and convenience system, brake interventions and vehicle acceleration only take place within defined limits. Even with Adaptive Cruise Control switched on, it remains the driver’s responsibility to monitor the speed and distance from the vehicle in front.
Objective:
- Developing Adaptive Cruise Control feature as per the Requirement Document using MATLAB Simulink.
- Follow all the MBD-related processes: Requirement Tagging & Traceability, SLDD creation, Configuration Parameter changes, Model Advisor check & Code Generation.
- In Configuration Parameters: enable “Support Floating Numbers” under Code Generation settings.
- Use Embedded Coder to generate the code.
- If choosing code generation, Storage class for Input signals: ImportedExtern; Storage class for Output signal: Export to File; Storage class for local signals: localizable; Storage class for calibration signals: Const.
- Choose sample time for all signals as 0.01s
Data Dictionary for Model:
The data dictionary for the Adaptive Cruise Control model is created by using the above-given data.
|
Signal / Calibration Name |
Signal Type |
Data Type |
Dimension |
Min |
Max |
Initial Value |
Units |
|
CameraInput_LeadVehicle |
Input |
Uint8 |
1 |
0 |
255 |
- |
- |
|
RadarInput_LeadVehicle |
Input |
Uint8 |
1 |
0 |
255 |
- |
- |
|
CameraInput_DriveVehicle |
Input |
Uint8 |
1 |
0 |
255 |
- |
- |
|
RadarInput_DriveVehicle |
Input |
Uint8 |
1 |
0 |
255 |
- |
- |
|
Time_Gap |
Input |
Uint8 |
1 |
0 |
255 |
- |
- |
|
Set_Speed |
Input |
Uint8 |
1 |
0 |
255 |
- |
- |
|
Set_Gap |
Input |
Uint8 |
1 |
0 |
255 |
- |
- |
|
CruiseSwitch |
Input |
Boolean |
1 |
0 |
1 |
- |
- |
|
SetSwitch |
Input |
Boolean |
1 |
0 |
1 |
- |
- |
|
Acceleration_Mode |
Output |
Uint8 |
1 |
0 |
255 |
- |
- |
|
LeadVehicle_Speed |
Output |
Uint8 |
1 |
0 |
255 |
- |
- |
|
DriveVehicle_Speed |
Output |
Uint8 |
1 |
0 |
255 |
- |
- |
|
LeadVehicle_Detected |
Output |
Uint8 |
1 |
0 |
255 |
- |
- |
The below-given data dictionary is created to simulate the model. The steps to create the data dictionary is to click on the modeling tab and expand the design section, in the design section we can see the 'link to data dictionary' tab click on it. Once we click on to link to the data dictionary, it asks us to use the existing data file or create a new file for the data. We need to create a new data file here, so click on new to create an SLDD file. Once the SLDD file is created it links to the data dictionary. In that file, we can save the data. Below-mentioned steps will help us to create a data dictionary for the Simulink model.
In the data dictionary, in the design data section, we can create the data variables. If the data is input or output we need to consider that parameter as a signal, if we use the data used in constant blocks we need to consider that parameter as a constant signal.
Solver and Code generation Target File:
The code generation target file and solver setting must satisfy the MAB guidelines, if the solver settings don't satisfy the MAB guidelines we can get an error or a warning during or after the simulation process.
The solver must be a 'Fixed-step' with discrete (no continuous states). In solver settings, we need to change the stop time and sample time default conditions to the required conditions. The simulation start time 'is 0' seconds, the stop time is '10' seconds, and the sample time is '0.01' seconds ( this means the model will get an update for every 0.01 seconds).
We need to change the default code generation settings 'grt.tlc : generic real-time target' to 'ert.tlc : Embedded coder'. Now the code will be generated in C language. The code generation target file and solver settings are given-below.
Model Building:
The models is created by using the above-given requirements. Initially the entire model is in a subsystem, inside the subsystem the logic is implemented by using the subsystems. The main subsystem 'Adaptive_Cruise_Control' is given below,
The Adaptive_Cruise_Control will be inputted with nine different parameters, those inputs are defined in the data dictionary in the model explorer. We have 3 more subsystems inside the Adaptive_Cruise_Control model, those three subsystems are 'Lead_Vehicle', 'Drive_Vehicle', and ACC_Logic'. These three subsystems are created by using the above-mentioned requirement-1, requirement-2, and requirement-3. In requirement-3, we have three sub-requirements 3a,3b, and 3c, in 3c we have six sub-requirements again.
Requirement 1– Lead Vehicle:
- Lead Vehicle is a vehicle which is driving in the road ahead of our drive vehicle. Two input signals (Signal Name: CameraInput_LeadVehicle & RadarInput_LeadVehicle).
- Ideally sensor fusion techniques will be deployed to process & analyze data from camera & radar. For complexity reasons, let’s not adapt to any such algorithms.
- We can simply add both the radar & camera inputs & the corresponding output is read as Speed profile output (Signal Name: LeadVehicle_Speed).
- Speed data of the lead vehicle is critical in implementing the Adaptive Cruise Control algorithm.
The 'CameraInput_LeadVehicle' and 'RadarInput_leadVehicle' are the inputs for the Lead_Vehicle model, these two inputs are connected to add the block to get the 'LeadVehicle_Speed' as an output. The LeadVehicle_Speed is the required output from the subsystem.
Requirement 2 – Drive Vehicle:
- Drive Vehicle is the vehicle driven by the user & this is the vehicle which has ACC algorithm in it.
- Like the Lead Vehicle, Drive Vehicle algorithm also has 2 input signals (Signal Name: CameraInput_DriveVehicle, RadarInput_DriveVehicle) & one signal coming as an Input to this subsystem (Signal Name: Acceleration_Mode) – three inputs into this requirement in total.
- Like the above requirement, sensor fusion techniques will also be deployed here, for complexity reasons we are ignoring them.
- Two output signals come from this subsystem (Signal Name: DriveVehicle_Speed & LeadVehicle_Detected).
- Signal DriveVehicle_Speed is summation of three input signals mentioned above & LeadVehicle_Detected is renamed from Input Signal RadarInput_DriveVehicle by mere use of Signal Conversion block.
The 'CameraInput_DriveVehicle', 'Acceleration_Mode', and 'RadarInput_DriveVehicle' are the inputs for this Drive_Vehicle model, these inputs are connected to add the block to get the 'DriveVehicle_Speed' as output. The signal conversion block is connected to the third input of the subsystem 'RadarInput_DriveVehicel' to get the 'LeadVehicle_Detected' as another output from this subsystem.
Requirement 3 – ACC_Algorithm:
- Adaptive Cruise Control feature has 3 major modes of operation: OFF Mode, STANDBY Mode & ON Mode. This particular requirement has to be implemented as state machine logic in Simulink.
- The input signals to this state machine system are (Signal Name: Time_Gap, Set_Speed, Set_Gap, CruiseSwitch, SetSwitch).
- Also, the output signals (Signal Name: DriveVehicle_Speed & LeadVehicle_Detected) from requirement-2 is fed back as an input signal into this state machine block.
- Additionally, output signal (Signal Name: LeadVehicle_Speed) from requirement-1 is given as an input signal to this state machine block as well.
- Output from this subsystem is a signal (Signal Name: Acceleration_Mode) which governs the vehicular speed of the drive vehicle which automatically adjusts its speed & velocity to match the lead vehicle.
The "CruiseSwitch, Time_Gap, Set_Speed, Set_Gap, SetSwitch" are the inputs for this ACC_Algorithm model, along with these five inputs this model has another 3 inputs from the outputs of 'Lead_Vehicle' and 'Drive_Vehicle', totally this ACC_Algorithm has eight inputs.
The ACC_Algorithm model is created with the help of a chart block to implement the state flow logic in it. The state flow has three stages, those are 'ACC_OFF_MODE', 'ACC_STANDBY_MODE', and 'ACC_ON_MODE'. Each mode inside the state-flow has individual requirements, those are
Requirement 3a – ACC OFF MODE state logic:
- This is the default state inside state machine logic. Output signal Acceleration_Mode is at value 0 in this state.
- This state is governed by input signal CruiseSwitch.
- If CruiseSwitch is equal to 1, state ACC STANDBY mode will get activated. If CruiseSwitch is equal to 0, state ACC OFF mode will get activated, from either ACC ON mode or ACC STANDBY mode.
The ACC_OFF_MODE entry condition is at acceleration equal to '0'. If the cruise switch is equal to 1 the acc_off_mode will be deactivated and the acc_standby_mode will be activated, if the cruise switch is equal to 0 the acc_standby_mode will be deactivated and acc_off_mode will get activated.
Requirement 3b – ACC STANDBY MODE state logic:
- This is the second activated state inside state machine logic. Output signal Acceleration_Mode is at value 1 in this state.
- This state is governed by both input signals CruiseSwitch & SetSwitch.
- If CruiseSwitch is equal to 1, state ACC STANDBY mode will get activated. If CruiseSwitch is equal to 0, state ACC OFF mode will get activated, from either ACC ON mode or ACC STANDBY mode
- If SetSwitch is equal to 1, state ACC ON mode will get activated. If SetSwitch is equal to 0, state ACC STANDBY mode will get activated.
The ACC_STANDBY_MODE entry condition is at acceleration equal to '1'. If the cruise switch is equal to 1 the acc_standby_mode will get activated. If the set switch is equal to 1 the acc_standby_mode will be deactivated and acc_on_mode will get activated, if the set switch is equal to 0 the acc_on_mode will be deactivated and acc_standby_mode will get activated again.
Requirement 3c – ACC ON MODE state logic:
This state will be activated when the input signal SetSwitch is equal to 1. There are 6 sub-states to this state logic: They are:
- LeadVehicle_Detected_Follow (Default)
- LeadVehicle_Not_Detected
- LeadVehicle_Detected_Resume
- LeadVehicle_Not_Detected_Resume
- LeadVehicle_Speed_lessthan_Set_Speed
- LeadVehicle_Speed_equal_Set_Speed
Each sub-state has individual requirements for the state transitions, those requirements are given below:
Requirement 3c (i) – LeadVehicle_Detected_Follow (ACC ON MODE):
- This is the default substate inside ACC ON MODE state. Output signal Acceleration_Mode is equal to 2.
- Condition to transit from LeadVehicle_Detected_Follow to LeadVehicle_Not_Detected; Input signal condition LeadVehicle_Detected == 0.
- Condition to transit from LeadVehicle_Detected_Follow to LeadVehicle_Speed_lessthan_Set_Speed; Input Signals condition (LeadVehicle_Detected == 1) && (LeadVehicle_Speed < Set_Speed) || (Time_Gap < Set_Gap).
Requirement 3c (ii) – LeadVehicle_Not_Detected (ACC ON MODE):
- Output signal Acceleration_Mode is equal to 1.
- Condition to transit from LeadVehicle_Not_Detected to LeadVehicle_Detected_Follow; Input signals condition [(LeadVehicle_Detected==1) && (DriveVehicle_Speed == Set_Speed) && (LeadVehicle_Speed >= Set_Speed) && (Time_Gap >= Set_Gap)]
- Condition to transit from LeadVehicle_Not_Detected to LeadVehicle_Speed_lessthan_Set_Speed; Input signals condition [(LeadVehicle_Detected == 1) && (LeadVehicle_Speed < Set_Speed) || (Time_Gap < Set_Gap)]
Requirement 3c (iii) – LeadVehicle_Detected_Resume (ACC ON MODE):
- Output signal Acceleration_Mode is equal to 3.
- Condition to transit from LeadVehicle_Detected_Resume to LeadVehicle_Detected_Follow; Input signals condition [(DriveVehicle_Speed == Set_Speed) && (LeadVehicle_Speed >= Set_Speed) && (Time_Gap >= Set_Gap)]
- Condition to transit from LeadVehicle_Detected_Resume to LeadVehicle_Not_Detected_Resume; Input signal condition LeadVehicle_Detected==0.
- Condition to transit from LeadVehicle_Detected_Resume to LeadVehicle_Speed_equal_Set_Speed; Input Signal condition [(DriveVehicle_Speed < Set_Speed) && (LeadVehicle_Speed > DriveVehicle_Speed) && (Time_Gap >= Set_Gap)]
Requirement 3c (iv) - LeadVehicle_Not_Detected_Resume (ACC ON MODE):
- Output signal Acceleration_Mode is equal to 1.
Requirement 3c (v) - LeadVehicle_Speed_lessthan_Set_Speed (ACC ON MODE):
- Output signal Acceleration_Mode is equal to 4.
- Condition to transit from LeadVehicle_Speed_lessthan_Set_Speed to LeadVehicle_Not_Detected; Input signal condition [(LeadVehicle_Detected == 0) && (DriveVehicle_Speed == Set_Speed)]
- Condition to transit from LeadVehicle_Speed_lessthan_Set_Speed to LeadVehicle_Speed_equal_Set_Speed; Input signals condition [((LeadVehicle_Speed*1.25>=DriveVehicle_Speed) && (LeadVehicle_Speed * 0.75<=DriveVehicle_Speed)) && (DriveVehicle_Speed < Set_Speed) && ((Time_Gap<=1.25*Set_Gap) && (Time_Gap >=0.75*Set_Gap))]
Requirement 3c (vi) - LeadVehicle_Speed_equal_Set_Speed (ACC ON MODE):
- Output signal Acceleration_Mode is equal to 5.
- Condition to transit from LeadVehicle_Speed_equal_Set_Speed to LeadVehicle_Not_Detected_Resume; Input signal conditions is [(LeadVehicle_Detected == 0) || (DriveVehicle_Speed <= Set_Speed)]
- Condition to transit from LeadVehicle_Speed_equal_Set_Speed to LeadVehicle_Detected_Resume; Input signal conditions [(DriveVehicle_Speed < Set_Speed) && (LeadVehicle_Speed > DriveVehicle_Speed) || (Time_Gap >= Set_Gap)]
- Condition to transit from LeadVehicle_Speed_equal_Set_Speed to LeadVehicle_Speed_lessthan_Set_Speed; Input signals conditions [(LeadVehicle_Speed
The ACC_ON_MODE will be activated when the set switch is equal to 1, if the set switch is equal to 0 the acc_on_mode will be deactivated and acc_standby_mode will get activated. If the cruise switch is equal to 0 the acc_on_mode will be deactivated and acc_off_mode will get activated. Here, all three stages 'ACC_OFF_MODE', 'ACC_STANDBY_MODE', and 'ACC_ON_MODE' are activated and deactivated according to the cruise switch and ste switch values.
With the help of the above-mentioned requirements, the ACC_ON_MODE state logic is implemented in it. The state transitions from one state to another state are also mentioned above. After successfully implementing the three stages inside the Stateflow, the ACC_Logic chart will seem like the below. The 'Acceleration_Mode' is the output from this state-flow logic of the ACC_Logic chart block. This Acceleration block is the final output from this Adaptive_Cruise_Control model. This Acceleration_Mode is fed to the Dirive_Vehicle model as input by delaying the signal with the help of the 'unit dealy' block.
After implementing the state flow logic we need to define the signals in the symbols pane, which signals are input signals which signals are output signals, and which signals are local. The below-given image shows the process to define the signal type in the symbols pane.
The below-given image visualizes the input, output, and local connections between the subsystems inside the Adaptive_Cruise_Control model.
Requirement Tagging:
We need to give the requirement tags for each subsystem. To add the requirement tags for the subsystem, initially highlight the requirement in the word document and open the subsystem in Simulink and right-click on the subsystem & click on Requirements and select 'Link to Selection in Word'. Once you click on link selection to word document the requirement tag will be added to the selected subsystem. The requirement tags for all three subsystems 'Lead_Vehicle', 'Drive_Vehicle', and 'ACC_Algorithm' are given-below.
Signal Resolving and Propagation:
The signal resolving is to name the signals when the signal appears for the first time. Signal propagation is to name the signal, which is already been resolved previously. The signal resolving and propagation will give a better understanding of the signals when the signal connections are more and the signal propagation will help us to transfer the data without changing.
To resolve the signals right click on the signal and go to properties and enter the signal name same as like in the data dictionary, now click on 'signal name must resolve to Simulink signal object' the signal will be resolved. To propagate the signal when it appears for the second time in the model, double click on the signal and type angular braces and press enter the signal will be propagated with the name of the previously resolved name. The process to resolve and propagating the signal will be shown below.
Model Advisor Checks for MAB Guidelines:
The model advisor checks are mandatory in model-based development. The model advisor checks help to check whether the model is created under MAB guidelines are not. The Model Advisor produces a report that lists all the suboptimal conditions or settings that it finds, suggesting better model configuration settings where appropriate. The Model Advisor can be started through menus or the command line and can also be configured and used through a comprehensive API. The model advisor checks report is saved in HTML file format in the same directory in which the model is saved. The steps for model advisor checks are given below.
C - Code Generation:
After completing all the checks successfully and resolving & propagated signals properly for the Adaptive Cruise control model, we need to generate the code for the model. To generate the C-code, go to the Apps section on top and select the 'Embedded Coder' option. Then it will open another tab 'C Code', in the C Code tab expand the 'Build' option and click on Build to generate the code for the built model. We can see the code again by clicking on the 'View Code' option in the C Code section on top. The process to generate the C code is shown below. The generated C code is given-below.
C-code:
/*
* File: ACC_Project.c
*
* Code generated for Simulink model 'ACC_Project'.
*
* Model version : 1.18
* Simulink Coder version : 9.5 (R2021a) 14-Nov-2020
* C/C++ source code generated on : Sun May 29 10:02:28 2022
*
* Target selection: ert.tlc
* Embedded hardware selection: Intel->x86-64 (Windows64)
* Code generation objectives: Unspecified
* Validation result: Not run
*/
#include "ACC_Project.h"
#include "ACC_Project_private.h"
/* Named constants for Chart: '/ACC_Logic' */
#define ACC_IN_LeadVehicle_Not_Detected ((uint8_T)3U)
#define ACC_Project_IN_ACC_OFF_MODE ((uint8_T)1U)
#define ACC_Project_IN_ACC_ON_MODE ((uint8_T)2U)
#define ACC_Project_IN_ACC_STANDBY_MODE ((uint8_T)3U)
#define ACC_Project_IN_NO_ACTIVE_CHILD ((uint8_T)0U)
#define IN_LeadVehicle_Detected_Follow ((uint8_T)1U)
#define IN_LeadVehicle_Detected_Resume ((uint8_T)2U)
#define IN_LeadVehicle_Not_Detected_Res ((uint8_T)4U)
#define IN_LeadVehicle_Speed_equal_Set_ ((uint8_T)5U)
#define IN_LeadVehicle_Speed_lessthan_S ((uint8_T)6U)
/* Exported data definition */
/* Definition for custom storage class: ExportToFile */
uint8_T Acceleration_Mode; /* '/Unit Delay' */
/* Block states (default storage) */
DW_ACC_Project_T ACC_Project_DW;
/* External outputs (root outports fed by signals with default storage) */
ExtY_ACC_Project_T ACC_Project_Y;
/* Real-time model */
static RT_MODEL_ACC_Project_T ACC_Project_M_;
RT_MODEL_ACC_Project_T *const ACC_Project_M = &ACC_Project_M_;
/* Model step function */
void ACC_Project_step(void)
{
/* local block i/o variables */
uint8_T LeadVehicle_Speed;
uint8_T LeadVehicle_Detected;
uint8_T rtb_DriveVehicle_Speed;
/* Sum: '/Add' incorporates:
* Inport: '/CameraInput_LeadVehicle'
* Inport: '/RadarInput_LeadVehicle'
*/
LeadVehicle_Speed = (uint8_T)((uint32_T)CameraInput_LeadVehicle +
RadarInput_LeadVehicle);
/* UnitDelay: '/Unit Delay' */
Acceleration_Mode = ACC_Project_Y.Acceleration_Mode_k;
/* Sum: '/Add' incorporates:
* Inport: '/CameraInput_DriveVehicle'
* Inport: '/RadarInput_DriveVehicle'
*/
rtb_DriveVehicle_Speed = (uint8_T)((uint32_T)(uint8_T)((uint32_T)
CameraInput_DriveVehicle + Acceleration_Mode) + RadarInput_DriveVehicle);
/* SignalConversion: '/Signal Conversion' incorporates:
* Inport: '/RadarInput_DriveVehicle'
*/
LeadVehicle_Detected = RadarInput_DriveVehicle;
/* Chart: '/ACC_Logic' incorporates:
* Inport: '/CruiseSwitch'
* Inport: '/SetSwitch'
* Inport: '/Set_Gap'
* Inport: '/Set_Speed'
* Inport: '/Time_Gap'
* UnitDelay: '/Unit Delay'
*/
if (ACC_Project_DW.is_active_c3_ACC_Project == 0U) {
ACC_Project_DW.is_active_c3_ACC_Project = 1U;
ACC_Project_DW.is_c3_ACC_Project = ACC_Project_IN_ACC_OFF_MODE;
ACC_Project_Y.Acceleration_Mode_k = 0U;
} else {
switch (ACC_Project_DW.is_c3_ACC_Project) {
case ACC_Project_IN_ACC_OFF_MODE:
ACC_Project_Y.Acceleration_Mode_k = 0U;
if (CruiseSwitch) {
ACC_Project_DW.is_c3_ACC_Project = ACC_Project_IN_ACC_STANDBY_MODE;
ACC_Project_Y.Acceleration_Mode_k = 1U;
}
break;
case ACC_Project_IN_ACC_ON_MODE:
if (!SetSwitch) {
ACC_Project_DW.is_ACC_ON_MODE = ACC_Project_IN_NO_ACTIVE_CHILD;
ACC_Project_DW.is_c3_ACC_Project = ACC_Project_IN_ACC_STANDBY_MODE;
ACC_Project_Y.Acceleration_Mode_k = 1U;
} else if (!CruiseSwitch) {
ACC_Project_DW.is_ACC_ON_MODE = ACC_Project_IN_NO_ACTIVE_CHILD;
ACC_Project_DW.is_c3_ACC_Project = ACC_Project_IN_ACC_OFF_MODE;
ACC_Project_Y.Acceleration_Mode_k = 0U;
} else {
switch (ACC_Project_DW.is_ACC_ON_MODE) {
case IN_LeadVehicle_Detected_Follow:
ACC_Project_Y.Acceleration_Mode_k = 2U;
if (LeadVehicle_Detected == 0) {
ACC_Project_DW.is_ACC_ON_MODE = ACC_IN_LeadVehicle_Not_Detected;
ACC_Project_Y.Acceleration_Mode_k = 1U;
/* */
} else if (((LeadVehicle_Detected == 1) && (LeadVehicle_Speed <
Set_Speed)) || (Time_Gap < Set_Gap)) {
ACC_Project_DW.is_ACC_ON_MODE = IN_LeadVehicle_Speed_lessthan_S;
ACC_Project_Y.Acceleration_Mode_k = 4U;
}
break;
case IN_LeadVehicle_Detected_Resume:
ACC_Project_Y.Acceleration_Mode_k = 3U;
/* */
if ((rtb_DriveVehicle_Speed == Set_Speed) && (LeadVehicle_Speed >=
Set_Speed) && (Time_Gap >= Set_Gap)) {
ACC_Project_DW.is_ACC_ON_MODE = IN_LeadVehicle_Detected_Follow;
ACC_Project_Y.Acceleration_Mode_k = 2U;
} else if (LeadVehicle_Detected == 0) {
ACC_Project_DW.is_ACC_ON_MODE = IN_LeadVehicle_Not_Detected_Res;
ACC_Project_Y.Acceleration_Mode_k = 1U;
/* */
} else if ((rtb_DriveVehicle_Speed < Set_Speed) && (LeadVehicle_Speed >
rtb_DriveVehicle_Speed) && (Time_Gap >= Set_Gap)) {
ACC_Project_DW.is_ACC_ON_MODE = IN_LeadVehicle_Speed_equal_Set_;
ACC_Project_Y.Acceleration_Mode_k = 5U;
}
break;
case ACC_IN_LeadVehicle_Not_Detected:
ACC_Project_Y.Acceleration_Mode_k = 1U;
/* */
if ((LeadVehicle_Detected == 1) && (rtb_DriveVehicle_Speed ==
Set_Speed) && (LeadVehicle_Speed >= Set_Speed) && (Time_Gap >=
Set_Gap)) {
ACC_Project_DW.is_ACC_ON_MODE = IN_LeadVehicle_Detected_Follow;
ACC_Project_Y.Acceleration_Mode_k = 2U;
/* */
} else if (((LeadVehicle_Detected == 1) && (LeadVehicle_Speed <
Set_Speed)) || (Time_Gap < Set_Gap)) {
ACC_Project_DW.is_ACC_ON_MODE = IN_LeadVehicle_Speed_lessthan_S;
ACC_Project_Y.Acceleration_Mode_k = 4U;
}
break;
case IN_LeadVehicle_Not_Detected_Res:
ACC_Project_Y.Acceleration_Mode_k = 1U;
break;
case IN_LeadVehicle_Speed_equal_Set_:
ACC_Project_Y.Acceleration_Mode_k = 5U;
/* */
if ((LeadVehicle_Detected == 0) || (rtb_DriveVehicle_Speed <=
Set_Speed)) {
ACC_Project_DW.is_ACC_ON_MODE = IN_LeadVehicle_Not_Detected_Res;
ACC_Project_Y.Acceleration_Mode_k = 1U;
/* */
} else if (((rtb_DriveVehicle_Speed < Set_Speed) && (LeadVehicle_Speed
> rtb_DriveVehicle_Speed)) || (Time_Gap >= Set_Gap)) {
ACC_Project_DW.is_ACC_ON_MODE = IN_LeadVehicle_Detected_Resume;
ACC_Project_Y.Acceleration_Mode_k = 3U;
/* */
} else if (((LeadVehicle_Speed < Set_Speed) && (LeadVehicle_Speed <
rtb_DriveVehicle_Speed)) || (0.75 * (real_T)Set_Gap ==
Time_Gap)) {
ACC_Project_DW.is_ACC_ON_MODE = IN_LeadVehicle_Speed_lessthan_S;
ACC_Project_Y.Acceleration_Mode_k = 4U;
}
break;
default:
/* case IN_LeadVehicle_Speed_lessthan_Set_Speed: */
ACC_Project_Y.Acceleration_Mode_k = 4U;
/* */
if ((LeadVehicle_Detected == 0) && (rtb_DriveVehicle_Speed ==
Set_Speed)) {
ACC_Project_DW.is_ACC_ON_MODE = ACC_IN_LeadVehicle_Not_Detected;
ACC_Project_Y.Acceleration_Mode_k = 1U;
/* */
} else if (((real_T)LeadVehicle_Speed * 1.25 >= rtb_DriveVehicle_Speed)
&& ((real_T)LeadVehicle_Speed * 0.75 <=
rtb_DriveVehicle_Speed) && (rtb_DriveVehicle_Speed <
Set_Speed) && ((Time_Gap <= 1.25 * (real_T)Set_Gap) &&
(Time_Gap >= 0.75 * (real_T)Set_Gap))) {
ACC_Project_DW.is_ACC_ON_MODE = IN_LeadVehicle_Speed_equal_Set_;
ACC_Project_Y.Acceleration_Mode_k = 5U;
}
break;
}
}
break;
default:
/* case IN_ACC_STANDBY_MODE: */
ACC_Project_Y.Acceleration_Mode_k = 1U;
if (!CruiseSwitch) {
ACC_Project_DW.is_c3_ACC_Project = ACC_Project_IN_ACC_OFF_MODE;
ACC_Project_Y.Acceleration_Mode_k = 0U;
} else if (SetSwitch) {
ACC_Project_DW.is_c3_ACC_Project = ACC_Project_IN_ACC_ON_MODE;
ACC_Project_DW.is_ACC_ON_MODE = IN_LeadVehicle_Detected_Follow;
ACC_Project_Y.Acceleration_Mode_k = 2U;
}
break;
}
}
/* End of Chart: '/ACC_Logic' */
}
/* Model initialize function */
void ACC_Project_initialize(void)
{
/* (no initialization code required) */
}
/* Model terminate function */
void ACC_Project_terminate(void)
{
/* (no terminate code required) */
}
/*
* File trailer for generated code.
*
* [EOF]
*/
'The required model, data dictionary, C code, and model advisory checks HTML files are attached as Zip folder in below browse section'.