Project 2 Adaptive Cruise Control

To Develop an MBD-based Adaptive Cruise Control Features as per given requirements using Matlab Simulink.

Objective:

1. Developing Adaptive Cruise Control feature as per the Requirement Document using MATLAB Simulink.
2. Follow all the MBD-related processes: Requirement Tagging & Traceability, SLDD creation, Configuration Parameter changes, Model Advisor check & Code Generation.
3. In Configuration Parameters: enable “Support Floating Numbers” under Code Generation settings.
4. Use Embedded Coder to generate the code.
5. If choosing code generation, the Storage class for Input signals: ImportedExtern; the Storage class for Output signal: Export to File; the Storage class for local signals: localizable; the Storage class for calibration signals: Const.
6. Choose sample time for all signals as 0.01s

Modeling:

Create SLDD file

• Create a blank model and save it and create a sldd by linking to Dictionary.
• Add Signals and parameters as provided in the data list.

Simulink Model for Adaptive Cruise Control:

We create modeling by creating a subsystem with nine input parameters and one output parameter for acceleration response.

Three Subsystems are created for the requirement names Lead_Vehicel, Drive_Vehicle, and ACC_Algorithm.

Lead_Vehcle Subsystem:

The camera and radar input values are taken as inputs and vehicle speed will be the Output.

Drive_Vehicle Subsystem:

This subsystem is based on requirement 2 and takes 3 input values cameraInput,Radar Input and Acceleration Mode and 2 outputs as Vehicle Speed and Vehicle Detection

Acc Algorithm Subsystem:

This Subsystem is made using the concept of Stateflow. It takes 8 inputs and gives acceleration as output.

ACC Algorithm StateFlow Diagram 

The State flow Chart is developed based on the Requirement 3 and Sub requirements.

StateFlow Symbols:

Signal Resolving And propagation:

Signal to resolve: Right Click on the signal>>Properties>>Enter a valid signal name on suggestion>>Click OK.

• Accelertion_mode is resolved and given as feedback.

model Advisor Check:

• Model Advisor checks are done to check compliance of the model with different guidelines
• Run the model and check for any errors.
• Goto modeladvisor>>Select the whole>>ok

Code Generation:

Select the Subsystem then rightClick Code>>Build Code>>ok.

