Project 2-Highway Assistant-Lane Changing Assistant

                                                                Project: Highway Assistance- Lane Changing Assistat

Aim:  To create a model of Highway Assistance-Lane Changing Assistat based on Model Based Development and MAAB guidelines. Generating Model Advisory report, Code generation using Autosar Coder and AUTOSAR port mapping for the same.

Objectives: 

• Model Based Development using MAAB geuidlines
• Creating Simulink data Dictionary for the Model
• Generating Model Advisory Report
• AUTOSAR Port mapping using AUTOSAR Port Editor 
• Code Generation using AUTOSAR Coder

Introduction to the Feature:

The crash investigation report defines the lane change related crashes when the crash occurs during the at-fault drivers changing the lane suddenly. In this case, the crash cause is recorded in the crash report as “sudden lane changing”.

              

As an active safety system, the lane-change assistant helps prevent accidents by avoiding hazardous situations when changing lanes as far as possible. In doing so, it makes an important contribution to reducing accident statistics in spite of increasingly dense road traffic. 

The Highway Assistant supports the driver and takes over the longitudinal and lateral guidance of the vehicle in monotonous driving situations on highways. The partially automated function can automatically start, accelerate, brake as well as steer the vehicle to a certain extent. The driver has to permanently supervise the system and be ready to take over the complete control of the vehicle at any time.

Drivers are taught to assess surrounding traffic before changing lanes by checking their rearview and side mirrors and looking over each shoulder. However, even for those who follow this sequence of checks, the vehicle's blind spot – the area alongside and just behind the vehicle – is a constant source of danger and often the cause of serious accidents. Even vehicles approaching quickly from behind can pose a risk. To make changing lanes safer, this feature has been developed.

Basic Working Principle:

Highway Assistant is a partially automated driving function for a speed range of up to 180 km/h (112 mph) on highways. It combines the radar-based longitudinal guidance of Adaptive Cruise Control (ACC) with the video-based lateral guidance of lane keeping support in one system. Highway Assistant can be supplemented by an automatic lane change initiated and monitored by the driver in a speed range of 60 – 130 km/h (35 – 80 mph).

The lane Change Assistant works by using two mid-range radar sensors that are concealed in the rear bumper – one on the left, one on the right. These two sensors monitor the area alongside and behind the car. Powerful control software collates the sensor information to create a complete picture of all traffic in the area behind the vehicle.Whenever another vehicle approaches at speed from behind or is already present in the blind spot, a signal such as a warning light in the side mirror alerts the driver to the hazard. Should the driver still activate the turn signal with the intention of changing lanes, the system issues an additional acoustic and/or haptic warning.

SLDD Signal requirment:

Highway_Input_Signal	uint8	0 - 255
Enable_Display	uint8	0 – 255
Input_Switch	uint8	0 – 255
Lane_Input_Signal	uint8	0 - 255

Local Signals:

Name of the Signal	Data Type	Range
Highway_Display_Mode_1	uint8	0 - 255
Highway_Display_Mode_2	uint8	0 – 255
Highway_Display_Mode_3	uint8	0 – 255
Highway_Display_Mode_4	uint8	0 – 255
Lane_Display_Mode_1	uint8	0 – 255
Lane_Display_Mode_2	uint8	0 – 255
Lane_Display_Mode_3	uint8	0 – 255
Lane_Display_Mode_4	uint8	0 – 255

Output Signals:

Name of the Signal	Data Type	Range
Display_Mode_1	uint8	0 - 255
Display_Mode_2	uint8	0 – 255
Display_Mode_3	uint8	0 – 255
Display_Mode_4	uint8	0 - 255

Requirement No 1 [Highway_DisplayUnit]:

Inputs to this particular subsystem are “Highway_Input_Signal”, “Enable_Display”, “Input_Switch”. These three input signals, when assigned to a particular value will give output signals of specific value. The output signals are “Highway_Display_Mode_1”, “Highway_Display_Mode_2”, “Highway_Display_Mode_3”, “Highway_Display_Mode_4”. The requirement must be implemented in the form of a Stateflow logic.

