Analysis Information

Model Information

S-Function Instance

Tests

Summary

File/Complexity		Test 1
		Decision		Condition		MCDC
TOTAL COVERAGE	11	82%		67%		50%
1. . . . EZTEST_wrapper.c	3	--		--		--
2. . . . LighTsControl.c	8	82%		67%		50%

Analysis Information

File Information

Tests

Summary

Details

Code

        

          
1
/* Wrapper for TRACE32-PIL */
          
2

          
3
#include "EZTEST_wrapper.h"
          
4
#include "QFP.h"
          
5
#include "LighTsControl.h"
          
6

          
7
void EZTEST_init(ez_uint32 EZTEST_HysteresisStepsOff, ez_uint32 EZTEST_HysteresisStepsOn, ez_uint32 EZTEST_MinLightOff, ez_uint32 EZTEST_MinLightOn)
          
8
{
          
9
  /* Call mapped function */
          
10
  INIT_LighTsControl();
          
11

          
12
  /* Set model parameters */
          
13
  QFParams.HysteresisStepsOff = EZTEST_HysteresisStepsOff;
          
14
  QFParams.HysteresisStepsOn = EZTEST_HysteresisStepsOn;
          
15
  QFParams.MinLightOff = EZTEST_MinLightOff;
          
16
  QFParams.MinLightOn = EZTEST_MinLightOn;
          
17
}
          
18

          
19
void EZTEST_step(ez_uint32 EZTEST_light_switch, ez_uint32 EZTEST_light_intensity, ez_boolean EZTEST_headlight[1])
          
20
{
          
21
  /* Declare persistent matrix variables */
          
22
  static ez_boolean headlight = 0;
          
23

          
24
  /* Call mapped function */
          
25
  STEP_LighTsControl(EZTEST_light_switch, EZTEST_light_intensity, EZTEST_headlight);
          
26

          
27
  /* Store matrix content */
          
28
  headlight = EZTEST_headlight[0];
          
29
}
          
30

          
31
void EZTEST_term(void)
          
32
{
          
33
}
          
34

        
      

Analysis Information

File Information

Tests

Summary

File Contents/Complexity		Test 1
		Decision		Condition		MCDC
1 . LighTsControl.c	8	82%		67%		50%
2 . . . STEP_LighTsControl	7	82%		67%		50%
3 . . . INIT_LighTsControl	1	--		--		--

Details

Code

        

          
1
/*
          
2
 * File: LighTsControl.c
          
3
 *
          
4
 * Code generated for Simulink model 'LighTsControl'.
          
5
 *
          
6
 * Model version                  : 1.284
          
7
 * Simulink Coder version         : 8.7 (R2014b) 08-Sep-2014
          
8
 * C/C++ source code generated on : Fri Dec 09 15:07:50 2016
          
9
 *
          
10
 * Target selection: ert.tlc
          
11
 * Embedded hardware selection: 32-bit Generic
          
12
 * Code generation objectives: Unspecified
          
13
 * Validation result: Not run
          
14
 */
          
15

          
16
#include "LighTsControl.h"
          
17

          
18
/* Exported data definition */
          
19

          
20
/* Definition for custom storage class: FileScope */
          
21
static boolean_T LighTsControl_UnitDelay;
          
22
static uint32_T LighTsControl_UnitDelay1;
          
23
static uint32_T LighTsControl_UnitDelay2;
          
24
static boolean_T LighTsControl_UnitDelay3;
          
25

          
26
/* Model step function */
          
27
void STEP_LighTsControl(const uint32_T light_switch, const uint32_T
          
28
  light_intensity, boolean_T *headlight)
          
