Project 2 - Development of TFT Cluster Speedometer Software Component
Develop the Simulink model based on the given requirements and also create SLDD file and link the same to the model.
Aim:-
To develope a simulink model as per the requirement and sldd creation, JMAAB Testing, MIL and SIL Coverage report & Harness results for the model to be done.
Description:-
Cluster Instrument receives the signals from other ECU's via CAN bus interface. It also receives commands from the driver via steering wheel buttons. The signals are then processed by the Cluster ECU, after which the Cluster ECU may send the vehicle information to the LCD or light the LEDs and so forth, according to the results. Therefore, the Cluster ECU can be viewed as a carrier of the information flow.
Simulink Model:
As per Requirements the subsystems are made which is as seen below.
Requirements:
Requirement 1:- Input_Processing
Average Vehicle Speed would be displayed only if its between 2 kmph & 250 kmph. Any value outside this range will be discarded by its lower limit & upper limit
When Average Vehicle Speed is < 2 kmph, DisplaySpeed = 2 kmph
When Average Vehicle Speed is in between 2 kmph & 250 kmph, Display Speed = Average Vehicle Speed
When Average Vehicle Speed is > 250 kmph, Display Speed = 250 kmph
Requirement 2:- Main_Data_Filtering
Main Data Filtering subsystem will be activated for every 10th millisecond
DisplaySpeed1 (t) = ((DisplaySpeed (t) x 0.65)/ Main Filter Speed Value) - 0.05
Requirement 3:- Auxillary Data Filtering
Auxillary Data Filtering subsystem will be activated for every 10th millisecond
DisplaySpeed_Filter (t) = ((DisplaySpeed1 (t) x 0.78)/ Auxillary Filter Speed Value) - 0.03\
Requirement4:- TFT Speed Output:-
If |(DisplaySpeedFilter - DisplaySpeed)| > 1.5
{
Vehicle Speed Display = DisplaySpeed
}
else
{
Vehicle Speed Display = DisplaySpeed Filter
}
SLDD file
Requirement tagging report
JMAAB Guideline Check
Functional test case, MIL, SIL harness, coverage Reports
Signal Builder
MIL
SIL
Code generation
/*
* TFT_cluster_speedometer.c
*
* Student License - for use by students to meet course requirements and
* perform academic research at degree granting institutions only. Not
* for government, commercial, or other organizational use.
*
* Code generation for model "TFT_cluster_speedometer".
*
* Model version : 1.22
* Simulink Coder version : 9.8 (R2022b) 13-May-2022
* C source code generated on : Wed Oct 26 18:49:44 2022
*
* Target selection: grt.tlc
* Note: GRT includes extra infrastructure and instrumentation for prototyping
* Embedded hardware selection: Intel->x86-64 (Windows64)
* Code generation objectives: Unspecified
* Validation result: Not run
*/
#include "TFT_cluster_speedometer.h"
#include "rtwtypes.h"
#include "TFT_cluster_speedometer_private.h"
#include
#include "rt_nonfinite.h"
#include
#include
/* Exported block signals */
uint16_T Out_VehicleSpeedDisplay; /* '/Switch' */
/* Block signals (default storage) */
B_TFT_cluster_speedometer_T TFT_cluster_speedometer_B;
/* External inputs (root inport signals with default storage) */
ExtU_TFT_cluster_speedometer_T TFT_cluster_speedometer_U;
/* External outputs (root outports fed by signals with default storage) */
ExtY_TFT_cluster_speedometer_T TFT_cluster_speedometer_Y;
/* Real-time model */
static RT_MODEL_TFT_cluster_speedome_T TFT_cluster_speedometer_M_;
RT_MODEL_TFT_cluster_speedome_T *const TFT_cluster_speedometer_M =
&TFT_cluster_speedometer_M_;
real_T rt_remd_snf(real_T u0, real_T u1)
{
real_T y;
if (rtIsNaN(u0) || rtIsNaN(u1) || rtIsInf(u0)) {
y = (rtNaN);
} else if (rtIsInf(u1)) {
y = u0;
} else if ((u1 != 0.0) && (u1 != trunc(u1))) {
real_T q;
q = fabs(u0 / u1);
if (!(fabs(q - floor(q + 0.5)) > DBL_EPSILON * q)) {
y = 0.0 * u0;
} else {
y = fmod(u0, u1);
}
} else {
y = fmod(u0, u1);
}
return y;
}
/* Model step function */
void TFT_cluster_speedometer_step(void)
{
/* Saturate: '/Saturation' incorporates:
* Inport: '/Avg_vehiclespeed'
*/
if (TFT_cluster_speedometer_U.Avg_vehiclespeed >
TFT_cluster_speedometer_P.Saturation_UpperSat) {
/* Saturate: '/Saturation' */
TFT_cluster_speedometer_B.Displayspeed =
TFT_cluster_speedometer_P.Saturation_UpperSat;
} else if (TFT_cluster_speedometer_U.Avg_vehiclespeed <
TFT_cluster_speedometer_P.Saturation_LowerSat) {
/* Saturate: '/Saturation' */
TFT_cluster_speedometer_B.Displayspeed =
TFT_cluster_speedometer_P.Saturation_LowerSat;
} else {
/* Saturate: '/Saturation' */
TFT_cluster_speedometer_B.Displayspeed =
TFT_cluster_speedometer_U.Avg_vehiclespeed;
}
/* End of Saturate: '/Saturation' */
/* Outputs for Enabled SubSystem: '/Requirement3' incorporates:
* EnablePort: '/Enable'
*/
/* Outputs for Enabled SubSystem: '/Requirement2' incorporates:
* EnablePort: '/Enable'
*/
/* RelationalOperator: '/Compare' incorporates:
* Constant: '/Constant'
* Constant: '/Constant'
* Inport: '/Time_Input'
* Math: '/Rem'
*/
if (rt_remd_snf(TFT_cluster_speedometer_U.Time_Input,
TFT_cluster_speedometer_P.Constant_Value) ==
TFT_cluster_speedometer_P.CompareToConstant_const) {
uint16_T tmp;
/* Product: '/Divide' incorporates:
* Constant: '/Constant'
* Inport: '/In_MainFilt_SpeedValue'
* Product: '/Product'
*/
if (TFT_cluster_speedometer_U.In_MainFilt_SpeedValue == 0U) {
tmp = MAX_uint16_T;
/* Divide by zero handler */
} else {
tmp = (uint16_T)((uint32_T)(uint16_T)
(TFT_cluster_speedometer_B.Displayspeed *
TFT_cluster_speedometer_P.Constant_Value_m) /
TFT_cluster_speedometer_U.In_MainFilt_SpeedValue);
}
/* Sum: '/Subtract' incorporates:
* Constant: '/Constant1'
* Product: '/Divide'
*/
TFT_cluster_speedometer_B.Displayspeed1 = (uint16_T)(tmp -
TFT_cluster_speedometer_P.Constant1_Value);
/* Product: '/Divide' incorporates:
* Constant: '/Constant'
* Inport: '/In_AuxillaryFilt_SpeedValue'
* Product: '/Product'
*/
if (TFT_cluster_speedometer_U.In_AuxillaryFilt_SpeedValue == 0U) {
tmp = MAX_uint16_T;
/* Divide by zero handler */
} else {
tmp = (uint16_T)((uint32_T)(uint16_T)
(TFT_cluster_speedometer_B.Displayspeed1 *
TFT_cluster_speedometer_P.Constant_Value_c) /
TFT_cluster_speedometer_U.In_AuxillaryFilt_SpeedValue);
}
/* Sum: '/Subtract' incorporates:
* Constant: '/Constant1'
* Product: '/Divide'
*/
TFT_cluster_speedometer_B.Displayspeed_Filter = (uint16_T)(tmp -
TFT_cluster_speedometer_P.Constant1_Value_b);
}
/* End of RelationalOperator: '/Compare' */
/* End of Outputs for SubSystem: '/Requirement2' */
/* End of Outputs for SubSystem: '/Requirement3' */
/* Switch: '/Switch' incorporates:
* Constant: '/Constant'
* RelationalOperator: '/Compare'
* Sum: '/Subtract'
*/
if ((uint16_T)(TFT_cluster_speedometer_B.Displayspeed_Filter -
TFT_cluster_speedometer_B.Displayspeed) >
TFT_cluster_speedometer_P.CompareToConstant_const_l) {
/* Switch: '/Switch' */
Out_VehicleSpeedDisplay = TFT_cluster_speedometer_B.Displayspeed;
} else {
/* Switch: '/Switch' */
Out_VehicleSpeedDisplay = TFT_cluster_speedometer_B.Displayspeed_Filter;
}
/* End of Switch: '/Switch' */
/* Outport: '/Out_VehicleSpeedDisplay' */
TFT_cluster_speedometer_Y.Out_VehicleSpeedDisplay_e = Out_VehicleSpeedDisplay;
/* Matfile logging */
rt_UpdateTXYLogVars(TFT_cluster_speedometer_M->rtwLogInfo,
(&TFT_cluster_speedometer_M->Timing.taskTime0));
/* signal main to stop simulation */
{ /* Sample time: [0.2s, 0.0s] */
if ((rtmGetTFinal(TFT_cluster_speedometer_M)!=-1) &&
!((rtmGetTFinal(TFT_cluster_speedometer_M)-
TFT_cluster_speedometer_M->Timing.taskTime0) >
TFT_cluster_speedometer_M->Timing.taskTime0 * (DBL_EPSILON))) {
rtmSetErrorStatus(TFT_cluster_speedometer_M, "Simulation finished");
}
}
/* Update absolute time for base rate */
/* The "clockTick0" counts the number of times the code of this task has
* been executed. The absolute time is the multiplication of "clockTick0"
* and "Timing.stepSize0". Size of "clockTick0" ensures timer will not
* overflow during the application lifespan selected.
* Timer of this task consists of two 32 bit unsigned integers.
* The two integers represent the low bits Timing.clockTick0 and the high bits
* Timing.clockTickH0. When the low bit overflows to 0, the high bits increment.
*/
if (!(++TFT_cluster_speedometer_M->Timing.clockTick0)) {
++TFT_cluster_speedometer_M->Timing.clockTickH0;
}
TFT_cluster_speedometer_M->Timing.taskTime0 =
TFT_cluster_speedometer_M->Timing.clockTick0 *
TFT_cluster_speedometer_M->Timing.stepSize0 +
TFT_cluster_speedometer_M->Timing.clockTickH0 *
TFT_cluster_speedometer_M->Timing.stepSize0 * 4294967296.0;
}
/* Model initialize function */
void TFT_cluster_speedometer_initialize(void)
{
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)TFT_cluster_speedometer_M, 0,
sizeof(RT_MODEL_TFT_cluster_speedome_T));
rtmSetTFinal(TFT_cluster_speedometer_M, 10.0);
TFT_cluster_speedometer_M->Timing.stepSize0 = 0.2;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
rt_DataLoggingInfo.loggingInterval = (NULL);
TFT_cluster_speedometer_M->rtwLogInfo = &rt_DataLoggingInfo;
}
/* Setup for data logging */
{
rtliSetLogXSignalInfo(TFT_cluster_speedometer_M->rtwLogInfo, (NULL));
rtliSetLogXSignalPtrs(TFT_cluster_speedometer_M->rtwLogInfo, (NULL));
rtliSetLogT(TFT_cluster_speedometer_M->rtwLogInfo, "tout");
rtliSetLogX(TFT_cluster_speedometer_M->rtwLogInfo, "");
rtliSetLogXFinal(TFT_cluster_speedometer_M->rtwLogInfo, "");
rtliSetLogVarNameModifier(TFT_cluster_speedometer_M->rtwLogInfo, "rt_");
rtliSetLogFormat(TFT_cluster_speedometer_M->rtwLogInfo, 4);
rtliSetLogMaxRows(TFT_cluster_speedometer_M->rtwLogInfo, 0);
rtliSetLogDecimation(TFT_cluster_speedometer_M->rtwLogInfo, 1);
rtliSetLogY(TFT_cluster_speedometer_M->rtwLogInfo, "");
rtliSetLogYSignalInfo(TFT_cluster_speedometer_M->rtwLogInfo, (NULL));
rtliSetLogYSignalPtrs(TFT_cluster_speedometer_M->rtwLogInfo, (NULL));
}
/* block I/O */
(void) memset(((void *) &TFT_cluster_speedometer_B), 0,
sizeof(B_TFT_cluster_speedometer_T));
/* exported global signals */
Out_VehicleSpeedDisplay = 0U;
/* external inputs */
(void)memset(&TFT_cluster_speedometer_U, 0, sizeof
(ExtU_TFT_cluster_speedometer_T));
/* external outputs */
TFT_cluster_speedometer_Y.Out_VehicleSpeedDisplay_e = 0U;
/* Matfile logging */
rt_StartDataLoggingWithStartTime(TFT_cluster_speedometer_M->rtwLogInfo, 0.0,
rtmGetTFinal(TFT_cluster_speedometer_M),
TFT_cluster_speedometer_M->Timing.stepSize0, (&rtmGetErrorStatus
(TFT_cluster_speedometer_M)));
/* SystemInitialize for Enabled SubSystem: '/Requirement2' */
/* SystemInitialize for Sum: '/Subtract' incorporates:
* Outport: '/Displayspeed1'
*/
TFT_cluster_speedometer_B.Displayspeed1 =
TFT_cluster_speedometer_P.Displayspeed1_Y0;
/* End of SystemInitialize for SubSystem: '/Requirement2' */
/* SystemInitialize for Enabled SubSystem: '/Requirement3' */
/* SystemInitialize for Sum: '/Subtract' incorporates:
* Outport: '/Displayspeed_Filter'
*/
TFT_cluster_speedometer_B.Displayspeed_Filter =
TFT_cluster_speedometer_P.Displayspeed_Filter_Y0;
/* End of SystemInitialize for SubSystem: '/Requirement3' */
}
/* Model terminate function */
void TFT_cluster_speedometer_terminate(void)
{
/* (no terminate code required) */
}
Report:
Result
The simulink model is developed as per the requirement and sldd creation, JMAAB Testing, MIL and SIL Coverage report & Harness results for the model are done.