Condition	Action
Highway_Input_Signal = 1 Enable_Display = off  Input_Switch = on	Highway_Display_Mode_1 = 232 Highway_Display_Mode_2 = 183 Highway_Display_Mode_3 = 41 Highway_Display_Mode_4 = 94
Highway_Input_Signal = 1 Enable_Display = on Input_Switch = on	Highway_Display_Mode_1 = 213 Highway_Display_Mode_2 = 183 Highway_Display_Mode_3 = 9 Highway_Display_Mode_4 = 94

Requirement No 2 [Lane_DisplayUnit]:

Inputs to this particular subsystem are “Enable_Display”, “Input_Switch”, “Lane_Input_Signal”. These three input signals, when assigned to a particular value will give output signals of specific value. The output signals are “Lane_Display_Mode_1”, “Lane_Display_Mode_2”, “Lane_Display_Mode_3”, “Lane_Display_Mode_4”. The requirement must be implemented in the form of Stateflow logic.

Condition	Action
Lane_Input_Signal= 6 Enable_Display = off Input_Switch = on	Lane_Display_Mode_1 = 132 Lane_Display_Mode_2 = 185 Lane_Display_Mode_3 = 54 Lane_Display_Mode_4 = 67
Lane_Input_Signal= 6 Enable_Display = on Input_Switch = on	Lane_Display_Mode_1 = 127 Lane_Display_Mode_2 = 248 Lane_Display_Mode_3 = 186 Lane_Display_Mode_4 = 84

Requirement No 3:

Signals coming from both subsystems “Highway_Display_Mode_1” & “Lane_Display_Mode_1” are given as inputs to a switch block which will have input signal “Highway_Input_Signal” given as 2^nd input to the switch block. Corresponding output from this particular switch block is output signal “Display_Mode_1”.

Signals coming from both subsystems “Highway_Display_Mode_2” & “Lane_Display_Mode_2” are given as inputs to a switch block which will have input signal “Highway_Input_Signal” given as 2^nd input to the switch block. Corresponding output from this particular switch block is output signal “Display_Mode_2”.

Signals coming from both subsystems “Highway_Display_Mode_3” & “Lane_Display_Mode_3” are given as inputs to a switch block which will have input signal “Highway_Input_Signal” given as 2^nd input to the switch block. Corresponding output from this particular switch block is output signal “Display_Mode_3”.

Signals coming from both subsystems “Highway_Display_Mode_4” & “Lane_Display_Mode_4” are given as inputs to a switch block which will have input signal “Highway_Input_Signal” given as 2^nd input to the switch block. Corresponding output from this particular switch block is output signal “Display_Mode_4”.

Steps:

• Simulink Data Dictionary Creation: Firstly we need to understand the signal requirment i.e Input signal, Output signal and Local signals as per given model. And then create SLDD file from the respective signal list and finally link this SLDD file to the model using "Link to Data Dictionary" .

• Model Designing:  The Model contains 3 requirments, From these requirment1 has 2 condtions, 3 input signal and 4 output signal. The conditions is designed using Stateflow block, were we have designed the logic as per the requirment.

                                                                             

This requirment has two condtional blocks there we have specified diffrent values for signals like Highway_Display_Mode_1, Highway_Display_Mode_2, Highway_Display_Mode_3, Highway_Display_Mode_4.

After designing the logic we add respective signals in the Model Explorer of the chart.

         

Similarly, The same process is carried out for designing of the Requirment2 only the output signals are diffrent i.e Lane_Dispkay_Mode_1, Lane_Dispkay_Mode_2, Lane_Dispkay_Mode_3, Lane_Dispkay_Mode_4. But the logic remains as previous Requirment1.

                                                                   

Requirment3 has 4 Simulink Switch blocks respectively, Input1 and Input3 are taken each from Ouput signals of Requrment1 and Requrment2 eg. Highway_Display_Mode_1 is first input of the Switch block and Lane_Display_Mode_1   is Third input of the Suitch block, and the Second Input is comming from the Input signal Highway_Input_Signal for each Switch block.

                                                                 

The Figure of final model  is shown below:

                                                                

Finally creating the subsystem of these Requirments which forms our main Highway Assistant-Lane Changing Assistant System.

                                                                           