29
{
          
30
  boolean_T rtb_intensity_isOn;
          
31

          
32
  /* Outputs for Atomic SubSystem: '<Root>/LighTsControl' */
          
33
  /* RelationalOperator: '<S1>/RelationalOperator1' incorporates:
          
34
   *  Constant: '<S1>/HysteresisStepsOn'
          
35
   *  UnitDelay: '<S3>/LighTsControl_UnitDelay2'
          
36
   */
          
37
  rtb_intensity_isOn = (LighTsControl_UnitDelay2 >= QFParams.HysteresisStepsOn);
          
38

          
39
  /* Switch: '<S1>/Switch1' incorporates:
          
40
   *  Constant: '<S1>/HysteresisStepsOff'
          
41
   *  Logic: '<S1>/switchheadlighttoonoroff'
          
42
   *  RelationalOperator: '<S1>/RelationalOperator2'
          
43
   *  Switch: '<S1>/Switch'
          
44
   *  UnitDelay: '<S1>/LighTsControl_UnitDelay3'
          
45
   *  UnitDelay: '<S2>/LighTsControl_UnitDelay1'
          
46
   */
          
47
  if ((LighTsControl_UnitDelay1 >= QFParams.HysteresisStepsOff) || rtb_intensity_isOn) {
          
48
    LighTsControl_UnitDelay = rtb_intensity_isOn;
          
49
  } else {
          
50
    if (LighTsControl_UnitDelay3) {
          
51
      /* Switch: '<S1>/Switch' incorporates:
          
52
       *  Constant: '<S1>/MinLightOff'
          
53
       *  Inport: '<Root>/light_intensity'
          
54
       *  RelationalOperator: '<S1>/RelationalOperator'
          
55
       */
          
56
      LighTsControl_UnitDelay = (light_intensity <= QFParams.MinLightOff);
          
57
    }
          
58
  }
          
59

          
60
  /* End of Switch: '<S1>/Switch1' */
          
61

          
62
  /* Switch: '<S2>/counttime1' incorporates:
          
63
   *  Constant: '<S1>/MinLightOff1'
          
64
   *  Inport: '<Root>/light_intensity'
          
65
   *  RelationalOperator: '<S1>/RelationalOperator3'
          
66
   */
          
67
  if (light_intensity > QFParams.MinLightOff) {
          
68
    /* Update for UnitDelay: '<S2>/LighTsControl_UnitDelay1' incorporates:
          
69
     *  Constant: '<S2>/Constant'
          
70
     *  Sum: '<S2>/Add1'
          
71
     *  UnitDelay: '<S2>/LighTsControl_UnitDelay1'
          
72
     */
          
73
    LighTsControl_UnitDelay1 = LighTsControl_UnitDelay1 + 1U;
          
74
  } else {
          
75
    /* Update for UnitDelay: '<S2>/LighTsControl_UnitDelay1' incorporates:
          
76
     *  Constant: '<S2>/Constant3'
          
77
     */
          
78
    LighTsControl_UnitDelay1 = 0U;
          
79
  }
          
80

          
81
  /* End of Switch: '<S2>/counttime1' */
          
82

          
83
  /* Switch: '<S3>/counttime1' incorporates:
          
84
   *  Constant: '<S1>/MinLightOn'
          
85
   *  Inport: '<Root>/light_intensity'
          
86
   *  RelationalOperator: '<S1>/RelationalOperator4'
          
87
   */
          
88
  if (light_intensity < QFParams.MinLightOn) {
          
89
    /* Update for UnitDelay: '<S3>/LighTsControl_UnitDelay2' incorporates:
          
90
     *  Constant: '<S3>/Constant'
          
91
     *  Sum: '<S3>/Add1'
          
92
     *  UnitDelay: '<S3>/LighTsControl_UnitDelay2'
          
93
     */
          
94
    LighTsControl_UnitDelay2 = LighTsControl_UnitDelay2 + 1U;
          
95
  } else {
          
96
    /* Update for UnitDelay: '<S3>/LighTsControl_UnitDelay2' incorporates:
          
97
     *  Constant: '<S3>/Constant3'
          
98
     */
          
99
    LighTsControl_UnitDelay2 = 0U;
          
100
  }
          
101

          
102
  /* End of Switch: '<S3>/counttime1' */
          
103

          
104
  /* MultiPortSwitch: '<S1>/MultiportSwitch' incorporates:
          
105
   *  Inport: '<Root>/light_switch'
          
106
   */
          
107
  switch (light_switch) {
          
108
   case 0:
          
109
    /* Outport: '<Root>/headlight' incorporates:
          
110
     *  Constant: '<S1>/Constant'
          
111
     */
          
112
    *headlight = false;
          
113
    break;
          
114

          
115
   case 1:
          
116
    /* Outport: '<Root>/headlight' */
          
117
    *headlight = LighTsControl_UnitDelay;
          
118
    break;
          
119

          
120
   default:
          
121
    /* Outport: '<Root>/headlight' incorporates:
          
122
     *  Constant: '<S1>/Constant1'
          
123
     */
          
124
    *headlight = true;
          
125
    break;
          
126
  }
          
127

          
128
  /* End of MultiPortSwitch: '<S1>/MultiportSwitch' */
          
129

          
130
  /* Update for UnitDelay: '<S1>/LighTsControl_UnitDelay3' incorporates:
          
131
   *  Constant: '<S1>/Constant2'
          
132
   */
          
133
  LighTsControl_UnitDelay3 = false;
          
134

          
135
  /* End of Outputs for SubSystem: '<Root>/LighTsControl' */
          
136
}
          
137

          
138
/* Model initialize function */
          
139
void INIT_LighTsControl(void)
          
140
{
          
141
  /* Registration code */
          
142

          
143
  /* states (dwork) */
          
144

          
145
  /* custom states */
          
146
  LighTsControl_UnitDelay2 = 0U;
          
147
  LighTsControl_UnitDelay1 = 0U;
          
148
  LighTsControl_UnitDelay = false;
          
149
  LighTsControl_UnitDelay3 = false;
          
150

          
151
  /* InitializeConditions for Atomic SubSystem: '<Root>/LighTsControl' */
          
152
  /* InitializeConditions for UnitDelay: '<S1>/LighTsControl_UnitDelay3' */
          
153
  LighTsControl_UnitDelay3 = true;
          
154

          
155
  /* End of InitializeConditions for SubSystem: '<Root>/LighTsControl' */
          
156
}
          
157

          
158
/*
          
159
 * File trailer for generated code.
          
160
 *
          
161
 * [EOF]
          
162
 */
          
163

        
      

Analysis Information

Model Information

S-Function Instance

Tests

Summary

File/Complexity		Test 1
		Decision		Condition		MCDC
TOTAL COVERAGE	11	82%		67%		50%
1. . . . EZTEST_wrapper.c	3	--		--		--
2. . . . LighTsControl.c	8	82%		67%		50%