Project 2 Adaptive Cruise Control
AIM:
To develop an Adaptive Cruise Control feature as per the Requirement Document using MATLAB Simulink.
General Overview:
Adaptive Cruise Control Feature for passenger cars allows the host vehicle to adapt to the speed in line with traffic flow. Driving in heavy traffic or keeping a safe distance from 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 a 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 car 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 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.
The objective of the Main Project:
- 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
Creating an SLDD file:
- As per the given signals and calibration data, I have to create the SLDD file shown below.
- SLDD file is a tool that is available in the Simulink it is used to keep all parameters in the single variables names later we create a model and resolve the signal means it automatically updated the file.
- As per the given objectives we have to update out data into the SLDD file
Signals & Calibration Data List:
|
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 |
- |
- |
Steps to create the SLDD file to update the signals and calibration value:
Step-1
Open the simulink model and select the modeling option which is available at the top of the simulink model then select the option to data dictionary file are shown below.
- After selecting this option a new popup window can be opened and select the new button which means we have to create a new SLDD file and update the given signals and calibration can be shown below.
- In this case, I have already created the SLDD file so I can select the browse option and select the required SLDD file from the file manager.
- After selecting this, I have to click the model explore option available at the top of the Simulink window and a new window can be opened.
- From the above figure, I have updated all the signals and calibration data list.
Development of Simulink model:
- Here I can build a model which is consist of three subsystems based on the given requirements.
- Once I click the adaptive cruise control subsystem it takes the insides of the subsystem and shows the 3 different subsystems which I can build as per the requirements can be shown below.
- Based on the three requirements I can create the three subsystems and name the subsystems at different variables.
- Requirments-1 subsystem is named as the Lead vehicle.
- Requirments-2 subsystem is named the Drive vehicle.
- Requirements-3 subsystem is named the ACC logic.
Requirement 1– Lead Vehicle:
- Lead Vehicle is a vehicle that is driving on 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 cameras & 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.
- As per the given requirements, I can use the 2 inport block which is connected to the sum block and connected the outport and named as the Lead vehicle speed.
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, the 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.
- As per the given Requirements, I can connect the 2 inport with the sum block and named as camera input drive vehicle & acceleration Mode.
- And another sum block is used to connect the rador input drive vehicle & lead vehicle detected and it would be added with drive vehicle speed and it provide the two output.
Requirement 3 – Adaptive Cruise Control 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.
model explanation:
- As per the third requirement, i can design a model using Stateflow logic to implement the requirements.
- The inputs for the state flow are
- Time_gap
- set_speed
- Set_gap
- Cruise_switch
- Set_switch
- Drivevehicle_speed
- Leadvehicle_speed
- Leadvehicle_detected
State flow explanation:
In this logic I have created three modes of operation:
- ACC_OFF mode
- ACC_STANDBY mode
- ACC_ON mode
In ACC_ON mode we have a further 6 mode of Requirments can be shown below:
- LeadVehicle_Detected_Follow (ACC ON MODE)
- LeadVehicle_Not_Detected (ACC ON MODE)
- LeadVehicle_Detected_Resume (ACC ON MODE)
- LeadVehicle_Not_Detected_Resume (ACC ON MODE)
- LeadVehicle_Speed_lessthan_Set_Speed (ACC ON MODE)
- LeadVehicle_Speed_equal_Set_Speed (ACC ON MODE)
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
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.
Requirement 3c – ACC ON MODE state logic:
This state will be activated when 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
Requirement 3c (i) – LeadVehicle_Detected_Follow (ACC ON MODE):
- This is the default sub state 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<Set_Speed) && (LeadVehicle_Speed<DriveVehicle_Speed) || (Time_Gap == 0.75*Set_Gap)]
- Based on the 6 modes of requirements I have designed the state flow logic method.
Output from the Stateflow:
- Acceleration_mode is based on the leadvehicle_speed the Acceleration_mode is adjust its controlling acceleration given output to maintain the constant speed.
Requirment Tagging:
Requirement Tagging:
- In this project, I can update my project details and block explanation in ms word which attach with this model hereafter anyone is able to know the definition and requirements of the block means just simply click the requirement option to Simulink and automatically open the ms word file and highlight the paragraph or points.
- Make sure while doing this requirement process your ms word application should be open.
- After selecting this requirement i have have to conclude that is shown in the below figure.
- Once I select the requirements option I have to check the subsystem once I select the requirement 1 means its automatically select the requirment-1 .so we use to refer to the word docx for further consideration.
Code Generation:
- By the given condition, I have generated the c-code automatically based upon my model design
- Now let me explain the code generation by steps.
Step-1
- Select the model setting then new pop-up window can be opened and select the solver option to change the solvers and the sampling time which is given in the objectives are shown below.
- After selecting the solver select the code generation option andselect the required parameters are shown below.
- After selecting the process select the Apps which is available in the top of the stimulink model then select the embaded code are shown below.
- After selecting this option a new column is created nearer to the Apps the column name is code after that we select the build option it would be automatically generated the C-code are shown in the below
- After selecting the build option simulink automatically starts created the c-code for us are shown in the below fif.
The generated C-code i can call on matlab editor wind and the generated code can shown below.
/*
* File: vehicle_cruse_control.c
*
* Code generated for Simulink model 'vehicle_cruse_control'.
*
* Model version : 1.8
* Simulink Coder version : 9.5 (R2021a) 14-Nov-2020
* C/C++ source code generated on : Sat May 28 16:41:57 2022
*
* Target selection: ert.tlc
* Embedded hardware selection: Intel->x86-64 (Windows64)
* Code generation objectives: Unspecified
* Validation result: Not run
*/
#include "vehicle_cruse_control.h"
#include "vehicle_cruse_control_private.h"
/* Named constants for Chart: '<S1>/Adaptive_Cruise_Control_Algorithm' */
#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)
#define veh_IN_LeadVehicle_Not_Detected ((uint8_T)3U)
#define vehicle_cru_IN_ACC_STANDBY_MODE ((uint8_T)3U)
#define vehicle_crus_IN_NO_ACTIVE_CHILD ((uint8_T)0U)
#define vehicle_cruse_c_IN_ACC_OFF_MODE ((uint8_T)1U)
#define vehicle_cruse_co_IN_ACC_ON_MODE ((uint8_T)2U)
/* Exported data definition */
/* Definition for custom storage class: ExportToFile */
uint8_T Acceleration_Mode; /* '<S1>/Adaptive_Cruise_Control_Algorithm' */
uint8_T DriveVehicle_Speed; /* '<S3>/Add1' */
uint8_T LeadVehicle_Detected; /* '<S3>/Signal Conversion' */
uint8_T LeadVehicle_Speed; /* '<S4>/Add' */
/* Block states (default storage) */
DW_vehicle_cruse_control_T vehicle_cruse_control_DW;
/* External inputs (root inport signals with default storage) */
ExtU_vehicle_cruse_control_T vehicle_cruse_control_U;
/* Real-time model */
static RT_MODEL_vehicle_cruse_contro_T vehicle_cruse_control_M_;
RT_MODEL_vehicle_cruse_contro_T *const vehicle_cruse_control_M =
&vehicle_cruse_control_M_;
real_T rt_roundd_snf(real_T u)
{
real_T y;
if (fabs(u) < 4.503599627370496E+15) {
if (u >= 0.5) {
y = floor(u + 0.5);
} else if (u > -0.5) {
y = u * 0.0;
} else {
y = ceil(u - 0.5);
}
} else {
y = u;
}
return y;
}
/* Model step function */
void vehicle_cruse_control_step(void)
{
int32_T tmp;
int32_T tmp_0;
uint8_T tmp_1;
uint8_T tmp_2;
/* Sum: '<S3>/Add1' incorporates:
* Inport: '<Root>/CameraInput_DriveVehicle'
* Inport: '<Root>/RadarInput_DriveVehicle'
* Sum: '<S3>/Add'
* UnitDelay: '<S1>/Unit Delay'
*/
DriveVehicle_Speed = (uint8_T)((uint32_T)(uint8_T)((uint32_T)
Camera_Input_Drive_Vehicle + Acceleration_Mode) + Radar_Input_Drive_Vehicle);
/* SignalConversion: '<S3>/Signal Conversion' incorporates:
* Inport: '<Root>/RadarInput_DriveVehicle'
*/
LeadVehicle_Detected = Radar_Input_Drive_Vehicle;
/* Sum: '<S4>/Add' incorporates:
* Inport: '<Root>/CameraInput_LeadVehicle'
* Inport: '<Root>/RadarInput_LeadVehicle'
*/
LeadVehicle_Speed = (uint8_T)((uint32_T)Camera_Input_Lead_Vehicle +
Radar_Input_Lead_Vehicle);
/* Chart: '<S1>/Adaptive_Cruise_Control_Algorithm' incorporates:
* Inport: '<Root>/CruiseSwitch'
* Inport: '<Root>/Set_Gap'
* Inport: '<Root>/Set_Speed'
* Inport: '<Root>/Set_Switch'
* Inport: '<Root>/Time_Gap'
*/
if (vehicle_cruse_control_DW.is_active_c3_vehicle_cruse_cont == 0U) {
vehicle_cruse_control_DW.is_active_c3_vehicle_cruse_cont = 1U;
vehicle_cruse_control_DW.is_c3_vehicle_cruse_control =
vehicle_cruse_c_IN_ACC_OFF_MODE;
Acceleration_Mode = 0U;
} else {
switch (vehicle_cruse_control_DW.is_c3_vehicle_cruse_control) {
case vehicle_cruse_c_IN_ACC_OFF_MODE:
Acceleration_Mode = 0U;
if (CruiseSwitch) {
vehicle_cruse_control_DW.is_c3_vehicle_cruse_control =
vehicle_cru_IN_ACC_STANDBY_MODE;
Acceleration_Mode = 1U;
}
break;
case vehicle_cruse_co_IN_ACC_ON_MODE:
if (!SetSwitch) {
vehicle_cruse_control_DW.is_ACC_ON_MODE =
vehicle_crus_IN_NO_ACTIVE_CHILD;
vehicle_cruse_control_DW.is_c3_vehicle_cruse_control =
vehicle_cru_IN_ACC_STANDBY_MODE;
Acceleration_Mode = 1U;
} else {
switch (vehicle_cruse_control_DW.is_ACC_ON_MODE) {
case IN_LeadVehicle_Detected_Follow:
Acceleration_Mode = 2U;
if (DriveVehicle_Speed == 0) {
vehicle_cruse_control_DW.is_ACC_ON_MODE =
veh_IN_LeadVehicle_Not_Detected;
Acceleration_Mode = 1U;
} else if (((DriveVehicle_Speed == 1) && (LeadVehicle_Speed <
Set_Speed)) || (Time_Gap < Set_Gap)) {
vehicle_cruse_control_DW.is_ACC_ON_MODE =
IN_LeadVehicle_Speed_lessthan_S;
Acceleration_Mode = 4U;
}
break;
case IN_LeadVehicle_Detected_Resume:
Acceleration_Mode = 3U;
if ((LeadVehicle_Detected == Set_Speed) && (LeadVehicle_Speed >=
Set_Speed) && (Time_Gap >= Set_Gap)) {
vehicle_cruse_control_DW.is_ACC_ON_MODE =
IN_LeadVehicle_Detected_Follow;
Acceleration_Mode = 2U;
} else if (DriveVehicle_Speed == 0) {
vehicle_cruse_control_DW.is_ACC_ON_MODE =
IN_LeadVehicle_Not_Detected_Res;
Acceleration_Mode = 1U;
} else if ((LeadVehicle_Detected < Set_Speed) && (LeadVehicle_Speed >
LeadVehicle_Detected) && (Time_Gap >= Set_Gap)) {
vehicle_cruse_control_DW.is_ACC_ON_MODE =
IN_LeadVehicle_Speed_equal_Set_;
Acceleration_Mode = 5U;
}
break;
case veh_IN_LeadVehicle_Not_Detected:
Acceleration_Mode = 1U;
if ((DriveVehicle_Speed == 1) && (LeadVehicle_Detected == Set_Speed) &&
(LeadVehicle_Speed >= Set_Speed) && (Time_Gap >= Set_Gap)) {
vehicle_cruse_control_DW.is_ACC_ON_MODE =
IN_LeadVehicle_Detected_Follow;
Acceleration_Mode = 2U;
} else if (((DriveVehicle_Speed == 1) && (LeadVehicle_Speed <
Set_Speed)) || (Time_Gap < Set_Gap)) {
vehicle_cruse_control_DW.is_ACC_ON_MODE =
IN_LeadVehicle_Speed_lessthan_S;
Acceleration_Mode = 4U;
}
break;
case IN_LeadVehicle_Not_Detected_Res:
Acceleration_Mode = 1U;
break;
case IN_LeadVehicle_Speed_equal_Set_:
Acceleration_Mode = 5U;
if ((DriveVehicle_Speed == 0) || (LeadVehicle_Detected <= Set_Speed))
{
vehicle_cruse_control_DW.is_ACC_ON_MODE =
IN_LeadVehicle_Not_Detected_Res;
Acceleration_Mode = 1U;
} else if (((LeadVehicle_Detected < Set_Speed) && (LeadVehicle_Speed >
LeadVehicle_Detected)) || (Time_Gap >= Set_Gap)) {
vehicle_cruse_control_DW.is_ACC_ON_MODE =
IN_LeadVehicle_Detected_Resume;
Acceleration_Mode = 3U;
} else if (((LeadVehicle_Speed < Set_Speed) && (LeadVehicle_Speed <
LeadVehicle_Detected)) || ((int32_T)rt_roundd_snf(0.75 *
(real_T)Set_Gap) == Time_Gap)) {
vehicle_cruse_control_DW.is_ACC_ON_MODE =
IN_LeadVehicle_Speed_lessthan_S;
Acceleration_Mode = 4U;
}
break;
default:
/* case IN_LeadVehicle_Speed_lessthan_Set_Speed: */
Acceleration_Mode = 4U;
if ((DriveVehicle_Speed == 0) && (LeadVehicle_Detected == Set_Speed))
{
vehicle_cruse_control_DW.is_ACC_ON_MODE =
veh_IN_LeadVehicle_Not_Detected;
Acceleration_Mode = 1U;
} else {
tmp = (int32_T)rt_roundd_snf((real_T)LeadVehicle_Speed * 1.25);
tmp_0 = (int32_T)rt_roundd_snf(1.25 * (real_T)Set_Gap);
if (tmp < 256) {
tmp_1 = (uint8_T)tmp;
} else {
tmp_1 = MAX_uint8_T;
}
if (tmp_0 < 256) {
tmp_2 = (uint8_T)tmp_0;
} else {
tmp_2 = MAX_uint8_T;
}
if ((tmp_1 >= LeadVehicle_Detected) && ((int32_T)rt_roundd_snf
((real_T)LeadVehicle_Speed * 0.75) <= LeadVehicle_Detected) &&
(LeadVehicle_Detected < Set_Speed) && (Time_Gap <= tmp_2) &&
(Time_Gap >= (int32_T)rt_roundd_snf(0.75 * (real_T)Set_Gap))) {
vehicle_cruse_control_DW.is_ACC_ON_MODE =
IN_LeadVehicle_Speed_equal_Set_;
Acceleration_Mode = 5U;
}
}
break;
}
}
break;
default:
/* case IN_ACC_STANDBY_MODE: */
Acceleration_Mode = 1U;
if (!CruiseSwitch) {
vehicle_cruse_control_DW.is_c3_vehicle_cruse_control =
vehicle_cruse_c_IN_ACC_OFF_MODE;
Acceleration_Mode = 0U;
} else if (SetSwitch) {
vehicle_cruse_control_DW.is_c3_vehicle_cruse_control =
vehicle_cruse_co_IN_ACC_ON_MODE;
vehicle_cruse_control_DW.is_ACC_ON_MODE = IN_LeadVehicle_Detected_Follow;
Acceleration_Mode = 2U;
}
break;
}
}
/* End of Chart: '<S1>/Adaptive_Cruise_Control_Algorithm' */
}
/* Model initialize function */
void vehicle_cruse_control_initialize(void)
{
/* (no initialization code required) */
}
/* Model terminate function */
void vehicle_cruse_control_terminate(void)
{
/* (no terminate code required) */
}
/*
* File trailer for generated code.
*
* [EOF]
*/
Model Advisor:
- A model advisor is a tool that automatically checks the model for errors using pre-defined checks.
- Model advisor as a tool is available in the core Simulink block set that automatically enables the user to check for common modeling mistakes which we miss out to notice during model development.
- The model advisor can analyze the entire model or a sub-set of the model. Upon selecting the model advisor option as shown below, the developer can choose which version he would like to test.
- After clicking this model adviser a new window can be opened in that window we can de-select all the guidance we can select the MAB guidance.
- If we press the run button which is mentioned in the above fig. after analyzing all the blocks it shows the results as no of pass, no of fail, and no of warnings.
- After that, we have to generate the report for that and it the report can explain our model very clearly can shown below fig.
Conclusion:
- In the project is done the process of requirement tagging, generating code, model advisor,design a model based on the requirements.