• Configuring AUTOSAR Coder: Now, once we have done modeling and linking the SLDD to model we need to change the Congiguration Parameter Settings as per our model. In this we set System target file to autosar.tlc and Solver to Fixed and discrete, then Apply the settings to current model.

• AUTOSAR Port Mapping:  Once we are done configuring our model for AUTOSAR coder we Configur AUTOSAR software component properties and start the port mapping. As we click on the AUTOSAR Code App we get a pop up which is used to configure the SWC properties. After finishing this process we Start AUTOSAR port mapping of our model.We open the AUTOSAR Editor by clicking on Code Mapping - AUTOSAR software component at left bottom of our screen.

First we configure the Xml properties in this editor:

Second, We set our Sender Reciever Interfaces with perfix 'SRIf_' for all the signals:

Third, We set the Data Elements with prefix 'DE_' for all the SR-interfaces respectively

And then we add the Sender with prefix 'Pp_' and reciver port has prefix 'Rp_' along with thier SRIf signals.

  

• Model Advisory Report: We have done all the port mapping and configuration changes as per AUTOSAR guidelines, now we have to check the waring and error by checking and generating Model Advisory Report.  

• Code Genration: After checking the Model Advisory Report we are now able to Generate the code for this model, We have to click on Generate Code button availabe in AUTOSAR code App, and finally we get our code.

Code:

/*
* File: Lane_changing.c
*
* Code generated for Simulink model 'Lane_changing'.
*
* Model version : 1.8
* Simulink Coder version : 9.3 (R2020a) 18-Nov-2019
* C/C++ source code generated on : Wed Jun 1 23:06:37 2022
*
* Target selection: autosar.tlc
* Embedded hardware selection: Intel->x86-64 (Windows64)
* Code generation objectives:
* 1. Execution efficiency
* 2. RAM efficiency
* Validation result: Not run
*/

#include "Lane_changing.h"

/* Named constants for Chart: '/Requirment1' */
#define IN_Condition1 ((uint8)1U)
#define IN_Condition2 ((uint8)2U)

/* Block signals and states (default storage) */
DW rtDW;

