1/*
2 * File: BSER_BattSocCalc.c
3 *
4 * Code generated for Simulink model 'BSER_BattSocCalc'.
5 *
6 * Model version : 'M1.5.6'
7 * Simulink Coder version : 8.13 (R2017b) 24-Jul-2017
8 * C/C++ source code generated on : Wed Jul 7 17:01:26 2021
9 *
10 * Target selection: ert.tlc
11 * Embedded hardware selection: Infineon->TriCore
12 * Code generation objectives:
13 * 1. MISRA C:2012 guidelines
14 * 2. Execution efficiency
15 * Validation result: Not run
16 */
17
18#include "BSER_BattSocCalc.h"
19#include "BSER_BattSocCalc_private.h"
20#include "look1_iflf_binlcapw.h"
21#include "look1_iu32lftf_binlcapw.h"
22#include "look2_iflf_binlcapw.h"
23
24/* Named constants for Chart: '<S19>/Chart' */
25#define BSER_BattSocCa_IN_SocFulDefault ((uint8_T)1U)
26#define BSER_BattSocCalc_IN_SocFulSet ((uint8_T)2U)
27
28/* Named constants for Chart: '<S41>/Chart' */
29#define BSER_BattSocCa_IN_AddCourse_Stt ((uint8_T)1U)
30#define BSER_BattSocCalc_IN_Default_Stt ((uint8_T)2U)
31
32/* Named constants for Chart: '<S20>/Chart' */
33#define BSER_BattSocCalc_IN_Del_Course ((uint8_T)1U)
34#define BSER_BattSocCalc_IN_Del_Default ((uint8_T)2U)
35
36/* Named constants for Chart: '<S35>/Chart' */
37#define BSER_BattSocCalc_IN_control ((uint8_T)1U)
38#define BSER_BattSocCalc_IN_int ((uint8_T)2U)
39
40/* Named constants for Chart: '<S18>/SOC State' */
41#define BSER_BattSocCa_IN_littltcurrent ((uint8_T)4U)
42#define BSER_BattSocCalc_IN_Fault ((uint8_T)1U)
43#define BSER_BattSocCalc_IN_Intial ((uint8_T)2U)
44#define BSER_BattSocCalc_IN_Run ((uint8_T)3U)
45#define BSER_BattSocCalc_IN_pre_INI ((uint8_T)5U)
46
47/* Exported data definition */
48
49/* Volatile memory section */
50#define ASW1_OEM_START_SEC_DEFAULT_RAM1_CLEARED_UNSPECIFIED
51#include "Asw1_OEM_MemMap.h"
52
53/* Definition for custom storage class: Volatile */
54volatile real32_T BSER_cSocDchAhFulRev;/* DchAh Since Full Rev Soc. */
55volatile real32_T BSER_rSocAvrg;
56volatile real32_T BSER_rSocMax;
57volatile real32_T BSER_rSocMin;
58volatile uint8_T BSER_stSocFulHld;
59
60#define ASW1_OEM_STOP_SEC_DEFAULT_RAM1_CLEARED_UNSPECIFIED
61#include "Asw1_OEM_MemMap.h"
62#define ASW1_OEM_START_SEC_DEFAULT_RAM1_CLEARED_UNSPECIFIED
63#include "Asw1_OEM_MemMap.h"
64
65/* Definition for custom storage class: OutputSignal */
66volatile boolean_T BSER_DispSOCZero_flg;
67volatile real32_T BSER_LowSocCorLowCellVoltThres2_C;
68volatile real32_T BSER_LowSocCorLowCellVoltThres3_C;
69volatile boolean_T BSER_flgSocSave;
70volatile real32_T BSER_rRSocTableUpLimit_C;
71volatile real32_T BSER_rSoc;
72volatile real32_T BSER_rSocDspl;
73
74#define ASW1_OEM_STOP_SEC_DEFAULT_RAM1_CLEARED_UNSPECIFIED
75#include "Asw1_OEM_MemMap.h"
76
77/* Block signals (auto storage) */
78B_BSER_BattSocCalc_T BSER_BattSocCalc_B;
79
80/* Block states (auto storage) */
81DW_BSER_BattSocCalc_T BSER_BattSocCalc_DW;
82
83/* External outputs (root outports fed by signals with auto storage) */
84ExtY_BSER_BattSocCalc_T BSER_BattSocCalc_Y;
85
86/* Forward declaration for local functions */
87static void BSER_enter_internal_RS_FlipFlop(const boolean_T *DataTypeConversion1,
88 const boolean_T *LogicalOperator3);
89static void BSER_BattSocCalc_RS_FlipFlop(const boolean_T *DataTypeConversion1,
90 const boolean_T *LogicalOperator3);
91
92/* Function for Chart: '<S33>/RS' */
93static void BSER_enter_internal_RS_FlipFlop(const boolean_T *DataTypeConversion1,
94 const boolean_T *LogicalOperator3)
95{
96 if (*LogicalOperator3) {
97 BSER_BattSocCalc_B.Q = false;
98 } else {
99 if (*DataTypeConversion1) {
100 BSER_BattSocCalc_B.Q = true;
101 }
102 }
103}
104
105/* Function for Chart: '<S33>/RS' */
106static void BSER_BattSocCalc_RS_FlipFlop(const boolean_T *DataTypeConversion1,
107 const boolean_T *LogicalOperator3)
108{
109 BSER_enter_internal_RS_FlipFlop(DataTypeConversion1, LogicalOperator3);
110}
111
112/* Model step function */
113void BSER_BattSocCalc_step(void)
114{
115 boolean_T rtb_LogicalOperator_bs;
116 real32_T rtb_Product;
117 real32_T rtb_Abs1;
118 boolean_T rtb_OR7;
119 real32_T rtb_Switch;
120 real32_T rtb_Switch4;
121 boolean_T rtb_Compare_ng;
122 boolean_T rtb_bDel;
123 real32_T rtb_Product_j;
124 uint8_T rtb_DataTypeConversion_i;
125 real32_T rtb_Switch3_c5;
126 real32_T rtb_Product_p;
127 real32_T rtb_Product_d;
128 real32_T rtb_Switch3;
129 boolean_T rtb_LogicalOperator3_d;
130 uint8_T rtb_Switch_f;
131 real32_T rtb_Switch_dt;
132 real32_T rtb_Switch_b;
133 real32_T rtb_Switch5_j;
134 real32_T rtb_Switch1_j;
135 real32_T rtb_Subtract1_h;
136 real32_T rtb_Sum;
137 enmSocFulHldSts rtb_stSocFulHld;
138 int32_T tmp;
139 real_T Sum_tmp;
140 BSER_rRSocTableUpLimit_C = look1_iu32lftf_binlcapw(BSPR_TotalOdometer, ((const
141 uint32_T *)&(BSER_SOCOdoTableOdo_C[0])), ((const real32_T *)
142 &(BSER_SOCOdoTableSOC_C[0])), 9U);
143 rtb_Compare_ng = !BSPR_bRSocNvmVldFlg;
144 rtb_LogicalOperator_bs = (((DSMR_stFaultRank > 2) && DSMR_bFaultRankVldFlg_C) ||
145 (rtb_Compare_ng && (!BSPR_bCellVoltVldFlg_C)) || (!BSPR_bCurrVldFlg_C) ||
146 (!BSER_bBattCapVldFlg_C));
147 if (rtb_LogicalOperator_bs) {
148 rtb_Product_j = 0.02F;
149 } else {
150 rtb_Product_j = 0.0F;
151 }
152
153 rtb_Product = (rtb_Product_j + fminf(BSER_tiInputFualtFusf_C,
154 BSER_BattSocCalc_DW.Delay_DSTATE)) * (real32_T)rtb_LogicalOperator_bs;
155 rtb_Switch = fabsf(BSPR_iBattCurr);
156 if (BSER_BattSocCalc_DW.is_active_c1_BSER_BattSocCalc == 0U) {
157 BSER_BattSocCalc_DW.is_active_c1_BSER_BattSocCalc = 1U;
158 BSER_BattSocCalc_DW.is_c1_BSER_BattSocCalc = BSER_BattSocCalc_IN_pre_INI;
159 BSER_BattSocCalc_B.Initial_Enable = true;
160 BSER_BattSocCalc_B.bOcvRevHld = false;
161 } else {
162 switch (BSER_BattSocCalc_DW.is_c1_BSER_BattSocCalc) {
163 case BSER_BattSocCalc_IN_Fault:
164 break;
165
166 case BSER_BattSocCalc_IN_Intial:
167 if (((BSER_BattSocCalc_DW.count >= 50.0F) && (BMCR_stBmsModeCtrl > 1) &&
168 (BMCR_stBmsModeCtrl < 20)) || ((rtb_Switch > BSER_iRunIniCurrThres_C)
169 && (BSER_BattSocCalc_DW.count >= 50.0F))) {
170 BSER_BattSocCalc_B.RunINI = false;
171 BSER_BattSocCalc_B.bOcvRevHld = false;
172 BSER_BattSocCalc_DW.is_c1_BSER_BattSocCalc = BSER_BattSocCalc_IN_Run;
173 BSER_BattSocCalc_B.Ah_Enable = true;
174 BSER_BattSocCalc_B.Initial_Enable = false;
175 BSER_BattSocCalc_B.Fault_Enable = false;
176 BSER_BattSocCalc_Y.BSER_bSocVldFlg = true;
177 BSER_BattSocCalc_DW.counter = 0.0F;
178 } else {
179 BSER_BattSocCalc_B.Initial_Enable = true;
180 BSER_BattSocCalc_DW.count++;
181 }
182 break;
183
184 case BSER_BattSocCalc_IN_Run:
185 if (rtb_Product >= BSER_tiInputFualtFusf_C) {
186 BSER_BattSocCalc_DW.is_c1_BSER_BattSocCalc = BSER_BattSocCalc_IN_Fault;
187 BSER_BattSocCalc_B.Ah_Enable = true;
188 BSER_BattSocCalc_B.Initial_Enable = false;
189 BSER_BattSocCalc_B.Fault_Enable = false;
190 BSER_BattSocCalc_Y.BSER_bSocVldFlg = false;
191 BSER_BattSocCalc_DW.counter = 0.0F;
192 } else {
193 if (rtb_Switch <= BSER_iRunIniCurrThres_C) {
194 BSER_BattSocCalc_DW.is_c1_BSER_BattSocCalc =
195 BSER_BattSocCa_IN_littltcurrent;
196 BSER_BattSocCalc_B.RunINI = false;
197 BSER_BattSocCalc_DW.counter = 0.0F;
198 }
199 }
200 break;
201
202 case BSER_BattSocCa_IN_littltcurrent:
203 if (rtb_Product >= BSER_tiInputFualtFusf_C) {
204 BSER_BattSocCalc_B.RunINI = false;
205 BSER_BattSocCalc_DW.is_c1_BSER_BattSocCalc = BSER_BattSocCalc_IN_Fault;
206 BSER_BattSocCalc_B.Ah_Enable = true;
207 BSER_BattSocCalc_B.Initial_Enable = false;
208 BSER_BattSocCalc_B.Fault_Enable = false;
209 BSER_BattSocCalc_Y.BSER_bSocVldFlg = false;
210 BSER_BattSocCalc_DW.counter = 0.0F;
211 } else if ((real_T)BSER_BattSocCalc_DW.counter >= BSER_numRunCorrHit_C) {
212 BSER_BattSocCalc_B.bOcvRevHld = true;
213 BSER_BattSocCalc_B.RunINI = false;
214 BSER_BattSocCalc_DW.is_c1_BSER_BattSocCalc = BSER_BattSocCalc_IN_Intial;
215 BSER_BattSocCalc_B.Initial_Enable = true;
216 BSER_BattSocCalc_B.Ah_Enable = false;
217 BSER_BattSocCalc_B.Fault_Enable = false;
218 BSER_BattSocCalc_Y.BSER_bSocVldFlg = true;
219 BSER_BattSocCalc_DW.count = 0.0F;
220 } else if (rtb_Switch > BSER_iRunIniCurrThres_C) {
221 BSER_BattSocCalc_B.RunINI = false;
222 BSER_BattSocCalc_DW.is_c1_BSER_BattSocCalc = BSER_BattSocCalc_IN_Run;
223 BSER_BattSocCalc_B.Ah_Enable = true;
224 BSER_BattSocCalc_B.Initial_Enable = false;
225 BSER_BattSocCalc_B.Fault_Enable = false;
226 BSER_BattSocCalc_Y.BSER_bSocVldFlg = true;
227 BSER_BattSocCalc_DW.counter = 0.0F;
228 } else {
229 BSER_BattSocCalc_DW.counter++;
230 BSER_BattSocCalc_B.Ah_Enable = true;
231 BSER_BattSocCalc_B.Initial_Enable = false;
232 }
233 break;
234
235 default:
236 BSER_BattSocCalc_DW.is_c1_BSER_BattSocCalc = BSER_BattSocCalc_IN_Intial;
237 BSER_BattSocCalc_B.Initial_Enable = true;
238 BSER_BattSocCalc_B.Ah_Enable = false;
239 BSER_BattSocCalc_B.Fault_Enable = false;
240 BSER_BattSocCalc_Y.BSER_bSocVldFlg = true;
241 BSER_BattSocCalc_DW.count = 0.0F;
242 break;
243 }
244 }
245
246 if (BSER_BattSocCalc_B.Initial_Enable) {
247 rtb_Abs1 = 100.0F * look2_iflf_binlcapw(BSPR_uCellVoltAvrg,
248 BSPR_tCellTempAvrg, ((const real32_T *)&(BSER_uSocOCV_A[0])), ((const
249 real32_T *)&(BSER_tSocOCVTemp_A[0])), ((const real32_T *)
250 &(BSER_rSocOCV_MAP[0])), rtCP_uDLookupTable_maxIndex, 16U);
251 rtb_LogicalOperator_bs = (COMR_bStopTimeVldFlg && BSPR_bCellVoltVldFlg_C);
252 rtb_OR7 = (((rtb_LogicalOperator_bs && (COMR_tiStopTime >=
253 BSER_tiStoptimeThres_C)) || rtb_Compare_ng || BSER_BattSocCalc_B.RunINI ||
254 ((fabsf(BSPR_rNvmSocAvrg - BSPR_rNvmSocMin) >=
255 BSER_rInitRSocDiffThres_C) || (fabsf(BSPR_rNvmSocMax -
256 BSPR_rNvmSocAvrg) >= BSER_rInitRSocDiffThres_C) || (fabsf(BSPR_rNvmSocAvrg
257 - rtb_Abs1) >= BSER_rInitRSocDiffThres_C) || BSER_bSocResetCmd_C) ||
258 BSER_BattSocCalc_B.bOcvRevHld) && ((BSPR_uCellVoltMin >
259 BSER_numSocCorLowCellVoltThres_C) && (BSPR_uCellVoltMin <
260 BSER_numSocCorHighCellVoltThres_C)));
261 if (!rtb_OR7) {
262 rtb_Abs1 = BSPR_rNvmSocAvrg;
263 }
264
265 if (rtb_Abs1 > 100.0F) {
266 BSER_BattSocCalc_B.Saturation3 = 100.0F;
267 } else if (rtb_Abs1 < 0.0F) {
268 BSER_BattSocCalc_B.Saturation3 = 0.0F;
269 } else {
270 BSER_BattSocCalc_B.Saturation3 = rtb_Abs1;
271 }
272
273 if (BSER_BattSocCalc_B.bOcvRevHld) {
274 rtb_Abs1 = BSER_BattSocCalc_DW.Delay8_DSTATE;
275 } else {
276 rtb_Abs1 = look2_iflf_binlcapw(BSER_BattSocCalc_B.Saturation3,
277 BSPR_tCellTempAvrg, ((const real32_T *)&(BSER_rDsplSocRSoc_A[0])), ((
278 const real32_T *)&(BSER_tBattDsplSocTemp_A[0])), ((const real32_T *)
279 &(BSER_rDsplSocRSoc_MAP[0])), rtCP_uDLookupTable1_maxIndex_d, 17U);
280 if (!(BSER_bSocResetCmd_C || (rtb_LogicalOperator_bs && (COMR_tiStopTime >=
281 BSER_tiDsplSocStoptimeThres_C)) || rtb_Compare_ng ||
282 (rtb_LogicalOperator_bs && BSER_BattSocCalc_B.RunINI && (fabsf
283 (BSER_BattSocCalc_DW.Delay4_DSTATE - rtb_Abs1) >=
284 BSER_rInitDSocDiffThres_C)) || (rtb_LogicalOperator_bs && (fabsf
285 (rtb_Abs1 - BSPR_rDsplNvmSoc) >= BSER_rInitDSocDiffThres_C)))) {
286 rtb_Abs1 = BSPR_rDsplNvmSoc;
287 }
288 }
289
290 if (rtb_Abs1 > 100.0F) {
291 BSER_BattSocCalc_B.Saturation = 100.0F;
292 } else if (rtb_Abs1 < 0.0F) {
293 BSER_BattSocCalc_B.Saturation = 0.0F;
294 } else {
295 BSER_BattSocCalc_B.Saturation = rtb_Abs1;
296 }
297
298 if (rtb_OR7) {
299 rtb_Abs1 = 100.0F * look2_iflf_binlcapw(BSPR_uCellVoltMax,
300 BSPR_tCellTempAvrg, ((const real32_T *)&(BSER_uSocOCV_A[0])), ((const
301 real32_T *)&(BSER_tSocOCVTemp_A[0])), ((const real32_T *)
302 &(BSER_rSocOCV_MAP[0])), rtCP_uDLookupTable2_maxIndex, 16U);
303 } else {
304 rtb_Abs1 = BSPR_rNvmSocMax;
305 }
306
307 if (rtb_Abs1 > 100.0F) {
308 BSER_BattSocCalc_B.Saturation1 = 100.0F;
309 } else if (rtb_Abs1 < 0.0F) {
310 BSER_BattSocCalc_B.Saturation1 = 0.0F;
311 } else {
312 BSER_BattSocCalc_B.Saturation1 = rtb_Abs1;
313 }
314
315 if (rtb_OR7) {
316 rtb_Abs1 = 100.0F * look2_iflf_binlcapw(BSPR_uCellVoltMin,
317 BSPR_tCellTempAvrg, ((const real32_T *)&(BSER_uSocOCV_A[0])), ((const
318 real32_T *)&(BSER_tSocOCVTemp_A[0])), ((const real32_T *)
319 &(BSER_rSocOCV_MAP[0])), rtCP_uDLookupTable1_maxIndex_i, 16U);
320 } else {
321 rtb_Abs1 = BSPR_rNvmSocMin;
322 }
323
324 if (rtb_Abs1 > 100.0F) {
325 BSER_BattSocCalc_B.Saturation2 = 100.0F;
326 } else if (rtb_Abs1 < 0.0F) {
327 BSER_BattSocCalc_B.Saturation2 = 0.0F;
328 } else {
329 BSER_BattSocCalc_B.Saturation2 = rtb_Abs1;
330 }
331 }
332
333 if (rtb_Switch > BESR_iOcvRevThres_C) {
334 rtb_Switch = BSPR_iBattCurr;
335 } else {
336 rtb_Switch = 0.0F;
337 }
338
339 rtb_LogicalOperator_bs = BSER_BattSocCalc_DW.Delay3_DSTATE;
340 if (BSER_BattSocCalc_B.Ah_Enable) {
341 if (rtb_LogicalOperator_bs) {
342 rtb_Product_j = BSER_BattSocCalc_B.Saturation3;
343 } else {
344 rtb_Product_j = BSER_BattSocCalc_DW.Delay5_DSTATE;
345 }
346
347 rtb_Switch3_c5 = fabsf(BSER_ahBattCap_C);
348 if (rtb_Switch3_c5 > 0.1F) {
349 rtb_Abs1 = BSER_ahBattCap_C;
350 } else {
351 rtb_Abs1 = 1.0F;
352 }
353
354 Sum_tmp = (real_T)rtb_Switch * BSER_facColmB_C * 0.02777777798473835 *
355 BSER_tiSocStep_C;
356 BSER_BattSocCalc_B.Sum = rtb_Product_j - (real32_T)(Sum_tmp / rtb_Abs1);
357 if (rtb_LogicalOperator_bs) {
358 rtb_Product_j = BSER_BattSocCalc_B.Saturation1;
359 } else {
360 rtb_Product_j = BSER_BattSocCalc_DW.Delay7_DSTATE;
361 }
362
363 if (rtb_Switch3_c5 > 0.1F) {
364 rtb_Abs1 = BSER_ahBattCap_C;
365 } else {
366 rtb_Abs1 = 1.0F;
367 }
368
369 BSER_BattSocCalc_B.Sum_o = rtb_Product_j - (real32_T)(Sum_tmp / rtb_Abs1);
370 if (rtb_LogicalOperator_bs) {
371 rtb_Product_j = BSER_BattSocCalc_B.Saturation2;
372 } else {
373 rtb_Product_j = BSER_BattSocCalc_DW.Delay6_DSTATE;
374 }
375
376 if (rtb_Switch3_c5 > 0.1F) {
377 rtb_Switch3_c5 = BSER_ahBattCap_C;
378 } else {
379 rtb_Switch3_c5 = 1.0F;
380 }
381
382 BSER_BattSocCalc_B.Sum_op = rtb_Product_j - (real32_T)(Sum_tmp /
383 rtb_Switch3_c5);
384 if (fabsf(BSER_ahBattCap) > 0.1F) {
385 rtb_Switch1_j = BSER_ahBattCap;
386 } else {
387 rtb_Switch1_j = 1.0F;
388 }
389
390 if (BSER_BattSocCalc_DW.Delay2_DSTATE > BSER_rRSocTableUpLimit_C) {
391 BSER_BattSocCalc_B.Switch2 = 100.0F;
392 } else {
393 if (BSER_BattSocCalc_DW.Delay2_DSTATE <= BSER_rRSocLowLimit_C) {
394 rtb_Abs1 = 0.0F;
395 } else {
396 if (rtb_LogicalOperator_bs) {
397 rtb_Abs1 = BSER_BattSocCalc_B.Saturation;
398 } else {
399 rtb_Abs1 = BSER_BattSocCalc_DW.Delay1_DSTATE;
400 }
401
402 rtb_Sum = rtb_Abs1 - look2_iflf_binlcapw
403 (BSER_BattSocCalc_DW.Delay2_DSTATE, BSPR_tCellTempAvrg, ((const
404 real32_T *)&(BSER_rDsplSocRSoc_A[0])), ((const real32_T *)
405 &(BSER_tBattDsplSocTemp_A[0])), ((const real32_T *)
406 &(BSER_rDsplSocRSoc_MAP[0])), rtCP_uDLookupTable1_maxIndex, 17U);
407 if (fabsf(rtb_Sum) > BSER_rDsplSocDiffAllowThres_C) {
408 if (rtb_Switch > 0.0F) {
409 if (rtb_Sum > 0.0F) {
410 if (rtb_Switch < 0.6F) {
411 rtb_Switch1_j = rtb_Switch / rtb_Switch1_j * BSER_tiSocStep_C *
412 0.027777778F * BSER_rChgDsplSocFast_C * 6.0F;
413 } else {
414 rtb_Switch1_j = rtb_Switch / rtb_Switch1_j * BSER_tiSocStep_C *
415 0.027777778F * BSER_rChgDsplSocFast_C;
416 }
417 } else {
418 rtb_Switch1_j = rtb_Switch / rtb_Switch1_j * BSER_tiSocStep_C *
419 0.027777778F * BSER_rChgDsplSocSlow_C;
420 }
421 } else if (rtb_Sum > 0.0F) {
422 rtb_Switch1_j = rtb_Switch / rtb_Switch1_j * BSER_tiSocStep_C *
423 0.027777778F * BSER_rDisChDsplSocSlow_C;
424 } else {
425 rtb_Switch1_j = rtb_Switch / rtb_Switch1_j * BSER_tiSocStep_C *
426 0.027777778F * BSER_rDisChDsplSocFast_C;
427 }
428 } else {
429 rtb_Switch1_j = rtb_Switch / rtb_Switch1_j * BSER_tiSocStep_C *
430 0.027777778F * BSER_rDsplSocNrm_C;
431 }
432
433 rtb_Abs1 -= rtb_Switch1_j;
434 }
435
436 BSER_BattSocCalc_B.Switch2 = rtb_Abs1;
437 }
438 }
439
440 if (BSER_BattSocCalc_B.Initial_Enable) {
441 rtb_Sum = BSER_BattSocCalc_B.Saturation1;
442 rtb_Switch4 = BSER_BattSocCalc_B.Saturation2;
443 } else {
444 rtb_Sum = BSER_BattSocCalc_B.Sum_o;
445 rtb_Switch4 = BSER_BattSocCalc_B.Sum_op;
446 }
447
448 if (BSER_BattSocCalc_B.Fault_Enable) {
449 rtb_Switch1_j = BSER_BattSocCalc_DW.Delay1_DSTATE_i;
450 } else if (BSER_BattSocCalc_B.Initial_Enable) {
451 rtb_Switch1_j = BSER_BattSocCalc_B.Saturation;
452 } else {
453 rtb_Switch1_j = BSER_BattSocCalc_B.Switch2;
454 }
455
456 if (BSER_BattSocCalc_B.Initial_Enable) {
457 rtb_Switch3 = BSER_BattSocCalc_B.Saturation3;
458 } else {
459 rtb_Switch3 = BSER_BattSocCalc_B.Sum;
460 }
461
462 if (rtb_Switch4 < BSER_PackSocCorMinSOC_C) {
463 rtb_Abs1 = rtb_Switch4;
464 } else if (rtb_Sum > BSER_PackSocCorMaxSOC_C) {
465 rtb_Abs1 = rtb_Sum;
466 } else {
467 rtb_Abs1 = (BSER_rRSocTableUpLimit_C - BSER_rRSocLowLimit_C) - (rtb_Sum -
468 rtb_Switch4);
469 if (!(fabsf(rtb_Abs1) > 0.1F)) {
470 rtb_Abs1 = 1.0F;
471 }
472
473 rtb_Abs1 = (BSER_rRSocTableUpLimit_C * rtb_Switch4 - BSER_rRSocLowLimit_C *
474 rtb_Sum) / rtb_Abs1;
475 rtb_Abs1 = fmaxf(rtb_Abs1, rtb_Switch4);
476 rtb_Abs1 = fminf(rtb_Abs1, rtb_Sum);
477 }
478
479 BSER_BattSocCalc_DW.Delay1_DSTATE_i = rtb_Switch1_j;
480 rtb_LogicalOperator_bs = ((BMCR_stBmsModeCtrl == 5) || (BMCR_stBmsModeCtrl ==
481 6));
482 rtb_OR7 = (BSER_BattSocCalc_DW.Delay1_DSTATE_dx && (!rtb_LogicalOperator_bs));
483 BSER_BattSocCalc_DW.Delay1_DSTATE_dx = rtb_LogicalOperator_bs;
484 if (BSER_BattSocCalc_DW.is_active_c4_BSER_BattSocCalc == 0U) {
485 BSER_BattSocCalc_DW.is_active_c4_BSER_BattSocCalc = 1U;
486 BSER_BattSocCalc_DW.is_c4_BSER_BattSocCalc = BSER_BattSocCalc_IN_Del_Default;
487 rtb_bDel = false;
488 BSER_BattSocCalc_DW.cnt = 0.0F;
489 } else if (BSER_BattSocCalc_DW.is_c4_BSER_BattSocCalc ==
490 BSER_BattSocCalc_IN_Del_Course) {
491 rtb_bDel = true;
492 if (BSER_BattSocCalc_DW.cnt > BSER_cntSocBmsStsDel_C) {
493 BSER_BattSocCalc_DW.is_c4_BSER_BattSocCalc =
494 BSER_BattSocCalc_IN_Del_Default;
495 rtb_bDel = false;
496 BSER_BattSocCalc_DW.cnt = 0.0F;
497 } else {
498 BSER_BattSocCalc_DW.cnt++;
499 }
500 } else {
501 rtb_bDel = false;
502 if (rtb_OR7) {
503 BSER_BattSocCalc_DW.is_c4_BSER_BattSocCalc =
504 BSER_BattSocCalc_IN_Del_Course;
505 rtb_bDel = true;
506 BSER_BattSocCalc_DW.cnt++;
507 }
508 }
509
510 rtb_LogicalOperator_bs = ((rtb_bDel || rtb_LogicalOperator_bs) &&
511 (BCMR_bChrgFul && BCMR_bChrgFulVldFlg_C));
512 if (rtb_LogicalOperator_bs) {
513 rtb_Product_j = 0.02F;
514 } else {
515 rtb_Product_j = 0.0F;
516 }
517
518 rtb_Product_j = (rtb_Product_j + fminf(BSER_tiFullChgtFusf_C,
519 BSER_BattSocCalc_DW.Delay_DSTATE_l)) * (real32_T)rtb_LogicalOperator_bs;
520 rtb_bDel = (rtb_Product_j >= BSER_tiFullChgtFusf_C);
521 rtb_LogicalOperator3_d = !BSER_BattSocCalc_DW.Delay1_DSTATE_g;
522 BSER_BattSocCalc_DW.Delay1_DSTATE_g = rtb_bDel;
523 rtb_LogicalOperator_bs = (BSER_BattSocCalc_DW.Delay_DSTATE_k ||
524 BSER_BattSocCalc_DW.Delay2_DSTATE_i);
525 if (BSER_BattSocCalc_DW.Delay1_DSTATE_j) {
526 rtb_Switch_f = BSER_BattSocCalc_DW.Delay_DSTATE_g;
527 } else {
528 rtb_Switch_f = BSER_stSocFulHld;
529 }
530
531 if (BSER_BattSocCalc_DW.is_active_c5_BSER_BattSocCalc == 0U) {
532 BSER_BattSocCalc_DW.is_active_c5_BSER_BattSocCalc = 1U;
533 BSER_BattSocCalc_DW.is_c5_BSER_BattSocCalc = BSER_BattSocCa_IN_SocFulDefault;
534 rtb_stSocFulHld = enmSocFulHldSts_Default;
535 rtb_OR7 = false;
536 } else if (BSER_BattSocCalc_DW.is_c5_BSER_BattSocCalc ==
537 BSER_BattSocCa_IN_SocFulDefault) {
538 rtb_stSocFulHld = enmSocFulHldSts_Default;
539 rtb_OR7 = false;
540 if (rtb_LogicalOperator_bs) {
541 rtb_DataTypeConversion_i = BSER_BattSocCalc_ConstB.DataTypeConversion1;
542 } else {
543 rtb_DataTypeConversion_i = rtb_Switch_f;
544 }
545
546 if ((BSPR_bRSocNvmVldFlg && (rtb_DataTypeConversion_i != 0)) ||
547 (rtb_LogicalOperator3_d && rtb_bDel)) {
548 BSER_BattSocCalc_DW.is_c5_BSER_BattSocCalc = BSER_BattSocCalc_IN_SocFulSet;
549 rtb_stSocFulHld = enmSocFulHldSts_FulHld;
550 rtb_OR7 = true;
551 }
552 } else {
553 rtb_stSocFulHld = enmSocFulHldSts_FulHld;
554 rtb_OR7 = true;
555 if (BSER_BattSocCalc_DW.Delay1_DSTATE_e > BSER_cSocAhFulHldThres_C) {
556 BSER_BattSocCalc_DW.is_c5_BSER_BattSocCalc =
557 BSER_BattSocCa_IN_SocFulDefault;
558 rtb_stSocFulHld = enmSocFulHldSts_Default;
559 rtb_OR7 = false;
560 }
561 }
562
563 if (BSER_BattSocCalc_DW.is_active_c6_BSER_BattSocCalc == 0U) {
564 BSER_BattSocCalc_DW.is_active_c6_BSER_BattSocCalc = 1U;
565 BSER_BattSocCalc_DW.is_c6_BSER_BattSocCalc = BSER_BattSocCalc_IN_Default_Stt;
566 BSER_BattSocCalc_DW.i = 0U;
567 rtb_bDel = false;
568 } else if (BSER_BattSocCalc_DW.is_c6_BSER_BattSocCalc ==
569 BSER_BattSocCa_IN_AddCourse_Stt) {
570 rtb_bDel = true;
571 if (BSER_BattSocCalc_DW.i > BSER_cntSocStbNum_C) {
572 BSER_BattSocCalc_DW.is_c6_BSER_BattSocCalc =
573 BSER_BattSocCalc_IN_Default_Stt;
574 BSER_BattSocCalc_DW.i = 0U;
575 rtb_bDel = false;
576 } else {
577 tmp = BSER_BattSocCalc_DW.i + 1;
578 if (tmp > 255) {
579 tmp = 255;
580 }
581
582 BSER_BattSocCalc_DW.i = (uint8_T)tmp;
583 }
584 } else {
585 rtb_bDel = false;
586 if (rtb_stSocFulHld != BSER_BattSocCalc_DW.DelayInput1_DSTATE) {
587 BSER_BattSocCalc_DW.is_c6_BSER_BattSocCalc =
588 BSER_BattSocCa_IN_AddCourse_Stt;
589 rtb_bDel = true;
590 }
591 }
592
593 if (rtb_bDel) {
594 rtb_DataTypeConversion_i = BSER_BattSocCalc_DW.Delay1_DSTATE_h;
595 } else {
596 rtb_DataTypeConversion_i = rtb_stSocFulHld;
597 }
598
599 rtb_bDel = (BSER_BattSocCalc_DW.Delay1_DSTATE_b && (!(rtb_DataTypeConversion_i
600 != 0)));
601 BSER_BattSocCalc_DW.Delay1_DSTATE_b = (rtb_DataTypeConversion_i != 0);
602 rtb_bDel = (rtb_bDel || BSER_BattSocCalc_DW.Delay2_DSTATE_f);
603 if (BSER_BattSocCalc_DW.Delay1_DSTATE_iy) {
604 rtb_Switch_dt = BSER_BattSocCalc_DW.Delay_DSTATE_e;
605 } else {
606 rtb_Switch_dt = BSER_cSocDchAhFulRev;
607 }
608
609 if (rtb_DataTypeConversion_i != 0) {
610 if (fabsf(rtb_Switch) > BSER_iSocCurrEff_C) {
611 rtb_Switch_b = rtb_Switch * BSER_tiSocRunT_C / 3.6E+6F;
612 } else {
613 rtb_Switch_b = 0.0F;
614 }
615 } else {
616 rtb_Switch_b = 0.0F;
617 }
618
619 if ((rtb_DataTypeConversion_i != 0) != (int32_T)
620 BSER_BattSocCalc_DW.DelayInput1_DSTATE_h) {
621 rtb_Switch3_c5 = 0.0F;
622 } else {
623 rtb_Switch3_c5 = BSER_BattSocCalc_DW.Delay_DSTATE_p;
624 }
625
626 rtb_Switch_b += rtb_Switch3_c5;
627 if (rtb_DataTypeConversion_i != 0) {
628 if (rtb_Compare_ng || rtb_bDel) {
629 rtb_Switch3_c5 = 0.0F;
630 } else {
631 rtb_Switch3_c5 = rtb_Switch_dt;
632 }
633
634 rtb_Switch3_c5 += rtb_Switch_b;
635 } else {
636 rtb_Switch3_c5 = 0.0F;
637 }
638
639 BSER_cSocDchAhFulRev = rtb_Switch3_c5;
640 BSER_stSocFulHld = rtb_DataTypeConversion_i;
641 rtb_Compare_ng = (rtb_DataTypeConversion_i != 0);
642 rtb_LogicalOperator3_d = ((!(rtb_DataTypeConversion_i != 0)) &&
643 (BSER_BattSocCalc_DW.Delay1_DSTATE_d > 99.99F));
644 if (BSER_BattSocCalc_DW.is_active_c2_BSER_BattSocCalc == 0U) {
645 BSER_BattSocCalc_DW.is_active_c2_BSER_BattSocCalc = 1U;
646 BSER_enter_internal_RS_FlipFlop(&rtb_Compare_ng, &rtb_LogicalOperator3_d);
647 } else {
648 BSER_BattSocCalc_RS_FlipFlop(&rtb_Compare_ng, &rtb_LogicalOperator3_d);
649 }
650
651 if (BSER_BattSocCalc_B.Q) {
652 rtb_Switch1_j = 100.0F;
653 } else {
654 if ((!BSER_BattSocCalc_B.Initial_Enable) && (rtb_Switch < 0.0F) &&
655 (!BSER_BattSocCalc_B.Q)) {
656 rtb_Switch1_j = fminf(rtb_Switch1_j, 99.9F);
657 }
658 }
659
660 if (GbBSW_DispSOCOverWrite_flg) {
661 rtb_Switch1_j = GcBSW_DispSOCOverWrite_pct;
662 rtb_Switch5_j = GcBSW_DispSOCOverWrite_pct;
663 } else {
664 if (!(BSER_BattSocCalc_B.Initial_Enable || BSER_BattSocCalc_B.Q)) {
665 if (fabsf(rtb_Switch) <= BSER_iSocHoldCurrThres_C) {
666 rtb_Switch1_j = BSER_BattSocCalc_DW.Delay_DSTATE_j;
667 } else if ((rtb_Switch > 0.0F) || ((BMCR_stBmsModeCtrl == 4) &&
668 (COMR_YearSet != 2080))) {
669 rtb_Switch1_j = fminf(BSER_BattSocCalc_DW.Delay_DSTATE_j, rtb_Switch1_j);
670 } else {
671 rtb_Switch1_j = fmaxf(BSER_BattSocCalc_DW.Delay_DSTATE_j, rtb_Switch1_j);
672 }
673 }
674
675 if (BSER_BattSocCalc_B.Initial_Enable) {
676 rtb_Switch5_j = rtb_Switch1_j;
677 } else {
678 rtb_Subtract1_h = rtb_Switch1_j - BSER_BattSocCalc_DW.Delay_DSTATE_b;
679 if (fabsf(rtb_Subtract1_h) <= BSER_rDsplSocFilter_C) {
680 rtb_Subtract1_h = rtb_Switch1_j;
681 } else {
682 if (rtb_Subtract1_h < 0.0F) {
683 rtb_Subtract1_h = -1.0F;
684 } else {
685 if (rtb_Subtract1_h > 0.0F) {
686 rtb_Subtract1_h = 1.0F;
687 }
688 }
689
690 rtb_Subtract1_h = rtb_Subtract1_h * BSER_rDsplSocFilter_C +
691 BSER_BattSocCalc_DW.Delay_DSTATE_b;
692 }
693
694 if (rtb_Subtract1_h > 100.0F) {
695 rtb_Switch5_j = 100.0F;
696 } else if (rtb_Subtract1_h < 0.0F) {
697 rtb_Switch5_j = 0.0F;
698 } else {
699 rtb_Switch5_j = rtb_Subtract1_h;
700 }
701 }
702 }
703
704 BSER_LowSocCorLowCellVoltThres2_C = look1_iflf_binlcapw(BSPR_tCellTempAvrg, ((
705 const real32_T *)&(BSER_uMinCellVoltTemp[0])), ((const real32_T *)
706 &(BSER_uSOCZeorVolt_MAP[0])), 9U);
707 rtb_Compare_ng = ((fabsf(rtb_Switch) <= BSER_LowSocCorCurrThres1_C) &&
708 (BSER_LowSocCorLowCellVoltThres1_C <= BSPR_uCellVoltMin) &&
709 (BSPR_uCellVoltMin <= BSER_LowSocCorLowCellVoltThres2_C));
710 if (rtb_Compare_ng) {
711 rtb_Switch = 0.02F;
712 } else {
713 rtb_Switch = 0.0F;
714 }
715
716 rtb_Product_p = (rtb_Switch + fminf(BSER_tiLowSOCCor1_C,
717 BSER_BattSocCalc_DW.Delay_DSTATE_i)) * (real32_T)rtb_Compare_ng;
718 BSER_LowSocCorLowCellVoltThres3_C = look1_iflf_binlcapw(BSPR_tCellTempAvrg, ((
719 const real32_T *)&(BSER_uMinCellVoltTemp[0])), ((const real32_T *)
720 &(BSER_uSOCOneVolt_MAP[0])), 9U);
721 rtb_Compare_ng = (BSPR_uCellVoltMin > BSER_LowSocCorLowCellVoltThres3_C);
722 if (rtb_Compare_ng) {
723 rtb_Switch = 0.02F;
724 } else {
725 rtb_Switch = 0.0F;
726 }
727
728 rtb_Product_d = (rtb_Switch + fminf(BSER_tiLowSOCCor1_C,
729 BSER_BattSocCalc_DW.Delay_DSTATE_iu)) * (real32_T)rtb_Compare_ng;
730 if (rtb_Product_p >= BSER_tiLowSOCCor1_C) {
731 BSER_DispSOCZero_flg = true;
732 } else {
733 BSER_DispSOCZero_flg = ((!(rtb_Product_d >= BSER_tiLowSOCCor1_C)) &&
734 BSER_DispSOCZero_flg);
735 }
736
737 if (BSER_DispSOCZero_flg) {
738 rtb_Switch = 0.0F;
739 } else {
740 rtb_Switch = fmaxf(rtb_Switch5_j, BSER_SocCorMinValue_C);
741 }
742
743 rtb_Compare_ng = (BCMR_bChrgFul && (!BSER_BattSocCalc_DW.UnitDelay_DSTATE_a));
744 BSER_BattSocCalc_DW.UnitDelay_DSTATE_a = BCMR_bChrgFul;
745 if (GbBSW_RealSOCOverWrite_flg) {
746 rtb_Switch3 = GcBSW_RealSOCOverWrite_pct;
747 rtb_Subtract1_h = GcBSW_RealSOCOverWrite_pct;
748 rtb_Sum = GcBSW_RealSOCOverWrite_pct;
749 } else if ((BSPR_tCellTempAvrg > BSER_RealSocZeroTemp_C) &&
750 BSER_DispSOCZero_flg) {
751 rtb_Switch3 = (rtb_Switch3 - rtb_Switch4) + BSER_LowSocCorMinSOC1_C;
752 rtb_Subtract1_h = BSER_LowSocCorMinSOC1_C;
753 rtb_Sum = (rtb_Sum - rtb_Switch4) + BSER_LowSocCorMinSOC1_C;
754 } else if (rtb_Compare_ng) {
755 rtb_Switch3 = BSER_rRSocTableUpLimit_C - (rtb_Sum - rtb_Switch3);
756 rtb_Subtract1_h = BSER_rRSocTableUpLimit_C - (rtb_Sum - rtb_Switch4);
757 rtb_Sum = BSER_rRSocTableUpLimit_C;
758 } else {
759 rtb_Switch3 = fmaxf(rtb_Switch3, BSER_SocCorMinValue_C);
760 rtb_Subtract1_h = fmaxf(rtb_Switch4, BSER_SocCorMinValue_C);
761 rtb_Sum = fmaxf(rtb_Sum, BSER_SocCorMinValue_C);
762 }
763
764 if (BSER_BattSocCalc_DW.Delay2_DSTATE_h || BSER_BattSocCalc_B.Initial_Enable)
765 {
766 BSER_BattSocCalc_B.In1 = rtb_Switch5_j;
767 }
768
769 rtb_Compare_ng = (fabsf(BSER_BattSocCalc_B.In1 - rtb_Switch5_j) >=
770 BESR_numSocSaveStep_C);
771 if (BSER_BattSocCalc_DW.is_active_c3_BSER_BattSocCalc == 0U) {
772 BSER_BattSocCalc_DW.is_active_c3_BSER_BattSocCalc = 1U;
773 BSER_BattSocCalc_DW.is_c3_BSER_BattSocCalc = BSER_BattSocCalc_IN_int;
774 BSER_BattSocCalc_DW.conter = 1.0;
775 BSER_BattSocCalc_B.flag = false;
776 } else if (BSER_BattSocCalc_DW.is_c3_BSER_BattSocCalc ==
777 BSER_BattSocCalc_IN_control) {
778 if (BSER_BattSocCalc_DW.conter >= BESR_numSocSaveFlgStep_C) {
779 BSER_BattSocCalc_DW.is_c3_BSER_BattSocCalc = BSER_BattSocCalc_IN_int;
780 BSER_BattSocCalc_DW.conter = 1.0;
781 BSER_BattSocCalc_B.flag = false;
782 } else {
783 BSER_BattSocCalc_DW.conter++;
784 BSER_BattSocCalc_B.flag = true;
785 }
786 } else {
787 if (rtb_Compare_ng) {
788 BSER_BattSocCalc_DW.is_c3_BSER_BattSocCalc = BSER_BattSocCalc_IN_control;
789 }
790 }
791
792 rtb_LogicalOperator3_d = !BSER_BattSocCalc_DW.UnitDelay_DSTATE;
793 BSER_BattSocCalc_DW.UnitDelay_DSTATE = BCMR_bChrgFul;
794 BSER_flgSocSave = (BSER_BattSocCalc_B.flag || (BCMR_bChrgFul &&
795 rtb_LogicalOperator3_d));
796 BSER_BattSocCalc_DW.Delay1_DSTATE_h = rtb_DataTypeConversion_i;
797 BSER_BattSocCalc_DW.Delay1_DSTATE_e = rtb_Switch3_c5;
798 BSER_BattSocCalc_DW.Delay_DSTATE_l = rtb_Product_j;
799 BSER_BattSocCalc_DW.Delay_DSTATE_k = rtb_OR7;
800 BSER_BattSocCalc_DW.Delay2_DSTATE_i = rtb_LogicalOperator_bs;
801 BSER_BattSocCalc_DW.Delay_DSTATE_g = rtb_Switch_f;
802 BSER_BattSocCalc_DW.Delay1_DSTATE_j = true;
803 BSER_BattSocCalc_DW.DelayInput1_DSTATE = rtb_stSocFulHld;
804 BSER_BattSocCalc_DW.Delay2_DSTATE_f = rtb_bDel;
805 BSER_BattSocCalc_DW.Delay_DSTATE_e = rtb_Switch_dt;
806 BSER_BattSocCalc_DW.Delay1_DSTATE_iy = true;
807 BSER_BattSocCalc_DW.DelayInput1_DSTATE_h = (rtb_DataTypeConversion_i != 0);
808 BSER_BattSocCalc_DW.Delay_DSTATE_p = rtb_Switch_b;
809 BSER_BattSocCalc_DW.Delay1_DSTATE_d = rtb_Switch5_j;
810 BSER_BattSocCalc_DW.Delay_DSTATE_j = rtb_Switch1_j;
811 BSER_BattSocCalc_DW.Delay_DSTATE_b = rtb_Switch5_j;
812 BSER_BattSocCalc_DW.Delay_DSTATE_i = rtb_Product_p;
813 BSER_BattSocCalc_DW.Delay_DSTATE_iu = rtb_Product_d;
814 BSER_BattSocCalc_DW.Delay2_DSTATE_h = rtb_Compare_ng;
815 if (BSER_rRSocTableUpLimit_C < rtb_Abs1) {
816 rtb_Switch1_j = BSER_rRSocTableUpLimit_C;
817 } else {
818 rtb_Switch1_j = rtb_Abs1;
819 }
820
821 if (rtb_Switch1_j > 0.0F) {
822 BSER_rSoc = rtb_Switch1_j;
823 } else {
824 BSER_rSoc = 0.0F;
825 }
826
827 if (BSER_rRSocTableUpLimit_C < rtb_Sum) {
828 rtb_Switch1_j = BSER_rRSocTableUpLimit_C;
829 } else {
830 rtb_Switch1_j = rtb_Sum;
831 }
832
833 if (rtb_Switch1_j > 0.0F) {
834 BSER_rSocMax = rtb_Switch1_j;
835 } else {
836 BSER_rSocMax = 0.0F;
837 }
838
839 if (BSER_rRSocTableUpLimit_C < rtb_Subtract1_h) {
840 rtb_Switch1_j = BSER_rRSocTableUpLimit_C;
841 } else {
842 rtb_Switch1_j = rtb_Subtract1_h;
843 }
844
845 if (rtb_Switch1_j > 0.0F) {
846 BSER_rSocMin = rtb_Switch1_j;
847 } else {
848 BSER_rSocMin = 0.0F;
849 }
850
851 if (BSER_rRSocTableUpLimit_C < rtb_Switch3) {
852 rtb_Switch1_j = BSER_rRSocTableUpLimit_C;
853 } else {
854 rtb_Switch1_j = rtb_Switch3;
855 }
856
857 if (rtb_Switch1_j > 0.0F) {
858 BSER_rSocAvrg = rtb_Switch1_j;
859 } else {
860 BSER_rSocAvrg = 0.0F;
861 }
862
863 if (rtb_Switch > 100.0F) {
864 BSER_rSocDspl = 100.0F;
865 } else if (rtb_Switch < 0.0F) {
866 BSER_rSocDspl = 0.0F;
867 } else {
868 BSER_rSocDspl = rtb_Switch;
869 }
870
871 BSER_BattSocCalc_DW.Delay_DSTATE = rtb_Product;
872 BSER_BattSocCalc_DW.Delay4_DSTATE = rtb_Switch;
873 BSER_BattSocCalc_DW.Delay8_DSTATE = rtb_Switch;
874 BSER_BattSocCalc_DW.Delay1_DSTATE = rtb_Switch;
875 BSER_BattSocCalc_DW.Delay2_DSTATE = rtb_Abs1;
876 BSER_BattSocCalc_DW.Delay3_DSTATE = BSER_BattSocCalc_B.Initial_Enable;
877 BSER_BattSocCalc_DW.Delay5_DSTATE = rtb_Switch3;
878 BSER_BattSocCalc_DW.Delay6_DSTATE = rtb_Subtract1_h;
879 BSER_BattSocCalc_DW.Delay7_DSTATE = rtb_Sum;
880}
881
882/* Model initialize function */
883void BSER_BattSocCalc_initialize(void)
884{
885 /* Registration code */
886
887 /* block I/O */
888
889 /* custom signals */
890 BSER_rSocDspl = 0.0F;
891 BSER_rSocAvrg = 0.0F;
892 BSER_rSocMin = 0.0F;
893 BSER_rSocMax = 0.0F;
894 BSER_rSoc = 0.0F;
895 BSER_flgSocSave = false;
896
897 /* external outputs */
898 (void) memset((void *)&BSER_BattSocCalc_Y, 0,
899 sizeof(ExtY_BSER_BattSocCalc_T));
900 BSER_BattSocCalc_DW.Delay1_DSTATE_g = true;
901}
902
903/*
904 * File trailer for generated code.
905 *
906 * [EOF]
907 */
908