*
2	* File: Acc.c
3	*
4	* Code generated for Simulink model 'Acc'.
5	*
6	* Model version : 1.26
7	* Simulink Coder version : 9.3 (R2020a) 18-Nov-2019
8	* C/C++ source code generated on : Thu Apr 20 21:21:49 2023
9	*
10	* Target selection: ert.tlc
11	* Embedded hardware selection: Intel->x86-64 (Windows64)
12	* Code generation objectives: Unspecified
13	* Validation result: Not run
14	*/
15
16	#include "Acc.h"
17	#include "Acc_private.h"
18
19	/* Named constants for Chart: '/Chart' */
20	#define Acc_IN_ACC_OFF_MODE ((uint8_T)1U)
21	#define Acc_IN_ACC_ON_MODE ((uint8_T)2U)
22	#define Acc_IN_ACC_STANDBY_MODE ((uint8_T)3U)
23	#define Acc_IN_LeadVehicle_Detected ((uint8_T)1U)
24	#define Acc_IN_LeadVehicle_Not_Detected ((uint8_T)3U)
25	#define Acc_IN_NO_ACTIVE_CHILD ((uint8_T)0U)
26	#define IN_LeadVehicle_Detected_Resume ((uint8_T)2U)
27	#define IN_LeadVehicle_Not_Detected_Res ((uint8_T)4U)
28	#define IN_LeadVehicle_Speed_Equal_SetS ((uint8_T)5U)
29	#define IN_Lead_Vehicle_Speed_islesstha ((uint8_T)6U)
30
31	/* Exported data definition */
32
33	/* Definition for custom storage class: ExportToFile */
34	uint8_T Acceleration_Mode; /* '/Chart' */
35	uint8_T DriveVehicle_Speed; /* '/Add' */
36	uint8_T LeadVehicle_Detected; /* '/Signal Conversion' */
37	uint8_T LeadVehicle_Speed; /* '/Add' */
38
39	/* Block states (default storage) */
40	DW_Acc_T Acc_DW;
41
42	/* Real-time model */
43	RT_MODEL_Acc_T Acc_M_;
44	RT_MODEL_Acc_T *const Acc_M = &Acc_M_;
45
46	/* Model step function */
47	void Acc_step(void)
48	{
49	real_T tmp;
50
51	/* Sum: '/Add' incorporates:
52	* Inport: '/CameraInput_LeadVehicle'
53	* Inport: '/RadarInput_LeadVehicle'
54	*/
55	LeadVehicle_Speed = (uint8_T)((uint32_T)CameraInput_LeadVehicle +
56	RadarInput_LeadVehicle);
57
58	/* Sum: '/Add' incorporates:
59	* Inport: '/CameraInput_DriveVehicle'
60	* Inport: '/RadarInput_DriveVehicle'
61	* UnitDelay: '/Unit Delay'
62	*/
63	DriveVehicle_Speed = (uint8_T)((uint32_T)(uint8_T)((uint32_T)
64	CameraInput_DriveVehicle + Acceleration_Mode) + RadarInput_DriveVehicle);
65
66	/* SignalConversion: '/Signal Conversion' incorporates:
67	* Inport: '/RadarInput_DriveVehicle'
68	*/
69	LeadVehicle_Detected = RadarInput_DriveVehicle;
70
71	/* Chart: '/Chart' incorporates:
72	* Inport: '/CruiseSwitch'
73	* Inport: '/Set_Gap'
74	* Inport: '/Set_Speed'
75	* Inport: '/Set_Switch'
76	* Inport: '/Time_Gap'
77	*/
78	if (Acc_DW.is_active_c3_Acc == 0U) {
79	Acc_DW.is_active_c3_Acc = 1U;
80	Acc_DW.is_c3_Acc = Acc_IN_ACC_OFF_MODE;
81	Acceleration_Mode = 0U;
82	} else {
83	switch (Acc_DW.is_c3_Acc) {
84	case Acc_IN_ACC_OFF_MODE:
85	if (!CruiseSwitch) {
86	Acc_DW.is_c3_Acc = Acc_IN_ACC_ON_MODE;
87	tmp = 0.75 * (real_T)Set_Gap;
88	if (((LeadVehicle_Speed < Set_Speed) && (LeadVehicle_Speed <
89	DriveVehicle_Speed)) || (tmp == Time_Gap)) {
90	Acc_DW.is_ACC_ON_MODE = IN_Lead_Vehicle_Speed_islesstha;
91	Acceleration_Mode = 4U;
92	} else if (((real_T)LeadVehicle_Speed * 1.25 >= DriveVehicle_Speed) &&
93	((real_T)LeadVehicle_Speed * 0.75 <= DriveVehicle_Speed) &&
94	(DriveVehicle_Speed < Set_Speed) && (Time_Gap <= 1.25 *
95	(real_T)Set_Gap) && (Time_Gap >= tmp)) {
96	Acc_DW.is_ACC_ON_MODE = IN_LeadVehicle_Speed_Equal_SetS;
97	Acceleration_Mode = 5U;
98	} else {
99	Acc_DW.is_ACC_ON_MODE = Acc_IN_LeadVehicle_Detected;
100	Acceleration_Mode = 2U;
101	}
102	} else {
103	Acc_DW.is_c3_Acc = Acc_IN_ACC_STANDBY_MODE;
104	Acceleration_Mode = 1U;
105	}
106	break;
107
108	case Acc_IN_ACC_ON_MODE:
109	if (!SetSwitch) {
110	Acc_DW.is_ACC_ON_MODE = Acc_IN_NO_ACTIVE_CHILD;
111	Acc_DW.is_c3_Acc = Acc_IN_ACC_STANDBY_MODE;
112	Acceleration_Mode = 1U;
113	} else {
114	switch (Acc_DW.is_ACC_ON_MODE) {
115	case Acc_IN_LeadVehicle_Detected:
116	if (((LeadVehicle_Detected == 1) && (LeadVehicle_Speed < Set_Speed)) ||
117	(Time_Gap < Set_Gap)) {
118	Acc_DW.is_ACC_ON_MODE = IN_Lead_Vehicle_Speed_islesstha;
119	Acceleration_Mode = 4U;
120	} else {
121	Acc_DW.is_ACC_ON_MODE = Acc_IN_LeadVehicle_Not_Detected;
122	Acceleration_Mode = 1U;
123	}
124	break;
125
126	case IN_LeadVehicle_Detected_Resume:
127	Acceleration_Mode = 3U;
128	if ((DriveVehicle_Speed == Set_Speed) && (LeadVehicle_Speed >=
129	Set_Speed) && (Time_Gap >= Set_Gap)) {
130	Acc_DW.is_ACC_ON_MODE = Acc_IN_LeadVehicle_Detected;
131	Acceleration_Mode = 2U;
132	} else {
133	if ((DriveVehicle_Speed < Set_Speed) && (LeadVehicle_Speed >
134	DriveVehicle_Speed) && (Time_Gap >= Set_Gap)) {
135	Acc_DW.is_ACC_ON_MODE = IN_LeadVehicle_Speed_Equal_SetS;
136	Acceleration_Mode = 5U;
137	}
138	}
139	break;
140
141	case Acc_IN_LeadVehicle_Not_Detected:
142	Acceleration_Mode = 1U;
143	if (((LeadVehicle_Detected == 1) && (LeadVehicle_Speed < Set_Speed)) ||
144	(Time_Gap < Set_Gap)) {
145	Acc_DW.is_ACC_ON_MODE = IN_Lead_Vehicle_Speed_islesstha;
146	Acceleration_Mode = 4U;
147	} else {
148	if ((LeadVehicle_Detected == 1) && (DriveVehicle_Speed == Set_Speed)
149	&& (LeadVehicle_Speed >= Set_Speed) && (Time_Gap >= Set_Gap)) {
150	Acc_DW.is_ACC_ON_MODE = Acc_IN_LeadVehicle_Detected;
151	Acceleration_Mode = 2U;
152	}
153	}
154	break;
155
156	case IN_LeadVehicle_Not_Detected_Res:
157	Acceleration_Mode = 1U;
158	if (LeadVehicle_Detected == 0) {
159	Acc_DW.is_ACC_ON_MODE = IN_LeadVehicle_Detected_Resume;
160	Acceleration_Mode = 3U;
161	}
162	break;
163
164	case IN_LeadVehicle_Speed_Equal_SetS:
165	Acceleration_Mode = 5U;
166	if ((DriveVehicle_Speed < Set_Speed) && (LeadVehicle_Speed >
167	DriveVehicle_Speed) && (Time_Gap >= Set_Gap)) {
168	Acc_DW.is_ACC_ON_MODE = IN_LeadVehicle_Detected_Resume;
169	Acceleration_Mode = 3U;
170	} else {
171	if ((LeadVehicle_Detected == 0) || (DriveVehicle_Speed <= Set_Speed))
172	{
173	Acc_DW.is_ACC_ON_MODE = IN_LeadVehicle_Not_Detected_Res;
174	Acceleration_Mode = 1U;
175	}
176	}
177	break;
178
179	default:
180	/* case IN_Lead_Vehicle_Speed_islessthan_SetSpeed: */
181	Acceleration_Mode = 4U;
182	if ((LeadVehicle_Detected == 0) && (DriveVehicle_Speed == Set_Speed))
183	{
184	Acc_DW.is_ACC_ON_MODE = Acc_IN_LeadVehicle_Not_Detected;
185	Acceleration_Mode = 1U;
186	}
187	break;
188	}
189	}
190	break;
191
192	default:
193	/* case IN_ACC_STANDBY_MODE: */
194	if (SetSwitch) {
195	Acc_DW.is_c3_Acc = Acc_IN_ACC_ON_MODE;
196	tmp = 0.75 * (real_T)Set_Gap;
197	if (((LeadVehicle_Speed < Set_Speed) && (LeadVehicle_Speed <
198	DriveVehicle_Speed)) || (tmp == Time_Gap)) {
199	Acc_DW.is_ACC_ON_MODE = IN_Lead_Vehicle_Speed_islesstha;
200	Acceleration_Mode = 4U;
201	} else if (((real_T)LeadVehicle_Speed * 1.25 >= DriveVehicle_Speed) &&
202	((real_T)LeadVehicle_Speed * 0.75 <= DriveVehicle_Speed) &&
203	(DriveVehicle_Speed < Set_Speed) && (Time_Gap <= 1.25 *
204	(real_T)Set_Gap) && (Time_Gap >= tmp)) {
205	Acc_DW.is_ACC_ON_MODE = IN_LeadVehicle_Speed_Equal_SetS;
206	Acceleration_Mode = 5U;
207	} else {
208	Acc_DW.is_ACC_ON_MODE = Acc_IN_LeadVehicle_Detected;
209	Acceleration_Mode = 2U;
210	}
211	} else {
212	Acc_DW.is_c3_Acc = Acc_IN_ACC_OFF_MODE;
213	Acceleration_Mode = 0U;
214	}
215	break;
216	}
217	}
218
219	/* End of Chart: '/Chart' */
220	}
221
222	/* Model initialize function */
223	void Acc_initialize(void)
224	{
225	/* (no initialization code required) */
226	}
227
228	/* Model terminate function */
229	void Acc_terminate(void)
230	{
231	/* (no terminate code required) */
232	}
233
234	/*
235	* File trailer for generated code.
236	*
237	* [EOF]
238	*/
239

Result:

• The Adaptive Cruise Control is Modelled in Simulink as per the given requirements. If the model is running without any error it works as per requirement. 
• Solver and Code generation are configured.
• SLDD file is created and linked to the model.
• Model advisor report is generated.
• C-code for the model is generated.

Conclusion:

Hence the Adaptive Cruise Control Model is Developed as per Requirement.