1/*
2 * File: DGM.c
3 *
4 * Code generated for Simulink model 'DGM'.
5 *
6 * Model version : 1.1
7 * Simulink Coder version : 8.13 (R2017b) 24-Jul-2017
8 * C/C++ source code generated on : Thu Jun 18 17:43:41 2020
9 *
10 * Target selection: ert.tlc
11 * Embedded hardware selection: Generic->Unspecified (assume 32-bit Generic)
12 * Code generation objectives: Unspecified
13 * Validation result: Not run
14 */
15
16#include "DGM.h"
17#include "DGM_private.h"
18
19/* Exported block signals */
20uint32_T VeDGM_flgFltReactnPt; /* '<S8>/Switch' */
21uint32_T VeDGM_flgFltReactnAux; /* '<S6>/Switch' */
22uint8_T VeDGM_enmVehFltLvl; /* '<S7>/Switch' */
23boolean_T COMR_DFC_Msg17DTmt; /* '<S197>/rff_cti' */
24boolean_T COMR_DFC_ChkSumMsg2EBErr; /* '<S192>/rff_cti' */
25boolean_T COMR_DFC_Msg2EBTmt; /* '<S188>/rff_cti' */
26boolean_T COMR_DFC_RcMsg2E6Mis; /* '<S184>/rff_cti' */
27boolean_T COMR_DFC_ChkSumMsg2E6Err; /* '<S180>/rff_cti' */
28boolean_T COMR_DFC_Msg2E6Tmt; /* '<S176>/rff_cti' */
29boolean_T COMR_DFC_RcMsg2E1Mis; /* '<S172>/rff_cti' */
30boolean_T COMR_DFC_Msg28CTmt; /* '<S168>/rff_cti' */
31boolean_T COMR_DFC_Msg37FTmt; /* '<S164>/rff_cti' */
32boolean_T COMR_DFC_Msg195Tmt; /* '<S160>/rff_cti' */
33boolean_T COMR_DFC_ChkSumMsg2E1Err; /* '<S156>/rff_cti' */
34boolean_T COMR_DFC_Msg2F1Tmt; /* '<S152>/rff_cti' */
35boolean_T COMR_DFC_RcMsg050Mis; /* '<S148>/rff_cti' */
36boolean_T COMR_DFC_ChkSumMsg050Err; /* '<S144>/rff_cti' */
37boolean_T COMR_DFC_Msg050Tmt; /* '<S140>/rff_cti' */
38boolean_T COMR_DFC_Msg3AATmt; /* '<S136>/rff_cti' */
39boolean_T COMR_DFC_Msg2DFTmt; /* '<S132>/rff_cti' */
40boolean_T COMR_DFC_Msg2BBTmt; /* '<S128>/rff_cti' */
41boolean_T COMR_DFC_Msg2ADTmt; /* '<S124>/rff_cti' */
42boolean_T COMR_DFC_RcMsg2A7Mis; /* '<S120>/rff_cti' */
43boolean_T COMR_DFC_ChkSumMsg2A7Err; /* '<S116>/rff_cti' */
44boolean_T COMR_DFC_Msg2E1Tmt; /* '<S112>/rff_cti' */
45boolean_T COMR_DFC_Msg2A7Tmt; /* '<S108>/rff_cti' */
46boolean_T COMR_DFC_RcMsg2A5Mis; /* '<S104>/rff_cti' */
47boolean_T COMR_DFC_ChkSumMsg2A5Err; /* '<S100>/rff_cti' */
48boolean_T COMR_DFC_Msg2A5Tmt; /* '<S96>/rff_cti' */
49boolean_T COMR_DFC_RcMsg2A3Mis; /* '<S92>/rff_cti' */
50boolean_T COMR_DFC_ChkSumMsg2A3Err; /* '<S88>/rff_cti' */
51boolean_T COMR_DFC_Msg2A3Tmt; /* '<S84>/rff_cti' */
52boolean_T COMR_DFC_Msg0B5Tmt; /* '<S80>/rff_cti' */
53boolean_T COMR_DFC_MsgCABTmt; /* '<S76>/rff_cti' */
54boolean_T COMR_DFC_RcMsg2EBMis; /* '<S72>/rff_cti' */
55boolean_T COMR_DFC_Msg130Tmt; /* '<S68>/rff_cti' */
56
57/* Exported data definition */
58
59/* ConstVolatile memory section */
60#define ASW1_OEM_START_SEC_DEFAULT_CALIB_32
61#include "Asw1_OEM_MemMap.h"
62
63/* Definition for custom storage class: ConstVolatile_32 */
64volatile const uint32_T KeDGM_bIOSDFC1Ovrdval = 4294967295U;
65volatile const uint32_T KeDGM_bIOSDFCOvrdval = 4294967295U;
66volatile const uint32_T KeDGM_flgFltReactnAuxVal = 0U;
67volatile const uint32_T KeDGM_flgFltReactnPtVal = 0U;
68
69#define ASW1_OEM_STOP_SEC_DEFAULT_CALIB_32
70#include "Asw1_OEM_MemMap.h"
71
72/* ConstVolatile memory section */
73#define ASW1_OEM_START_SEC_DEFAULT_CALIB_8
74#include "Asw1_OEM_MemMap.h"
75
76/* Definition for custom storage class: ConstVolatile_8 */
77volatile const uint8_T KeDGM_FltLvlVal = 0U;
78volatile const boolean_T KeDGM_bFltLvlFlg = 0;
79volatile const boolean_T KeDGM_bFltReactnAuxFlg = 0;
80volatile const boolean_T KeDGM_bFltReactnPtFlg = 0;
81
82#define ASW1_OEM_STOP_SEC_DEFAULT_CALIB_8
83#include "Asw1_OEM_MemMap.h"
84
85/* Block signals (auto storage) */
86BlockIO_DGM DGM_B;
87
88/* Block states (auto storage) */
89D_Work_DGM DGM_DWork;
90
91/* Real-time model */
92RT_MODEL_DGM DGM_M_;
93RT_MODEL_DGM *const DGM_M = &DGM_M_;
94
95/* Output and update for atomic system: '<S3>/OnAfterDelay' */
96boolean_T DGM_OnAfterDelay(boolean_T rtu_OnSignal, rtB_OnAfterDelay_DGM *localB,
97 rtDW_OnAfterDelay_DGM *localDW, uint32_T rtp_taskTime, uint32_T rtp_delayTime)
98{
99 uint32_T qY;
100 boolean_T rty_OnAfterDelay_0;
101
102 /* Outputs for Enabled SubSystem: '<S10>/Enabled Subsystem' incorporates:
103 * EnablePort: '<S32>/Enable'
104 */
105 if (rtu_OnSignal) {
106 if (!localDW->bitsForTID0.EnabledSubsystem_MODE) {
107 /* InitializeConditions for UnitDelay: '<S32>/Unit Delay' */
108 localDW->UnitDelay_DSTATE = 0U;
109 localDW->bitsForTID0.EnabledSubsystem_MODE = true;
110 }
111
112 /* Sum: '<S32>/Add' incorporates:
113 * Constant: '<S32>/Constant'
114 * UnitDelay: '<S32>/Unit Delay'
115 */
116 qY = rtp_taskTime + localDW->UnitDelay_DSTATE;
117 if (qY < rtp_taskTime) {
118 qY = MAX_uint32_T;
119 }
120
121 /* RelationalOperator: '<S32>/Relational Operator' incorporates:
122 * Constant: '<S32>/Constant1'
123 * Sum: '<S32>/Add'
124 */
125 localB->bitsForTID0.RelationalOperator = (rtp_delayTime < qY);
126
127 /* Update for UnitDelay: '<S32>/Unit Delay' incorporates:
128 * Sum: '<S32>/Add'
129 */
130 localDW->UnitDelay_DSTATE = qY;
131 } else {
132 if (localDW->bitsForTID0.EnabledSubsystem_MODE) {
133 localDW->bitsForTID0.EnabledSubsystem_MODE = false;
134 }
135 }
136
137 /* End of Outputs for SubSystem: '<S10>/Enabled Subsystem' */
138
139 /* Logic: '<S10>/Logical Operator' */
140 rty_OnAfterDelay_0 = (rtu_OnSignal && localB->bitsForTID0.RelationalOperator);
141 return rty_OnAfterDelay_0;
142}
143
144/* Output and update for atomic system: '<S3>/OnAfterDelay1' */
145boolean_T DGM_OnAfterDelay1(boolean_T rtu_OnSignal, rtB_OnAfterDelay_DGM_f
146 *localB, rtDW_OnAfterDelay_DGM_m *localDW, uint32_T rtp_taskTime, uint32_T
147 rtp_delayTime)
148{
149 uint32_T qY;
150 boolean_T rty_OnAfterDelay_0;
151
152 /* Outputs for Enabled SubSystem: '<S11>/Enabled Subsystem' incorporates:
153 * EnablePort: '<S33>/Enable'
154 */
155 if (rtu_OnSignal) {
156 if (!localDW->bitsForTID0.EnabledSubsystem_MODE) {
157 /* InitializeConditions for UnitDelay: '<S33>/Unit Delay' */
158 localDW->UnitDelay_DSTATE = 0U;
159 localDW->bitsForTID0.EnabledSubsystem_MODE = true;
160 }
161
162 /* Sum: '<S33>/Add' incorporates:
163 * Constant: '<S33>/Constant'
164 * UnitDelay: '<S33>/Unit Delay'
165 */
166 qY = rtp_taskTime + localDW->UnitDelay_DSTATE;
167 if (qY < rtp_taskTime) {
168 qY = MAX_uint32_T;
169 }
170
171 /* RelationalOperator: '<S33>/Relational Operator' incorporates:
172 * Constant: '<S33>/Constant1'
173 * Sum: '<S33>/Add'
174 */
175 localB->bitsForTID0.RelationalOperator = (rtp_delayTime < qY);
176
177 /* Update for UnitDelay: '<S33>/Unit Delay' incorporates:
178 * Sum: '<S33>/Add'
179 */
180 localDW->UnitDelay_DSTATE = qY;
181 } else {
182 if (localDW->bitsForTID0.EnabledSubsystem_MODE) {
183 localDW->bitsForTID0.EnabledSubsystem_MODE = false;
184 }
185 }
186
187 /* End of Outputs for SubSystem: '<S11>/Enabled Subsystem' */
188
189 /* Logic: '<S11>/Logical Operator' */
190 rty_OnAfterDelay_0 = (rtu_OnSignal && localB->bitsForTID0.RelationalOperator);
191 return rty_OnAfterDelay_0;
192}
193
194/* Output and update for atomic system: '<S3>/OnAfterDelay2' */
195boolean_T DGM_OnAfterDelay2(boolean_T rtu_OnSignal, rtB_OnAfterDelay_DGM_j
196 *localB, rtDW_OnAfterDelay_DGM_i *localDW, uint32_T rtp_taskTime, uint32_T
197 rtp_delayTime)
198{
199 uint32_T qY;
200 boolean_T rty_OnAfterDelay_0;
201
202 /* Outputs for Enabled SubSystem: '<S12>/Enabled Subsystem' incorporates:
203 * EnablePort: '<S34>/Enable'
204 */
205 if (rtu_OnSignal) {
206 if (!localDW->bitsForTID0.EnabledSubsystem_MODE) {
207 /* InitializeConditions for UnitDelay: '<S34>/Unit Delay' */
208 localDW->UnitDelay_DSTATE = 0U;
209 localDW->bitsForTID0.EnabledSubsystem_MODE = true;
210 }
211
212 /* Sum: '<S34>/Add' incorporates:
213 * Constant: '<S34>/Constant'
214 * UnitDelay: '<S34>/Unit Delay'
215 */
216 qY = rtp_taskTime + localDW->UnitDelay_DSTATE;
217 if (qY < rtp_taskTime) {
218 qY = MAX_uint32_T;
219 }
220
221 /* RelationalOperator: '<S34>/Relational Operator' incorporates:
222 * Constant: '<S34>/Constant1'
223 * Sum: '<S34>/Add'
224 */
225 localB->bitsForTID0.RelationalOperator = (rtp_delayTime < qY);
226
227 /* Update for UnitDelay: '<S34>/Unit Delay' incorporates:
228 * Sum: '<S34>/Add'
229 */
230 localDW->UnitDelay_DSTATE = qY;
231 } else {
232 if (localDW->bitsForTID0.EnabledSubsystem_MODE) {
233 localDW->bitsForTID0.EnabledSubsystem_MODE = false;
234 }
235 }
236
237 /* End of Outputs for SubSystem: '<S12>/Enabled Subsystem' */
238
239 /* Logic: '<S12>/Logical Operator' */
240 rty_OnAfterDelay_0 = (rtu_OnSignal && localB->bitsForTID0.RelationalOperator);
241 return rty_OnAfterDelay_0;
242}
243
244/* Output and update for atomic system: '<S3>/OnHoldT' */
245boolean_T DGM_OnHoldT(boolean_T rtu_OnSignal, rtB_OnHoldT_DGM *localB,
246 rtDW_OnHoldT_DGM *localDW, uint32_T rtp_taskTime, uint32_T
247 rtp_delayTime)
248{
249 uint32_T qY;
250 boolean_T rty_OnAfterDelay_0;
251
252 /* Outputs for Enabled SubSystem: '<S13>/Enabled Subsystem' incorporates:
253 * EnablePort: '<S35>/Enable'
254 */
255 if (rtu_OnSignal) {
256 if (!localDW->bitsForTID0.EnabledSubsystem_MODE) {
257 /* InitializeConditions for UnitDelay: '<S35>/Unit Delay' */
258 localDW->UnitDelay_DSTATE = 0U;
259 localDW->bitsForTID0.EnabledSubsystem_MODE = true;
260 }
261
262 /* Sum: '<S35>/Add' incorporates:
263 * Constant: '<S35>/Constant'
264 * UnitDelay: '<S35>/Unit Delay'
265 */
266 qY = rtp_taskTime + localDW->UnitDelay_DSTATE;
267 if (qY < rtp_taskTime) {
268 qY = MAX_uint32_T;
269 }
270
271 /* RelationalOperator: '<S35>/Relational Operator' incorporates:
272 * Constant: '<S35>/Constant1'
273 * Sum: '<S35>/Add'
274 */
275 localB->bitsForTID0.RelationalOperator = (rtp_delayTime > qY);
276
277 /* Update for UnitDelay: '<S35>/Unit Delay' incorporates:
278 * Sum: '<S35>/Add'
279 */
280 localDW->UnitDelay_DSTATE = qY;
281 } else {
282 if (localDW->bitsForTID0.EnabledSubsystem_MODE) {
283 localDW->bitsForTID0.EnabledSubsystem_MODE = false;
284 }
285 }
286
287 /* End of Outputs for SubSystem: '<S13>/Enabled Subsystem' */
288
289 /* Logic: '<S13>/Logical Operator' */
290 rty_OnAfterDelay_0 = (rtu_OnSignal && localB->bitsForTID0.RelationalOperator);
291 return rty_OnAfterDelay_0;
292}
293
294/*
295 * System initialize for atomic system:
296 * '<S68>/rff_cti'
297 * '<S72>/rff_cti'
298 * '<S76>/rff_cti'
299 * '<S80>/rff_cti'
300 * '<S84>/rff_cti'
301 * '<S88>/rff_cti'
302 * '<S92>/rff_cti'
303 * '<S96>/rff_cti'
304 * '<S100>/rff_cti'
305 * '<S104>/rff_cti'
306 * ...
307 */
308void DGM_rff_cti_Init(boolean_T *rty_fault_flg)
309{
310 *rty_fault_flg = false;
311}
312
313/*
314 * Output and update for atomic system:
315 * '<S68>/rff_cti'
316 * '<S72>/rff_cti'
317 * '<S76>/rff_cti'
318 * '<S80>/rff_cti'
319 * '<S84>/rff_cti'
320 * '<S88>/rff_cti'
321 * '<S92>/rff_cti'
322 * '<S96>/rff_cti'
323 * '<S100>/rff_cti'
324 * '<S104>/rff_cti'
325 * ...
326 */
327void DGM_rff_cti(boolean_T rtu_i_fault, int16_T rtu_sat, int16_T rtu_inc,
328 int16_T rtu_dec, boolean_T rtu_lock, boolean_T *rty_fault_flg,
329 rtDW_rff_cti_DGM *localDW)
330{
331 /* Chart: '<S68>/rff_cti' */
332 /* Gateway: Fault Operation/DGM_flt_debounce/rff_cti */
333 /* During: Fault Operation/DGM_flt_debounce/rff_cti */
334 /* Entry Internal: Fault Operation/DGM_flt_debounce/rff_cti */
335 /* Transition: '<S71>:8' */
336 if (rtu_i_fault) {
337 /* Transition: '<S71>:11' */
338 localDW->count += rtu_inc;
339 } else if (!rtu_lock) {
340 /* Transition: '<S71>:10' */
341 localDW->count -= rtu_dec;
342 } else {
343 /* Transition: '<S71>:22' */
344 }
345
346 /* Transition: '<S71>:13' */
347 if (localDW->count >= rtu_sat) {
348 /* Transition: '<S71>:16' */
349 localDW->count = rtu_sat;
350 *rty_fault_flg = true;
351 } else if (localDW->count <= 0) {
352 /* Transition: '<S71>:17' */
353 localDW->count = 0;
354 *rty_fault_flg = false;
355 } else {
356 /* Transition: '<S71>:15' */
357 }
358
359 /* End of Chart: '<S68>/rff_cti' */
360 /* Transition: '<S71>:19' */
361}
362
363/* System initialize for atomic system: '<S1>/IOS' */
364void DGM_IOS_Init(void)
365{
366 /* SystemInitialize for Chart: '<S68>/rff_cti' */
367 DGM_rff_cti_Init(&COMR_DFC_Msg130Tmt);
368
369 /* SystemInitialize for Chart: '<S112>/rff_cti' */
370 DGM_rff_cti_Init(&COMR_DFC_Msg2E1Tmt);
371
372 /* SystemInitialize for Chart: '<S156>/rff_cti' */
373 DGM_rff_cti_Init(&COMR_DFC_ChkSumMsg2E1Err);
374
375 /* SystemInitialize for Chart: '<S172>/rff_cti' */
376 DGM_rff_cti_Init(&COMR_DFC_RcMsg2E1Mis);
377
378 /* SystemInitialize for Chart: '<S176>/rff_cti' */
379 DGM_rff_cti_Init(&COMR_DFC_Msg2E6Tmt);
380
381 /* SystemInitialize for Chart: '<S180>/rff_cti' */
382 DGM_rff_cti_Init(&COMR_DFC_ChkSumMsg2E6Err);
383
384 /* SystemInitialize for Chart: '<S184>/rff_cti' */
385 DGM_rff_cti_Init(&COMR_DFC_RcMsg2E6Mis);
386
387 /* SystemInitialize for Chart: '<S188>/rff_cti' */
388 DGM_rff_cti_Init(&COMR_DFC_Msg2EBTmt);
389
390 /* SystemInitialize for Chart: '<S192>/rff_cti' */
391 DGM_rff_cti_Init(&COMR_DFC_ChkSumMsg2EBErr);
392
393 /* SystemInitialize for Chart: '<S72>/rff_cti' */
394 DGM_rff_cti_Init(&COMR_DFC_RcMsg2EBMis);
395
396 /* SystemInitialize for Chart: '<S76>/rff_cti' */
397 DGM_rff_cti_Init(&COMR_DFC_MsgCABTmt);
398
399 /* SystemInitialize for Chart: '<S80>/rff_cti' */
400 DGM_rff_cti_Init(&COMR_DFC_Msg0B5Tmt);
401
402 /* SystemInitialize for Chart: '<S84>/rff_cti' */
403 DGM_rff_cti_Init(&COMR_DFC_Msg2A3Tmt);
404
405 /* SystemInitialize for Chart: '<S88>/rff_cti' */
406 DGM_rff_cti_Init(&COMR_DFC_ChkSumMsg2A3Err);
407
408 /* SystemInitialize for Chart: '<S92>/rff_cti' */
409 DGM_rff_cti_Init(&COMR_DFC_RcMsg2A3Mis);
410
411 /* SystemInitialize for Chart: '<S96>/rff_cti' */
412 DGM_rff_cti_Init(&COMR_DFC_Msg2A5Tmt);
413
414 /* SystemInitialize for Chart: '<S100>/rff_cti' */
415 DGM_rff_cti_Init(&COMR_DFC_ChkSumMsg2A5Err);
416
417 /* SystemInitialize for Chart: '<S104>/rff_cti' */
418 DGM_rff_cti_Init(&COMR_DFC_RcMsg2A5Mis);
419
420 /* SystemInitialize for Chart: '<S108>/rff_cti' */
421 DGM_rff_cti_Init(&COMR_DFC_Msg2A7Tmt);
422
423 /* SystemInitialize for Chart: '<S116>/rff_cti' */
424 DGM_rff_cti_Init(&COMR_DFC_ChkSumMsg2A7Err);
425
426 /* SystemInitialize for Chart: '<S120>/rff_cti' */
427 DGM_rff_cti_Init(&COMR_DFC_RcMsg2A7Mis);
428
429 /* SystemInitialize for Chart: '<S124>/rff_cti' */
430 DGM_rff_cti_Init(&COMR_DFC_Msg2ADTmt);
431
432 /* SystemInitialize for Chart: '<S128>/rff_cti' */
433 DGM_rff_cti_Init(&COMR_DFC_Msg2BBTmt);
434
435 /* SystemInitialize for Chart: '<S132>/rff_cti' */
436 DGM_rff_cti_Init(&COMR_DFC_Msg2DFTmt);
437
438 /* SystemInitialize for Chart: '<S136>/rff_cti' */
439 DGM_rff_cti_Init(&COMR_DFC_Msg3AATmt);
440
441 /* SystemInitialize for Chart: '<S140>/rff_cti' */
442 DGM_rff_cti_Init(&COMR_DFC_Msg050Tmt);
443
444 /* SystemInitialize for Chart: '<S144>/rff_cti' */
445 DGM_rff_cti_Init(&COMR_DFC_ChkSumMsg050Err);
446
447 /* SystemInitialize for Chart: '<S148>/rff_cti' */
448 DGM_rff_cti_Init(&COMR_DFC_RcMsg050Mis);
449
450 /* SystemInitialize for Chart: '<S152>/rff_cti' */
451 DGM_rff_cti_Init(&COMR_DFC_Msg2F1Tmt);
452
453 /* SystemInitialize for Chart: '<S160>/rff_cti' */
454 DGM_rff_cti_Init(&COMR_DFC_Msg195Tmt);
455
456 /* SystemInitialize for Chart: '<S164>/rff_cti' */
457 DGM_rff_cti_Init(&COMR_DFC_Msg37FTmt);
458
459 /* SystemInitialize for Chart: '<S168>/rff_cti' */
460 DGM_rff_cti_Init(&COMR_DFC_Msg28CTmt);
461}
462
463/* Output and update for atomic system: '<S1>/IOS' */
464void DGM_IOS(void)
465{
466 uint8_T u0;
467 uint8_T u1;
468
469 /* Chart: '<S68>/rff_cti' incorporates:
470 * Constant: '<S68>/decrement'
471 * Constant: '<S68>/increment'
472 * Constant: '<S68>/limit'
473 * Constant: '<S68>/lock'
474 * DataTypeConversion: '<S36>/Data Type Conversion'
475 * DataTypeConversion: '<S69>/Extract Desired Bits'
476 * DataTypeConversion: '<S70>/Extract Desired Bits'
477 * Logic: '<S36>/AND'
478 */
479 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) && ((int32_T)
480 (DGM_B.Bitwise_AUX_b >> 31) != 0), 10, 1, 2, false, &COMR_DFC_Msg130Tmt,
481 &DGM_DWork.sf_rff_cti);
482
483 /* Chart: '<S112>/rff_cti' incorporates:
484 * Constant: '<S112>/decrement'
485 * Constant: '<S112>/increment'
486 * Constant: '<S112>/limit'
487 * Constant: '<S112>/lock'
488 * DataTypeConversion: '<S113>/Extract Desired Bits'
489 * DataTypeConversion: '<S114>/Extract Desired Bits'
490 * DataTypeConversion: '<S47>/Data Type Conversion'
491 * Logic: '<S47>/AND'
492 */
493 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
494 (((int32_T)(DGM_B.Bitwise_AUX_b >> 30) & 1) != 0), 100, 1, 2,
495 false, &COMR_DFC_Msg2E1Tmt, &DGM_DWork.sf_rff_cti_n);
496
497 /* Chart: '<S156>/rff_cti' incorporates:
498 * Constant: '<S156>/decrement'
499 * Constant: '<S156>/increment'
500 * Constant: '<S156>/limit'
501 * Constant: '<S156>/lock'
502 * DataTypeConversion: '<S157>/Extract Desired Bits'
503 * DataTypeConversion: '<S158>/Extract Desired Bits'
504 * DataTypeConversion: '<S58>/Data Type Conversion'
505 * Logic: '<S58>/AND'
506 */
507 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
508 (((int32_T)(DGM_B.Bitwise_AUX_b >> 29) & 1) != 0), 100, 1, 2,
509 false, &COMR_DFC_ChkSumMsg2E1Err, &DGM_DWork.sf_rff_cti_g);
510
511 /* Chart: '<S172>/rff_cti' incorporates:
512 * Constant: '<S172>/decrement'
513 * Constant: '<S172>/increment'
514 * Constant: '<S172>/limit'
515 * Constant: '<S172>/lock'
516 * DataTypeConversion: '<S173>/Extract Desired Bits'
517 * DataTypeConversion: '<S174>/Extract Desired Bits'
518 * DataTypeConversion: '<S62>/Data Type Conversion'
519 * Logic: '<S62>/AND'
520 */
521 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
522 (((int32_T)(DGM_B.Bitwise_AUX_b >> 28) & 1) != 0), 100, 1, 2,
523 false, &COMR_DFC_RcMsg2E1Mis, &DGM_DWork.sf_rff_cti_l);
524
525 /* Chart: '<S176>/rff_cti' incorporates:
526 * Constant: '<S176>/decrement'
527 * Constant: '<S176>/increment'
528 * Constant: '<S176>/limit'
529 * Constant: '<S176>/lock'
530 * DataTypeConversion: '<S177>/Extract Desired Bits'
531 * DataTypeConversion: '<S178>/Extract Desired Bits'
532 * DataTypeConversion: '<S63>/Data Type Conversion'
533 * Logic: '<S63>/AND'
534 */
535 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
536 (((int32_T)(DGM_B.Bitwise_AUX_b >> 27) & 1) != 0), 100, 1, 2,
537 false, &COMR_DFC_Msg2E6Tmt, &DGM_DWork.sf_rff_cti_j);
538
539 /* Chart: '<S180>/rff_cti' incorporates:
540 * Constant: '<S180>/decrement'
541 * Constant: '<S180>/increment'
542 * Constant: '<S180>/limit'
543 * Constant: '<S180>/lock'
544 * DataTypeConversion: '<S181>/Extract Desired Bits'
545 * DataTypeConversion: '<S182>/Extract Desired Bits'
546 * DataTypeConversion: '<S64>/Data Type Conversion'
547 * Logic: '<S64>/AND'
548 */
549 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
550 (((int32_T)(DGM_B.Bitwise_AUX_b >> 26) & 1) != 0), 100, 1, 2,
551 false, &COMR_DFC_ChkSumMsg2E6Err, &DGM_DWork.sf_rff_cti_p);
552
553 /* Chart: '<S184>/rff_cti' incorporates:
554 * Constant: '<S184>/decrement'
555 * Constant: '<S184>/increment'
556 * Constant: '<S184>/limit'
557 * Constant: '<S184>/lock'
558 * DataTypeConversion: '<S185>/Extract Desired Bits'
559 * DataTypeConversion: '<S186>/Extract Desired Bits'
560 * DataTypeConversion: '<S65>/Data Type Conversion'
561 * Logic: '<S65>/AND'
562 */
563 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
564 (((int32_T)(DGM_B.Bitwise_AUX_b >> 25) & 1) != 0), 100, 1, 2,
565 false, &COMR_DFC_RcMsg2E6Mis, &DGM_DWork.sf_rff_cti_m);
566
567 /* Chart: '<S188>/rff_cti' incorporates:
568 * Constant: '<S188>/decrement'
569 * Constant: '<S188>/increment'
570 * Constant: '<S188>/limit'
571 * Constant: '<S188>/lock'
572 * DataTypeConversion: '<S189>/Extract Desired Bits'
573 * DataTypeConversion: '<S190>/Extract Desired Bits'
574 * DataTypeConversion: '<S66>/Data Type Conversion'
575 * Logic: '<S66>/AND'
576 */
577 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
578 (((int32_T)(DGM_B.Bitwise_AUX_b >> 24) & 1) != 0), 100, 1, 2,
579 false, &COMR_DFC_Msg2EBTmt, &DGM_DWork.sf_rff_cti_d);
580
581 /* Chart: '<S192>/rff_cti' incorporates:
582 * Constant: '<S192>/decrement'
583 * Constant: '<S192>/increment'
584 * Constant: '<S192>/limit'
585 * Constant: '<S192>/lock'
586 * DataTypeConversion: '<S193>/Extract Desired Bits'
587 * DataTypeConversion: '<S194>/Extract Desired Bits'
588 * DataTypeConversion: '<S67>/Data Type Conversion'
589 * Logic: '<S67>/AND'
590 */
591 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
592 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 23) & 1) != 0), 100, 1, 2,
593 false, &COMR_DFC_ChkSumMsg2EBErr, &DGM_DWork.sf_rff_cti_k);
594
595 /* Chart: '<S72>/rff_cti' incorporates:
596 * Constant: '<S72>/decrement'
597 * Constant: '<S72>/increment'
598 * Constant: '<S72>/limit'
599 * Constant: '<S72>/lock'
600 * DataTypeConversion: '<S37>/Data Type Conversion'
601 * DataTypeConversion: '<S73>/Extract Desired Bits'
602 * DataTypeConversion: '<S74>/Extract Desired Bits'
603 * Logic: '<S37>/AND'
604 */
605 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
606 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 22) & 1) != 0), 100, 1, 2,
607 false, &COMR_DFC_RcMsg2EBMis, &DGM_DWork.sf_rff_cti_gn);
608
609 /* Chart: '<S76>/rff_cti' incorporates:
610 * Constant: '<S76>/decrement'
611 * Constant: '<S76>/increment'
612 * Constant: '<S76>/limit'
613 * Constant: '<S76>/lock'
614 * DataTypeConversion: '<S38>/Data Type Conversion'
615 * DataTypeConversion: '<S77>/Extract Desired Bits'
616 * DataTypeConversion: '<S78>/Extract Desired Bits'
617 * Logic: '<S38>/AND'
618 */
619 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
620 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 21) & 1) != 0), 10, 1, 2, false,
621 &COMR_DFC_MsgCABTmt, &DGM_DWork.sf_rff_cti_b);
622
623 /* Chart: '<S80>/rff_cti' incorporates:
624 * Constant: '<S80>/decrement'
625 * Constant: '<S80>/increment'
626 * Constant: '<S80>/limit'
627 * Constant: '<S80>/lock'
628 * DataTypeConversion: '<S39>/Data Type Conversion'
629 * DataTypeConversion: '<S81>/Extract Desired Bits'
630 * DataTypeConversion: '<S82>/Extract Desired Bits'
631 * Logic: '<S39>/AND'
632 */
633 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
634 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 20) & 1) != 0), 10, 1, 2, false,
635 &COMR_DFC_Msg0B5Tmt, &DGM_DWork.sf_rff_cti_gv);
636
637 /* Chart: '<S84>/rff_cti' incorporates:
638 * Constant: '<S84>/decrement'
639 * Constant: '<S84>/increment'
640 * Constant: '<S84>/limit'
641 * Constant: '<S84>/lock'
642 * DataTypeConversion: '<S40>/Data Type Conversion'
643 * DataTypeConversion: '<S85>/Extract Desired Bits'
644 * DataTypeConversion: '<S86>/Extract Desired Bits'
645 * Logic: '<S40>/AND'
646 */
647 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
648 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 19) & 1) != 0), 10, 1, 2, false,
649 &COMR_DFC_Msg2A3Tmt, &DGM_DWork.sf_rff_cti_e);
650
651 /* Chart: '<S88>/rff_cti' incorporates:
652 * Constant: '<S88>/decrement'
653 * Constant: '<S88>/increment'
654 * Constant: '<S88>/limit'
655 * Constant: '<S88>/lock'
656 * DataTypeConversion: '<S41>/Data Type Conversion'
657 * DataTypeConversion: '<S89>/Extract Desired Bits'
658 * DataTypeConversion: '<S90>/Extract Desired Bits'
659 * Logic: '<S41>/AND'
660 */
661 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
662 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 18) & 1) != 0), 10, 1, 2, false,
663 &COMR_DFC_ChkSumMsg2A3Err, &DGM_DWork.sf_rff_cti_o);
664
665 /* Chart: '<S92>/rff_cti' incorporates:
666 * Constant: '<S92>/decrement'
667 * Constant: '<S92>/increment'
668 * Constant: '<S92>/limit'
669 * Constant: '<S92>/lock'
670 * DataTypeConversion: '<S42>/Data Type Conversion'
671 * DataTypeConversion: '<S93>/Extract Desired Bits'
672 * DataTypeConversion: '<S94>/Extract Desired Bits'
673 * Logic: '<S42>/AND'
674 */
675 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
676 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 17) & 1) != 0), 10, 1, 2, false,
677 &COMR_DFC_RcMsg2A3Mis, &DGM_DWork.sf_rff_cti_f);
678
679 /* Chart: '<S96>/rff_cti' incorporates:
680 * Constant: '<S96>/decrement'
681 * Constant: '<S96>/increment'
682 * Constant: '<S96>/limit'
683 * Constant: '<S96>/lock'
684 * DataTypeConversion: '<S43>/Data Type Conversion'
685 * DataTypeConversion: '<S97>/Extract Desired Bits'
686 * DataTypeConversion: '<S98>/Extract Desired Bits'
687 * Logic: '<S43>/AND'
688 */
689 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
690 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 16) & 1) != 0), 100, 1, 2,
691 false, &COMR_DFC_Msg2A5Tmt, &DGM_DWork.sf_rff_cti_ph);
692
693 /* Chart: '<S100>/rff_cti' incorporates:
694 * Constant: '<S100>/decrement'
695 * Constant: '<S100>/increment'
696 * Constant: '<S100>/limit'
697 * Constant: '<S100>/lock'
698 * DataTypeConversion: '<S101>/Extract Desired Bits'
699 * DataTypeConversion: '<S102>/Extract Desired Bits'
700 * DataTypeConversion: '<S44>/Data Type Conversion'
701 * Logic: '<S44>/AND'
702 */
703 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
704 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 15) & 1) != 0), 100, 1, 2,
705 false, &COMR_DFC_ChkSumMsg2A5Err, &DGM_DWork.sf_rff_cti_c);
706
707 /* Chart: '<S104>/rff_cti' incorporates:
708 * Constant: '<S104>/decrement'
709 * Constant: '<S104>/increment'
710 * Constant: '<S104>/limit'
711 * Constant: '<S104>/lock'
712 * DataTypeConversion: '<S105>/Extract Desired Bits'
713 * DataTypeConversion: '<S106>/Extract Desired Bits'
714 * DataTypeConversion: '<S45>/Data Type Conversion'
715 * Logic: '<S45>/AND'
716 */
717 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
718 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 14) & 1) != 0), 100, 1, 2,
719 false, &COMR_DFC_RcMsg2A5Mis, &DGM_DWork.sf_rff_cti_e3);
720
721 /* Chart: '<S108>/rff_cti' incorporates:
722 * Constant: '<S108>/decrement'
723 * Constant: '<S108>/increment'
724 * Constant: '<S108>/limit'
725 * Constant: '<S108>/lock'
726 * DataTypeConversion: '<S109>/Extract Desired Bits'
727 * DataTypeConversion: '<S110>/Extract Desired Bits'
728 * DataTypeConversion: '<S46>/Data Type Conversion'
729 * Logic: '<S46>/AND'
730 */
731 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
732 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 13) & 1) != 0), 100, 1, 2,
733 false, &COMR_DFC_Msg2A7Tmt, &DGM_DWork.sf_rff_cti_el);
734
735 /* Chart: '<S116>/rff_cti' incorporates:
736 * Constant: '<S116>/decrement'
737 * Constant: '<S116>/increment'
738 * Constant: '<S116>/limit'
739 * Constant: '<S116>/lock'
740 * DataTypeConversion: '<S117>/Extract Desired Bits'
741 * DataTypeConversion: '<S118>/Extract Desired Bits'
742 * DataTypeConversion: '<S48>/Data Type Conversion'
743 * Logic: '<S48>/AND'
744 */
745 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
746 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 12) & 1) != 0), 100, 1, 2,
747 false, &COMR_DFC_ChkSumMsg2A7Err, &DGM_DWork.sf_rff_cti_fx);
748
749 /* Chart: '<S120>/rff_cti' incorporates:
750 * Constant: '<S120>/decrement'
751 * Constant: '<S120>/increment'
752 * Constant: '<S120>/limit'
753 * Constant: '<S120>/lock'
754 * DataTypeConversion: '<S121>/Extract Desired Bits'
755 * DataTypeConversion: '<S122>/Extract Desired Bits'
756 * DataTypeConversion: '<S49>/Data Type Conversion'
757 * Logic: '<S49>/AND'
758 */
759 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
760 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 11) & 1) != 0), 100, 1, 2,
761 false, &COMR_DFC_RcMsg2A7Mis, &DGM_DWork.sf_rff_cti_bp);
762
763 /* Chart: '<S124>/rff_cti' incorporates:
764 * Constant: '<S124>/decrement'
765 * Constant: '<S124>/increment'
766 * Constant: '<S124>/limit'
767 * Constant: '<S124>/lock'
768 * DataTypeConversion: '<S125>/Extract Desired Bits'
769 * DataTypeConversion: '<S126>/Extract Desired Bits'
770 * DataTypeConversion: '<S50>/Data Type Conversion'
771 * Logic: '<S50>/AND'
772 */
773 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
774 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 10) & 1) != 0), 100, 1, 2,
775 false, &COMR_DFC_Msg2ADTmt, &DGM_DWork.sf_rff_cti_jg);
776
777 /* Chart: '<S128>/rff_cti' incorporates:
778 * Constant: '<S128>/decrement'
779 * Constant: '<S128>/increment'
780 * Constant: '<S128>/limit'
781 * Constant: '<S128>/lock'
782 * DataTypeConversion: '<S129>/Extract Desired Bits'
783 * DataTypeConversion: '<S130>/Extract Desired Bits'
784 * DataTypeConversion: '<S51>/Data Type Conversion'
785 * Logic: '<S51>/AND'
786 */
787 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
788 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 9) & 1) != 0), 100, 1, 2, false,
789 &COMR_DFC_Msg2BBTmt, &DGM_DWork.sf_rff_cti_eg);
790
791 /* Chart: '<S132>/rff_cti' incorporates:
792 * Constant: '<S132>/decrement'
793 * Constant: '<S132>/increment'
794 * Constant: '<S132>/limit'
795 * Constant: '<S132>/lock'
796 * DataTypeConversion: '<S133>/Extract Desired Bits'
797 * DataTypeConversion: '<S134>/Extract Desired Bits'
798 * DataTypeConversion: '<S52>/Data Type Conversion'
799 * Logic: '<S52>/AND'
800 */
801 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
802 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 8) & 1) != 0), 100, 1, 2, false,
803 &COMR_DFC_Msg2DFTmt, &DGM_DWork.sf_rff_cti_mi);
804
805 /* Chart: '<S136>/rff_cti' incorporates:
806 * Constant: '<S136>/decrement'
807 * Constant: '<S136>/increment'
808 * Constant: '<S136>/limit'
809 * Constant: '<S136>/lock'
810 * DataTypeConversion: '<S137>/Extract Desired Bits'
811 * DataTypeConversion: '<S138>/Extract Desired Bits'
812 * DataTypeConversion: '<S53>/Data Type Conversion'
813 * Logic: '<S53>/AND'
814 */
815 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
816 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 7) & 1) != 0), 1000, 1, 2,
817 false, &COMR_DFC_Msg3AATmt, &DGM_DWork.sf_rff_cti_j2);
818
819 /* Chart: '<S140>/rff_cti' incorporates:
820 * Constant: '<S140>/decrement'
821 * Constant: '<S140>/increment'
822 * Constant: '<S140>/limit'
823 * Constant: '<S140>/lock'
824 * DataTypeConversion: '<S141>/Extract Desired Bits'
825 * DataTypeConversion: '<S142>/Extract Desired Bits'
826 * DataTypeConversion: '<S54>/Data Type Conversion'
827 * Logic: '<S54>/AND'
828 */
829 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
830 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 6) & 1) != 0), 100, 1, 2, false,
831 &COMR_DFC_Msg050Tmt, &DGM_DWork.sf_rff_cti_fp);
832
833 /* Chart: '<S144>/rff_cti' incorporates:
834 * Constant: '<S144>/decrement'
835 * Constant: '<S144>/increment'
836 * Constant: '<S144>/limit'
837 * Constant: '<S144>/lock'
838 * DataTypeConversion: '<S145>/Extract Desired Bits'
839 * DataTypeConversion: '<S146>/Extract Desired Bits'
840 * DataTypeConversion: '<S55>/Data Type Conversion'
841 * Logic: '<S55>/AND'
842 */
843 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
844 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 5) & 1) != 0), 100, 1, 2, false,
845 &COMR_DFC_ChkSumMsg050Err, &DGM_DWork.sf_rff_cti_dw);
846
847 /* Chart: '<S148>/rff_cti' incorporates:
848 * Constant: '<S148>/decrement'
849 * Constant: '<S148>/increment'
850 * Constant: '<S148>/limit'
851 * Constant: '<S148>/lock'
852 * DataTypeConversion: '<S149>/Extract Desired Bits'
853 * DataTypeConversion: '<S150>/Extract Desired Bits'
854 * DataTypeConversion: '<S56>/Data Type Conversion'
855 * Logic: '<S56>/AND'
856 */
857 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
858 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 4) & 1) != 0), 100, 1, 2, false,
859 &COMR_DFC_RcMsg050Mis, &DGM_DWork.sf_rff_cti_f2);
860
861 /* Chart: '<S152>/rff_cti' incorporates:
862 * Constant: '<S152>/decrement'
863 * Constant: '<S152>/increment'
864 * Constant: '<S152>/limit'
865 * Constant: '<S152>/lock'
866 * DataTypeConversion: '<S153>/Extract Desired Bits'
867 * DataTypeConversion: '<S154>/Extract Desired Bits'
868 * DataTypeConversion: '<S57>/Data Type Conversion'
869 * Logic: '<S57>/AND'
870 */
871 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
872 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 3) & 1) != 0), 100, 1, 2, false,
873 &COMR_DFC_Msg2F1Tmt, &DGM_DWork.sf_rff_cti_mb);
874
875 /* Chart: '<S160>/rff_cti' incorporates:
876 * Constant: '<S160>/decrement'
877 * Constant: '<S160>/increment'
878 * Constant: '<S160>/limit'
879 * Constant: '<S160>/lock'
880 * DataTypeConversion: '<S161>/Extract Desired Bits'
881 * DataTypeConversion: '<S162>/Extract Desired Bits'
882 * DataTypeConversion: '<S59>/Data Type Conversion'
883 * Logic: '<S59>/AND'
884 */
885 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
886 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 2) & 1) != 0), 500, 1, 2, false,
887 &COMR_DFC_Msg195Tmt, &DGM_DWork.sf_rff_cti_mb1);
888
889 /* Chart: '<S164>/rff_cti' incorporates:
890 * Constant: '<S164>/decrement'
891 * Constant: '<S164>/increment'
892 * Constant: '<S164>/limit'
893 * Constant: '<S164>/lock'
894 * DataTypeConversion: '<S165>/Extract Desired Bits'
895 * DataTypeConversion: '<S166>/Extract Desired Bits'
896 * DataTypeConversion: '<S60>/Data Type Conversion'
897 * Logic: '<S60>/AND'
898 */
899 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
900 (((uint8_T)(DGM_B.Bitwise_AUX_b >> 1) & 1) != 0), 500, 1, 2, false,
901 &COMR_DFC_Msg37FTmt, &DGM_DWork.sf_rff_cti_e4);
902
903 /* Chart: '<S168>/rff_cti' incorporates:
904 * Constant: '<S168>/decrement'
905 * Constant: '<S168>/increment'
906 * Constant: '<S168>/limit'
907 * Constant: '<S168>/lock'
908 * DataTypeConversion: '<S169>/Extract Desired Bits'
909 * DataTypeConversion: '<S170>/Extract Desired Bits'
910 * DataTypeConversion: '<S61>/Data Type Conversion'
911 * Logic: '<S61>/AND'
912 */
913 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) &&
914 (((uint8_T)DGM_B.Bitwise_AUX_b & 1) != 0), 500, 1, 2, false,
915 &COMR_DFC_Msg28CTmt, &DGM_DWork.sf_rff_cti_f1);
916
917 /* S-Function (sfix_bitop): '<S4>/Bitwise_AUX' incorporates:
918 * Constant: '<S36>/Calibration9'
919 * Constant: '<S37>/Calibration9'
920 * Constant: '<S38>/Calibration9'
921 * Constant: '<S39>/Calibration9'
922 * Constant: '<S40>/Calibration9'
923 * Constant: '<S41>/Calibration9'
924 * Constant: '<S42>/Calibration9'
925 * Constant: '<S43>/Calibration9'
926 * Constant: '<S44>/Calibration9'
927 * Constant: '<S45>/Calibration9'
928 * Constant: '<S46>/Calibration9'
929 * Constant: '<S47>/Calibration9'
930 * Constant: '<S48>/Calibration9'
931 * Constant: '<S49>/Calibration9'
932 * Constant: '<S50>/Calibration9'
933 * Constant: '<S51>/Calibration9'
934 * Constant: '<S52>/Calibration9'
935 * Constant: '<S53>/Calibration9'
936 * Constant: '<S54>/Calibration9'
937 * Constant: '<S55>/Calibration9'
938 * Constant: '<S56>/Calibration9'
939 * Constant: '<S57>/Calibration9'
940 * Constant: '<S58>/Calibration9'
941 * Constant: '<S59>/Calibration9'
942 * Constant: '<S60>/Calibration9'
943 * Constant: '<S61>/Calibration9'
944 * Constant: '<S62>/Calibration9'
945 * Constant: '<S63>/Calibration9'
946 * Constant: '<S64>/Calibration9'
947 * Constant: '<S65>/Calibration9'
948 * Constant: '<S66>/Calibration9'
949 * Constant: '<S67>/Calibration9'
950 * Product: '<S36>/Product2'
951 * Product: '<S37>/Product2'
952 * Product: '<S38>/Product2'
953 * Product: '<S39>/Product2'
954 * Product: '<S40>/Product2'
955 * Product: '<S41>/Product2'
956 * Product: '<S42>/Product2'
957 * Product: '<S43>/Product2'
958 * Product: '<S44>/Product2'
959 * Product: '<S45>/Product2'
960 * Product: '<S46>/Product2'
961 * Product: '<S47>/Product2'
962 * Product: '<S48>/Product2'
963 * Product: '<S49>/Product2'
964 * Product: '<S50>/Product2'
965 * Product: '<S51>/Product2'
966 * Product: '<S52>/Product2'
967 * Product: '<S53>/Product2'
968 * Product: '<S54>/Product2'
969 * Product: '<S55>/Product2'
970 * Product: '<S56>/Product2'
971 * Product: '<S57>/Product2'
972 * Product: '<S58>/Product2'
973 * Product: '<S59>/Product2'
974 * Product: '<S60>/Product2'
975 * Product: '<S61>/Product2'
976 * Product: '<S62>/Product2'
977 * Product: '<S63>/Product2'
978 * Product: '<S64>/Product2'
979 * Product: '<S65>/Product2'
980 * Product: '<S66>/Product2'
981 * Product: '<S67>/Product2'
982 */
983 DGM_B.Bitwise_AUX = 0U;
984
985 /* S-Function (sfix_bitop): '<S4>/Bitwise_PT' incorporates:
986 * Constant: '<S36>/Calibration6'
987 * Product: '<S36>/Product97'
988 * Product: '<S47>/Product97'
989 * Product: '<S58>/Product97'
990 * Product: '<S62>/Product97'
991 * Product: '<S63>/Product97'
992 * Product: '<S64>/Product97'
993 * Product: '<S65>/Product97'
994 * Product: '<S66>/Product97'
995 * Product: '<S67>/Product97'
996 */
997 DGM_B.Bitwise_PT_i = (uint32_T)COMR_DFC_Msg2E1Tmt << 28 | (COMR_DFC_Msg130Tmt ?
998 3221225472U : 0U) | (uint32_T)COMR_DFC_ChkSumMsg2E1Err << 28 | (uint32_T)
999 COMR_DFC_RcMsg2E1Mis << 28 | (uint32_T)COMR_DFC_Msg2E6Tmt << 28 | (uint32_T)
1000 COMR_DFC_ChkSumMsg2E6Err << 28 | (uint32_T)COMR_DFC_RcMsg2E6Mis << 28 |
1001 (uint32_T)COMR_DFC_Msg2EBTmt << 28 | (uint32_T)COMR_DFC_ChkSumMsg2EBErr <<
1002 28;
1003
1004 /* MinMax: '<S4>/Max' incorporates:
1005 * Constant: '<S36>/Calibration7'
1006 * Constant: '<S37>/Calibration7'
1007 * Constant: '<S38>/Calibration7'
1008 * Constant: '<S39>/Calibration7'
1009 * Constant: '<S40>/Calibration7'
1010 * Constant: '<S41>/Calibration7'
1011 * Constant: '<S42>/Calibration7'
1012 * Constant: '<S43>/Calibration7'
1013 * Constant: '<S44>/Calibration7'
1014 * Constant: '<S45>/Calibration7'
1015 * Constant: '<S46>/Calibration7'
1016 * Constant: '<S47>/Calibration7'
1017 * Constant: '<S48>/Calibration7'
1018 * Constant: '<S49>/Calibration7'
1019 * Constant: '<S50>/Calibration7'
1020 * Constant: '<S51>/Calibration7'
1021 * Constant: '<S52>/Calibration7'
1022 * Constant: '<S53>/Calibration7'
1023 * Constant: '<S54>/Calibration7'
1024 * Constant: '<S55>/Calibration7'
1025 * Constant: '<S56>/Calibration7'
1026 * Constant: '<S57>/Calibration7'
1027 * Constant: '<S58>/Calibration7'
1028 * Constant: '<S59>/Calibration7'
1029 * Constant: '<S60>/Calibration7'
1030 * Constant: '<S61>/Calibration7'
1031 * Constant: '<S62>/Calibration7'
1032 * Constant: '<S63>/Calibration7'
1033 * Constant: '<S64>/Calibration7'
1034 * Constant: '<S65>/Calibration7'
1035 * Constant: '<S66>/Calibration7'
1036 * Constant: '<S67>/Calibration7'
1037 * Product: '<S36>/Product1'
1038 * Product: '<S37>/Product1'
1039 * Product: '<S38>/Product1'
1040 * Product: '<S39>/Product1'
1041 * Product: '<S40>/Product1'
1042 * Product: '<S41>/Product1'
1043 * Product: '<S42>/Product1'
1044 * Product: '<S43>/Product1'
1045 * Product: '<S44>/Product1'
1046 * Product: '<S45>/Product1'
1047 * Product: '<S46>/Product1'
1048 * Product: '<S47>/Product1'
1049 * Product: '<S48>/Product1'
1050 * Product: '<S49>/Product1'
1051 * Product: '<S50>/Product1'
1052 * Product: '<S51>/Product1'
1053 * Product: '<S52>/Product1'
1054 * Product: '<S53>/Product1'
1055 * Product: '<S54>/Product1'
1056 * Product: '<S55>/Product1'
1057 * Product: '<S56>/Product1'
1058 * Product: '<S57>/Product1'
1059 * Product: '<S58>/Product1'
1060 * Product: '<S59>/Product1'
1061 * Product: '<S60>/Product1'
1062 * Product: '<S61>/Product1'
1063 * Product: '<S62>/Product1'
1064 * Product: '<S63>/Product1'
1065 * Product: '<S64>/Product1'
1066 * Product: '<S65>/Product1'
1067 * Product: '<S66>/Product1'
1068 * Product: '<S67>/Product1'
1069 */
1070 u0 = (uint8_T)(COMR_DFC_Msg130Tmt ? 3 : 0);
1071 u1 = (uint8_T)(COMR_DFC_Msg2E1Tmt ? 3 : 0);
1072 if (u0 > u1) {
1073 u1 = u0;
1074 }
1075
1076 u0 = (uint8_T)(COMR_DFC_ChkSumMsg2E1Err ? 3 : 0);
1077 if (u1 > u0) {
1078 u0 = u1;
1079 }
1080
1081 u1 = (uint8_T)(COMR_DFC_RcMsg2E1Mis ? 3 : 0);
1082 if (u0 > u1) {
1083 u1 = u0;
1084 }
1085
1086 u0 = (uint8_T)(COMR_DFC_Msg2E6Tmt ? 3 : 0);
1087 if (u1 > u0) {
1088 u0 = u1;
1089 }
1090
1091 u1 = (uint8_T)(COMR_DFC_ChkSumMsg2E6Err ? 3 : 0);
1092 if (u0 > u1) {
1093 u1 = u0;
1094 }
1095
1096 u0 = (uint8_T)(COMR_DFC_RcMsg2E6Mis ? 3 : 0);
1097 if (u1 > u0) {
1098 u0 = u1;
1099 }
1100
1101 u1 = (uint8_T)(COMR_DFC_Msg2EBTmt ? 3 : 0);
1102 if (u0 > u1) {
1103 u1 = u0;
1104 }
1105
1106 u0 = (uint8_T)(COMR_DFC_ChkSumMsg2EBErr ? 3 : 0);
1107 if (u1 > u0) {
1108 u0 = u1;
1109 }
1110
1111 u1 = (uint8_T)(COMR_DFC_RcMsg2EBMis ? 3 : 0);
1112 if (u0 > u1) {
1113 u1 = u0;
1114 }
1115
1116 u0 = (uint8_T)(COMR_DFC_MsgCABTmt ? 3 : 0);
1117 if (u1 > u0) {
1118 u0 = u1;
1119 }
1120
1121 u1 = (uint8_T)(COMR_DFC_Msg0B5Tmt ? 3 : 0);
1122 if (u0 > u1) {
1123 u1 = u0;
1124 }
1125
1126 u0 = (uint8_T)(COMR_DFC_Msg2A3Tmt ? 3 : 0);
1127 if (u1 > u0) {
1128 u0 = u1;
1129 }
1130
1131 u1 = (uint8_T)(COMR_DFC_ChkSumMsg2A3Err ? 3 : 0);
1132 if (u0 > u1) {
1133 u1 = u0;
1134 }
1135
1136 u0 = (uint8_T)(COMR_DFC_RcMsg2A3Mis ? 3 : 0);
1137 if (u1 > u0) {
1138 u0 = u1;
1139 }
1140
1141 u1 = (uint8_T)(COMR_DFC_Msg2A5Tmt ? 3 : 0);
1142 if (u0 > u1) {
1143 u1 = u0;
1144 }
1145
1146 u0 = (uint8_T)(COMR_DFC_ChkSumMsg2A5Err ? 3 : 0);
1147 if (u1 > u0) {
1148 u0 = u1;
1149 }
1150
1151 u1 = (uint8_T)(COMR_DFC_RcMsg2A5Mis ? 3 : 0);
1152 if (u0 > u1) {
1153 u1 = u0;
1154 }
1155
1156 u0 = (uint8_T)(COMR_DFC_Msg2A7Tmt ? 3 : 0);
1157 if (u1 > u0) {
1158 u0 = u1;
1159 }
1160
1161 u1 = (uint8_T)(COMR_DFC_ChkSumMsg2A7Err ? 3 : 0);
1162 if (u0 > u1) {
1163 u1 = u0;
1164 }
1165
1166 u0 = (uint8_T)(COMR_DFC_RcMsg2A7Mis ? 3 : 0);
1167 if (u1 > u0) {
1168 u0 = u1;
1169 }
1170
1171 u1 = (uint8_T)(COMR_DFC_Msg2ADTmt ? 3 : 0);
1172 if (u0 > u1) {
1173 u1 = u0;
1174 }
1175
1176 u0 = (uint8_T)(COMR_DFC_Msg2BBTmt ? 3 : 0);
1177 if (u1 > u0) {
1178 u0 = u1;
1179 }
1180
1181 u1 = (uint8_T)(COMR_DFC_Msg2DFTmt ? 3 : 0);
1182 if (u0 > u1) {
1183 u1 = u0;
1184 }
1185
1186 u0 = (uint8_T)(COMR_DFC_Msg3AATmt ? 3 : 0);
1187 if (u1 > u0) {
1188 u0 = u1;
1189 }
1190
1191 u1 = (uint8_T)(COMR_DFC_Msg050Tmt ? 3 : 0);
1192 if (u0 > u1) {
1193 u1 = u0;
1194 }
1195
1196 u0 = (uint8_T)(COMR_DFC_ChkSumMsg050Err ? 3 : 0);
1197 if (u1 > u0) {
1198 u0 = u1;
1199 }
1200
1201 u1 = (uint8_T)(COMR_DFC_RcMsg050Mis ? 3 : 0);
1202 if (u0 > u1) {
1203 u1 = u0;
1204 }
1205
1206 u0 = (uint8_T)(COMR_DFC_Msg2F1Tmt ? 3 : 0);
1207 if (u1 > u0) {
1208 u0 = u1;
1209 }
1210
1211 u1 = (uint8_T)(COMR_DFC_Msg195Tmt ? 3 : 0);
1212 if (u0 > u1) {
1213 u1 = u0;
1214 }
1215
1216 u0 = (uint8_T)(COMR_DFC_Msg37FTmt ? 3 : 0);
1217 if (u1 > u0) {
1218 u0 = u1;
1219 }
1220
1221 u1 = (uint8_T)(COMR_DFC_Msg28CTmt ? 3 : 0);
1222 if (u0 > u1) {
1223 DGM_B.Max = u0;
1224 } else {
1225 DGM_B.Max = u1;
1226 }
1227
1228 /* End of MinMax: '<S4>/Max' */
1229}
1230
1231/* System initialize for atomic system: '<S1>/IOS1' */
1232void DGM_IOS1_Init(void)
1233{
1234 /* SystemInitialize for Chart: '<S197>/rff_cti' */
1235 DGM_rff_cti_Init(&COMR_DFC_Msg17DTmt);
1236}
1237
1238/* Output and update for atomic system: '<S1>/IOS1' */
1239void DGM_IOS1(void)
1240{
1241 /* Chart: '<S197>/rff_cti' incorporates:
1242 * Constant: '<S197>/decrement'
1243 * Constant: '<S197>/increment'
1244 * Constant: '<S197>/limit'
1245 * Constant: '<S197>/lock'
1246 * DataTypeConversion: '<S196>/Data Type Conversion'
1247 * DataTypeConversion: '<S198>/Extract Desired Bits'
1248 * DataTypeConversion: '<S199>/Extract Desired Bits'
1249 * Logic: '<S196>/AND'
1250 */
1251 DGM_rff_cti((((int32_T)((uint32_T)DGM_B.Product1 >> 5) & 1) != 0) && ((int32_T)
1252 (DGM_B.Bitwise_AUX_b >> 31) != 0), 20, 1, 2, false, &COMR_DFC_Msg17DTmt,
1253 &DGM_DWork.sf_rff_cti_i);
1254
1255 /* S-Function (sfix_bitop): '<S5>/Bitwise_AUX' incorporates:
1256 * Constant: '<S196>/Calibration9'
1257 * Product: '<S196>/Product2'
1258 */
1259 DGM_B.Bitwise_AUX_b = 0U;
1260
1261 /* S-Function (sfix_bitop): '<S5>/Bitwise_PT' incorporates:
1262 * Constant: '<S196>/Calibration6'
1263 * Product: '<S196>/Product97'
1264 */
1265 DGM_B.Bitwise_PT = 0U;
1266
1267 /* Product: '<S196>/Product1' incorporates:
1268 * Constant: '<S196>/Calibration7'
1269 */
1270 DGM_B.Product1 = (uint8_T)(COMR_DFC_Msg17DTmt ? 3 : 0);
1271}
1272
1273/* Model step function */
1274void DGM_step(void)
1275{
1276 boolean_T rtb_NOT;
1277 boolean_T rtb_LogicalOperator_a;
1278 boolean_T rtb_AND_o4;
1279 boolean_T rtb_LogicalOperator_c;
1280 uint8_T rtb_Switch_k;
1281 uint32_T rtb_Switch_ku;
1282
1283 /* Logic: '<S3>/NOT' incorporates:
1284 * Inport: '<Root>/COMR_stEol'
1285 */
1286 rtb_NOT = !COMR_stEol;
1287
1288 /* Switch: '<S15>/Switch' incorporates:
1289 * Constant: '<S9>/Constant'
1290 * Inport: '<Root>/COMR_bLvComDiagEn'
1291 * Logic: '<S3>/AND4'
1292 * S-Function (sfix_bitop): '<S22>/FixPt Bitwise Operator3'
1293 * S-Function (sfix_bitop): '<S22>/FixPt Bitwise Operator4'
1294 * S-Function (sfix_bitop): '<S22>/FixPt Bitwise Operator5'
1295 * S-Function (sfix_bitop): '<S23>/FixPt Bitwise Operator1'
1296 */
1297 if (rtb_NOT && COMR_bLvComDiagEn) {
1298 rtb_Switch_k = 192U;
1299 } else {
1300 rtb_Switch_k = 128U;
1301 }
1302
1303 /* End of Switch: '<S15>/Switch' */
1304
1305 /* Outputs for Atomic SubSystem: '<S3>/OnAfterDelay2' */
1306
1307 /* Logic: '<S3>/Logical Operator' incorporates:
1308 * Inport: '<Root>/BMCR_bWkUpVCU'
1309 * Inport: '<Root>/BSPR_bKl15WkUp'
1310 * Inport: '<Root>/VCAN_NMMsgRx'
1311 */
1312 rtb_LogicalOperator_a = DGM_OnAfterDelay2(VCAN_NMMsgRx || BMCR_bWkUpVCU ||
1313 BSPR_bKl15WkUp, &DGM_B.OnAfterDelay2, &DGM_DWork.OnAfterDelay2, 10U, 2000U);
1314
1315 /* End of Outputs for SubSystem: '<S3>/OnAfterDelay2' */
1316
1317 /* Logic: '<S3>/AND' incorporates:
1318 * Inport: '<Root>/COMR_bLvComDiagEn'
1319 */
1320 rtb_AND_o4 = (COMR_bLvComDiagEn && rtb_LogicalOperator_a);
1321
1322 /* Switch: '<S14>/Switch' incorporates:
1323 * Logic: '<S3>/AND5'
1324 * S-Function (sfix_bitop): '<S20>/FixPt Bitwise Operator3'
1325 * S-Function (sfix_bitop): '<S20>/FixPt Bitwise Operator4'
1326 * S-Function (sfix_bitop): '<S20>/FixPt Bitwise Operator5'
1327 * S-Function (sfix_bitop): '<S21>/FixPt Bitwise Operator1'
1328 */
1329 if (rtb_NOT && rtb_AND_o4) {
1330 rtb_Switch_k = (uint8_T)(rtb_Switch_k | 32);
1331 } else {
1332 rtb_Switch_k = (uint8_T)~(uint8_T)((uint8_T)~rtb_Switch_k | 32U);
1333 }
1334
1335 /* End of Switch: '<S14>/Switch' */
1336
1337 /* Outputs for Atomic SubSystem: '<S3>/OnAfterDelay' */
1338
1339 /* Constant: '<S3>/Constant1' */
1340 rtb_LogicalOperator_a = DGM_OnAfterDelay(false, &DGM_B.OnAfterDelay,
1341 &DGM_DWork.OnAfterDelay, 10U, 2000U);
1342
1343 /* End of Outputs for SubSystem: '<S3>/OnAfterDelay' */
1344
1345 /* Switch: '<S17>/Switch' incorporates:
1346 * Inport: '<Root>/COMR_bLvComDiagEn'
1347 * Logic: '<S3>/AND1'
1348 * Logic: '<S3>/AND6'
1349 * S-Function (sfix_bitop): '<S26>/FixPt Bitwise Operator3'
1350 * S-Function (sfix_bitop): '<S26>/FixPt Bitwise Operator4'
1351 * S-Function (sfix_bitop): '<S26>/FixPt Bitwise Operator5'
1352 * S-Function (sfix_bitop): '<S27>/FixPt Bitwise Operator1'
1353 */
1354 if (rtb_NOT && (COMR_bLvComDiagEn && rtb_LogicalOperator_a)) {
1355 rtb_Switch_k |= 16U;
1356 } else {
1357 rtb_Switch_k = (uint8_T)~(uint8_T)((uint8_T)~rtb_Switch_k | 16U);
1358 }
1359
1360 /* End of Switch: '<S17>/Switch' */
1361
1362 /* Outputs for Atomic SubSystem: '<S3>/OnAfterDelay1' */
1363
1364 /* Inport: '<Root>/BSPR_bKl15WkUp' */
1365 rtb_LogicalOperator_c = DGM_OnAfterDelay1(BSPR_bKl15WkUp, &DGM_B.OnAfterDelay1,
1366 &DGM_DWork.OnAfterDelay1, 10U, 2000U);
1367
1368 /* End of Outputs for SubSystem: '<S3>/OnAfterDelay1' */
1369
1370 /* Switch: '<S16>/Switch' incorporates:
1371 * Inport: '<Root>/COMR_bLvComDiagEn'
1372 * Logic: '<S3>/AND2'
1373 * Logic: '<S3>/AND7'
1374 * S-Function (sfix_bitop): '<S24>/FixPt Bitwise Operator3'
1375 * S-Function (sfix_bitop): '<S24>/FixPt Bitwise Operator4'
1376 * S-Function (sfix_bitop): '<S24>/FixPt Bitwise Operator5'
1377 * S-Function (sfix_bitop): '<S25>/FixPt Bitwise Operator1'
1378 */
1379 if (rtb_NOT && (COMR_bLvComDiagEn && rtb_LogicalOperator_c)) {
1380 rtb_Switch_k |= 8U;
1381 } else {
1382 rtb_Switch_k = (uint8_T)~(uint8_T)((uint8_T)~rtb_Switch_k | 8U);
1383 }
1384
1385 /* End of Switch: '<S16>/Switch' */
1386
1387 /* Switch: '<S19>/Switch' incorporates:
1388 * S-Function (sfix_bitop): '<S30>/FixPt Bitwise Operator3'
1389 * S-Function (sfix_bitop): '<S30>/FixPt Bitwise Operator4'
1390 * S-Function (sfix_bitop): '<S30>/FixPt Bitwise Operator5'
1391 */
1392 rtb_Switch_k = (uint8_T)~(uint8_T)((uint8_T)~rtb_Switch_k | 4U);
1393
1394 /* Outputs for Atomic SubSystem: '<S3>/OnHoldT' */
1395 rtb_LogicalOperator_a = DGM_OnHoldT(rtb_LogicalOperator_c, &DGM_B.OnHoldT,
1396 &DGM_DWork.OnHoldT, 10U, 500U);
1397
1398 /* End of Outputs for SubSystem: '<S3>/OnHoldT' */
1399
1400 /* Switch: '<S18>/Switch' incorporates:
1401 * Inport: '<Root>/COMR_bLvComDiagEn'
1402 * Logic: '<S3>/AND10'
1403 * Logic: '<S3>/AND9'
1404 * S-Function (sfix_bitop): '<S28>/FixPt Bitwise Operator3'
1405 * S-Function (sfix_bitop): '<S28>/FixPt Bitwise Operator4'
1406 * S-Function (sfix_bitop): '<S28>/FixPt Bitwise Operator5'
1407 * S-Function (sfix_bitop): '<S29>/FixPt Bitwise Operator1'
1408 */
1409 if (rtb_NOT && (COMR_bLvComDiagEn && rtb_LogicalOperator_a)) {
1410 DGM_B.Product1 = (uint8_T)(rtb_Switch_k | 2U);
1411 } else {
1412 DGM_B.Product1 = (uint8_T)~(uint8_T)((uint8_T)~rtb_Switch_k | 2U);
1413 }
1414
1415 /* End of Switch: '<S18>/Switch' */
1416
1417 /* Switch: '<S214>/Switch' incorporates:
1418 * Constant: '<S201>/BitSet0'
1419 * Inport: '<Root>/hld_PrivateCAN_0x130_TimeoutErr'
1420 * Inport: '<Root>/hld_PrivateCAN_0x2E1_TimeoutErr'
1421 * S-Function (sfix_bitop): '<S246>/FixPt Bitwise Operator1'
1422 * Switch: '<S203>/Switch'
1423 */
1424 if (hld_PrivateCAN_0x2E1_TimeoutErr) {
1425 /* Switch: '<S203>/Switch' incorporates:
1426 * Constant: '<S201>/BitSet0'
1427 * Inport: '<Root>/hld_PrivateCAN_0x130_TimeoutErr'
1428 */
1429 if (hld_PrivateCAN_0x130_TimeoutErr) {
1430 rtb_Switch_ku = DGM_ConstB.FixPtBitwiseOperator1;
1431 } else {
1432 rtb_Switch_ku = 0U;
1433 }
1434
1435 rtb_Switch_ku |= 1073741824U;
1436 } else if (hld_PrivateCAN_0x130_TimeoutErr) {
1437 /* Switch: '<S203>/Switch' */
1438 rtb_Switch_ku = DGM_ConstB.FixPtBitwiseOperator1;
1439 } else {
1440 rtb_Switch_ku = 0U;
1441 }
1442
1443 /* End of Switch: '<S214>/Switch' */
1444
1445 /* Switch: '<S225>/Switch' incorporates:
1446 * Inport: '<Root>/hld_PrivateCAN_0x2E1_ChksumErr'
1447 * S-Function (sfix_bitop): '<S257>/FixPt Bitwise Operator1'
1448 */
1449 if (hld_PrivateCAN_0x2E1_ChksumErr) {
1450 rtb_Switch_ku |= 536870912U;
1451 }
1452
1453 /* End of Switch: '<S225>/Switch' */
1454
1455 /* Switch: '<S229>/Switch' incorporates:
1456 * Inport: '<Root>/hld_PrivateCAN_0x2E1_RolcntErr'
1457 * S-Function (sfix_bitop): '<S261>/FixPt Bitwise Operator1'
1458 */
1459 if (hld_PrivateCAN_0x2E1_RolcntErr) {
1460 rtb_Switch_ku |= 268435456U;
1461 }
1462
1463 /* End of Switch: '<S229>/Switch' */
1464
1465 /* Switch: '<S230>/Switch' incorporates:
1466 * Inport: '<Root>/hld_PrivateCAN_0x2E6_TimeoutErr'
1467 * S-Function (sfix_bitop): '<S262>/FixPt Bitwise Operator1'
1468 */
1469 if (hld_PrivateCAN_0x2E6_TimeoutErr) {
1470 rtb_Switch_ku |= 134217728U;
1471 }
1472
1473 /* End of Switch: '<S230>/Switch' */
1474
1475 /* Switch: '<S231>/Switch' incorporates:
1476 * Inport: '<Root>/hld_PrivateCAN_0x2E6_ChksumErr'
1477 * S-Function (sfix_bitop): '<S263>/FixPt Bitwise Operator1'
1478 */
1479 if (hld_PrivateCAN_0x2E6_ChksumErr) {
1480 rtb_Switch_ku |= 67108864U;
1481 }
1482
1483 /* End of Switch: '<S231>/Switch' */
1484
1485 /* Switch: '<S232>/Switch' incorporates:
1486 * Inport: '<Root>/hld_PrivateCAN_0x2E6_RolcntErr'
1487 * S-Function (sfix_bitop): '<S264>/FixPt Bitwise Operator1'
1488 */
1489 if (hld_PrivateCAN_0x2E6_RolcntErr) {
1490 rtb_Switch_ku |= 33554432U;
1491 }
1492
1493 /* End of Switch: '<S232>/Switch' */
1494
1495 /* Switch: '<S233>/Switch' incorporates:
1496 * Inport: '<Root>/hld_PrivateCAN_0x2EB_TimeoutErr'
1497 * S-Function (sfix_bitop): '<S265>/FixPt Bitwise Operator1'
1498 */
1499 if (hld_PrivateCAN_0x2EB_TimeoutErr) {
1500 rtb_Switch_ku |= 16777216U;
1501 }
1502
1503 /* End of Switch: '<S233>/Switch' */
1504
1505 /* Switch: '<S234>/Switch' incorporates:
1506 * Inport: '<Root>/hld_PrivateCAN_0x2EB_ChksumErr'
1507 * S-Function (sfix_bitop): '<S266>/FixPt Bitwise Operator1'
1508 */
1509 if (hld_PrivateCAN_0x2EB_ChksumErr) {
1510 rtb_Switch_ku |= 8388608U;
1511 }
1512
1513 /* End of Switch: '<S234>/Switch' */
1514
1515 /* Switch: '<S204>/Switch' incorporates:
1516 * Inport: '<Root>/hld_PrivateCAN_0x2EB_RolcntErr'
1517 * S-Function (sfix_bitop): '<S236>/FixPt Bitwise Operator1'
1518 */
1519 if (hld_PrivateCAN_0x2EB_RolcntErr) {
1520 rtb_Switch_ku |= 4194304U;
1521 }
1522
1523 /* End of Switch: '<S204>/Switch' */
1524
1525 /* Switch: '<S205>/Switch' incorporates:
1526 * Inport: '<Root>/hld_PrivateCAN_0x3C2_TimeoutErr'
1527 * S-Function (sfix_bitop): '<S237>/FixPt Bitwise Operator1'
1528 */
1529 if (hld_PrivateCAN_0x3C2_TimeoutErr) {
1530 rtb_Switch_ku |= 2097152U;
1531 }
1532
1533 /* End of Switch: '<S205>/Switch' */
1534
1535 /* Switch: '<S206>/Switch' incorporates:
1536 * Inport: '<Root>/hld_PrivateCAN_0x0B5_TimeoutErr'
1537 * S-Function (sfix_bitop): '<S238>/FixPt Bitwise Operator1'
1538 */
1539 if (hld_PrivateCAN_0x0B5_TimeoutErr) {
1540 rtb_Switch_ku |= 1048576U;
1541 }
1542
1543 /* End of Switch: '<S206>/Switch' */
1544
1545 /* Switch: '<S207>/Switch' incorporates:
1546 * Inport: '<Root>/hld_PrivateCAN_0x2A3_TimeoutErr'
1547 * S-Function (sfix_bitop): '<S239>/FixPt Bitwise Operator1'
1548 */
1549 if (hld_PrivateCAN_0x2A3_TimeoutErr) {
1550 rtb_Switch_ku |= 524288U;
1551 }
1552
1553 /* End of Switch: '<S207>/Switch' */
1554
1555 /* Switch: '<S208>/Switch' incorporates:
1556 * Inport: '<Root>/hld_PrivateCAN_0x2A3_ChksumErr'
1557 * S-Function (sfix_bitop): '<S240>/FixPt Bitwise Operator1'
1558 */
1559 if (hld_PrivateCAN_0x2A3_ChksumErr) {
1560 rtb_Switch_ku |= 262144U;
1561 }
1562
1563 /* End of Switch: '<S208>/Switch' */
1564
1565 /* Switch: '<S209>/Switch' incorporates:
1566 * Inport: '<Root>/hld_PrivateCAN_0x2A3_RolcntErr'
1567 * S-Function (sfix_bitop): '<S241>/FixPt Bitwise Operator1'
1568 */
1569 if (hld_PrivateCAN_0x2A3_RolcntErr) {
1570 rtb_Switch_ku |= 131072U;
1571 }
1572
1573 /* End of Switch: '<S209>/Switch' */
1574
1575 /* Switch: '<S210>/Switch' incorporates:
1576 * Inport: '<Root>/hld_PrivateCAN_0x2A5_TimeoutErr'
1577 * S-Function (sfix_bitop): '<S242>/FixPt Bitwise Operator1'
1578 */
1579 if (hld_PrivateCAN_0x2A5_TimeoutErr) {
1580 rtb_Switch_ku |= 65536U;
1581 }
1582
1583 /* End of Switch: '<S210>/Switch' */
1584
1585 /* Switch: '<S211>/Switch' incorporates:
1586 * Inport: '<Root>/hld_PrivateCAN_0x2A5_ChksumErr'
1587 * S-Function (sfix_bitop): '<S243>/FixPt Bitwise Operator1'
1588 */
1589 if (hld_PrivateCAN_0x2A5_ChksumErr) {
1590 rtb_Switch_ku |= 32768U;
1591 }
1592
1593 /* End of Switch: '<S211>/Switch' */
1594
1595 /* Switch: '<S212>/Switch' incorporates:
1596 * Inport: '<Root>/hld_PrivateCAN_0x2A5_RolcntErr'
1597 * S-Function (sfix_bitop): '<S244>/FixPt Bitwise Operator1'
1598 */
1599 if (hld_PrivateCAN_0x2A5_RolcntErr) {
1600 rtb_Switch_ku |= 16384U;
1601 }
1602
1603 /* End of Switch: '<S212>/Switch' */
1604
1605 /* Switch: '<S213>/Switch' incorporates:
1606 * Inport: '<Root>/hld_PrivateCAN_0x2A7_TimeoutErr'
1607 * S-Function (sfix_bitop): '<S245>/FixPt Bitwise Operator1'
1608 */
1609 if (hld_PrivateCAN_0x2A7_TimeoutErr) {
1610 rtb_Switch_ku |= 8192U;
1611 }
1612
1613 /* End of Switch: '<S213>/Switch' */
1614
1615 /* Switch: '<S215>/Switch' incorporates:
1616 * Inport: '<Root>/hld_PrivateCAN_0x2A7_ChksumErr'
1617 * S-Function (sfix_bitop): '<S247>/FixPt Bitwise Operator1'
1618 */
1619 if (hld_PrivateCAN_0x2A7_ChksumErr) {
1620 rtb_Switch_ku |= 4096U;
1621 }
1622
1623 /* End of Switch: '<S215>/Switch' */
1624
1625 /* Switch: '<S216>/Switch' incorporates:
1626 * Inport: '<Root>/hld_PrivateCAN_0x2A7_RolcntErr'
1627 * S-Function (sfix_bitop): '<S248>/FixPt Bitwise Operator1'
1628 */
1629 if (hld_PrivateCAN_0x2A7_RolcntErr) {
1630 rtb_Switch_ku |= 2048U;
1631 }
1632
1633 /* End of Switch: '<S216>/Switch' */
1634
1635 /* Switch: '<S217>/Switch' incorporates:
1636 * Inport: '<Root>/hld_PrivateCAN_0x2AD_TimeoutErr'
1637 * S-Function (sfix_bitop): '<S249>/FixPt Bitwise Operator1'
1638 */
1639 if (hld_PrivateCAN_0x2AD_TimeoutErr) {
1640 rtb_Switch_ku |= 1024U;
1641 }
1642
1643 /* End of Switch: '<S217>/Switch' */
1644
1645 /* Switch: '<S218>/Switch' incorporates:
1646 * Inport: '<Root>/hld_PrivateCAN_0x2BB_TimeoutErr'
1647 * S-Function (sfix_bitop): '<S250>/FixPt Bitwise Operator1'
1648 */
1649 if (hld_PrivateCAN_0x2BB_TimeoutErr) {
1650 rtb_Switch_ku |= 512U;
1651 }
1652
1653 /* End of Switch: '<S218>/Switch' */
1654
1655 /* Switch: '<S219>/Switch' incorporates:
1656 * Inport: '<Root>/hld_PrivateCAN_0x2DF_TimeoutErr'
1657 * S-Function (sfix_bitop): '<S251>/FixPt Bitwise Operator1'
1658 */
1659 if (hld_PrivateCAN_0x2DF_TimeoutErr) {
1660 rtb_Switch_ku |= 256U;
1661 }
1662
1663 /* End of Switch: '<S219>/Switch' */
1664
1665 /* Switch: '<S220>/Switch' incorporates:
1666 * Inport: '<Root>/hld_PrivateCAN_0x3AA_TimeoutErr'
1667 * S-Function (sfix_bitop): '<S252>/FixPt Bitwise Operator1'
1668 */
1669 if (hld_PrivateCAN_0x3AA_TimeoutErr) {
1670 rtb_Switch_ku |= 128U;
1671 }
1672
1673 /* End of Switch: '<S220>/Switch' */
1674
1675 /* Switch: '<S221>/Switch' incorporates:
1676 * Inport: '<Root>/hld_PrivateCAN_0x050_TimeoutErr'
1677 * S-Function (sfix_bitop): '<S253>/FixPt Bitwise Operator1'
1678 */
1679 if (hld_PrivateCAN_0x050_TimeoutErr) {
1680 rtb_Switch_ku |= 64U;
1681 }
1682
1683 /* End of Switch: '<S221>/Switch' */
1684
1685 /* Switch: '<S222>/Switch' incorporates:
1686 * Inport: '<Root>/hld_PrivateCAN_0x050_ChksumErr'
1687 * S-Function (sfix_bitop): '<S254>/FixPt Bitwise Operator1'
1688 */
1689 if (hld_PrivateCAN_0x050_ChksumErr) {
1690 rtb_Switch_ku |= 32U;
1691 }
1692
1693 /* End of Switch: '<S222>/Switch' */
1694
1695 /* Switch: '<S223>/Switch' incorporates:
1696 * Inport: '<Root>/hld_PrivateCAN_0x050_RolcntErr'
1697 * S-Function (sfix_bitop): '<S255>/FixPt Bitwise Operator1'
1698 */
1699 if (hld_PrivateCAN_0x050_RolcntErr) {
1700 rtb_Switch_ku |= 16U;
1701 }
1702
1703 /* End of Switch: '<S223>/Switch' */
1704
1705 /* Switch: '<S224>/Switch' incorporates:
1706 * Inport: '<Root>/hld_PrivateCAN_0x2F1_TimeoutErr'
1707 * S-Function (sfix_bitop): '<S256>/FixPt Bitwise Operator1'
1708 */
1709 if (hld_PrivateCAN_0x2F1_TimeoutErr) {
1710 rtb_Switch_ku |= 8U;
1711 }
1712
1713 /* End of Switch: '<S224>/Switch' */
1714
1715 /* Switch: '<S226>/Switch' incorporates:
1716 * Inport: '<Root>/hld_PrivateCAN_0x195_TimeoutErr'
1717 * S-Function (sfix_bitop): '<S258>/FixPt Bitwise Operator1'
1718 */
1719 if (hld_PrivateCAN_0x195_TimeoutErr) {
1720 rtb_Switch_ku |= 4U;
1721 }
1722
1723 /* End of Switch: '<S226>/Switch' */
1724
1725 /* Switch: '<S227>/Switch' incorporates:
1726 * Inport: '<Root>/hld_PrivateCAN_0x37F_TimeoutErr'
1727 * S-Function (sfix_bitop): '<S259>/FixPt Bitwise Operator1'
1728 */
1729 if (hld_PrivateCAN_0x37F_TimeoutErr) {
1730 rtb_Switch_ku |= 2U;
1731 }
1732
1733 /* End of Switch: '<S227>/Switch' */
1734
1735 /* Switch: '<S228>/Switch' incorporates:
1736 * Inport: '<Root>/hld_PrivateCAN_0x28C_TimeoutErr'
1737 * S-Function (sfix_bitop): '<S260>/FixPt Bitwise Operator1'
1738 */
1739 if (hld_PrivateCAN_0x28C_TimeoutErr) {
1740 rtb_Switch_ku |= 1U;
1741 }
1742
1743 /* End of Switch: '<S228>/Switch' */
1744
1745 /* S-Function (sfix_bitop): '<S201>/Ovrd' incorporates:
1746 * Constant: '<S201>/Cal'
1747 */
1748 DGM_B.Bitwise_AUX_b = rtb_Switch_ku & KeDGM_bIOSDFCOvrdval;
1749
1750 /* Outputs for Atomic SubSystem: '<S1>/IOS' */
1751 DGM_IOS();
1752
1753 /* End of Outputs for SubSystem: '<S1>/IOS' */
1754
1755 /* Switch: '<S267>/Switch' incorporates:
1756 * Constant: '<S202>/BitSet0'
1757 * Inport: '<Root>/hld_PrivateCAN_0x17D_TimeoutErr'
1758 */
1759 if (hld_PrivateCAN_0x17D_TimeoutErr) {
1760 rtb_Switch_ku = DGM_ConstB.FixPtBitwiseOperator1_j;
1761 } else {
1762 rtb_Switch_ku = 0U;
1763 }
1764
1765 /* End of Switch: '<S267>/Switch' */
1766
1767 /* S-Function (sfix_bitop): '<S202>/Ovrd' incorporates:
1768 * Constant: '<S202>/Cal'
1769 */
1770 DGM_B.Bitwise_AUX_b = rtb_Switch_ku & KeDGM_bIOSDFC1Ovrdval;
1771
1772 /* Outputs for Atomic SubSystem: '<S1>/IOS1' */
1773 DGM_IOS1();
1774
1775 /* End of Outputs for SubSystem: '<S1>/IOS1' */
1776
1777 /* Switch: '<S8>/Switch' incorporates:
1778 * Constant: '<S8>/Constant'
1779 * Constant: '<S8>/Constant1'
1780 * S-Function (sfix_bitop): '<S1>/Bitwise_PT'
1781 */
1782 if (KeDGM_bFltReactnPtFlg) {
1783 VeDGM_flgFltReactnPt = KeDGM_flgFltReactnPtVal;
1784 } else {
1785 VeDGM_flgFltReactnPt = DGM_B.Bitwise_PT_i | DGM_B.Bitwise_PT;
1786 }
1787
1788 /* End of Switch: '<S8>/Switch' */
1789
1790 /* Switch: '<S6>/Switch' incorporates:
1791 * Constant: '<S6>/Constant'
1792 * Constant: '<S6>/Constant1'
1793 * S-Function (sfix_bitop): '<S1>/Bitwise_AUX'
1794 */
1795 if (KeDGM_bFltReactnAuxFlg) {
1796 VeDGM_flgFltReactnAux = KeDGM_flgFltReactnAuxVal;
1797 } else {
1798 VeDGM_flgFltReactnAux = DGM_B.Bitwise_AUX | DGM_B.Bitwise_AUX_b;
1799 }
1800
1801 /* End of Switch: '<S6>/Switch' */
1802
1803 /* Switch: '<S7>/Switch' incorporates:
1804 * Constant: '<S7>/Constant'
1805 * Constant: '<S7>/Constant1'
1806 * MinMax: '<S1>/Max'
1807 */
1808 if (KeDGM_bFltLvlFlg) {
1809 VeDGM_enmVehFltLvl = KeDGM_FltLvlVal;
1810 } else if (DGM_B.Max > DGM_B.Product1) {
1811 /* MinMax: '<S1>/Max' */
1812 VeDGM_enmVehFltLvl = DGM_B.Max;
1813 } else {
1814 VeDGM_enmVehFltLvl = DGM_B.Product1;
1815 }
1816
1817 /* End of Switch: '<S7>/Switch' */
1818}
1819
1820/* Model initialize function */
1821void DGM_initialize(void)
1822{
1823 /* SystemInitialize for Atomic SubSystem: '<S1>/IOS' */
1824 DGM_IOS_Init();
1825
1826 /* End of SystemInitialize for SubSystem: '<S1>/IOS' */
1827
1828 /* SystemInitialize for Atomic SubSystem: '<S1>/IOS1' */
1829 DGM_IOS1_Init();
1830
1831 /* End of SystemInitialize for SubSystem: '<S1>/IOS1' */
1832}
1833
1834/* Model terminate function */
1835void DGM_terminate(void)
1836{
1837 /* (no terminate code required) */
1838}
1839
1840/*
1841 * File trailer for generated code.
1842 *
1843 * [EOF]
1844 */
1845