/* Model step function */
void Lane_changing_Step(void)
{
uint8 rtb_Lane_Display_Mode_1;
uint8 rtb_Lane_Display_Mode_2;
uint8 rtb_Lane_Display_Mode_3;
uint8 rtb_Lane_Display_Mode_4;
float64 tmp;

/* Chart: '/Requirment1' incorporates:
* Inport: '/Enable_Display'
* Inport: '/Highway_Input_Signal'
* Inport: '/Input_Switch'
*/
if (rtDW.is_active_c3_Lane_changing == 0U) {
rtDW.is_active_c3_Lane_changing = 1U;
rtDW.is_c3_Lane_changing = IN_Condition1;
} else if (rtDW.is_c3_Lane_changing == IN_Condition1) {
if ((Rte_IRead_Lane_changing_Step_Rp_Highway_Input_Signal_DE_Highway_Input_Signal
() == 1.0) &&
(Rte_IRead_Lane_changing_Step_Rp_Enable_Display_DE_Enable_Display() == 1)
&& (Rte_IRead_Lane_changing_Step_Rp_Input_Switch_DE_Input_Switch() == 1))
{
rtDW.is_c3_Lane_changing = IN_Condition2;
}
} else {
/* case IN_Condition2: */
if ((Rte_IRead_Lane_changing_Step_Rp_Highway_Input_Signal_DE_Highway_Input_Signal
() == 1.0) &&
(Rte_IRead_Lane_changing_Step_Rp_Enable_Display_DE_Enable_Display() == 0)
&& (Rte_IRead_Lane_changing_Step_Rp_Input_Switch_DE_Input_Switch() == 1))
{
rtDW.is_c3_Lane_changing = IN_Condition1;
}
}

/* End of Chart: '/Requirment1' */

/* Chart: '/Requirment2' incorporates:
* Inport: '/Enable_Display'
* Inport: '/Input_Switch'
* Inport: '/Lane_Input_Signal'
*/
if (rtDW.is_active_c1_Lane_changing == 0U) {
rtDW.is_active_c1_Lane_changing = 1U;
rtDW.is_c1_Lane_changing = IN_Condition1;
rtb_Lane_Display_Mode_1 = 132U;
rtb_Lane_Display_Mode_2 = 185U;
rtb_Lane_Display_Mode_3 = 54U;
rtb_Lane_Display_Mode_4 = 67U;
} else if (rtDW.is_c1_Lane_changing == IN_Condition1) {
if ((Rte_IRead_Lane_changing_Step_Rp_Lane_Input_Signal_DE_Lane_Input_Signal()
== 6) &&
(Rte_IRead_Lane_changing_Step_Rp_Enable_Display_DE_Enable_Display() == 1)
&& (Rte_IRead_Lane_changing_Step_Rp_Input_Switch_DE_Input_Switch() == 1))
{
rtDW.is_c1_Lane_changing = IN_Condition2;
rtb_Lane_Display_Mode_1 = 127U;
rtb_Lane_Display_Mode_2 = 248U;
rtb_Lane_Display_Mode_3 = 186U;
rtb_Lane_Display_Mode_4 = 84U;
} else {
rtb_Lane_Display_Mode_1 = 132U;
rtb_Lane_Display_Mode_2 = 185U;
rtb_Lane_Display_Mode_3 = 54U;
rtb_Lane_Display_Mode_4 = 67U;
}
} else {
/* case IN_Condition2: */
if ((Rte_IRead_Lane_changing_Step_Rp_Lane_Input_Signal_DE_Lane_Input_Signal()
== 6) &&
(Rte_IRead_Lane_changing_Step_Rp_Enable_Display_DE_Enable_Display() == 0)
&& (Rte_IRead_Lane_changing_Step_Rp_Input_Switch_DE_Input_Switch() == 1))
{
rtDW.is_c1_Lane_changing = IN_Condition1;
rtb_Lane_Display_Mode_1 = 132U;
rtb_Lane_Display_Mode_2 = 185U;
rtb_Lane_Display_Mode_3 = 54U;
rtb_Lane_Display_Mode_4 = 67U;
} else {
rtb_Lane_Display_Mode_1 = 127U;
rtb_Lane_Display_Mode_2 = 248U;
rtb_Lane_Display_Mode_3 = 186U;
rtb_Lane_Display_Mode_4 = 84U;
}
}

/* End of Chart: '/Requirment2' */

/* Switch: '/Switch' incorporates:
* Inport: '/Highway_Input_Signal'
* Switch: '/Switch1'
* Switch: '/Switch2'
* Switch: '/Switch3'
*/
tmp =
Rte_IRead_Lane_changing_Step_Rp_Highway_Input_Signal_DE_Highway_Input_Signal
();
if (tmp > 0.0) {
rtb_Lane_Display_Mode_1 = 232U;
}

/* End of Switch: '/Switch' */

/* Outport: '/Display_Mode_1' */
Rte_IWrite_Lane_changing_Step_Pp_Display_Mode_1_DE_Display_Mode_1
(rtb_Lane_Display_Mode_1);

/* Switch: '/Switch1' */
if (tmp > 0.0) {
rtb_Lane_Display_Mode_2 = 183U;
}

/* Outport: '/Display_Mode_2' */
Rte_IWrite_Lane_changing_Step_Pp_Display_Mode_2_DE_Display_Mode_2
(rtb_Lane_Display_Mode_2);

/* Switch: '/Switch2' */
if (tmp > 0.0) {
rtb_Lane_Display_Mode_3 = 41U;
}

/* Outport: '/Display_Mode_3' */
Rte_IWrite_Lane_changing_Step_Pp_Display_Mode_3_DE_Display_Mode_3
(rtb_Lane_Display_Mode_3);

/* Switch: '/Switch3' */
if (tmp > 0.0) {
rtb_Lane_Display_Mode_4 = 94U;
}

/* Outport: '/Display_Mode_4' */
Rte_IWrite_Lane_changing_Step_Pp_Display_Mode_4_DE_Display_Mode_4
(rtb_Lane_Display_Mode_4);
}

/* Model initialize function */
void Lane_changing_Init(void)
{
/* (no initialization code required) */
}

/*
* File trailer for generated code.
*
* [EOF]
*/