1 | /* |
2 | * BMS.c |
3 | * |
4 | * Code generation for model "BMS". |
5 | * |
6 | * Model version : 1.15 |
7 | * Simulink Coder version : 9.2 (R2019b) 18-Jul-2019 |
8 | * C source code generated on : Thu Aug 20 14:49:14 2020 |
9 | * |
10 | * Target selection: grt.tlc |
11 | * Note: GRT includes extra infrastructure and instrumentation for prototyping |
12 | * Embedded hardware selection: Intel->x86-64 (Windows64) |
13 | * Code generation objectives: Unspecified |
14 | * Validation result: Not run |
15 | */ |
16 | |
17 | #include "rt_logging_mmi.h" |
18 | #include "BMS_capi.h" |
19 | #include "BMS.h" |
20 | #include "BMS_private.h" |
21 | |
22 | /* Block signals (default storage) */ |
23 | B_BMS_T BMS_B; |
24 | |
25 | /* Continuous states */ |
26 | X_BMS_T BMS_X; |
27 | |
28 | /* Block states (default storage) */ |
29 | DW_BMS_T BMS_DW; |
30 | |
31 | /* External inputs (root inport signals with default storage) */ |
32 | ExtU_BMS_T BMS_U; |
33 | |
34 | /* External outputs (root outports fed by signals with default storage) */ |
35 | ExtY_BMS_T BMS_Y; |
36 | |
37 | /* Real-time model */ |
38 | RT_MODEL_BMS_T BMS_M_; |
39 | RT_MODEL_BMS_T *const BMS_M = &BMS_M_; |
40 | |
41 | /* Forward declaration for local functions */ |
42 | static int32_T BMS_thirdOfFive(const real_T v[8], int32_T ia, int32_T ib); |
43 | static void BMS_quickselect(real_T v[8], int32_T n, int32_T idx0, int32_T vlen, |
44 | real_T *vn, int32_T *nfirst, int32_T *nlast); |
45 | real_T look2_binlxpw(real_T u0, real_T u1, const real_T bp0[], const real_T bp1[], |
46 | const real_T table[], const uint32_T maxIndex[], uint32_T |
47 | stride) |
48 | { |
49 | real_T frac; |
50 | uint32_T bpIndices[2]; |
51 | real_T fractions[2]; |
52 | real_T yL_1d; |
53 | uint32_T iRght; |
54 | uint32_T bpIdx; |
55 | uint32_T iLeft; |
56 | |
57 | /* Column-major Lookup 2-D |
58 | Search method: 'binary' |
59 | Use previous index: 'off' |
60 | Interpolation method: 'Linear point-slope' |
61 | Extrapolation method: 'Linear' |
62 | Use last breakpoint for index at or above upper limit: 'off' |
63 | Remove protection against out-of-range input in generated code: 'off' |
64 | */ |
65 | /* Prelookup - Index and Fraction |
66 | Index Search method: 'binary' |
67 | Extrapolation method: 'Linear' |
68 | Use previous index: 'off' |
69 | Use last breakpoint for index at or above upper limit: 'off' |
70 | Remove protection against out-of-range input in generated code: 'off' |
71 | */ |
72 | if (u0 <= bp0[0U]) { |
73 | iLeft = 0U; |
74 | frac = (u0 - bp0[0U]) / (bp0[1U] - bp0[0U]); |
75 | } else if (u0 < bp0[maxIndex[0U]]) { |
76 | /* Binary Search */ |
77 | bpIdx = maxIndex[0U] >> 1U; |
78 | iLeft = 0U; |
79 | iRght = maxIndex[0U]; |
80 | while (iRght - iLeft > 1U) { |
81 | if (u0 < bp0[bpIdx]) { |
82 | iRght = bpIdx; |
83 | } else { |
84 | iLeft = bpIdx; |
85 | } |
86 | |
87 | bpIdx = (iRght + iLeft) >> 1U; |
88 | } |
89 | |
90 | frac = (u0 - bp0[iLeft]) / (bp0[iLeft + 1U] - bp0[iLeft]); |
91 | } else { |
92 | iLeft = maxIndex[0U] - 1U; |
93 | frac = (u0 - bp0[maxIndex[0U] - 1U]) / (bp0[maxIndex[0U]] - bp0[maxIndex[0U] |
94 | - 1U]); |
95 | } |
96 | |
97 | fractions[0U] = frac; |
98 | bpIndices[0U] = iLeft; |
99 | |
100 | /* Prelookup - Index and Fraction |
101 | Index Search method: 'binary' |
102 | Extrapolation method: 'Linear' |
103 | Use previous index: 'off' |
104 | Use last breakpoint for index at or above upper limit: 'off' |
105 | Remove protection against out-of-range input in generated code: 'off' |
106 | */ |
107 | if (u1 <= bp1[0U]) { |
108 | iLeft = 0U; |
109 | frac = (u1 - bp1[0U]) / (bp1[1U] - bp1[0U]); |
110 | } else if (u1 < bp1[maxIndex[1U]]) { |
111 | /* Binary Search */ |
112 | bpIdx = maxIndex[1U] >> 1U; |
113 | iLeft = 0U; |
114 | iRght = maxIndex[1U]; |
115 | while (iRght - iLeft > 1U) { |
116 | if (u1 < bp1[bpIdx]) { |
117 | iRght = bpIdx; |
118 | } else { |
119 | iLeft = bpIdx; |
120 | } |
121 | |
122 | bpIdx = (iRght + iLeft) >> 1U; |
123 | } |
124 | |
125 | frac = (u1 - bp1[iLeft]) / (bp1[iLeft + 1U] - bp1[iLeft]); |
126 | } else { |
127 | iLeft = maxIndex[1U] - 1U; |
128 | frac = (u1 - bp1[maxIndex[1U] - 1U]) / (bp1[maxIndex[1U]] - bp1[maxIndex[1U] |
129 | - 1U]); |
130 | } |
131 | |
132 | /* Column-major Interpolation 2-D |
133 | Interpolation method: 'Linear point-slope' |
134 | Use last breakpoint for index at or above upper limit: 'off' |
135 | Overflow mode: 'portable wrapping' |
136 | */ |
137 | bpIdx = iLeft * stride + bpIndices[0U]; |
138 | yL_1d = (table[bpIdx + 1U] - table[bpIdx]) * fractions[0U] + table[bpIdx]; |
139 | bpIdx += stride; |
140 | return (((table[bpIdx + 1U] - table[bpIdx]) * fractions[0U] + table[bpIdx]) - |
141 | yL_1d) * frac + yL_1d; |
142 | } |
143 | |
144 | real_T look1_binlxpw(real_T u0, const real_T bp0[], const real_T table[], |
145 | uint32_T maxIndex) |
146 | { |
147 | real_T frac; |
148 | uint32_T iRght; |
149 | uint32_T iLeft; |
150 | uint32_T bpIdx; |
151 | |
152 | /* Column-major Lookup 1-D |
153 | Search method: 'binary' |
154 | Use previous index: 'off' |
155 | Interpolation method: 'Linear point-slope' |
156 | Extrapolation method: 'Linear' |
157 | Use last breakpoint for index at or above upper limit: 'off' |
158 | Remove protection against out-of-range input in generated code: 'off' |
159 | */ |
160 | /* Prelookup - Index and Fraction |
161 | Index Search method: 'binary' |
162 | Extrapolation method: 'Linear' |
163 | Use previous index: 'off' |
164 | Use last breakpoint for index at or above upper limit: 'off' |
165 | Remove protection against out-of-range input in generated code: 'off' |
166 | */ |
167 | if (u0 <= bp0[0U]) { |
168 | iLeft = 0U; |
169 | frac = (u0 - bp0[0U]) / (bp0[1U] - bp0[0U]); |
170 | } else if (u0 < bp0[maxIndex]) { |
171 | /* Binary Search */ |
172 | bpIdx = maxIndex >> 1U; |
173 | iLeft = 0U; |
174 | iRght = maxIndex; |
175 | while (iRght - iLeft > 1U) { |
176 | if (u0 < bp0[bpIdx]) { |
177 | iRght = bpIdx; |
178 | } else { |
179 | iLeft = bpIdx; |
180 | } |
181 | |
182 | bpIdx = (iRght + iLeft) >> 1U; |
183 | } |
184 | |
185 | frac = (u0 - bp0[iLeft]) / (bp0[iLeft + 1U] - bp0[iLeft]); |
186 | } else { |
187 | iLeft = maxIndex - 1U; |
188 | frac = (u0 - bp0[maxIndex - 1U]) / (bp0[maxIndex] - bp0[maxIndex - 1U]); |
189 | } |
190 | |
191 | /* Column-major Interpolation 1-D |
192 | Interpolation method: 'Linear point-slope' |
193 | Use last breakpoint for index at or above upper limit: 'off' |
194 | Overflow mode: 'portable wrapping' |
195 | */ |
196 | return (table[iLeft + 1U] - table[iLeft]) * frac + table[iLeft]; |
197 | } |
198 | |
199 | /* |
200 | * This function updates continuous states using the ODE4 fixed-step |
201 | * solver algorithm |
202 | */ |
203 | static void rt_ertODEUpdateContinuousStates(RTWSolverInfo *si ) |
204 | { |
205 | time_T t = rtsiGetT(si); |
206 | time_T tnew = rtsiGetSolverStopTime(si); |
207 | time_T h = rtsiGetStepSize(si); |
208 | real_T *x = rtsiGetContStates(si); |
209 | ODE4_IntgData *id = (ODE4_IntgData *)rtsiGetSolverData(si); |
210 | real_T *y = id->y; |
211 | real_T *f0 = id->f[0]; |
212 | real_T *f1 = id->f[1]; |
213 | real_T *f2 = id->f[2]; |
214 | real_T *f3 = id->f[3]; |
215 | real_T temp; |
216 | int_T i; |
217 | int_T nXc = 112; |
218 | rtsiSetSimTimeStep(si,MINOR_TIME_STEP); |
219 | |
220 | /* Save the state values at time t in y, we'll use x as ynew. */ |
221 | (void) memcpy(y, x, |
222 | (uint_T)nXc*sizeof(real_T)); |
223 | |
224 | /* Assumes that rtsiSetT and ModelOutputs are up-to-date */ |
225 | /* f0 = f(t,y) */ |
226 | rtsiSetdX(si, f0); |
227 | BMS_derivatives(); |
228 | |
229 | /* f1 = f(t + (h/2), y + (h/2)*f0) */ |
230 | temp = 0.5 * h; |
231 | for (i = 0; i < nXc; i++) { |
232 | x[i] = y[i] + (temp*f0[i]); |
233 | } |
234 | |
235 | rtsiSetT(si, t + temp); |
236 | rtsiSetdX(si, f1); |
237 | BMS_output(); |
238 | BMS_derivatives(); |
239 | |
240 | /* f2 = f(t + (h/2), y + (h/2)*f1) */ |
241 | for (i = 0; i < nXc; i++) { |
242 | x[i] = y[i] + (temp*f1[i]); |
243 | } |
244 | |
245 | rtsiSetdX(si, f2); |
246 | BMS_output(); |
247 | BMS_derivatives(); |
248 | |
249 | /* f3 = f(t + h, y + h*f2) */ |
250 | for (i = 0; i < nXc; i++) { |
251 | x[i] = y[i] + (h*f2[i]); |
252 | } |
253 | |
254 | rtsiSetT(si, tnew); |
255 | rtsiSetdX(si, f3); |
256 | BMS_output(); |
257 | BMS_derivatives(); |
258 | |
259 | /* tnew = t + h |
260 | ynew = y + (h/6)*(f0 + 2*f1 + 2*f2 + 2*f3) */ |
261 | temp = h / 6.0; |
262 | for (i = 0; i < nXc; i++) { |
263 | x[i] = y[i] + temp*(f0[i] + 2.0*f1[i] + 2.0*f2[i] + f3[i]); |
264 | } |
265 | |
266 | rtsiSetSimTimeStep(si,MAJOR_TIME_STEP); |
267 | } |
268 | |
269 | /* |
270 | * Output and update for atomic system: |
271 | * '<S5>/dead_band' |
272 | * '<S5>/dead_band1' |
273 | * '<S5>/dead_band2' |
274 | * '<S5>/dead_band3' |
275 | * '<S5>/dead_band4' |
276 | * '<S5>/dead_band5' |
277 | * '<S5>/dead_band6' |
278 | * '<S5>/dead_band7' |
279 | */ |
280 | void BMS_dead_band(real_T rtu_u, B_dead_band_BMS_T *localB) |
281 | { |
282 | localB->y = (real_T)(fabs(rtu_u) > 0.4) * rtu_u; |
283 | } |
284 | |
285 | /* Function for MATLAB Function: '<S2>/median' */ |
286 | static int32_T BMS_thirdOfFive(const real_T v[8], int32_T ia, int32_T ib) |
287 | { |
288 | int32_T im; |
289 | int32_T j4; |
290 | int32_T j5; |
291 | real_T v4; |
292 | real_T v5; |
293 | int32_T b_j1; |
294 | int32_T j2; |
295 | real_T v5_tmp; |
296 | if ((ia == ib) || (ia + 1 == ib)) { |
297 | im = ia; |
298 | } else if ((ia + 2 == ib) || (ia + 3 == ib)) { |
299 | v4 = v[ia - 1]; |
300 | if (v4 < v[ia]) { |
301 | v5_tmp = v[ia + 1]; |
302 | if (v[ia] < v5_tmp) { |
303 | im = ia + 1; |
304 | } else if (v4 < v5_tmp) { |
305 | im = ia + 2; |
306 | } else { |
307 | im = ia; |
308 | } |
309 | } else { |
310 | v5_tmp = v[ia + 1]; |
311 | if (v4 < v5_tmp) { |
312 | im = ia; |
313 | } else if (v[ia] < v5_tmp) { |
314 | im = ia + 2; |
315 | } else { |
316 | im = ia + 1; |
317 | } |
318 | } |
319 | } else { |
320 | v4 = v[ia - 1]; |
321 | if (v4 < v[ia]) { |
322 | v5_tmp = v[ia + 1]; |
323 | if (v[ia] < v5_tmp) { |
324 | b_j1 = ia; |
325 | j2 = ia; |
326 | im = ia + 2; |
327 | } else if (v4 < v5_tmp) { |
328 | b_j1 = ia; |
329 | j2 = ia + 1; |
330 | im = ia + 1; |
331 | } else { |
332 | b_j1 = ia + 2; |
333 | j2 = ia - 1; |
334 | im = ia + 1; |
335 | } |
336 | } else { |
337 | v5_tmp = v[ia + 1]; |
338 | if (v4 < v5_tmp) { |
339 | b_j1 = ia + 1; |
340 | j2 = ia - 1; |
341 | im = ia + 2; |
342 | } else if (v[ia] < v5_tmp) { |
343 | b_j1 = ia + 1; |
344 | j2 = ia + 1; |
345 | im = ia; |
346 | } else { |
347 | b_j1 = ia + 2; |
348 | j2 = ia; |
349 | im = ia; |
350 | } |
351 | } |
352 | |
353 | j4 = ia; |
354 | j5 = ia + 1; |
355 | v4 = v[ia + 2]; |
356 | v5_tmp = v[ia + 3]; |
357 | v5 = v5_tmp; |
358 | if (v5_tmp < v4) { |
359 | j4 = ia + 1; |
360 | j5 = ia; |
361 | v5 = v4; |
362 | v4 = v5_tmp; |
363 | } |
364 | |
365 | if (v5 < v[b_j1 - 1]) { |
366 | im = b_j1; |
367 | } else if (v5 < v[j2]) { |
368 | im = j5 + 3; |
369 | } else if (v4 < v[j2]) { |
370 | im = j2 + 1; |
371 | } else { |
372 | if (v4 < v[im - 1]) { |
373 | im = j4 + 3; |
374 | } |
375 | } |
376 | } |
377 | |
378 | return im; |
379 | } |
380 | |
381 | /* Function for MATLAB Function: '<S2>/median' */ |
382 | static void BMS_quickselect(real_T v[8], int32_T n, int32_T idx0, int32_T vlen, |
383 | real_T *vn, int32_T *nfirst, int32_T *nlast) |
384 | { |
385 | int32_T itarget; |
386 | int32_T ipiv; |
387 | int32_T ia; |
388 | int32_T ib; |
389 | int32_T ifirst; |
390 | int32_T ilast; |
391 | int32_T oldnv; |
392 | boolean_T checkspeed; |
393 | boolean_T isslow; |
394 | real_T b_v[8]; |
395 | real_T vref; |
396 | real_T vk; |
397 | int32_T b_nlast; |
398 | int32_T i1; |
399 | int32_T destidx; |
400 | boolean_T exitg1; |
401 | boolean_T guard1 = false; |
402 | if ((n < 1) || (n > vlen)) { |
403 | *vn = (rtNaN); |
404 | *nfirst = 0; |
405 | *nlast = 0; |
406 | } else { |
407 | itarget = (idx0 + n) - 1; |
408 | ipiv = itarget - 1; |
409 | ia = idx0 - 1; |
410 | ib = (idx0 + vlen) - 2; |
411 | ifirst = idx0; |
412 | ilast = ib; |
413 | oldnv = vlen; |
414 | checkspeed = false; |
415 | isslow = false; |
416 | exitg1 = false; |
417 | while ((!exitg1) && (ia + 1 < ib + 1)) { |
418 | memcpy(&b_v[0], &v[0], sizeof(real_T) << 3U); |
419 | vref = v[ipiv]; |
420 | b_v[ipiv] = v[ib]; |
421 | b_v[ib] = v[ipiv]; |
422 | b_nlast = ia; |
423 | ifirst = -1; |
424 | for (ilast = ia; ilast < ib; ilast++) { |
425 | vk = b_v[ilast]; |
426 | if (b_v[ilast] == vref) { |
427 | b_v[ilast] = b_v[b_nlast]; |
428 | b_v[b_nlast] = vk; |
429 | ifirst++; |
430 | b_nlast++; |
431 | } else { |
432 | if (b_v[ilast] < vref) { |
433 | b_v[ilast] = b_v[b_nlast]; |
434 | b_v[b_nlast] = vk; |
435 | b_nlast++; |
436 | } |
437 | } |
438 | } |
439 | |
440 | b_v[ib] = b_v[b_nlast]; |
441 | b_v[b_nlast] = v[ipiv]; |
442 | memcpy(&v[0], &b_v[0], sizeof(real_T) << 3U); |
443 | ilast = b_nlast; |
444 | guard1 = false; |
445 | if (itarget <= b_nlast + 1) { |
446 | ifirst = b_nlast - ifirst; |
447 | if (itarget >= ifirst) { |
448 | exitg1 = true; |
449 | } else { |
450 | ib = b_nlast - 1; |
451 | guard1 = true; |
452 | } |
453 | } else { |
454 | ia = b_nlast + 1; |
455 | guard1 = true; |
456 | } |
457 | |
458 | if (guard1) { |
459 | ipiv = (ib - ia) + 1; |
460 | if (checkspeed) { |
461 | isslow = (ipiv > oldnv / 2); |
462 | oldnv = ipiv; |
463 | } |
464 | |
465 | checkspeed = !checkspeed; |
466 | if (isslow) { |
467 | while (ipiv > 1) { |
468 | ilast = ipiv / 5; |
469 | b_nlast = ipiv - ilast * 5; |
470 | ipiv = ilast; |
471 | for (ifirst = 0; ifirst < ilast; ifirst++) { |
472 | i1 = (ifirst * 5 + ia) + 1; |
473 | i1 = BMS_thirdOfFive(v, i1, i1 + 4) - 1; |
474 | destidx = ia + ifirst; |
475 | vref = v[destidx]; |
476 | v[destidx] = v[i1]; |
477 | v[i1] = vref; |
478 | } |
479 | |
480 | if (b_nlast > 0) { |
481 | i1 = (ilast * 5 + ia) + 1; |
482 | i1 = BMS_thirdOfFive(v, i1, (i1 + b_nlast) - 1) - 1; |
483 | destidx = ia + ilast; |
484 | vref = v[destidx]; |
485 | v[destidx] = v[i1]; |
486 | v[i1] = vref; |
487 | ipiv = ilast + 1; |
488 | } |
489 | } |
490 | } else { |
491 | if (ipiv >= 3) { |
492 | ipiv = (ipiv - 1) / 2 + ia; |
493 | if (b_v[ia] < b_v[ipiv]) { |
494 | if (b_v[ipiv] < b_v[ib]) { |
495 | ilast = ipiv + 1; |
496 | } else if (b_v[ia] < b_v[ib]) { |
497 | ilast = ib + 1; |
498 | } else { |
499 | ilast = ia + 1; |
500 | } |
501 | } else if (b_v[ia] < b_v[ib]) { |
502 | ilast = ia + 1; |
503 | } else if (b_v[ipiv] < b_v[ib]) { |
504 | ilast = ib + 1; |
505 | } else { |
506 | ilast = ipiv + 1; |
507 | } |
508 | |
509 | ipiv = ilast - 1; |
510 | if (ipiv + 1 > ia + 1) { |
511 | v[ia] = b_v[ipiv]; |
512 | v[ipiv] = b_v[ia]; |
513 | } |
514 | } |
515 | } |
516 | |
517 | ipiv = ia; |
518 | ifirst = ia + 1; |
519 | ilast = ib; |
520 | } |
521 | } |
522 | |
523 | *vn = v[ilast]; |
524 | *nfirst = (ifirst - idx0) + 1; |
525 | *nlast = (ilast - idx0) + 2; |
526 | } |
527 | } |
528 | |
529 | /* Model output function */ |
530 | void BMS_output(void) |
531 | { |
532 | int32_T sigIdx; |
533 | real_T v[8]; |
534 | int32_T ifirst; |
535 | int32_T unusedU2; |
536 | real_T rtb_Bias; |
537 | real_T rtb_Bias1; |
538 | real_T rtb_Bias2; |
539 | real_T rtb_Divide3; |
540 | real_T rtb_Add8; |
541 | real_T rtb_Product_o2; |
542 | real_T rtb_Sqrt; |
543 | real_T rtb_TransferFcn1; |
544 | real_T rtb_Add7; |
545 | real_T rtb_Add1_o; |
546 | real_T rtb_Add1_c; |
547 | real_T tmpForInput_tmp[8]; |
548 | int32_T exitg1; |
549 | if (rtmIsMajorTimeStep(BMS_M)) { |
550 | /* set solver stop time */ |
551 | if (!(BMS_M->Timing.clockTick0+1)) { |
552 | rtsiSetSolverStopTime(&BMS_M->solverInfo, ((BMS_M->Timing.clockTickH0 + 1) |
553 | * BMS_M->Timing.stepSize0 * 4294967296.0)); |
554 | } else { |
555 | rtsiSetSolverStopTime(&BMS_M->solverInfo, ((BMS_M->Timing.clockTick0 + 1) * |
556 | BMS_M->Timing.stepSize0 + BMS_M->Timing.clockTickH0 * |
557 | BMS_M->Timing.stepSize0 * 4294967296.0)); |
558 | } |
559 | } /* end MajorTimeStep */ |
560 | |
561 | /* Update absolute time of base rate at minor time step */ |
562 | if (rtmIsMinorTimeStep(BMS_M)) { |
563 | BMS_M->Timing.t[0] = rtsiGetT(&BMS_M->solverInfo); |
564 | } |
565 | |
566 | if (rtmIsMajorTimeStep(BMS_M)) { |
567 | /* Outport: '<Root>/Out1' incorporates: |
568 | * Memory: '<Root>/Memory' |
569 | */ |
570 | BMS_Y.Out1 = BMS_DW.Memory_PreviousInput; |
571 | |
572 | /* Outport: '<Root>/Out2' incorporates: |
573 | * Memory: '<Root>/Memory1' |
574 | */ |
575 | BMS_Y.Out2 = BMS_DW.Memory1_PreviousInput; |
576 | |
577 | /* Outport: '<Root>/Out3' incorporates: |
578 | * Memory: '<Root>/Memory2' |
579 | */ |
580 | BMS_Y.Out3 = BMS_DW.Memory2_PreviousInput; |
581 | |
582 | /* Outport: '<Root>/Out4' incorporates: |
583 | * Memory: '<Root>/Memory3' |
584 | */ |
585 | BMS_Y.Out4 = BMS_DW.Memory3_PreviousInput; |
586 | |
587 | /* Outport: '<Root>/Out5' incorporates: |
588 | * Memory: '<Root>/Memory4' |
589 | */ |
590 | BMS_Y.Out5 = BMS_DW.Memory4_PreviousInput; |
591 | |
592 | /* Outport: '<Root>/Out6' incorporates: |
593 | * Memory: '<Root>/Memory5' |
594 | */ |
595 | BMS_Y.Out6 = BMS_DW.Memory5_PreviousInput; |
596 | |
597 | /* Outport: '<Root>/Out7' incorporates: |
598 | * Memory: '<Root>/Memory6' |
599 | */ |
600 | BMS_Y.Out7 = BMS_DW.Memory6_PreviousInput; |
601 | |
602 | /* Outport: '<Root>/Out8' incorporates: |
603 | * Memory: '<Root>/Memory7' |
604 | */ |
605 | BMS_Y.Out8 = BMS_DW.Memory7_PreviousInput; |
606 | |
607 | /* Outport: '<Root>/Out9' incorporates: |
608 | * Memory: '<Root>/Memory8' |
609 | */ |
610 | BMS_Y.Out9 = BMS_DW.Memory8_PreviousInput; |
611 | |
612 | /* Outport: '<Root>/Out10' incorporates: |
613 | * Memory: '<Root>/Memory10' |
614 | */ |
615 | BMS_Y.Out10 = BMS_DW.Memory10_PreviousInput; |
616 | } |
617 | |
618 | /* Integrator: '<S32>/Integrator' */ |
619 | BMS_B.Integrator = BMS_X.Integrator_CSTATE; |
620 | |
621 | /* Integrator: '<S37>/Integrator' */ |
622 | BMS_B.Integrator_d = BMS_X.Integrator_CSTATE_k; |
623 | |
624 | /* Integrator: '<S42>/Integrator' */ |
625 | BMS_B.Integrator_g = BMS_X.Integrator_CSTATE_g; |
626 | |
627 | /* Integrator: '<S47>/Integrator' */ |
628 | BMS_B.Integrator_gh = BMS_X.Integrator_CSTATE_f; |
629 | |
630 | /* Integrator: '<S52>/Integrator' */ |
631 | BMS_B.Integrator_e = BMS_X.Integrator_CSTATE_h; |
632 | |
633 | /* Integrator: '<S57>/Integrator' */ |
634 | BMS_B.Integrator_j = BMS_X.Integrator_CSTATE_a; |
635 | |
636 | /* Integrator: '<S62>/Integrator' */ |
637 | BMS_B.Integrator_p = BMS_X.Integrator_CSTATE_n; |
638 | |
639 | /* Integrator: '<S67>/Integrator' */ |
640 | BMS_B.Integrator_h = BMS_X.Integrator_CSTATE_b; |
641 | |
642 | /* MinMax: '<S1>/MinMax' incorporates: |
643 | * MATLAB Function: '<S1>/mean' |
644 | * MATLAB Function: '<S2>/median' |
645 | * SignalConversion generated from: '<S15>/ SFunction ' |
646 | * SignalConversion generated from: '<S6>/ SFunction ' |
647 | */ |
648 | tmpForInput_tmp[0] = BMS_B.Integrator; |
649 | tmpForInput_tmp[1] = BMS_B.Integrator_d; |
650 | tmpForInput_tmp[2] = BMS_B.Integrator_g; |
651 | tmpForInput_tmp[3] = BMS_B.Integrator_gh; |
652 | tmpForInput_tmp[4] = BMS_B.Integrator_e; |
653 | tmpForInput_tmp[5] = BMS_B.Integrator_j; |
654 | tmpForInput_tmp[6] = BMS_B.Integrator_p; |
655 | tmpForInput_tmp[7] = BMS_B.Integrator_h; |
656 | rtb_Add1_c = BMS_B.Integrator; |
657 | for (sigIdx = 0; sigIdx < 7; sigIdx++) { |
658 | rtb_Add1_c = fmin(rtb_Add1_c, tmpForInput_tmp[sigIdx + 1]); |
659 | } |
660 | |
661 | /* RelationalOperator: '<S4>/Compare' incorporates: |
662 | * Constant: '<S4>/Constant' |
663 | * MinMax: '<S1>/MinMax' |
664 | */ |
665 | BMS_B.Compare = (rtb_Add1_c <= BMS_P.CompareToConstant_const); |
666 | |
667 | /* Stop: '<S1>/Stop Simulation' */ |
668 | if (rtmIsMajorTimeStep(BMS_M) && BMS_B.Compare) { |
669 | rtmSetStopRequested(BMS_M, 1); |
670 | } |
671 | |
672 | /* End of Stop: '<S1>/Stop Simulation' */ |
673 | |
674 | /* MATLAB Function: '<S2>/median' */ |
675 | sigIdx = 0; |
676 | do { |
677 | exitg1 = 0; |
678 | if (sigIdx < 8) { |
679 | if (rtIsNaN(tmpForInput_tmp[sigIdx])) { |
680 | rtb_Add1_c = (rtNaN); |
681 | exitg1 = 1; |
682 | } else { |
683 | sigIdx++; |
684 | } |
685 | } else { |
686 | memcpy(&v[0], &tmpForInput_tmp[0], sizeof(real_T) << 3U); |
687 | BMS_quickselect(v, 5, 1, 8, &rtb_Add1_c, &ifirst, &sigIdx); |
688 | if (4 < ifirst) { |
689 | BMS_quickselect(v, 4, 1, sigIdx - 1, &rtb_Add1_o, &ifirst, &unusedU2); |
690 | if (rtIsInf(rtb_Add1_c) || rtIsInf(rtb_Add1_o)) { |
691 | rtb_Add1_c = (rtb_Add1_c + rtb_Add1_o) / 2.0; |
692 | } else { |
693 | rtb_Add1_c += (rtb_Add1_o - rtb_Add1_c) / 2.0; |
694 | } |
695 | } |
696 | |
697 | exitg1 = 1; |
698 | } |
699 | } while (exitg1 == 0); |
700 | |
701 | /* Sum: '<S7>/Add1' incorporates: |
702 | * MATLAB Function: '<S2>/median' |
703 | */ |
704 | rtb_Add1_o = BMS_B.Integrator_d - rtb_Add1_c; |
705 | |
706 | /* Relay: '<S7>/Relay' incorporates: |
707 | * Relay: '<S7>/Relay1' |
708 | */ |
709 | if (rtmIsMajorTimeStep(BMS_M)) { |
710 | BMS_DW.Relay_Mode = ((rtb_Add1_o >= BMS_P.Relay_OnVal) || ((!(rtb_Add1_o <= |
711 | BMS_P.Relay_OffVal)) && BMS_DW.Relay_Mode)); |
712 | BMS_DW.Relay1_Mode = ((rtb_Add1_o >= BMS_P.Relay1_OnVal) || ((!(rtb_Add1_o <= |
713 | BMS_P.Relay1_OffVal)) && BMS_DW.Relay1_Mode)); |
714 | } |
715 | |
716 | if (rtmIsMajorTimeStep(BMS_M)) { |
717 | /* Relay: '<S7>/Relay' */ |
718 | if (BMS_DW.Relay_Mode) { |
719 | rtb_Add1_o = BMS_P.Relay_YOn; |
720 | } else { |
721 | rtb_Add1_o = BMS_P.Relay_YOff; |
722 | } |
723 | |
724 | /* Relay: '<S7>/Relay1' */ |
725 | if (BMS_DW.Relay1_Mode) { |
726 | rtb_Add7 = BMS_P.Relay1_YOn; |
727 | } else { |
728 | rtb_Add7 = BMS_P.Relay1_YOff; |
729 | } |
730 | |
731 | /* Sum: '<S7>/Add2' */ |
732 | BMS_B.Add2 = rtb_Add1_o + rtb_Add7; |
733 | } |
734 | |
735 | /* Sum: '<S8>/Add1' incorporates: |
736 | * MATLAB Function: '<S2>/median' |
737 | */ |
738 | rtb_Add1_o = BMS_B.Integrator_g - rtb_Add1_c; |
739 | |
740 | /* Relay: '<S8>/Relay' incorporates: |
741 | * Relay: '<S8>/Relay1' |
742 | */ |
743 | if (rtmIsMajorTimeStep(BMS_M)) { |
744 | BMS_DW.Relay_Mode_a = ((rtb_Add1_o >= BMS_P.Relay_OnVal_c) || ((!(rtb_Add1_o |
745 | <= BMS_P.Relay_OffVal_g)) && BMS_DW.Relay_Mode_a)); |
746 | BMS_DW.Relay1_Mode_j = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_g) || |
747 | ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_d)) && BMS_DW.Relay1_Mode_j)); |
748 | } |
749 | |
750 | if (rtmIsMajorTimeStep(BMS_M)) { |
751 | /* Relay: '<S8>/Relay' */ |
752 | if (BMS_DW.Relay_Mode_a) { |
753 | rtb_Add1_o = BMS_P.Relay_YOn_h; |
754 | } else { |
755 | rtb_Add1_o = BMS_P.Relay_YOff_j; |
756 | } |
757 | |
758 | /* Relay: '<S8>/Relay1' */ |
759 | if (BMS_DW.Relay1_Mode_j) { |
760 | rtb_Add7 = BMS_P.Relay1_YOn_i; |
761 | } else { |
762 | rtb_Add7 = BMS_P.Relay1_YOff_a; |
763 | } |
764 | |
765 | /* Sum: '<S8>/Add2' */ |
766 | BMS_B.Add2_l = rtb_Add1_o + rtb_Add7; |
767 | } |
768 | |
769 | /* Sum: '<S9>/Add1' incorporates: |
770 | * MATLAB Function: '<S2>/median' |
771 | */ |
772 | rtb_Add1_o = BMS_B.Integrator_gh - rtb_Add1_c; |
773 | |
774 | /* Relay: '<S9>/Relay' incorporates: |
775 | * Relay: '<S9>/Relay1' |
776 | */ |
777 | if (rtmIsMajorTimeStep(BMS_M)) { |
778 | BMS_DW.Relay_Mode_m = ((rtb_Add1_o >= BMS_P.Relay_OnVal_p) || ((!(rtb_Add1_o |
779 | <= BMS_P.Relay_OffVal_n)) && BMS_DW.Relay_Mode_m)); |
780 | BMS_DW.Relay1_Mode_e = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_l) || |
781 | ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_l)) && BMS_DW.Relay1_Mode_e)); |
782 | } |
783 | |
784 | if (rtmIsMajorTimeStep(BMS_M)) { |
785 | /* Relay: '<S9>/Relay' */ |
786 | if (BMS_DW.Relay_Mode_m) { |
787 | rtb_Add1_o = BMS_P.Relay_YOn_k; |
788 | } else { |
789 | rtb_Add1_o = BMS_P.Relay_YOff_b; |
790 | } |
791 | |
792 | /* Relay: '<S9>/Relay1' */ |
793 | if (BMS_DW.Relay1_Mode_e) { |
794 | rtb_Add7 = BMS_P.Relay1_YOn_ij; |
795 | } else { |
796 | rtb_Add7 = BMS_P.Relay1_YOff_i; |
797 | } |
798 | |
799 | /* Sum: '<S9>/Add2' */ |
800 | BMS_B.Add2_c = rtb_Add1_o + rtb_Add7; |
801 | } |
802 | |
803 | /* Sum: '<S10>/Add1' incorporates: |
804 | * MATLAB Function: '<S2>/median' |
805 | */ |
806 | rtb_Add1_o = BMS_B.Integrator_e - rtb_Add1_c; |
807 | |
808 | /* Relay: '<S10>/Relay' incorporates: |
809 | * Relay: '<S10>/Relay1' |
810 | */ |
811 | if (rtmIsMajorTimeStep(BMS_M)) { |
812 | BMS_DW.Relay_Mode_k = ((rtb_Add1_o >= BMS_P.Relay_OnVal_a) || ((!(rtb_Add1_o |
813 | <= BMS_P.Relay_OffVal_m)) && BMS_DW.Relay_Mode_k)); |
814 | BMS_DW.Relay1_Mode_n = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_a) || |
815 | ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_j)) && BMS_DW.Relay1_Mode_n)); |
816 | } |
817 | |
818 | if (rtmIsMajorTimeStep(BMS_M)) { |
819 | /* Relay: '<S10>/Relay' */ |
820 | if (BMS_DW.Relay_Mode_k) { |
821 | rtb_Add1_o = BMS_P.Relay_YOn_f; |
822 | } else { |
823 | rtb_Add1_o = BMS_P.Relay_YOff_jk; |
824 | } |
825 | |
826 | /* Relay: '<S10>/Relay1' */ |
827 | if (BMS_DW.Relay1_Mode_n) { |
828 | rtb_Add7 = BMS_P.Relay1_YOn_io; |
829 | } else { |
830 | rtb_Add7 = BMS_P.Relay1_YOff_ie; |
831 | } |
832 | |
833 | /* Sum: '<S10>/Add2' */ |
834 | BMS_B.Add2_c2 = rtb_Add1_o + rtb_Add7; |
835 | } |
836 | |
837 | /* Sum: '<S11>/Add1' incorporates: |
838 | * MATLAB Function: '<S2>/median' |
839 | */ |
840 | rtb_Add1_o = BMS_B.Integrator_j - rtb_Add1_c; |
841 | |
842 | /* Relay: '<S11>/Relay' incorporates: |
843 | * Relay: '<S11>/Relay1' |
844 | */ |
845 | if (rtmIsMajorTimeStep(BMS_M)) { |
846 | BMS_DW.Relay_Mode_p = ((rtb_Add1_o >= BMS_P.Relay_OnVal_i) || ((!(rtb_Add1_o |
847 | <= BMS_P.Relay_OffVal_o)) && BMS_DW.Relay_Mode_p)); |
848 | BMS_DW.Relay1_Mode_jl = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_i) || |
849 | ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_p)) && BMS_DW.Relay1_Mode_jl)); |
850 | } |
851 | |
852 | if (rtmIsMajorTimeStep(BMS_M)) { |
853 | /* Relay: '<S11>/Relay' */ |
854 | if (BMS_DW.Relay_Mode_p) { |
855 | rtb_Add1_o = BMS_P.Relay_YOn_o; |
856 | } else { |
857 | rtb_Add1_o = BMS_P.Relay_YOff_c; |
858 | } |
859 | |
860 | /* Relay: '<S11>/Relay1' */ |
861 | if (BMS_DW.Relay1_Mode_jl) { |
862 | rtb_Add7 = BMS_P.Relay1_YOn_o; |
863 | } else { |
864 | rtb_Add7 = BMS_P.Relay1_YOff_a0; |
865 | } |
866 | |
867 | /* Sum: '<S11>/Add2' */ |
868 | BMS_B.Add2_m = rtb_Add1_o + rtb_Add7; |
869 | } |
870 | |
871 | /* Sum: '<S12>/Add1' incorporates: |
872 | * MATLAB Function: '<S2>/median' |
873 | */ |
874 | rtb_Add1_o = BMS_B.Integrator - rtb_Add1_c; |
875 | |
876 | /* Relay: '<S12>/Relay' incorporates: |
877 | * Relay: '<S12>/Relay1' |
878 | */ |
879 | if (rtmIsMajorTimeStep(BMS_M)) { |
880 | BMS_DW.Relay_Mode_ax = ((rtb_Add1_o >= BMS_P.Relay_OnVal_n) || |
881 | ((!(rtb_Add1_o <= BMS_P.Relay_OffVal_nr)) && BMS_DW.Relay_Mode_ax)); |
882 | BMS_DW.Relay1_Mode_a = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_h) || |
883 | ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_m)) && BMS_DW.Relay1_Mode_a)); |
884 | } |
885 | |
886 | if (rtmIsMajorTimeStep(BMS_M)) { |
887 | /* Relay: '<S12>/Relay' */ |
888 | if (BMS_DW.Relay_Mode_ax) { |
889 | rtb_Add1_o = BMS_P.Relay_YOn_j; |
890 | } else { |
891 | rtb_Add1_o = BMS_P.Relay_YOff_i; |
892 | } |
893 | |
894 | /* Relay: '<S12>/Relay1' */ |
895 | if (BMS_DW.Relay1_Mode_a) { |
896 | rtb_Add7 = BMS_P.Relay1_YOn_i4; |
897 | } else { |
898 | rtb_Add7 = BMS_P.Relay1_YOff_e; |
899 | } |
900 | |
901 | /* Sum: '<S12>/Add2' */ |
902 | BMS_B.Add2_a = rtb_Add1_o + rtb_Add7; |
903 | } |
904 | |
905 | /* Sum: '<S13>/Add1' incorporates: |
906 | * MATLAB Function: '<S2>/median' |
907 | */ |
908 | rtb_Add1_o = BMS_B.Integrator_p - rtb_Add1_c; |
909 | |
910 | /* Relay: '<S13>/Relay' incorporates: |
911 | * Relay: '<S13>/Relay1' |
912 | */ |
913 | if (rtmIsMajorTimeStep(BMS_M)) { |
914 | BMS_DW.Relay_Mode_ai = ((rtb_Add1_o >= BMS_P.Relay_OnVal_g) || |
915 | ((!(rtb_Add1_o <= BMS_P.Relay_OffVal_od)) && BMS_DW.Relay_Mode_ai)); |
916 | BMS_DW.Relay1_Mode_n0 = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_p) || |
917 | ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_e)) && BMS_DW.Relay1_Mode_n0)); |
918 | } |
919 | |
920 | if (rtmIsMajorTimeStep(BMS_M)) { |
921 | /* Relay: '<S13>/Relay' */ |
922 | if (BMS_DW.Relay_Mode_ai) { |
923 | rtb_Add1_o = BMS_P.Relay_YOn_i; |
924 | } else { |
925 | rtb_Add1_o = BMS_P.Relay_YOff_a; |
926 | } |
927 | |
928 | /* Relay: '<S13>/Relay1' */ |
929 | if (BMS_DW.Relay1_Mode_n0) { |
930 | rtb_Add7 = BMS_P.Relay1_YOn_m; |
931 | } else { |
932 | rtb_Add7 = BMS_P.Relay1_YOff_h; |
933 | } |
934 | |
935 | /* Sum: '<S13>/Add2' */ |
936 | BMS_B.Add2_j = rtb_Add1_o + rtb_Add7; |
937 | } |
938 | |
939 | /* Sum: '<S14>/Add1' incorporates: |
940 | * MATLAB Function: '<S2>/median' |
941 | */ |
942 | rtb_Add1_c = BMS_B.Integrator_h - rtb_Add1_c; |
943 | |
944 | /* Relay: '<S14>/Relay' incorporates: |
945 | * Relay: '<S14>/Relay1' |
946 | */ |
947 | if (rtmIsMajorTimeStep(BMS_M)) { |
948 | BMS_DW.Relay_Mode_i = ((rtb_Add1_c >= BMS_P.Relay_OnVal_l) || ((!(rtb_Add1_c |
949 | <= BMS_P.Relay_OffVal_d)) && BMS_DW.Relay_Mode_i)); |
950 | BMS_DW.Relay1_Mode_f = ((rtb_Add1_c >= BMS_P.Relay1_OnVal_f) || |
951 | ((!(rtb_Add1_c <= BMS_P.Relay1_OffVal_dk)) && BMS_DW.Relay1_Mode_f)); |
952 | } |
953 | |
954 | if (rtmIsMajorTimeStep(BMS_M)) { |
955 | /* Relay: '<S14>/Relay' */ |
956 | if (BMS_DW.Relay_Mode_i) { |
957 | rtb_Add1_o = BMS_P.Relay_YOn_kk; |
958 | } else { |
959 | rtb_Add1_o = BMS_P.Relay_YOff_e; |
960 | } |
961 | |
962 | /* Relay: '<S14>/Relay1' */ |
963 | if (BMS_DW.Relay1_Mode_f) { |
964 | rtb_Add7 = BMS_P.Relay1_YOn_a; |
965 | } else { |
966 | rtb_Add7 = BMS_P.Relay1_YOff_l; |
967 | } |
968 | |
969 | /* Sum: '<S14>/Add2' */ |
970 | BMS_B.Add2_h = rtb_Add1_o + rtb_Add7; |
971 | } |
972 | |
973 | /* MinMax: '<S3>/MinMax1' incorporates: |
974 | * Inport: '<Root>/U1' |
975 | * Inport: '<Root>/U2' |
976 | * Inport: '<Root>/U3' |
977 | * Inport: '<Root>/U4' |
978 | * Inport: '<Root>/U5' |
979 | * Inport: '<Root>/U6' |
980 | * Inport: '<Root>/U7' |
981 | * Inport: '<Root>/U8' |
982 | */ |
983 | v[0] = BMS_U.U1; |
984 | v[1] = BMS_U.U2; |
985 | v[2] = BMS_U.U3; |
986 | v[3] = BMS_U.U4; |
987 | v[4] = BMS_U.U5; |
988 | v[5] = BMS_U.U6; |
989 | v[6] = BMS_U.U7; |
990 | v[7] = BMS_U.U8; |
991 | rtb_Add1_c = BMS_U.U1; |
992 | for (sigIdx = 0; sigIdx < 7; sigIdx++) { |
993 | rtb_Add1_c = fmax(rtb_Add1_c, v[sigIdx + 1]); |
994 | } |
995 | |
996 | /* Relay: '<S3>/Relay' incorporates: |
997 | * MinMax: '<S3>/MinMax1' |
998 | */ |
999 | if (rtmIsMajorTimeStep(BMS_M)) { |
1000 | BMS_DW.Relay_Mode_m5 = ((rtb_Add1_c >= BMS_P.Relay_OnVal_k) || |
1001 | ((!(rtb_Add1_c <= BMS_P.Relay_OffVal_gv)) && BMS_DW.Relay_Mode_m5)); |
1002 | } |
1003 | |
1004 | if (BMS_DW.Relay_Mode_m5) { |
1005 | BMS_B.Relay = BMS_P.Relay_YOn_l; |
1006 | } else { |
1007 | BMS_B.Relay = BMS_P.Relay_YOff_g; |
1008 | } |
1009 | |
1010 | /* End of Relay: '<S3>/Relay' */ |
1011 | if (rtmIsMajorTimeStep(BMS_M)) { |
1012 | /* Bias: '<S3>/Bias' */ |
1013 | rtb_Bias = BMS_B.Relay + BMS_P.Bias_Bias; |
1014 | |
1015 | /* Delay: '<S3>/Delay' */ |
1016 | BMS_B.Delay = BMS_DW.Delay_DSTATE[0]; |
1017 | } |
1018 | |
1019 | /* Product: '<S3>/Product' incorporates: |
1020 | * MinMax: '<S3>/MinMax1' |
1021 | */ |
1022 | rtb_Add1_o = BMS_B.Delay * rtb_Add1_c; |
1023 | |
1024 | /* Relay: '<S3>/Relay1' */ |
1025 | if (rtmIsMajorTimeStep(BMS_M)) { |
1026 | BMS_DW.Relay1_Mode_i = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_c) || |
1027 | ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_ed)) && BMS_DW.Relay1_Mode_i)); |
1028 | } |
1029 | |
1030 | if (BMS_DW.Relay1_Mode_i) { |
1031 | BMS_B.Relay1 = BMS_P.Relay1_YOn_mm; |
1032 | } else { |
1033 | BMS_B.Relay1 = BMS_P.Relay1_YOff_o; |
1034 | } |
1035 | |
1036 | /* End of Relay: '<S3>/Relay1' */ |
1037 | if (rtmIsMajorTimeStep(BMS_M)) { |
1038 | /* Bias: '<S3>/Bias1' */ |
1039 | rtb_Bias1 = BMS_B.Relay1 + BMS_P.Bias1_Bias; |
1040 | |
1041 | /* Delay: '<S3>/Delay1' */ |
1042 | BMS_B.Delay1 = BMS_DW.Delay1_DSTATE[0]; |
1043 | } |
1044 | |
1045 | /* Product: '<S3>/Product1' incorporates: |
1046 | * MinMax: '<S3>/MinMax1' |
1047 | */ |
1048 | rtb_Add1_o = BMS_B.Delay1 * rtb_Add1_c; |
1049 | |
1050 | /* Relay: '<S3>/Relay2' */ |
1051 | if (rtmIsMajorTimeStep(BMS_M)) { |
1052 | BMS_DW.Relay2_Mode = ((rtb_Add1_o >= BMS_P.Relay2_OnVal) || ((!(rtb_Add1_o <= |
1053 | BMS_P.Relay2_OffVal)) && BMS_DW.Relay2_Mode)); |
1054 | } |
1055 | |
1056 | if (BMS_DW.Relay2_Mode) { |
1057 | BMS_B.Relay2 = BMS_P.Relay2_YOn; |
1058 | } else { |
1059 | BMS_B.Relay2 = BMS_P.Relay2_YOff; |
1060 | } |
1061 | |
1062 | /* End of Relay: '<S3>/Relay2' */ |
1063 | if (rtmIsMajorTimeStep(BMS_M)) { |
1064 | /* Bias: '<S3>/Bias2' */ |
1065 | rtb_Bias2 = BMS_B.Relay2 + BMS_P.Bias2_Bias; |
1066 | |
1067 | /* Delay: '<S3>/Delay2' */ |
1068 | BMS_B.Delay2 = BMS_DW.Delay2_DSTATE[0]; |
1069 | } |
1070 | |
1071 | /* Product: '<S3>/Product2' incorporates: |
1072 | * MinMax: '<S3>/MinMax1' |
1073 | */ |
1074 | rtb_Add1_o = BMS_B.Delay2 * rtb_Add1_c; |
1075 | |
1076 | /* Relay: '<S3>/Relay3' */ |
1077 | if (rtmIsMajorTimeStep(BMS_M)) { |
1078 | BMS_DW.Relay3_Mode = ((rtb_Add1_o >= BMS_P.Relay3_OnVal) || ((!(rtb_Add1_o <= |
1079 | BMS_P.Relay3_OffVal)) && BMS_DW.Relay3_Mode)); |
1080 | } |
1081 | |
1082 | if (BMS_DW.Relay3_Mode) { |
1083 | BMS_B.Relay3 = BMS_P.Relay3_YOn; |
1084 | } else { |
1085 | BMS_B.Relay3 = BMS_P.Relay3_YOff; |
1086 | } |
1087 | |
1088 | /* End of Relay: '<S3>/Relay3' */ |
1089 | if (rtmIsMajorTimeStep(BMS_M)) { |
1090 | /* Delay: '<S3>/Delay3' */ |
1091 | BMS_B.Delay3 = BMS_DW.Delay3_DSTATE[0]; |
1092 | |
1093 | /* Product: '<S3>/Divide3' incorporates: |
1094 | * Bias: '<S3>/Bias3' |
1095 | * Constant: '<S3>/Constant' |
1096 | * Product: '<S3>/Divide' |
1097 | * Product: '<S3>/Divide1' |
1098 | * Product: '<S3>/Divide2' |
1099 | */ |
1100 | rtb_Divide3 = BMS_P.Constant_Value / rtb_Bias / rtb_Bias1 / rtb_Bias2 / |
1101 | (BMS_B.Relay3 + BMS_P.Bias3_Bias); |
1102 | } |
1103 | |
1104 | /* Product: '<S3>/Product3' incorporates: |
1105 | * MinMax: '<S3>/MinMax1' |
1106 | */ |
1107 | rtb_Bias = BMS_B.Delay3 * rtb_Add1_c; |
1108 | |
1109 | /* Relay: '<S3>/Relay6' */ |
1110 | if (rtmIsMajorTimeStep(BMS_M)) { |
1111 | BMS_DW.Relay6_Mode = ((rtb_Bias >= BMS_P.Relay6_OnVal) || ((!(rtb_Bias <= |
1112 | BMS_P.Relay6_OffVal)) && BMS_DW.Relay6_Mode)); |
1113 | } |
1114 | |
1115 | /* Product: '<S33>/Divide' incorporates: |
1116 | * Constant: '<S33>/Cnom' |
1117 | * Integrator: '<S33>/Integrator6' |
1118 | * Math: '<S33>/Math Function' |
1119 | * |
1120 | * About '<S33>/Math Function': |
1121 | * Operator: exp |
1122 | */ |
1123 | BMS_B.Divide = BMS_P.Cnom_Value * exp(BMS_X.Integrator6_CSTATE); |
1124 | |
1125 | /* Product: '<S38>/Divide' incorporates: |
1126 | * Constant: '<S38>/Cnom' |
1127 | * Integrator: '<S38>/Integrator6' |
1128 | * Math: '<S38>/Math Function' |
1129 | * |
1130 | * About '<S38>/Math Function': |
1131 | * Operator: exp |
1132 | */ |
1133 | BMS_B.Divide_l = BMS_P.Cnom_Value_d * exp(BMS_X.Integrator6_CSTATE_h); |
1134 | |
1135 | /* Product: '<S43>/Divide' incorporates: |
1136 | * Constant: '<S43>/Cnom' |
1137 | * Integrator: '<S43>/Integrator6' |
1138 | * Math: '<S43>/Math Function' |
1139 | * |
1140 | * About '<S43>/Math Function': |
1141 | * Operator: exp |
1142 | */ |
1143 | BMS_B.Divide_l4 = BMS_P.Cnom_Value_f * exp(BMS_X.Integrator6_CSTATE_d); |
1144 | |
1145 | /* Product: '<S48>/Divide' incorporates: |
1146 | * Constant: '<S48>/Cnom' |
1147 | * Integrator: '<S48>/Integrator6' |
1148 | * Math: '<S48>/Math Function' |
1149 | * |
1150 | * About '<S48>/Math Function': |
1151 | * Operator: exp |
1152 | */ |
1153 | BMS_B.Divide_m = BMS_P.Cnom_Value_m * exp(BMS_X.Integrator6_CSTATE_g); |
1154 | |
1155 | /* Product: '<S53>/Divide' incorporates: |
1156 | * Constant: '<S53>/Cnom' |
1157 | * Integrator: '<S53>/Integrator6' |
1158 | * Math: '<S53>/Math Function' |
1159 | * |
1160 | * About '<S53>/Math Function': |
1161 | * Operator: exp |
1162 | */ |
1163 | BMS_B.Divide_l2 = BMS_P.Cnom_Value_k * exp(BMS_X.Integrator6_CSTATE_a); |
1164 | |
1165 | /* Product: '<S58>/Divide' incorporates: |
1166 | * Constant: '<S58>/Cnom' |
1167 | * Integrator: '<S58>/Integrator6' |
1168 | * Math: '<S58>/Math Function' |
1169 | * |
1170 | * About '<S58>/Math Function': |
1171 | * Operator: exp |
1172 | */ |
1173 | BMS_B.Divide_a = BMS_P.Cnom_Value_i * exp(BMS_X.Integrator6_CSTATE_f); |
1174 | |
1175 | /* Product: '<S63>/Divide' incorporates: |
1176 | * Constant: '<S63>/Cnom' |
1177 | * Integrator: '<S63>/Integrator6' |
1178 | * Math: '<S63>/Math Function' |
1179 | * |
1180 | * About '<S63>/Math Function': |
1181 | * Operator: exp |
1182 | */ |
1183 | BMS_B.Divide_n = BMS_P.Cnom_Value_e * exp(BMS_X.Integrator6_CSTATE_hq); |
1184 | |
1185 | /* Product: '<S68>/Divide' incorporates: |
1186 | * Constant: '<S68>/Cnom' |
1187 | * Integrator: '<S68>/Integrator6' |
1188 | * Math: '<S68>/Math Function' |
1189 | * |
1190 | * About '<S68>/Math Function': |
1191 | * Operator: exp |
1192 | */ |
1193 | BMS_B.Divide_mm = BMS_P.Cnom_Value_mh * exp(BMS_X.Integrator6_CSTATE_b); |
1194 | if (rtmIsMajorTimeStep(BMS_M)) { |
1195 | /* Relay: '<S3>/Relay6' */ |
1196 | if (BMS_DW.Relay6_Mode) { |
1197 | rtb_Add1_o = BMS_P.Relay6_YOn; |
1198 | } else { |
1199 | rtb_Add1_o = BMS_P.Relay6_YOff; |
1200 | } |
1201 | |
1202 | /* Product: '<S3>/Product5' */ |
1203 | BMS_B.Product5 = rtb_Divide3 * rtb_Add1_o; |
1204 | } |
1205 | |
1206 | /* Product: '<S33>/Divide1' incorporates: |
1207 | * Constant: '<S33>/Rnom' |
1208 | * Integrator: '<S33>/Integrator3' |
1209 | * Math: '<S33>/Math Function1' |
1210 | * |
1211 | * About '<S33>/Math Function1': |
1212 | * Operator: exp |
1213 | */ |
1214 | BMS_B.Divide1 = BMS_P.Rnom_Value * exp(BMS_X.Integrator3_CSTATE); |
1215 | |
1216 | /* Product: '<S38>/Divide1' incorporates: |
1217 | * Constant: '<S38>/Rnom' |
1218 | * Integrator: '<S38>/Integrator3' |
1219 | * Math: '<S38>/Math Function1' |
1220 | * |
1221 | * About '<S38>/Math Function1': |
1222 | * Operator: exp |
1223 | */ |
1224 | BMS_B.Divide1_n = BMS_P.Rnom_Value_a * exp(BMS_X.Integrator3_CSTATE_i); |
1225 | |
1226 | /* Product: '<S43>/Divide1' incorporates: |
1227 | * Constant: '<S43>/Rnom' |
1228 | * Integrator: '<S43>/Integrator3' |
1229 | * Math: '<S43>/Math Function1' |
1230 | * |
1231 | * About '<S43>/Math Function1': |
1232 | * Operator: exp |
1233 | */ |
1234 | BMS_B.Divide1_j = BMS_P.Rnom_Value_m * exp(BMS_X.Integrator3_CSTATE_h); |
1235 | |
1236 | /* Product: '<S48>/Divide1' incorporates: |
1237 | * Constant: '<S48>/Rnom' |
1238 | * Integrator: '<S48>/Integrator3' |
1239 | * Math: '<S48>/Math Function1' |
1240 | * |
1241 | * About '<S48>/Math Function1': |
1242 | * Operator: exp |
1243 | */ |
1244 | BMS_B.Divide1_p = BMS_P.Rnom_Value_e * exp(BMS_X.Integrator3_CSTATE_hr); |
1245 | |
1246 | /* Product: '<S53>/Divide1' incorporates: |
1247 | * Constant: '<S53>/Rnom' |
1248 | * Integrator: '<S53>/Integrator3' |
1249 | * Math: '<S53>/Math Function1' |
1250 | * |
1251 | * About '<S53>/Math Function1': |
1252 | * Operator: exp |
1253 | */ |
1254 | BMS_B.Divide1_jl = BMS_P.Rnom_Value_l * exp(BMS_X.Integrator3_CSTATE_d); |
1255 | |
1256 | /* Product: '<S58>/Divide1' incorporates: |
1257 | * Constant: '<S58>/Rnom' |
1258 | * Integrator: '<S58>/Integrator3' |
1259 | * Math: '<S58>/Math Function1' |
1260 | * |
1261 | * About '<S58>/Math Function1': |
1262 | * Operator: exp |
1263 | */ |
1264 | BMS_B.Divide1_nb = BMS_P.Rnom_Value_d * exp(BMS_X.Integrator3_CSTATE_f); |
1265 | |
1266 | /* Product: '<S63>/Divide1' incorporates: |
1267 | * Constant: '<S63>/Rnom' |
1268 | * Integrator: '<S63>/Integrator3' |
1269 | * Math: '<S63>/Math Function1' |
1270 | * |
1271 | * About '<S63>/Math Function1': |
1272 | * Operator: exp |
1273 | */ |
1274 | BMS_B.Divide1_c = BMS_P.Rnom_Value_p * exp(BMS_X.Integrator3_CSTATE_dt); |
1275 | |
1276 | /* Product: '<S68>/Divide1' incorporates: |
1277 | * Constant: '<S68>/Rnom' |
1278 | * Integrator: '<S68>/Integrator3' |
1279 | * Math: '<S68>/Math Function1' |
1280 | * |
1281 | * About '<S68>/Math Function1': |
1282 | * Operator: exp |
1283 | */ |
1284 | BMS_B.Divide1_i = BMS_P.Rnom_Value_i * exp(BMS_X.Integrator3_CSTATE_o); |
1285 | if (rtmIsMajorTimeStep(BMS_M)) { |
1286 | /* Gain: '<S5>/Gain4' */ |
1287 | BMS_B.Gain4 = BMS_P.Gain4_Gain * BMS_B.Add2_c2; |
1288 | } |
1289 | |
1290 | /* MATLAB Function: '<S5>/dead_band4' incorporates: |
1291 | * Inport: '<Root>/I' |
1292 | */ |
1293 | BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band4); |
1294 | |
1295 | /* Sum: '<S5>/Add1' */ |
1296 | rtb_Divide3 = BMS_B.Gain4 + BMS_B.sf_dead_band4.y; |
1297 | if (rtmIsMajorTimeStep(BMS_M)) { |
1298 | /* Gain: '<S5>/Gain5' */ |
1299 | BMS_B.Gain5 = BMS_P.Gain5_Gain * BMS_B.Add2_m; |
1300 | } |
1301 | |
1302 | /* MATLAB Function: '<S5>/dead_band5' incorporates: |
1303 | * Inport: '<Root>/I' |
1304 | */ |
1305 | BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band5); |
1306 | |
1307 | /* Sum: '<S5>/Add2' */ |
1308 | rtb_Bias = BMS_B.Gain5 + BMS_B.sf_dead_band5.y; |
1309 | if (rtmIsMajorTimeStep(BMS_M)) { |
1310 | /* Gain: '<S5>/Gain6' */ |
1311 | BMS_B.Gain6 = BMS_P.Gain6_Gain * BMS_B.Add2_j; |
1312 | } |
1313 | |
1314 | /* MATLAB Function: '<S5>/dead_band6' incorporates: |
1315 | * Inport: '<Root>/I' |
1316 | */ |
1317 | BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band6); |
1318 | |
1319 | /* Sum: '<S5>/Add3' */ |
1320 | rtb_Bias1 = BMS_B.Gain6 + BMS_B.sf_dead_band6.y; |
1321 | if (rtmIsMajorTimeStep(BMS_M)) { |
1322 | /* Gain: '<S5>/Gain7' */ |
1323 | BMS_B.Gain7 = BMS_P.Gain7_Gain * BMS_B.Add2_h; |
1324 | } |
1325 | |
1326 | /* MATLAB Function: '<S5>/dead_band7' incorporates: |
1327 | * Inport: '<Root>/I' |
1328 | */ |
1329 | BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band7); |
1330 | |
1331 | /* Sum: '<S5>/Add4' */ |
1332 | rtb_Bias2 = BMS_B.Gain7 + BMS_B.sf_dead_band7.y; |
1333 | if (rtmIsMajorTimeStep(BMS_M)) { |
1334 | /* Gain: '<S5>/Gain3' */ |
1335 | BMS_B.Gain3 = BMS_P.Gain3_Gain * BMS_B.Add2_c; |
1336 | } |
1337 | |
1338 | /* MATLAB Function: '<S5>/dead_band3' incorporates: |
1339 | * Inport: '<Root>/I' |
1340 | */ |
1341 | BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band3); |
1342 | |
1343 | /* Sum: '<S5>/Add5' */ |
1344 | rtb_Add1_c = BMS_B.Gain3 + BMS_B.sf_dead_band3.y; |
1345 | if (rtmIsMajorTimeStep(BMS_M)) { |
1346 | /* Gain: '<S5>/Gain2' */ |
1347 | BMS_B.Gain2 = BMS_P.Gain2_Gain * BMS_B.Add2_l; |
1348 | } |
1349 | |
1350 | /* MATLAB Function: '<S5>/dead_band2' incorporates: |
1351 | * Inport: '<Root>/I' |
1352 | */ |
1353 | BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band2); |
1354 | |
1355 | /* Sum: '<S5>/Add6' */ |
1356 | rtb_Add1_o = BMS_B.Gain2 + BMS_B.sf_dead_band2.y; |
1357 | if (rtmIsMajorTimeStep(BMS_M)) { |
1358 | /* Gain: '<S5>/Gain1' */ |
1359 | BMS_B.Gain1 = BMS_P.Gain1_Gain * BMS_B.Add2; |
1360 | } |
1361 | |
1362 | /* MATLAB Function: '<S5>/dead_band1' incorporates: |
1363 | * Inport: '<Root>/I' |
1364 | */ |
1365 | BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band1); |
1366 | |
1367 | /* Sum: '<S5>/Add7' */ |
1368 | rtb_Add7 = BMS_B.Gain1 + BMS_B.sf_dead_band1.y; |
1369 | if (rtmIsMajorTimeStep(BMS_M)) { |
1370 | /* Gain: '<S5>/Gain' */ |
1371 | BMS_B.Gain = BMS_P.Gain_Gain * BMS_B.Add2_a; |
1372 | } |
1373 | |
1374 | /* MATLAB Function: '<S5>/dead_band' incorporates: |
1375 | * Inport: '<Root>/I' |
1376 | */ |
1377 | BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band); |
1378 | |
1379 | /* Sum: '<S5>/Add8' */ |
1380 | rtb_Add8 = BMS_B.Gain + BMS_B.sf_dead_band.y; |
1381 | |
1382 | /* Sum: '<S32>/Add2' incorporates: |
1383 | * Inport: '<Root>/T' |
1384 | * Inport: '<Root>/U1' |
1385 | * Lookup_n-D: '<S32>/2-D Lookup Table: OCV - SoC' |
1386 | * Product: '<S32>/Product1' |
1387 | * Sum: '<S32>/Add1' |
1388 | */ |
1389 | rtb_Sqrt = BMS_U.U1 - (BMS_B.Divide1 * rtb_Add8 + look2_binlxpw |
1390 | (BMS_B.Integrator, BMS_U.T, BMS_P.uDLookupTableOCVSoC_bp01Data, |
1391 | BMS_P.uDLookupTableOCVSoC_bp02Data, BMS_P.uDLookupTableOCVSoC_tableData, |
1392 | BMS_P.uDLookupTableOCVSoC_maxIndex, 21U)); |
1393 | |
1394 | /* Fcn: '<S34>/abs' incorporates: |
1395 | * Gain: '<S34>/Gain2' |
1396 | */ |
1397 | BMS_B.abs_p = fabs(BMS_P.Gain2_Gain_g * rtb_Add8); |
1398 | |
1399 | /* Lookup_n-D: '<S34>/1-D Lookup Table' incorporates: |
1400 | * Gain: '<S34>/Gain3' |
1401 | * Sum: '<S34>/Add3' |
1402 | * TransferFcn: '<S34>/Transfer Fcn1' |
1403 | */ |
1404 | BMS_B.uDLookupTable = look1_binlxpw((((BMS_P.TransferFcn1_C[0] * |
1405 | BMS_X.TransferFcn1_CSTATE[0] + BMS_P.TransferFcn1_C[1] * |
1406 | BMS_X.TransferFcn1_CSTATE[1]) + BMS_P.TransferFcn1_C[2] * |
1407 | BMS_X.TransferFcn1_CSTATE[2]) + BMS_B.abs_p) * BMS_P.Gain3_Gain_l, |
1408 | BMS_P.uDLookupTable_bp01Data, BMS_P.uDLookupTable_tableData, 6U); |
1409 | |
1410 | /* DeadZone: '<S32>/Dead Zone' */ |
1411 | if (rtb_Sqrt > BMS_P.DeadZone_End) { |
1412 | rtb_TransferFcn1 = rtb_Sqrt - BMS_P.DeadZone_End; |
1413 | } else if (rtb_Sqrt >= BMS_P.DeadZone_Start) { |
1414 | rtb_TransferFcn1 = 0.0; |
1415 | } else { |
1416 | rtb_TransferFcn1 = rtb_Sqrt - BMS_P.DeadZone_Start; |
1417 | } |
1418 | |
1419 | /* End of DeadZone: '<S32>/Dead Zone' */ |
1420 | |
1421 | /* Product: '<S32>/Product' incorporates: |
1422 | * Gain: '<S32>/Gain4' |
1423 | */ |
1424 | rtb_Product_o2 = BMS_P.SOCestimator_gainU * BMS_B.uDLookupTable * |
1425 | rtb_TransferFcn1; |
1426 | |
1427 | /* Gain: '<S32>/Gain' incorporates: |
1428 | * Product: '<S32>/Divide' |
1429 | * Sum: '<S32>/Sum1' |
1430 | */ |
1431 | BMS_B.Gain_p = (1.0 / BMS_B.Divide * rtb_Add8 + rtb_Product_o2) * |
1432 | BMS_P.Gain_Gain_e; |
1433 | |
1434 | /* TransferFcn: '<S35>/Transfer Fcn4' */ |
1435 | BMS_B.TransferFcn4 = 0.0; |
1436 | BMS_B.TransferFcn4 += BMS_P.TransferFcn4_C[0] * BMS_X.TransferFcn4_CSTATE[0]; |
1437 | BMS_B.TransferFcn4 += BMS_P.TransferFcn4_C[1] * BMS_X.TransferFcn4_CSTATE[1]; |
1438 | BMS_B.TransferFcn4 += BMS_P.TransferFcn4_C[2] * BMS_X.TransferFcn4_CSTATE[2]; |
1439 | |
1440 | /* TransferFcn: '<S35>/Transfer Fcn1' */ |
1441 | rtb_TransferFcn1 = BMS_P.TransferFcn1_C_j * BMS_X.TransferFcn1_CSTATE_j + |
1442 | BMS_P.TransferFcn1_D * BMS_B.TransferFcn4; |
1443 | |
1444 | /* Sqrt: '<S35>/Sqrt' |
1445 | * |
1446 | * About '<S35>/Sqrt': |
1447 | * Operator: signedSqrt |
1448 | */ |
1449 | if (rtb_TransferFcn1 < 0.0) { |
1450 | rtb_TransferFcn1 = -sqrt(fabs(rtb_TransferFcn1)); |
1451 | } else { |
1452 | rtb_TransferFcn1 = sqrt(rtb_TransferFcn1); |
1453 | } |
1454 | |
1455 | /* End of Sqrt: '<S35>/Sqrt' */ |
1456 | |
1457 | /* Gain: '<S35>/Gain' */ |
1458 | BMS_B.Gain_d = BMS_P.Gain_Gain_f * rtb_TransferFcn1; |
1459 | |
1460 | /* Product: '<S35>/Product' incorporates: |
1461 | * Gain: '<S35>/Gain1' |
1462 | */ |
1463 | BMS_B.Product = BMS_P.Gain1_Gain_b * rtb_Add8 * rtb_Sqrt; |
1464 | |
1465 | /* Integrator: '<S36>/Integrator' */ |
1466 | BMS_B.Integrator_i = BMS_X.Integrator_CSTATE_n5; |
1467 | if (rtmIsMajorTimeStep(BMS_M)) { |
1468 | } |
1469 | |
1470 | /* Gain: '<S36>/Gain3' */ |
1471 | BMS_B.Gain3_a = BMS_P.Gain3_Gain_h * rtb_Product_o2; |
1472 | if (rtmIsMajorTimeStep(BMS_M)) { |
1473 | } |
1474 | |
1475 | /* Gain: '<S36>/Gain1' incorporates: |
1476 | * Product: '<S36>/Product' |
1477 | */ |
1478 | BMS_B.Gain1_i = BMS_B.Integrator_i * BMS_B.Gain3_a * BMS_P.Gain1_Gain_i; |
1479 | if (rtmIsMajorTimeStep(BMS_M)) { |
1480 | } |
1481 | |
1482 | /* Gain: '<S36>/Gain' */ |
1483 | BMS_B.Gain_e = BMS_P.Gain_Gain_d * BMS_B.Gain1_i; |
1484 | |
1485 | /* Gain: '<S36>/Gain4' incorporates: |
1486 | * Gain: '<S36>/Gain2' |
1487 | * Gain: '<S36>/Gain5' |
1488 | * Product: '<S36>/Product1' |
1489 | * Sum: '<S36>/Sum' |
1490 | * TransferFcn: '<S36>/Transfer Fcn1' |
1491 | */ |
1492 | BMS_B.Gain4_h = (BMS_P.Gain2_Gain_gl * rtb_Add8 - ((BMS_P.TransferFcn1_C_f[0] * |
1493 | BMS_X.TransferFcn1_CSTATE_a[0] + BMS_P.TransferFcn1_C_f[1] * |
1494 | BMS_X.TransferFcn1_CSTATE_a[1]) + BMS_P.TransferFcn1_C_f[2] * |
1495 | BMS_X.TransferFcn1_CSTATE_a[2]) * BMS_B.Integrator_i * BMS_P.Gain5_Gain_d) * |
1496 | BMS_P.Gain4_Gain_h; |
1497 | |
1498 | /* Sum: '<S37>/Add2' incorporates: |
1499 | * Inport: '<Root>/T' |
1500 | * Inport: '<Root>/U2' |
1501 | * Lookup_n-D: '<S37>/2-D Lookup Table' |
1502 | * Product: '<S37>/Product1' |
1503 | * Sum: '<S37>/Add1' |
1504 | */ |
1505 | rtb_TransferFcn1 = BMS_U.U2 - (BMS_B.Divide1_n * rtb_Add7 + look2_binlxpw |
1506 | (BMS_B.Integrator_d, BMS_U.T, BMS_P.uDLookupTable_bp01Data_b, |
1507 | BMS_P.uDLookupTable_bp02Data, BMS_P.uDLookupTable_tableData_j, |
1508 | BMS_P.uDLookupTable_maxIndex, 21U)); |
1509 | |
1510 | /* Fcn: '<S39>/abs' incorporates: |
1511 | * Gain: '<S39>/Gain2' |
1512 | */ |
1513 | BMS_B.abs_j = fabs(BMS_P.Gain2_Gain_b * rtb_Add7); |
1514 | |
1515 | /* Lookup_n-D: '<S39>/1-D Lookup Table' incorporates: |
1516 | * Gain: '<S39>/Gain3' |
1517 | * Sum: '<S39>/Add3' |
1518 | * TransferFcn: '<S39>/Transfer Fcn1' |
1519 | */ |
1520 | BMS_B.uDLookupTable_b = look1_binlxpw((((BMS_P.TransferFcn1_C_p[0] * |
1521 | BMS_X.TransferFcn1_CSTATE_l[0] + BMS_P.TransferFcn1_C_p[1] * |
1522 | BMS_X.TransferFcn1_CSTATE_l[1]) + BMS_P.TransferFcn1_C_p[2] * |
1523 | BMS_X.TransferFcn1_CSTATE_l[2]) + BMS_B.abs_j) * BMS_P.Gain3_Gain_o, |
1524 | BMS_P.uDLookupTable_bp01Data_n, BMS_P.uDLookupTable_tableData_g, 6U); |
1525 | |
1526 | /* DeadZone: '<S37>/Dead Zone' */ |
1527 | if (rtb_TransferFcn1 > BMS_P.DeadZone_End_a) { |
1528 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_a; |
1529 | } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_a) { |
1530 | rtb_Add8 = 0.0; |
1531 | } else { |
1532 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_a; |
1533 | } |
1534 | |
1535 | /* End of DeadZone: '<S37>/Dead Zone' */ |
1536 | |
1537 | /* Product: '<S37>/Product' incorporates: |
1538 | * Gain: '<S37>/Gain4' |
1539 | */ |
1540 | rtb_Product_o2 = BMS_P.SOCestimator_gainU_p * BMS_B.uDLookupTable_b * rtb_Add8; |
1541 | |
1542 | /* Gain: '<S37>/Gain' incorporates: |
1543 | * Product: '<S37>/Divide' |
1544 | * Sum: '<S37>/Sum1' |
1545 | */ |
1546 | BMS_B.Gain_k = (1.0 / BMS_B.Divide_l * rtb_Add7 + rtb_Product_o2) * |
1547 | BMS_P.Gain_Gain_m; |
1548 | |
1549 | /* TransferFcn: '<S40>/Transfer Fcn4' */ |
1550 | BMS_B.TransferFcn4_h = 0.0; |
1551 | BMS_B.TransferFcn4_h += BMS_P.TransferFcn4_C_l[0] * |
1552 | BMS_X.TransferFcn4_CSTATE_e[0]; |
1553 | BMS_B.TransferFcn4_h += BMS_P.TransferFcn4_C_l[1] * |
1554 | BMS_X.TransferFcn4_CSTATE_e[1]; |
1555 | BMS_B.TransferFcn4_h += BMS_P.TransferFcn4_C_l[2] * |
1556 | BMS_X.TransferFcn4_CSTATE_e[2]; |
1557 | |
1558 | /* TransferFcn: '<S40>/Transfer Fcn1' */ |
1559 | rtb_Sqrt = BMS_P.TransferFcn1_C_d * BMS_X.TransferFcn1_CSTATE_g + |
1560 | BMS_P.TransferFcn1_D_b * BMS_B.TransferFcn4_h; |
1561 | |
1562 | /* Sqrt: '<S40>/Sqrt' |
1563 | * |
1564 | * About '<S40>/Sqrt': |
1565 | * Operator: signedSqrt |
1566 | */ |
1567 | if (rtb_Sqrt < 0.0) { |
1568 | rtb_Sqrt = -sqrt(fabs(rtb_Sqrt)); |
1569 | } else { |
1570 | rtb_Sqrt = sqrt(rtb_Sqrt); |
1571 | } |
1572 | |
1573 | /* End of Sqrt: '<S40>/Sqrt' */ |
1574 | |
1575 | /* Gain: '<S40>/Gain' */ |
1576 | BMS_B.Gain_c = BMS_P.Gain_Gain_h * rtb_Sqrt; |
1577 | |
1578 | /* Product: '<S40>/Product' incorporates: |
1579 | * Gain: '<S40>/Gain1' |
1580 | */ |
1581 | BMS_B.Product_c = BMS_P.Gain1_Gain_k * rtb_Add7 * rtb_TransferFcn1; |
1582 | |
1583 | /* Integrator: '<S41>/Integrator' */ |
1584 | BMS_B.Integrator_dt = BMS_X.Integrator_CSTATE_nm; |
1585 | if (rtmIsMajorTimeStep(BMS_M)) { |
1586 | } |
1587 | |
1588 | /* Gain: '<S41>/Gain3' */ |
1589 | BMS_B.Gain3_g = BMS_P.Gain3_Gain_n * rtb_Product_o2; |
1590 | if (rtmIsMajorTimeStep(BMS_M)) { |
1591 | } |
1592 | |
1593 | /* Gain: '<S41>/Gain1' incorporates: |
1594 | * Product: '<S41>/Product' |
1595 | */ |
1596 | BMS_B.Gain1_j = BMS_B.Integrator_dt * BMS_B.Gain3_g * BMS_P.Gain1_Gain_c; |
1597 | if (rtmIsMajorTimeStep(BMS_M)) { |
1598 | } |
1599 | |
1600 | /* Gain: '<S41>/Gain' */ |
1601 | BMS_B.Gain_n = BMS_P.Gain_Gain_j * BMS_B.Gain1_j; |
1602 | |
1603 | /* Gain: '<S41>/Gain4' incorporates: |
1604 | * Gain: '<S41>/Gain2' |
1605 | * Gain: '<S41>/Gain5' |
1606 | * Product: '<S41>/Product1' |
1607 | * Sum: '<S41>/Sum' |
1608 | * TransferFcn: '<S41>/Transfer Fcn1' |
1609 | */ |
1610 | BMS_B.Gain4_k = (BMS_P.Gain2_Gain_h * rtb_Add7 - ((BMS_P.TransferFcn1_C_m[0] * |
1611 | BMS_X.TransferFcn1_CSTATE_b[0] + BMS_P.TransferFcn1_C_m[1] * |
1612 | BMS_X.TransferFcn1_CSTATE_b[1]) + BMS_P.TransferFcn1_C_m[2] * |
1613 | BMS_X.TransferFcn1_CSTATE_b[2]) * BMS_B.Integrator_dt * BMS_P.Gain5_Gain_f) * |
1614 | BMS_P.Gain4_Gain_c; |
1615 | |
1616 | /* Sum: '<S42>/Add2' incorporates: |
1617 | * Inport: '<Root>/T' |
1618 | * Inport: '<Root>/U3' |
1619 | * Lookup_n-D: '<S42>/2-D Lookup Table' |
1620 | * Product: '<S42>/Product1' |
1621 | * Sum: '<S42>/Add1' |
1622 | */ |
1623 | rtb_TransferFcn1 = BMS_U.U3 - (BMS_B.Divide1_j * rtb_Add1_o + look2_binlxpw |
1624 | (BMS_B.Integrator_g, BMS_U.T, BMS_P.uDLookupTable_bp01Data_j, |
1625 | BMS_P.uDLookupTable_bp02Data_g, BMS_P.uDLookupTable_tableData_k, |
1626 | BMS_P.uDLookupTable_maxIndex_n, 21U)); |
1627 | |
1628 | /* Fcn: '<S44>/abs' incorporates: |
1629 | * Gain: '<S44>/Gain2' |
1630 | */ |
1631 | BMS_B.abs_e = fabs(BMS_P.Gain2_Gain_bv * rtb_Add1_o); |
1632 | |
1633 | /* Lookup_n-D: '<S44>/1-D Lookup Table' incorporates: |
1634 | * Gain: '<S44>/Gain3' |
1635 | * Sum: '<S44>/Add3' |
1636 | * TransferFcn: '<S44>/Transfer Fcn1' |
1637 | */ |
1638 | BMS_B.uDLookupTable_f = look1_binlxpw((((BMS_P.TransferFcn1_C_l[0] * |
1639 | BMS_X.TransferFcn1_CSTATE_c[0] + BMS_P.TransferFcn1_C_l[1] * |
1640 | BMS_X.TransferFcn1_CSTATE_c[1]) + BMS_P.TransferFcn1_C_l[2] * |
1641 | BMS_X.TransferFcn1_CSTATE_c[2]) + BMS_B.abs_e) * BMS_P.Gain3_Gain_j, |
1642 | BMS_P.uDLookupTable_bp01Data_d, BMS_P.uDLookupTable_tableData_g4, 6U); |
1643 | |
1644 | /* DeadZone: '<S42>/Dead Zone' */ |
1645 | if (rtb_TransferFcn1 > BMS_P.DeadZone_End_i) { |
1646 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_i; |
1647 | } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_m) { |
1648 | rtb_Add8 = 0.0; |
1649 | } else { |
1650 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_m; |
1651 | } |
1652 | |
1653 | /* End of DeadZone: '<S42>/Dead Zone' */ |
1654 | |
1655 | /* Product: '<S42>/Product' incorporates: |
1656 | * Gain: '<S42>/Gain4' |
1657 | */ |
1658 | rtb_Product_o2 = BMS_P.SOCestimator_gainU_h * BMS_B.uDLookupTable_f * rtb_Add8; |
1659 | |
1660 | /* Gain: '<S42>/Gain' incorporates: |
1661 | * Product: '<S42>/Divide' |
1662 | * Sum: '<S42>/Sum1' |
1663 | */ |
1664 | BMS_B.Gain_db = (1.0 / BMS_B.Divide_l4 * rtb_Add1_o + rtb_Product_o2) * |
1665 | BMS_P.Gain_Gain_l; |
1666 | |
1667 | /* TransferFcn: '<S45>/Transfer Fcn4' */ |
1668 | BMS_B.TransferFcn4_o = 0.0; |
1669 | BMS_B.TransferFcn4_o += BMS_P.TransferFcn4_C_c[0] * |
1670 | BMS_X.TransferFcn4_CSTATE_h[0]; |
1671 | BMS_B.TransferFcn4_o += BMS_P.TransferFcn4_C_c[1] * |
1672 | BMS_X.TransferFcn4_CSTATE_h[1]; |
1673 | BMS_B.TransferFcn4_o += BMS_P.TransferFcn4_C_c[2] * |
1674 | BMS_X.TransferFcn4_CSTATE_h[2]; |
1675 | |
1676 | /* TransferFcn: '<S45>/Transfer Fcn1' */ |
1677 | rtb_Sqrt = BMS_P.TransferFcn1_C_g * BMS_X.TransferFcn1_CSTATE_f + |
1678 | BMS_P.TransferFcn1_D_n * BMS_B.TransferFcn4_o; |
1679 | |
1680 | /* Sqrt: '<S45>/Sqrt' |
1681 | * |
1682 | * About '<S45>/Sqrt': |
1683 | * Operator: signedSqrt |
1684 | */ |
1685 | if (rtb_Sqrt < 0.0) { |
1686 | rtb_Sqrt = -sqrt(fabs(rtb_Sqrt)); |
1687 | } else { |
1688 | rtb_Sqrt = sqrt(rtb_Sqrt); |
1689 | } |
1690 | |
1691 | /* End of Sqrt: '<S45>/Sqrt' */ |
1692 | |
1693 | /* Gain: '<S45>/Gain' */ |
1694 | BMS_B.Gain_h = BMS_P.Gain_Gain_fy * rtb_Sqrt; |
1695 | |
1696 | /* Product: '<S45>/Product' incorporates: |
1697 | * Gain: '<S45>/Gain1' |
1698 | */ |
1699 | BMS_B.Product_e = BMS_P.Gain1_Gain_l * rtb_Add1_o * rtb_TransferFcn1; |
1700 | |
1701 | /* Integrator: '<S46>/Integrator' */ |
1702 | BMS_B.Integrator_k = BMS_X.Integrator_CSTATE_kc; |
1703 | if (rtmIsMajorTimeStep(BMS_M)) { |
1704 | } |
1705 | |
1706 | /* Gain: '<S46>/Gain3' */ |
1707 | BMS_B.Gain3_n = BMS_P.Gain3_Gain_p * rtb_Product_o2; |
1708 | if (rtmIsMajorTimeStep(BMS_M)) { |
1709 | } |
1710 | |
1711 | /* Gain: '<S46>/Gain1' incorporates: |
1712 | * Product: '<S46>/Product' |
1713 | */ |
1714 | BMS_B.Gain1_h = BMS_B.Integrator_k * BMS_B.Gain3_n * BMS_P.Gain1_Gain_c3; |
1715 | if (rtmIsMajorTimeStep(BMS_M)) { |
1716 | } |
1717 | |
1718 | /* Gain: '<S46>/Gain' */ |
1719 | BMS_B.Gain_f = BMS_P.Gain_Gain_jg * BMS_B.Gain1_h; |
1720 | |
1721 | /* Gain: '<S46>/Gain4' incorporates: |
1722 | * Gain: '<S46>/Gain2' |
1723 | * Gain: '<S46>/Gain5' |
1724 | * Product: '<S46>/Product1' |
1725 | * Sum: '<S46>/Sum' |
1726 | * TransferFcn: '<S46>/Transfer Fcn1' |
1727 | */ |
1728 | BMS_B.Gain4_i = (BMS_P.Gain2_Gain_by * rtb_Add1_o - ((BMS_P.TransferFcn1_C_h[0] |
1729 | * BMS_X.TransferFcn1_CSTATE_n[0] + BMS_P.TransferFcn1_C_h[1] * |
1730 | BMS_X.TransferFcn1_CSTATE_n[1]) + BMS_P.TransferFcn1_C_h[2] * |
1731 | BMS_X.TransferFcn1_CSTATE_n[2]) * BMS_B.Integrator_k * BMS_P.Gain5_Gain_h) * |
1732 | BMS_P.Gain4_Gain_n; |
1733 | |
1734 | /* Sum: '<S47>/Add2' incorporates: |
1735 | * Inport: '<Root>/T' |
1736 | * Inport: '<Root>/U4' |
1737 | * Lookup_n-D: '<S47>/2-D Lookup Table' |
1738 | * Product: '<S47>/Product1' |
1739 | * Sum: '<S47>/Add1' |
1740 | */ |
1741 | rtb_TransferFcn1 = BMS_U.U4 - (BMS_B.Divide1_p * rtb_Add1_c + look2_binlxpw |
1742 | (BMS_B.Integrator_gh, BMS_U.T, BMS_P.uDLookupTable_bp01Data_f, |
1743 | BMS_P.uDLookupTable_bp02Data_o, BMS_P.uDLookupTable_tableData_g5, |
1744 | BMS_P.uDLookupTable_maxIndex_l, 21U)); |
1745 | |
1746 | /* Fcn: '<S49>/abs' incorporates: |
1747 | * Gain: '<S49>/Gain2' |
1748 | */ |
1749 | BMS_B.abs_d = fabs(BMS_P.Gain2_Gain_o * rtb_Add1_c); |
1750 | |
1751 | /* Lookup_n-D: '<S49>/1-D Lookup Table' incorporates: |
1752 | * Gain: '<S49>/Gain3' |
1753 | * Sum: '<S49>/Add3' |
1754 | * TransferFcn: '<S49>/Transfer Fcn1' |
1755 | */ |
1756 | BMS_B.uDLookupTable_h = look1_binlxpw((((BMS_P.TransferFcn1_C_dc[0] * |
1757 | BMS_X.TransferFcn1_CSTATE_am[0] + BMS_P.TransferFcn1_C_dc[1] * |
1758 | BMS_X.TransferFcn1_CSTATE_am[1]) + BMS_P.TransferFcn1_C_dc[2] * |
1759 | BMS_X.TransferFcn1_CSTATE_am[2]) + BMS_B.abs_d) * BMS_P.Gain3_Gain_lw, |
1760 | BMS_P.uDLookupTable_bp01Data_a, BMS_P.uDLookupTable_tableData_p, 6U); |
1761 | |
1762 | /* DeadZone: '<S47>/Dead Zone' */ |
1763 | if (rtb_TransferFcn1 > BMS_P.DeadZone_End_k) { |
1764 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_k; |
1765 | } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_l) { |
1766 | rtb_Add8 = 0.0; |
1767 | } else { |
1768 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_l; |
1769 | } |
1770 | |
1771 | /* End of DeadZone: '<S47>/Dead Zone' */ |
1772 | |
1773 | /* Product: '<S47>/Product' incorporates: |
1774 | * Gain: '<S47>/Gain4' |
1775 | */ |
1776 | rtb_Product_o2 = BMS_P.SOCestimator_gainU_k * BMS_B.uDLookupTable_h * rtb_Add8; |
1777 | |
1778 | /* Gain: '<S47>/Gain' incorporates: |
1779 | * Product: '<S47>/Divide' |
1780 | * Sum: '<S47>/Sum1' |
1781 | */ |
1782 | BMS_B.Gain_pt = (1.0 / BMS_B.Divide_m * rtb_Add1_c + rtb_Product_o2) * |
1783 | BMS_P.Gain_Gain_en; |
1784 | |
1785 | /* TransferFcn: '<S50>/Transfer Fcn4' */ |
1786 | BMS_B.TransferFcn4_d = 0.0; |
1787 | BMS_B.TransferFcn4_d += BMS_P.TransferFcn4_C_k[0] * |
1788 | BMS_X.TransferFcn4_CSTATE_m[0]; |
1789 | BMS_B.TransferFcn4_d += BMS_P.TransferFcn4_C_k[1] * |
1790 | BMS_X.TransferFcn4_CSTATE_m[1]; |
1791 | BMS_B.TransferFcn4_d += BMS_P.TransferFcn4_C_k[2] * |
1792 | BMS_X.TransferFcn4_CSTATE_m[2]; |
1793 | |
1794 | /* TransferFcn: '<S50>/Transfer Fcn1' */ |
1795 | rtb_Sqrt = BMS_P.TransferFcn1_C_e * BMS_X.TransferFcn1_CSTATE_c1 + |
1796 | BMS_P.TransferFcn1_D_bu * BMS_B.TransferFcn4_d; |
1797 | |
1798 | /* Sqrt: '<S50>/Sqrt' |
1799 | * |
1800 | * About '<S50>/Sqrt': |
1801 | * Operator: signedSqrt |
1802 | */ |
1803 | if (rtb_Sqrt < 0.0) { |
1804 | rtb_Sqrt = -sqrt(fabs(rtb_Sqrt)); |
1805 | } else { |
1806 | rtb_Sqrt = sqrt(rtb_Sqrt); |
1807 | } |
1808 | |
1809 | /* End of Sqrt: '<S50>/Sqrt' */ |
1810 | |
1811 | /* Gain: '<S50>/Gain' */ |
1812 | BMS_B.Gain_b = BMS_P.Gain_Gain_g * rtb_Sqrt; |
1813 | |
1814 | /* Product: '<S50>/Product' incorporates: |
1815 | * Gain: '<S50>/Gain1' |
1816 | */ |
1817 | BMS_B.Product_b = BMS_P.Gain1_Gain_bs * rtb_Add1_c * rtb_TransferFcn1; |
1818 | |
1819 | /* Integrator: '<S51>/Integrator' */ |
1820 | BMS_B.Integrator_o = BMS_X.Integrator_CSTATE_fh; |
1821 | if (rtmIsMajorTimeStep(BMS_M)) { |
1822 | } |
1823 | |
1824 | /* Gain: '<S51>/Gain3' */ |
1825 | BMS_B.Gain3_c = BMS_P.Gain3_Gain_ny * rtb_Product_o2; |
1826 | if (rtmIsMajorTimeStep(BMS_M)) { |
1827 | } |
1828 | |
1829 | /* Gain: '<S51>/Gain1' incorporates: |
1830 | * Product: '<S51>/Product' |
1831 | */ |
1832 | BMS_B.Gain1_hl = BMS_B.Integrator_o * BMS_B.Gain3_c * BMS_P.Gain1_Gain_o; |
1833 | if (rtmIsMajorTimeStep(BMS_M)) { |
1834 | } |
1835 | |
1836 | /* Gain: '<S51>/Gain' */ |
1837 | BMS_B.Gain_nj = BMS_P.Gain_Gain_enb * BMS_B.Gain1_hl; |
1838 | |
1839 | /* Gain: '<S51>/Gain4' incorporates: |
1840 | * Gain: '<S51>/Gain2' |
1841 | * Gain: '<S51>/Gain5' |
1842 | * Product: '<S51>/Product1' |
1843 | * Sum: '<S51>/Sum' |
1844 | * TransferFcn: '<S51>/Transfer Fcn1' |
1845 | */ |
1846 | BMS_B.Gain4_l = (BMS_P.Gain2_Gain_j * rtb_Add1_c - ((BMS_P.TransferFcn1_C_n[0] |
1847 | * BMS_X.TransferFcn1_CSTATE_ff[0] + BMS_P.TransferFcn1_C_n[1] * |
1848 | BMS_X.TransferFcn1_CSTATE_ff[1]) + BMS_P.TransferFcn1_C_n[2] * |
1849 | BMS_X.TransferFcn1_CSTATE_ff[2]) * BMS_B.Integrator_o * BMS_P.Gain5_Gain_ff) |
1850 | * BMS_P.Gain4_Gain_nv; |
1851 | |
1852 | /* Sum: '<S52>/Add2' incorporates: |
1853 | * Inport: '<Root>/T' |
1854 | * Inport: '<Root>/U5' |
1855 | * Lookup_n-D: '<S52>/2-D Lookup Table' |
1856 | * Product: '<S52>/Product1' |
1857 | * Sum: '<S52>/Add1' |
1858 | */ |
1859 | rtb_TransferFcn1 = BMS_U.U5 - (BMS_B.Divide1_jl * rtb_Divide3 + look2_binlxpw |
1860 | (BMS_B.Integrator_e, BMS_U.T, BMS_P.uDLookupTable_bp01Data_h, |
1861 | BMS_P.uDLookupTable_bp02Data_i, BMS_P.uDLookupTable_tableData_f, |
1862 | BMS_P.uDLookupTable_maxIndex_e, 21U)); |
1863 | |
1864 | /* Fcn: '<S54>/abs' incorporates: |
1865 | * Gain: '<S54>/Gain2' |
1866 | */ |
1867 | BMS_B.abs_m = fabs(BMS_P.Gain2_Gain_i * rtb_Divide3); |
1868 | |
1869 | /* Lookup_n-D: '<S54>/1-D Lookup Table' incorporates: |
1870 | * Gain: '<S54>/Gain3' |
1871 | * Sum: '<S54>/Add3' |
1872 | * TransferFcn: '<S54>/Transfer Fcn1' |
1873 | */ |
1874 | BMS_B.uDLookupTable_hx = look1_binlxpw((((BMS_P.TransferFcn1_C_mq[0] * |
1875 | BMS_X.TransferFcn1_CSTATE_o[0] + BMS_P.TransferFcn1_C_mq[1] * |
1876 | BMS_X.TransferFcn1_CSTATE_o[1]) + BMS_P.TransferFcn1_C_mq[2] * |
1877 | BMS_X.TransferFcn1_CSTATE_o[2]) + BMS_B.abs_m) * BMS_P.Gain3_Gain_e, |
1878 | BMS_P.uDLookupTable_bp01Data_i, BMS_P.uDLookupTable_tableData_fn, 6U); |
1879 | |
1880 | /* DeadZone: '<S52>/Dead Zone' */ |
1881 | if (rtb_TransferFcn1 > BMS_P.DeadZone_End_h) { |
1882 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_h; |
1883 | } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_i) { |
1884 | rtb_Add8 = 0.0; |
1885 | } else { |
1886 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_i; |
1887 | } |
1888 | |
1889 | /* End of DeadZone: '<S52>/Dead Zone' */ |
1890 | |
1891 | /* Product: '<S52>/Product' incorporates: |
1892 | * Gain: '<S52>/Gain4' |
1893 | */ |
1894 | rtb_Product_o2 = BMS_P.SOCestimator_gainU_m * BMS_B.uDLookupTable_hx * |
1895 | rtb_Add8; |
1896 | |
1897 | /* Gain: '<S52>/Gain' incorporates: |
1898 | * Product: '<S52>/Divide' |
1899 | * Sum: '<S52>/Sum1' |
1900 | */ |
1901 | BMS_B.Gain_nb = (1.0 / BMS_B.Divide_l2 * rtb_Divide3 + rtb_Product_o2) * |
1902 | BMS_P.Gain_Gain_o; |
1903 | |
1904 | /* TransferFcn: '<S55>/Transfer Fcn4' */ |
1905 | BMS_B.TransferFcn4_j = 0.0; |
1906 | BMS_B.TransferFcn4_j += BMS_P.TransferFcn4_C_d[0] * |
1907 | BMS_X.TransferFcn4_CSTATE_e1[0]; |
1908 | BMS_B.TransferFcn4_j += BMS_P.TransferFcn4_C_d[1] * |
1909 | BMS_X.TransferFcn4_CSTATE_e1[1]; |
1910 | BMS_B.TransferFcn4_j += BMS_P.TransferFcn4_C_d[2] * |
1911 | BMS_X.TransferFcn4_CSTATE_e1[2]; |
1912 | |
1913 | /* TransferFcn: '<S55>/Transfer Fcn1' */ |
1914 | rtb_Sqrt = BMS_P.TransferFcn1_C_pi * BMS_X.TransferFcn1_CSTATE_e + |
1915 | BMS_P.TransferFcn1_D_h * BMS_B.TransferFcn4_j; |
1916 | |
1917 | /* Sqrt: '<S55>/Sqrt' |
1918 | * |
1919 | * About '<S55>/Sqrt': |
1920 | * Operator: signedSqrt |
1921 | */ |
1922 | if (rtb_Sqrt < 0.0) { |
1923 | rtb_Sqrt = -sqrt(fabs(rtb_Sqrt)); |
1924 | } else { |
1925 | rtb_Sqrt = sqrt(rtb_Sqrt); |
1926 | } |
1927 | |
1928 | /* End of Sqrt: '<S55>/Sqrt' */ |
1929 | |
1930 | /* Gain: '<S55>/Gain' */ |
1931 | BMS_B.Gain_pg = BMS_P.Gain_Gain_g3 * rtb_Sqrt; |
1932 | |
1933 | /* Product: '<S55>/Product' incorporates: |
1934 | * Gain: '<S55>/Gain1' |
1935 | */ |
1936 | BMS_B.Product_k = BMS_P.Gain1_Gain_h * rtb_Divide3 * rtb_TransferFcn1; |
1937 | |
1938 | /* Integrator: '<S56>/Integrator' */ |
1939 | BMS_B.Integrator_kq = BMS_X.Integrator_CSTATE_l; |
1940 | if (rtmIsMajorTimeStep(BMS_M)) { |
1941 | } |
1942 | |
1943 | /* Gain: '<S56>/Gain3' */ |
1944 | BMS_B.Gain3_d = BMS_P.Gain3_Gain_hw * rtb_Product_o2; |
1945 | if (rtmIsMajorTimeStep(BMS_M)) { |
1946 | } |
1947 | |
1948 | /* Gain: '<S56>/Gain1' incorporates: |
1949 | * Product: '<S56>/Product' |
1950 | */ |
1951 | BMS_B.Gain1_l = BMS_B.Integrator_kq * BMS_B.Gain3_d * BMS_P.Gain1_Gain_g; |
1952 | if (rtmIsMajorTimeStep(BMS_M)) { |
1953 | } |
1954 | |
1955 | /* Gain: '<S56>/Gain' */ |
1956 | BMS_B.Gain_nu = BMS_P.Gain_Gain_dc * BMS_B.Gain1_l; |
1957 | |
1958 | /* Gain: '<S56>/Gain4' incorporates: |
1959 | * Gain: '<S56>/Gain2' |
1960 | * Gain: '<S56>/Gain5' |
1961 | * Product: '<S56>/Product1' |
1962 | * Sum: '<S56>/Sum' |
1963 | * TransferFcn: '<S56>/Transfer Fcn1' |
1964 | */ |
1965 | BMS_B.Gain4_d = (BMS_P.Gain2_Gain_hz * rtb_Divide3 - ((BMS_P.TransferFcn1_C_b |
1966 | [0] * BMS_X.TransferFcn1_CSTATE_gz[0] + BMS_P.TransferFcn1_C_b[1] * |
1967 | BMS_X.TransferFcn1_CSTATE_gz[1]) + BMS_P.TransferFcn1_C_b[2] * |
1968 | BMS_X.TransferFcn1_CSTATE_gz[2]) * BMS_B.Integrator_kq * BMS_P.Gain5_Gain_g) |
1969 | * BMS_P.Gain4_Gain_l; |
1970 | |
1971 | /* Sum: '<S57>/Add2' incorporates: |
1972 | * Inport: '<Root>/T' |
1973 | * Inport: '<Root>/U6' |
1974 | * Lookup_n-D: '<S57>/2-D Lookup Table' |
1975 | * Product: '<S57>/Product1' |
1976 | * Sum: '<S57>/Add1' |
1977 | */ |
1978 | rtb_TransferFcn1 = BMS_U.U6 - (BMS_B.Divide1_nb * rtb_Bias + look2_binlxpw |
1979 | (BMS_B.Integrator_j, BMS_U.T, BMS_P.uDLookupTable_bp01Data_p, |
1980 | BMS_P.uDLookupTable_bp02Data_c, BMS_P.uDLookupTable_tableData_c, |
1981 | BMS_P.uDLookupTable_maxIndex_ly, 21U)); |
1982 | |
1983 | /* Fcn: '<S59>/abs' incorporates: |
1984 | * Gain: '<S59>/Gain2' |
1985 | */ |
1986 | BMS_B.abs_jn = fabs(BMS_P.Gain2_Gain_gw * rtb_Bias); |
1987 | |
1988 | /* Lookup_n-D: '<S59>/1-D Lookup Table' incorporates: |
1989 | * Gain: '<S59>/Gain3' |
1990 | * Sum: '<S59>/Add3' |
1991 | * TransferFcn: '<S59>/Transfer Fcn1' |
1992 | */ |
1993 | BMS_B.uDLookupTable_e = look1_binlxpw((((BMS_P.TransferFcn1_C_lj[0] * |
1994 | BMS_X.TransferFcn1_CSTATE_h[0] + BMS_P.TransferFcn1_C_lj[1] * |
1995 | BMS_X.TransferFcn1_CSTATE_h[1]) + BMS_P.TransferFcn1_C_lj[2] * |
1996 | BMS_X.TransferFcn1_CSTATE_h[2]) + BMS_B.abs_jn) * BMS_P.Gain3_Gain_b, |
1997 | BMS_P.uDLookupTable_bp01Data_o, BMS_P.uDLookupTable_tableData_d, 6U); |
1998 | |
1999 | /* DeadZone: '<S57>/Dead Zone' */ |
2000 | if (rtb_TransferFcn1 > BMS_P.DeadZone_End_l) { |
2001 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_l; |
2002 | } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_ah) { |
2003 | rtb_Add8 = 0.0; |
2004 | } else { |
2005 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_ah; |
2006 | } |
2007 | |
2008 | /* End of DeadZone: '<S57>/Dead Zone' */ |
2009 | |
2010 | /* Product: '<S57>/Product' incorporates: |
2011 | * Gain: '<S57>/Gain4' |
2012 | */ |
2013 | rtb_Product_o2 = BMS_P.SOCestimator_gainU_f * BMS_B.uDLookupTable_e * rtb_Add8; |
2014 | |
2015 | /* Gain: '<S57>/Gain' incorporates: |
2016 | * Product: '<S57>/Divide' |
2017 | * Sum: '<S57>/Sum1' |
2018 | */ |
2019 | BMS_B.Gain_n1 = (1.0 / BMS_B.Divide_a * rtb_Bias + rtb_Product_o2) * |
2020 | BMS_P.Gain_Gain_p; |
2021 | |
2022 | /* TransferFcn: '<S60>/Transfer Fcn4' */ |
2023 | BMS_B.TransferFcn4_a = 0.0; |
2024 | BMS_B.TransferFcn4_a += BMS_P.TransferFcn4_C_f[0] * |
2025 | BMS_X.TransferFcn4_CSTATE_eg[0]; |
2026 | BMS_B.TransferFcn4_a += BMS_P.TransferFcn4_C_f[1] * |
2027 | BMS_X.TransferFcn4_CSTATE_eg[1]; |
2028 | BMS_B.TransferFcn4_a += BMS_P.TransferFcn4_C_f[2] * |
2029 | BMS_X.TransferFcn4_CSTATE_eg[2]; |
2030 | |
2031 | /* TransferFcn: '<S60>/Transfer Fcn1' */ |
2032 | rtb_Sqrt = BMS_P.TransferFcn1_C_i * BMS_X.TransferFcn1_CSTATE_p + |
2033 | BMS_P.TransferFcn1_D_e * BMS_B.TransferFcn4_a; |
2034 | |
2035 | /* Sqrt: '<S60>/Sqrt' |
2036 | * |
2037 | * About '<S60>/Sqrt': |
2038 | * Operator: signedSqrt |
2039 | */ |
2040 | if (rtb_Sqrt < 0.0) { |
2041 | rtb_Sqrt = -sqrt(fabs(rtb_Sqrt)); |
2042 | } else { |
2043 | rtb_Sqrt = sqrt(rtb_Sqrt); |
2044 | } |
2045 | |
2046 | /* End of Sqrt: '<S60>/Sqrt' */ |
2047 | |
2048 | /* Gain: '<S60>/Gain' */ |
2049 | BMS_B.Gain_f1 = BMS_P.Gain_Gain_fd * rtb_Sqrt; |
2050 | |
2051 | /* Product: '<S60>/Product' incorporates: |
2052 | * Gain: '<S60>/Gain1' |
2053 | */ |
2054 | BMS_B.Product_d = BMS_P.Gain1_Gain_le * rtb_Bias * rtb_TransferFcn1; |
2055 | |
2056 | /* Integrator: '<S61>/Integrator' */ |
2057 | BMS_B.Integrator_ie = BMS_X.Integrator_CSTATE_fq; |
2058 | if (rtmIsMajorTimeStep(BMS_M)) { |
2059 | } |
2060 | |
2061 | /* Gain: '<S61>/Gain3' */ |
2062 | BMS_B.Gain3_at = BMS_P.Gain3_Gain_c * rtb_Product_o2; |
2063 | if (rtmIsMajorTimeStep(BMS_M)) { |
2064 | } |
2065 | |
2066 | /* Gain: '<S61>/Gain1' incorporates: |
2067 | * Product: '<S61>/Product' |
2068 | */ |
2069 | BMS_B.Gain1_b = BMS_B.Integrator_ie * BMS_B.Gain3_at * BMS_P.Gain1_Gain_e; |
2070 | if (rtmIsMajorTimeStep(BMS_M)) { |
2071 | } |
2072 | |
2073 | /* Gain: '<S61>/Gain' */ |
2074 | BMS_B.Gain_kp = BMS_P.Gain_Gain_i * BMS_B.Gain1_b; |
2075 | |
2076 | /* Gain: '<S61>/Gain4' incorporates: |
2077 | * Gain: '<S61>/Gain2' |
2078 | * Gain: '<S61>/Gain5' |
2079 | * Product: '<S61>/Product1' |
2080 | * Sum: '<S61>/Sum' |
2081 | * TransferFcn: '<S61>/Transfer Fcn1' |
2082 | */ |
2083 | BMS_B.Gain4_hb = (BMS_P.Gain2_Gain_hl * rtb_Bias - ((BMS_P.TransferFcn1_C_na[0] |
2084 | * BMS_X.TransferFcn1_CSTATE_p5[0] + BMS_P.TransferFcn1_C_na[1] * |
2085 | BMS_X.TransferFcn1_CSTATE_p5[1]) + BMS_P.TransferFcn1_C_na[2] * |
2086 | BMS_X.TransferFcn1_CSTATE_p5[2]) * BMS_B.Integrator_ie * BMS_P.Gain5_Gain_k) |
2087 | * BMS_P.Gain4_Gain_i; |
2088 | |
2089 | /* Sum: '<S62>/Add2' incorporates: |
2090 | * Inport: '<Root>/T' |
2091 | * Inport: '<Root>/U7' |
2092 | * Lookup_n-D: '<S62>/2-D Lookup Table' |
2093 | * Product: '<S62>/Product1' |
2094 | * Sum: '<S62>/Add1' |
2095 | */ |
2096 | rtb_TransferFcn1 = BMS_U.U7 - (BMS_B.Divide1_c * rtb_Bias1 + look2_binlxpw |
2097 | (BMS_B.Integrator_p, BMS_U.T, BMS_P.uDLookupTable_bp01Data_ng, |
2098 | BMS_P.uDLookupTable_bp02Data_f, BMS_P.uDLookupTable_tableData_ft, |
2099 | BMS_P.uDLookupTable_maxIndex_es, 21U)); |
2100 | |
2101 | /* Fcn: '<S64>/abs' incorporates: |
2102 | * Gain: '<S64>/Gain2' |
2103 | */ |
2104 | BMS_B.abs_ms = fabs(BMS_P.Gain2_Gain_ik * rtb_Bias1); |
2105 | |
2106 | /* Lookup_n-D: '<S64>/1-D Lookup Table' incorporates: |
2107 | * Gain: '<S64>/Gain3' |
2108 | * Sum: '<S64>/Add3' |
2109 | * TransferFcn: '<S64>/Transfer Fcn1' |
2110 | */ |
2111 | BMS_B.uDLookupTable_n = look1_binlxpw((((BMS_P.TransferFcn1_C_lg[0] * |
2112 | BMS_X.TransferFcn1_CSTATE_op[0] + BMS_P.TransferFcn1_C_lg[1] * |
2113 | BMS_X.TransferFcn1_CSTATE_op[1]) + BMS_P.TransferFcn1_C_lg[2] * |
2114 | BMS_X.TransferFcn1_CSTATE_op[2]) + BMS_B.abs_ms) * BMS_P.Gain3_Gain_jh, |
2115 | BMS_P.uDLookupTable_bp01Data_d3, BMS_P.uDLookupTable_tableData_jl, 6U); |
2116 | |
2117 | /* DeadZone: '<S62>/Dead Zone' */ |
2118 | if (rtb_TransferFcn1 > BMS_P.DeadZone_End_c) { |
2119 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_c; |
2120 | } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_ap) { |
2121 | rtb_Add8 = 0.0; |
2122 | } else { |
2123 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_ap; |
2124 | } |
2125 | |
2126 | /* End of DeadZone: '<S62>/Dead Zone' */ |
2127 | |
2128 | /* Product: '<S62>/Product' incorporates: |
2129 | * Gain: '<S62>/Gain4' |
2130 | */ |
2131 | rtb_Product_o2 = BMS_P.SOCestimator_gainU_a * BMS_B.uDLookupTable_n * rtb_Add8; |
2132 | |
2133 | /* Gain: '<S62>/Gain' incorporates: |
2134 | * Product: '<S62>/Divide' |
2135 | * Sum: '<S62>/Sum1' |
2136 | */ |
2137 | BMS_B.Gain_i = (1.0 / BMS_B.Divide_n * rtb_Bias1 + rtb_Product_o2) * |
2138 | BMS_P.Gain_Gain_hr; |
2139 | |
2140 | /* TransferFcn: '<S65>/Transfer Fcn4' */ |
2141 | BMS_B.TransferFcn4_ad = 0.0; |
2142 | BMS_B.TransferFcn4_ad += BMS_P.TransferFcn4_C_i[0] * |
2143 | BMS_X.TransferFcn4_CSTATE_p[0]; |
2144 | BMS_B.TransferFcn4_ad += BMS_P.TransferFcn4_C_i[1] * |
2145 | BMS_X.TransferFcn4_CSTATE_p[1]; |
2146 | BMS_B.TransferFcn4_ad += BMS_P.TransferFcn4_C_i[2] * |
2147 | BMS_X.TransferFcn4_CSTATE_p[2]; |
2148 | |
2149 | /* TransferFcn: '<S65>/Transfer Fcn1' */ |
2150 | rtb_Sqrt = BMS_P.TransferFcn1_C_o * BMS_X.TransferFcn1_CSTATE_on + |
2151 | BMS_P.TransferFcn1_D_o * BMS_B.TransferFcn4_ad; |
2152 | |
2153 | /* Sqrt: '<S65>/Sqrt' |
2154 | * |
2155 | * About '<S65>/Sqrt': |
2156 | * Operator: signedSqrt |
2157 | */ |
2158 | if (rtb_Sqrt < 0.0) { |
2159 | rtb_Sqrt = -sqrt(fabs(rtb_Sqrt)); |
2160 | } else { |
2161 | rtb_Sqrt = sqrt(rtb_Sqrt); |
2162 | } |
2163 | |
2164 | /* End of Sqrt: '<S65>/Sqrt' */ |
2165 | |
2166 | /* Gain: '<S65>/Gain' */ |
2167 | BMS_B.Gain_j = BMS_P.Gain_Gain_gy * rtb_Sqrt; |
2168 | |
2169 | /* Product: '<S65>/Product' incorporates: |
2170 | * Gain: '<S65>/Gain1' |
2171 | */ |
2172 | BMS_B.Product_bf = BMS_P.Gain1_Gain_p * rtb_Bias1 * rtb_TransferFcn1; |
2173 | |
2174 | /* Integrator: '<S66>/Integrator' */ |
2175 | BMS_B.Integrator_h1 = BMS_X.Integrator_CSTATE_c; |
2176 | if (rtmIsMajorTimeStep(BMS_M)) { |
2177 | } |
2178 | |
2179 | /* Gain: '<S66>/Gain3' */ |
2180 | BMS_B.Gain3_ab = BMS_P.Gain3_Gain_d * rtb_Product_o2; |
2181 | if (rtmIsMajorTimeStep(BMS_M)) { |
2182 | } |
2183 | |
2184 | /* Gain: '<S66>/Gain1' incorporates: |
2185 | * Product: '<S66>/Product' |
2186 | */ |
2187 | BMS_B.Gain1_e = BMS_B.Integrator_h1 * BMS_B.Gain3_ab * BMS_P.Gain1_Gain_m; |
2188 | if (rtmIsMajorTimeStep(BMS_M)) { |
2189 | } |
2190 | |
2191 | /* Gain: '<S66>/Gain' */ |
2192 | BMS_B.Gain_nl = BMS_P.Gain_Gain_gt * BMS_B.Gain1_e; |
2193 | |
2194 | /* Gain: '<S66>/Gain4' incorporates: |
2195 | * Gain: '<S66>/Gain2' |
2196 | * Gain: '<S66>/Gain5' |
2197 | * Product: '<S66>/Product1' |
2198 | * Sum: '<S66>/Sum' |
2199 | * TransferFcn: '<S66>/Transfer Fcn1' |
2200 | */ |
2201 | BMS_B.Gain4_g = (BMS_P.Gain2_Gain_k * rtb_Bias1 - ((BMS_P.TransferFcn1_C_mh[0] |
2202 | * BMS_X.TransferFcn1_CSTATE_bi[0] + BMS_P.TransferFcn1_C_mh[1] * |
2203 | BMS_X.TransferFcn1_CSTATE_bi[1]) + BMS_P.TransferFcn1_C_mh[2] * |
2204 | BMS_X.TransferFcn1_CSTATE_bi[2]) * BMS_B.Integrator_h1 * BMS_P.Gain5_Gain_m) |
2205 | * BMS_P.Gain4_Gain_o; |
2206 | |
2207 | /* Sum: '<S67>/Add2' incorporates: |
2208 | * Inport: '<Root>/T' |
2209 | * Inport: '<Root>/U8' |
2210 | * Lookup_n-D: '<S67>/2-D Lookup Table' |
2211 | * Product: '<S67>/Product1' |
2212 | * Sum: '<S67>/Add1' |
2213 | */ |
2214 | rtb_TransferFcn1 = BMS_U.U8 - (BMS_B.Divide1_i * rtb_Bias2 + look2_binlxpw |
2215 | (BMS_B.Integrator_h, BMS_U.T, BMS_P.uDLookupTable_bp01Data_jd, |
2216 | BMS_P.uDLookupTable_bp02Data_m, BMS_P.uDLookupTable_tableData_e, |
2217 | BMS_P.uDLookupTable_maxIndex_p, 21U)); |
2218 | |
2219 | /* Fcn: '<S69>/abs' incorporates: |
2220 | * Gain: '<S69>/Gain2' |
2221 | */ |
2222 | BMS_B.abs_b = fabs(BMS_P.Gain2_Gain_k5 * rtb_Bias2); |
2223 | |
2224 | /* Lookup_n-D: '<S69>/1-D Lookup Table' incorporates: |
2225 | * Gain: '<S69>/Gain3' |
2226 | * Sum: '<S69>/Add3' |
2227 | * TransferFcn: '<S69>/Transfer Fcn1' |
2228 | */ |
2229 | BMS_B.uDLookupTable_i = look1_binlxpw((((BMS_P.TransferFcn1_C_hm[0] * |
2230 | BMS_X.TransferFcn1_CSTATE_d[0] + BMS_P.TransferFcn1_C_hm[1] * |
2231 | BMS_X.TransferFcn1_CSTATE_d[1]) + BMS_P.TransferFcn1_C_hm[2] * |
2232 | BMS_X.TransferFcn1_CSTATE_d[2]) + BMS_B.abs_b) * BMS_P.Gain3_Gain_ld, |
2233 | BMS_P.uDLookupTable_bp01Data_ht, BMS_P.uDLookupTable_tableData_py, 6U); |
2234 | |
2235 | /* DeadZone: '<S67>/Dead Zone' */ |
2236 | if (rtb_TransferFcn1 > BMS_P.DeadZone_End_hq) { |
2237 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_hq; |
2238 | } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_e) { |
2239 | rtb_Add8 = 0.0; |
2240 | } else { |
2241 | rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_e; |
2242 | } |
2243 | |
2244 | /* End of DeadZone: '<S67>/Dead Zone' */ |
2245 | |
2246 | /* Product: '<S67>/Product' incorporates: |
2247 | * Gain: '<S67>/Gain4' |
2248 | */ |
2249 | rtb_Product_o2 = BMS_P.SOCestimator_gainU_e * BMS_B.uDLookupTable_i * rtb_Add8; |
2250 | |
2251 | /* Gain: '<S67>/Gain' incorporates: |
2252 | * Product: '<S67>/Divide' |
2253 | * Sum: '<S67>/Sum1' |
2254 | */ |
2255 | BMS_B.Gain_iy = (1.0 / BMS_B.Divide_mm * rtb_Bias2 + rtb_Product_o2) * |
2256 | BMS_P.Gain_Gain_oq; |
2257 | |
2258 | /* TransferFcn: '<S70>/Transfer Fcn4' */ |
2259 | BMS_B.TransferFcn4_c = 0.0; |
2260 | BMS_B.TransferFcn4_c += BMS_P.TransferFcn4_C_o[0] * |
2261 | BMS_X.TransferFcn4_CSTATE_mg[0]; |
2262 | BMS_B.TransferFcn4_c += BMS_P.TransferFcn4_C_o[1] * |
2263 | BMS_X.TransferFcn4_CSTATE_mg[1]; |
2264 | BMS_B.TransferFcn4_c += BMS_P.TransferFcn4_C_o[2] * |
2265 | BMS_X.TransferFcn4_CSTATE_mg[2]; |
2266 | |
2267 | /* TransferFcn: '<S70>/Transfer Fcn1' */ |
2268 | rtb_Sqrt = BMS_P.TransferFcn1_C_fv * BMS_X.TransferFcn1_CSTATE_hp + |
2269 | BMS_P.TransferFcn1_D_j * BMS_B.TransferFcn4_c; |
2270 | |
2271 | /* Sqrt: '<S70>/Sqrt' |
2272 | * |
2273 | * About '<S70>/Sqrt': |
2274 | * Operator: signedSqrt |
2275 | */ |
2276 | if (rtb_Sqrt < 0.0) { |
2277 | rtb_Sqrt = -sqrt(fabs(rtb_Sqrt)); |
2278 | } else { |
2279 | rtb_Sqrt = sqrt(rtb_Sqrt); |
2280 | } |
2281 | |
2282 | /* End of Sqrt: '<S70>/Sqrt' */ |
2283 | |
2284 | /* Gain: '<S70>/Gain' */ |
2285 | BMS_B.Gain_bj = BMS_P.Gain_Gain_hw * rtb_Sqrt; |
2286 | |
2287 | /* Product: '<S70>/Product' incorporates: |
2288 | * Gain: '<S70>/Gain1' |
2289 | */ |
2290 | BMS_B.Product_h = BMS_P.Gain1_Gain_c4 * rtb_Bias2 * rtb_TransferFcn1; |
2291 | |
2292 | /* Integrator: '<S71>/Integrator' */ |
2293 | BMS_B.Integrator_n = BMS_X.Integrator_CSTATE_e; |
2294 | if (rtmIsMajorTimeStep(BMS_M)) { |
2295 | } |
2296 | |
2297 | /* Gain: '<S71>/Gain3' */ |
2298 | BMS_B.Gain3_p = BMS_P.Gain3_Gain_os * rtb_Product_o2; |
2299 | if (rtmIsMajorTimeStep(BMS_M)) { |
2300 | } |
2301 | |
2302 | /* Gain: '<S71>/Gain1' incorporates: |
2303 | * Product: '<S71>/Product' |
2304 | */ |
2305 | BMS_B.Gain1_g = BMS_B.Integrator_n * BMS_B.Gain3_p * BMS_P.Gain1_Gain_cc; |
2306 | if (rtmIsMajorTimeStep(BMS_M)) { |
2307 | } |
2308 | |
2309 | /* Gain: '<S71>/Gain' */ |
2310 | BMS_B.Gain_l = BMS_P.Gain_Gain_hf * BMS_B.Gain1_g; |
2311 | |
2312 | /* Gain: '<S71>/Gain4' incorporates: |
2313 | * Gain: '<S71>/Gain2' |
2314 | * Gain: '<S71>/Gain5' |
2315 | * Product: '<S71>/Product1' |
2316 | * Sum: '<S71>/Sum' |
2317 | * TransferFcn: '<S71>/Transfer Fcn1' |
2318 | */ |
2319 | BMS_B.Gain4_c = (BMS_P.Gain2_Gain_ht * rtb_Bias2 - ((BMS_P.TransferFcn1_C_hp[0] |
2320 | * BMS_X.TransferFcn1_CSTATE_ao[0] + BMS_P.TransferFcn1_C_hp[1] * |
2321 | BMS_X.TransferFcn1_CSTATE_ao[1]) + BMS_P.TransferFcn1_C_hp[2] * |
2322 | BMS_X.TransferFcn1_CSTATE_ao[2]) * BMS_B.Integrator_n * BMS_P.Gain5_Gain_c) * |
2323 | BMS_P.Gain4_Gain_ok; |
2324 | |
2325 | /* MATLAB Function: '<S1>/mean' incorporates: |
2326 | * MinMax: '<S1>/MinMax' |
2327 | * SignalConversion generated from: '<S6>/ SFunction ' |
2328 | */ |
2329 | rtb_TransferFcn1 = BMS_B.Integrator; |
2330 | for (sigIdx = 0; sigIdx < 7; sigIdx++) { |
2331 | rtb_TransferFcn1 += tmpForInput_tmp[sigIdx + 1]; |
2332 | } |
2333 | |
2334 | BMS_B.y = rtb_TransferFcn1 / 8.0; |
2335 | } |
2336 | |
2337 | /* Model update function */ |
2338 | void BMS_update(void) |
2339 | { |
2340 | int_T idxDelay; |
2341 | if (rtmIsMajorTimeStep(BMS_M)) { |
2342 | /* Update for Memory: '<Root>/Memory' */ |
2343 | BMS_DW.Memory_PreviousInput = BMS_B.Add2_a; |
2344 | |
2345 | /* Update for Memory: '<Root>/Memory1' */ |
2346 | BMS_DW.Memory1_PreviousInput = BMS_B.Add2; |
2347 | |
2348 | /* Update for Memory: '<Root>/Memory2' */ |
2349 | BMS_DW.Memory2_PreviousInput = BMS_B.Add2_l; |
2350 | |
2351 | /* Update for Memory: '<Root>/Memory3' */ |
2352 | BMS_DW.Memory3_PreviousInput = BMS_B.Add2_c; |
2353 | |
2354 | /* Update for Memory: '<Root>/Memory4' */ |
2355 | BMS_DW.Memory4_PreviousInput = BMS_B.Add2_c2; |
2356 | |
2357 | /* Update for Memory: '<Root>/Memory5' */ |
2358 | BMS_DW.Memory5_PreviousInput = BMS_B.Add2_m; |
2359 | |
2360 | /* Update for Memory: '<Root>/Memory6' */ |
2361 | BMS_DW.Memory6_PreviousInput = BMS_B.Add2_j; |
2362 | |
2363 | /* Update for Memory: '<Root>/Memory7' */ |
2364 | BMS_DW.Memory7_PreviousInput = BMS_B.Add2_h; |
2365 | |
2366 | /* Update for Memory: '<Root>/Memory8' */ |
2367 | BMS_DW.Memory8_PreviousInput = BMS_B.y; |
2368 | |
2369 | /* Update for Memory: '<Root>/Memory10' */ |
2370 | BMS_DW.Memory10_PreviousInput = BMS_B.Product5; |
2371 | for (idxDelay = 0; idxDelay < 9; idxDelay++) { |
2372 | /* Update for Delay: '<S3>/Delay' */ |
2373 | BMS_DW.Delay_DSTATE[idxDelay] = BMS_DW.Delay_DSTATE[idxDelay + 1]; |
2374 | |
2375 | /* Update for Delay: '<S3>/Delay1' */ |
2376 | BMS_DW.Delay1_DSTATE[idxDelay] = BMS_DW.Delay1_DSTATE[idxDelay + 1]; |
2377 | |
2378 | /* Update for Delay: '<S3>/Delay2' */ |
2379 | BMS_DW.Delay2_DSTATE[idxDelay] = BMS_DW.Delay2_DSTATE[idxDelay + 1]; |
2380 | |
2381 | /* Update for Delay: '<S3>/Delay3' */ |
2382 | BMS_DW.Delay3_DSTATE[idxDelay] = BMS_DW.Delay3_DSTATE[idxDelay + 1]; |
2383 | } |
2384 | |
2385 | /* Update for Delay: '<S3>/Delay' */ |
2386 | BMS_DW.Delay_DSTATE[9] = BMS_B.Relay; |
2387 | |
2388 | /* Update for Delay: '<S3>/Delay1' */ |
2389 | BMS_DW.Delay1_DSTATE[9] = BMS_B.Relay1; |
2390 | |
2391 | /* Update for Delay: '<S3>/Delay2' */ |
2392 | BMS_DW.Delay2_DSTATE[9] = BMS_B.Relay2; |
2393 | |
2394 | /* Update for Delay: '<S3>/Delay3' */ |
2395 | BMS_DW.Delay3_DSTATE[9] = BMS_B.Relay3; |
2396 | } |
2397 | |
2398 | /* signal main to stop simulation */ |
2399 | { /* Sample time: [0.0s, 0.0s] */ |
2400 | if ((rtmGetTFinal(BMS_M)!=-1) && |
2401 | !((rtmGetTFinal(BMS_M)-(((BMS_M->Timing.clockTick1+ |
2402 | BMS_M->Timing.clockTickH1* 4294967296.0)) * 0.0005)) > |
2403 | (((BMS_M->Timing.clockTick1+BMS_M->Timing.clockTickH1* 4294967296.0)) * |
2404 | 0.0005) * (DBL_EPSILON))) { |
2405 | rtmSetErrorStatus(BMS_M, "Simulation finished"); |
2406 | } |
2407 | } |
2408 | |
2409 | if (rtmIsMajorTimeStep(BMS_M)) { |
2410 | rt_ertODEUpdateContinuousStates(&BMS_M->solverInfo); |
2411 | } |
2412 | |
2413 | /* Update absolute time for base rate */ |
2414 | /* The "clockTick0" counts the number of times the code of this task has |
2415 | * been executed. The absolute time is the multiplication of "clockTick0" |
2416 | * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not |
2417 | * overflow during the application lifespan selected. |
2418 | * Timer of this task consists of two 32 bit unsigned integers. |
2419 | * The two integers represent the low bits Timing.clockTick0 and the high bits |
2420 | * Timing.clockTickH0. When the low bit overflows to 0, the high bits increment. |
2421 | */ |
2422 | if (!(++BMS_M->Timing.clockTick0)) { |
2423 | ++BMS_M->Timing.clockTickH0; |
2424 | } |
2425 | |
2426 | BMS_M->Timing.t[0] = rtsiGetSolverStopTime(&BMS_M->solverInfo); |
2427 | |
2428 | { |
2429 | /* Update absolute timer for sample time: [0.0005s, 0.0s] */ |
2430 | /* The "clockTick1" counts the number of times the code of this task has |
2431 | * been executed. The resolution of this integer timer is 0.0005, which is the step size |
2432 | * of the task. Size of "clockTick1" ensures timer will not overflow during the |
2433 | * application lifespan selected. |
2434 | * Timer of this task consists of two 32 bit unsigned integers. |
2435 | * The two integers represent the low bits Timing.clockTick1 and the high bits |
2436 | * Timing.clockTickH1. When the low bit overflows to 0, the high bits increment. |
2437 | */ |
2438 | BMS_M->Timing.clockTick1++; |
2439 | if (!BMS_M->Timing.clockTick1) { |
2440 | BMS_M->Timing.clockTickH1++; |
2441 | } |
2442 | } |
2443 | } |
2444 | |
2445 | /* Derivatives for root system: '<Root>' */ |
2446 | void BMS_derivatives(void) |
2447 | { |
2448 | XDot_BMS_T *_rtXdot; |
2449 | _rtXdot = ((XDot_BMS_T *) BMS_M->derivs); |
2450 | |
2451 | /* Derivatives for Integrator: '<S32>/Integrator' */ |
2452 | _rtXdot->Integrator_CSTATE = BMS_B.Gain_p; |
2453 | |
2454 | /* Derivatives for Integrator: '<S37>/Integrator' */ |
2455 | _rtXdot->Integrator_CSTATE_k = BMS_B.Gain_k; |
2456 | |
2457 | /* Derivatives for Integrator: '<S42>/Integrator' */ |
2458 | _rtXdot->Integrator_CSTATE_g = BMS_B.Gain_db; |
2459 | |
2460 | /* Derivatives for Integrator: '<S47>/Integrator' */ |
2461 | _rtXdot->Integrator_CSTATE_f = BMS_B.Gain_pt; |
2462 | |
2463 | /* Derivatives for Integrator: '<S52>/Integrator' */ |
2464 | _rtXdot->Integrator_CSTATE_h = BMS_B.Gain_nb; |
2465 | |
2466 | /* Derivatives for Integrator: '<S57>/Integrator' */ |
2467 | _rtXdot->Integrator_CSTATE_a = BMS_B.Gain_n1; |
2468 | |
2469 | /* Derivatives for Integrator: '<S62>/Integrator' */ |
2470 | _rtXdot->Integrator_CSTATE_n = BMS_B.Gain_i; |
2471 | |
2472 | /* Derivatives for Integrator: '<S67>/Integrator' */ |
2473 | _rtXdot->Integrator_CSTATE_b = BMS_B.Gain_iy; |
2474 | |
2475 | /* Derivatives for Integrator: '<S33>/Integrator6' */ |
2476 | _rtXdot->Integrator6_CSTATE = BMS_B.Gain_e; |
2477 | |
2478 | /* Derivatives for Integrator: '<S38>/Integrator6' */ |
2479 | _rtXdot->Integrator6_CSTATE_h = BMS_B.Gain_n; |
2480 | |
2481 | /* Derivatives for Integrator: '<S43>/Integrator6' */ |
2482 | _rtXdot->Integrator6_CSTATE_d = BMS_B.Gain_f; |
2483 | |
2484 | /* Derivatives for Integrator: '<S48>/Integrator6' */ |
2485 | _rtXdot->Integrator6_CSTATE_g = BMS_B.Gain_nj; |
2486 | |
2487 | /* Derivatives for Integrator: '<S53>/Integrator6' */ |
2488 | _rtXdot->Integrator6_CSTATE_a = BMS_B.Gain_nu; |
2489 | |
2490 | /* Derivatives for Integrator: '<S58>/Integrator6' */ |
2491 | _rtXdot->Integrator6_CSTATE_f = BMS_B.Gain_kp; |
2492 | |
2493 | /* Derivatives for Integrator: '<S63>/Integrator6' */ |
2494 | _rtXdot->Integrator6_CSTATE_hq = BMS_B.Gain_nl; |
2495 | |
2496 | /* Derivatives for Integrator: '<S68>/Integrator6' */ |
2497 | _rtXdot->Integrator6_CSTATE_b = BMS_B.Gain_l; |
2498 | |
2499 | /* Derivatives for Integrator: '<S33>/Integrator3' */ |
2500 | _rtXdot->Integrator3_CSTATE = BMS_B.Gain_d; |
2501 | |
2502 | /* Derivatives for Integrator: '<S38>/Integrator3' */ |
2503 | _rtXdot->Integrator3_CSTATE_i = BMS_B.Gain_c; |
2504 | |
2505 | /* Derivatives for Integrator: '<S43>/Integrator3' */ |
2506 | _rtXdot->Integrator3_CSTATE_h = BMS_B.Gain_h; |
2507 | |
2508 | /* Derivatives for Integrator: '<S48>/Integrator3' */ |
2509 | _rtXdot->Integrator3_CSTATE_hr = BMS_B.Gain_b; |
2510 | |
2511 | /* Derivatives for Integrator: '<S53>/Integrator3' */ |
2512 | _rtXdot->Integrator3_CSTATE_d = BMS_B.Gain_pg; |
2513 | |
2514 | /* Derivatives for Integrator: '<S58>/Integrator3' */ |
2515 | _rtXdot->Integrator3_CSTATE_f = BMS_B.Gain_f1; |
2516 | |
2517 | /* Derivatives for Integrator: '<S63>/Integrator3' */ |
2518 | _rtXdot->Integrator3_CSTATE_dt = BMS_B.Gain_j; |
2519 | |
2520 | /* Derivatives for Integrator: '<S68>/Integrator3' */ |
2521 | _rtXdot->Integrator3_CSTATE_o = BMS_B.Gain_bj; |
2522 | |
2523 | /* Derivatives for TransferFcn: '<S34>/Transfer Fcn1' */ |
2524 | _rtXdot->TransferFcn1_CSTATE[0] = 0.0; |
2525 | _rtXdot->TransferFcn1_CSTATE[0] += BMS_P.TransferFcn1_A[0] * |
2526 | BMS_X.TransferFcn1_CSTATE[0]; |
2527 | _rtXdot->TransferFcn1_CSTATE[1] = 0.0; |
2528 | _rtXdot->TransferFcn1_CSTATE[0] += BMS_P.TransferFcn1_A[1] * |
2529 | BMS_X.TransferFcn1_CSTATE[1]; |
2530 | _rtXdot->TransferFcn1_CSTATE[2] = 0.0; |
2531 | _rtXdot->TransferFcn1_CSTATE[0] += BMS_P.TransferFcn1_A[2] * |
2532 | BMS_X.TransferFcn1_CSTATE[2]; |
2533 | _rtXdot->TransferFcn1_CSTATE[1] += BMS_X.TransferFcn1_CSTATE[0]; |
2534 | _rtXdot->TransferFcn1_CSTATE[2] += BMS_X.TransferFcn1_CSTATE[1]; |
2535 | _rtXdot->TransferFcn1_CSTATE[0] += BMS_B.abs_p; |
2536 | |
2537 | /* Derivatives for TransferFcn: '<S35>/Transfer Fcn4' */ |
2538 | _rtXdot->TransferFcn4_CSTATE[0] = 0.0; |
2539 | _rtXdot->TransferFcn4_CSTATE[0] += BMS_P.TransferFcn4_A[0] * |
2540 | BMS_X.TransferFcn4_CSTATE[0]; |
2541 | _rtXdot->TransferFcn4_CSTATE[1] = 0.0; |
2542 | _rtXdot->TransferFcn4_CSTATE[0] += BMS_P.TransferFcn4_A[1] * |
2543 | BMS_X.TransferFcn4_CSTATE[1]; |
2544 | _rtXdot->TransferFcn4_CSTATE[2] = 0.0; |
2545 | _rtXdot->TransferFcn4_CSTATE[0] += BMS_P.TransferFcn4_A[2] * |
2546 | BMS_X.TransferFcn4_CSTATE[2]; |
2547 | _rtXdot->TransferFcn4_CSTATE[1] += BMS_X.TransferFcn4_CSTATE[0]; |
2548 | _rtXdot->TransferFcn4_CSTATE[2] += BMS_X.TransferFcn4_CSTATE[1]; |
2549 | _rtXdot->TransferFcn4_CSTATE[0] += BMS_B.Product; |
2550 | |
2551 | /* Derivatives for TransferFcn: '<S35>/Transfer Fcn1' */ |
2552 | _rtXdot->TransferFcn1_CSTATE_j = 0.0; |
2553 | _rtXdot->TransferFcn1_CSTATE_j += BMS_P.TransferFcn1_A_k * |
2554 | BMS_X.TransferFcn1_CSTATE_j; |
2555 | _rtXdot->TransferFcn1_CSTATE_j += BMS_B.TransferFcn4; |
2556 | |
2557 | /* Derivatives for Integrator: '<S36>/Integrator' */ |
2558 | _rtXdot->Integrator_CSTATE_n5 = BMS_B.Gain4_h; |
2559 | |
2560 | /* Derivatives for TransferFcn: '<S36>/Transfer Fcn1' */ |
2561 | _rtXdot->TransferFcn1_CSTATE_a[0] = 0.0; |
2562 | _rtXdot->TransferFcn1_CSTATE_a[0] += BMS_P.TransferFcn1_A_j[0] * |
2563 | BMS_X.TransferFcn1_CSTATE_a[0]; |
2564 | _rtXdot->TransferFcn1_CSTATE_a[1] = 0.0; |
2565 | _rtXdot->TransferFcn1_CSTATE_a[0] += BMS_P.TransferFcn1_A_j[1] * |
2566 | BMS_X.TransferFcn1_CSTATE_a[1]; |
2567 | _rtXdot->TransferFcn1_CSTATE_a[2] = 0.0; |
2568 | _rtXdot->TransferFcn1_CSTATE_a[0] += BMS_P.TransferFcn1_A_j[2] * |
2569 | BMS_X.TransferFcn1_CSTATE_a[2]; |
2570 | _rtXdot->TransferFcn1_CSTATE_a[1] += BMS_X.TransferFcn1_CSTATE_a[0]; |
2571 | _rtXdot->TransferFcn1_CSTATE_a[2] += BMS_X.TransferFcn1_CSTATE_a[1]; |
2572 | _rtXdot->TransferFcn1_CSTATE_a[0] += BMS_B.uDLookupTable; |
2573 | |
2574 | /* Derivatives for TransferFcn: '<S39>/Transfer Fcn1' */ |
2575 | _rtXdot->TransferFcn1_CSTATE_l[0] = 0.0; |
2576 | _rtXdot->TransferFcn1_CSTATE_l[0] += BMS_P.TransferFcn1_A_b[0] * |
2577 | BMS_X.TransferFcn1_CSTATE_l[0]; |
2578 | _rtXdot->TransferFcn1_CSTATE_l[1] = 0.0; |
2579 | _rtXdot->TransferFcn1_CSTATE_l[0] += BMS_P.TransferFcn1_A_b[1] * |
2580 | BMS_X.TransferFcn1_CSTATE_l[1]; |
2581 | _rtXdot->TransferFcn1_CSTATE_l[2] = 0.0; |
2582 | _rtXdot->TransferFcn1_CSTATE_l[0] += BMS_P.TransferFcn1_A_b[2] * |
2583 | BMS_X.TransferFcn1_CSTATE_l[2]; |
2584 | _rtXdot->TransferFcn1_CSTATE_l[1] += BMS_X.TransferFcn1_CSTATE_l[0]; |
2585 | _rtXdot->TransferFcn1_CSTATE_l[2] += BMS_X.TransferFcn1_CSTATE_l[1]; |
2586 | _rtXdot->TransferFcn1_CSTATE_l[0] += BMS_B.abs_j; |
2587 | |
2588 | /* Derivatives for TransferFcn: '<S40>/Transfer Fcn4' */ |
2589 | _rtXdot->TransferFcn4_CSTATE_e[0] = 0.0; |
2590 | _rtXdot->TransferFcn4_CSTATE_e[0] += BMS_P.TransferFcn4_A_h[0] * |
2591 | BMS_X.TransferFcn4_CSTATE_e[0]; |
2592 | _rtXdot->TransferFcn4_CSTATE_e[1] = 0.0; |
2593 | _rtXdot->TransferFcn4_CSTATE_e[0] += BMS_P.TransferFcn4_A_h[1] * |
2594 | BMS_X.TransferFcn4_CSTATE_e[1]; |
2595 | _rtXdot->TransferFcn4_CSTATE_e[2] = 0.0; |
2596 | _rtXdot->TransferFcn4_CSTATE_e[0] += BMS_P.TransferFcn4_A_h[2] * |
2597 | BMS_X.TransferFcn4_CSTATE_e[2]; |
2598 | _rtXdot->TransferFcn4_CSTATE_e[1] += BMS_X.TransferFcn4_CSTATE_e[0]; |
2599 | _rtXdot->TransferFcn4_CSTATE_e[2] += BMS_X.TransferFcn4_CSTATE_e[1]; |
2600 | _rtXdot->TransferFcn4_CSTATE_e[0] += BMS_B.Product_c; |
2601 | |
2602 | /* Derivatives for TransferFcn: '<S40>/Transfer Fcn1' */ |
2603 | _rtXdot->TransferFcn1_CSTATE_g = 0.0; |
2604 | _rtXdot->TransferFcn1_CSTATE_g += BMS_P.TransferFcn1_A_p * |
2605 | BMS_X.TransferFcn1_CSTATE_g; |
2606 | _rtXdot->TransferFcn1_CSTATE_g += BMS_B.TransferFcn4_h; |
2607 | |
2608 | /* Derivatives for Integrator: '<S41>/Integrator' */ |
2609 | _rtXdot->Integrator_CSTATE_nm = BMS_B.Gain4_k; |
2610 | |
2611 | /* Derivatives for TransferFcn: '<S41>/Transfer Fcn1' */ |
2612 | _rtXdot->TransferFcn1_CSTATE_b[0] = 0.0; |
2613 | _rtXdot->TransferFcn1_CSTATE_b[0] += BMS_P.TransferFcn1_A_f[0] * |
2614 | BMS_X.TransferFcn1_CSTATE_b[0]; |
2615 | _rtXdot->TransferFcn1_CSTATE_b[1] = 0.0; |
2616 | _rtXdot->TransferFcn1_CSTATE_b[0] += BMS_P.TransferFcn1_A_f[1] * |
2617 | BMS_X.TransferFcn1_CSTATE_b[1]; |
2618 | _rtXdot->TransferFcn1_CSTATE_b[2] = 0.0; |
2619 | _rtXdot->TransferFcn1_CSTATE_b[0] += BMS_P.TransferFcn1_A_f[2] * |
2620 | BMS_X.TransferFcn1_CSTATE_b[2]; |
2621 | _rtXdot->TransferFcn1_CSTATE_b[1] += BMS_X.TransferFcn1_CSTATE_b[0]; |
2622 | _rtXdot->TransferFcn1_CSTATE_b[2] += BMS_X.TransferFcn1_CSTATE_b[1]; |
2623 | _rtXdot->TransferFcn1_CSTATE_b[0] += BMS_B.uDLookupTable_b; |
2624 | |
2625 | /* Derivatives for TransferFcn: '<S44>/Transfer Fcn1' */ |
2626 | _rtXdot->TransferFcn1_CSTATE_c[0] = 0.0; |
2627 | _rtXdot->TransferFcn1_CSTATE_c[0] += BMS_P.TransferFcn1_A_pq[0] * |
2628 | BMS_X.TransferFcn1_CSTATE_c[0]; |
2629 | _rtXdot->TransferFcn1_CSTATE_c[1] = 0.0; |
2630 | _rtXdot->TransferFcn1_CSTATE_c[0] += BMS_P.TransferFcn1_A_pq[1] * |
2631 | BMS_X.TransferFcn1_CSTATE_c[1]; |
2632 | _rtXdot->TransferFcn1_CSTATE_c[2] = 0.0; |
2633 | _rtXdot->TransferFcn1_CSTATE_c[0] += BMS_P.TransferFcn1_A_pq[2] * |
2634 | BMS_X.TransferFcn1_CSTATE_c[2]; |
2635 | _rtXdot->TransferFcn1_CSTATE_c[1] += BMS_X.TransferFcn1_CSTATE_c[0]; |
2636 | _rtXdot->TransferFcn1_CSTATE_c[2] += BMS_X.TransferFcn1_CSTATE_c[1]; |
2637 | _rtXdot->TransferFcn1_CSTATE_c[0] += BMS_B.abs_e; |
2638 | |
2639 | /* Derivatives for TransferFcn: '<S45>/Transfer Fcn4' */ |
2640 | _rtXdot->TransferFcn4_CSTATE_h[0] = 0.0; |
2641 | _rtXdot->TransferFcn4_CSTATE_h[0] += BMS_P.TransferFcn4_A_a[0] * |
2642 | BMS_X.TransferFcn4_CSTATE_h[0]; |
2643 | _rtXdot->TransferFcn4_CSTATE_h[1] = 0.0; |
2644 | _rtXdot->TransferFcn4_CSTATE_h[0] += BMS_P.TransferFcn4_A_a[1] * |
2645 | BMS_X.TransferFcn4_CSTATE_h[1]; |
2646 | _rtXdot->TransferFcn4_CSTATE_h[2] = 0.0; |
2647 | _rtXdot->TransferFcn4_CSTATE_h[0] += BMS_P.TransferFcn4_A_a[2] * |
2648 | BMS_X.TransferFcn4_CSTATE_h[2]; |
2649 | _rtXdot->TransferFcn4_CSTATE_h[1] += BMS_X.TransferFcn4_CSTATE_h[0]; |
2650 | _rtXdot->TransferFcn4_CSTATE_h[2] += BMS_X.TransferFcn4_CSTATE_h[1]; |
2651 | _rtXdot->TransferFcn4_CSTATE_h[0] += BMS_B.Product_e; |
2652 | |
2653 | /* Derivatives for TransferFcn: '<S45>/Transfer Fcn1' */ |
2654 | _rtXdot->TransferFcn1_CSTATE_f = 0.0; |
2655 | _rtXdot->TransferFcn1_CSTATE_f += BMS_P.TransferFcn1_A_g * |
2656 | BMS_X.TransferFcn1_CSTATE_f; |
2657 | _rtXdot->TransferFcn1_CSTATE_f += BMS_B.TransferFcn4_o; |
2658 | |
2659 | /* Derivatives for Integrator: '<S46>/Integrator' */ |
2660 | _rtXdot->Integrator_CSTATE_kc = BMS_B.Gain4_i; |
2661 | |
2662 | /* Derivatives for TransferFcn: '<S46>/Transfer Fcn1' */ |
2663 | _rtXdot->TransferFcn1_CSTATE_n[0] = 0.0; |
2664 | _rtXdot->TransferFcn1_CSTATE_n[0] += BMS_P.TransferFcn1_A_h[0] * |
2665 | BMS_X.TransferFcn1_CSTATE_n[0]; |
2666 | _rtXdot->TransferFcn1_CSTATE_n[1] = 0.0; |
2667 | _rtXdot->TransferFcn1_CSTATE_n[0] += BMS_P.TransferFcn1_A_h[1] * |
2668 | BMS_X.TransferFcn1_CSTATE_n[1]; |
2669 | _rtXdot->TransferFcn1_CSTATE_n[2] = 0.0; |
2670 | _rtXdot->TransferFcn1_CSTATE_n[0] += BMS_P.TransferFcn1_A_h[2] * |
2671 | BMS_X.TransferFcn1_CSTATE_n[2]; |
2672 | _rtXdot->TransferFcn1_CSTATE_n[1] += BMS_X.TransferFcn1_CSTATE_n[0]; |
2673 | _rtXdot->TransferFcn1_CSTATE_n[2] += BMS_X.TransferFcn1_CSTATE_n[1]; |
2674 | _rtXdot->TransferFcn1_CSTATE_n[0] += BMS_B.uDLookupTable_f; |
2675 | |
2676 | /* Derivatives for TransferFcn: '<S49>/Transfer Fcn1' */ |
2677 | _rtXdot->TransferFcn1_CSTATE_am[0] = 0.0; |
2678 | _rtXdot->TransferFcn1_CSTATE_am[0] += BMS_P.TransferFcn1_A_n[0] * |
2679 | BMS_X.TransferFcn1_CSTATE_am[0]; |
2680 | _rtXdot->TransferFcn1_CSTATE_am[1] = 0.0; |
2681 | _rtXdot->TransferFcn1_CSTATE_am[0] += BMS_P.TransferFcn1_A_n[1] * |
2682 | BMS_X.TransferFcn1_CSTATE_am[1]; |
2683 | _rtXdot->TransferFcn1_CSTATE_am[2] = 0.0; |
2684 | _rtXdot->TransferFcn1_CSTATE_am[0] += BMS_P.TransferFcn1_A_n[2] * |
2685 | BMS_X.TransferFcn1_CSTATE_am[2]; |
2686 | _rtXdot->TransferFcn1_CSTATE_am[1] += BMS_X.TransferFcn1_CSTATE_am[0]; |
2687 | _rtXdot->TransferFcn1_CSTATE_am[2] += BMS_X.TransferFcn1_CSTATE_am[1]; |
2688 | _rtXdot->TransferFcn1_CSTATE_am[0] += BMS_B.abs_d; |
2689 | |
2690 | /* Derivatives for TransferFcn: '<S50>/Transfer Fcn4' */ |
2691 | _rtXdot->TransferFcn4_CSTATE_m[0] = 0.0; |
2692 | _rtXdot->TransferFcn4_CSTATE_m[0] += BMS_P.TransferFcn4_A_i[0] * |
2693 | BMS_X.TransferFcn4_CSTATE_m[0]; |
2694 | _rtXdot->TransferFcn4_CSTATE_m[1] = 0.0; |
2695 | _rtXdot->TransferFcn4_CSTATE_m[0] += BMS_P.TransferFcn4_A_i[1] * |
2696 | BMS_X.TransferFcn4_CSTATE_m[1]; |
2697 | _rtXdot->TransferFcn4_CSTATE_m[2] = 0.0; |
2698 | _rtXdot->TransferFcn4_CSTATE_m[0] += BMS_P.TransferFcn4_A_i[2] * |
2699 | BMS_X.TransferFcn4_CSTATE_m[2]; |
2700 | _rtXdot->TransferFcn4_CSTATE_m[1] += BMS_X.TransferFcn4_CSTATE_m[0]; |
2701 | _rtXdot->TransferFcn4_CSTATE_m[2] += BMS_X.TransferFcn4_CSTATE_m[1]; |
2702 | _rtXdot->TransferFcn4_CSTATE_m[0] += BMS_B.Product_b; |
2703 | |
2704 | /* Derivatives for TransferFcn: '<S50>/Transfer Fcn1' */ |
2705 | _rtXdot->TransferFcn1_CSTATE_c1 = 0.0; |
2706 | _rtXdot->TransferFcn1_CSTATE_c1 += BMS_P.TransferFcn1_A_bo * |
2707 | BMS_X.TransferFcn1_CSTATE_c1; |
2708 | _rtXdot->TransferFcn1_CSTATE_c1 += BMS_B.TransferFcn4_d; |
2709 | |
2710 | /* Derivatives for Integrator: '<S51>/Integrator' */ |
2711 | _rtXdot->Integrator_CSTATE_fh = BMS_B.Gain4_l; |
2712 | |
2713 | /* Derivatives for TransferFcn: '<S51>/Transfer Fcn1' */ |
2714 | _rtXdot->TransferFcn1_CSTATE_ff[0] = 0.0; |
2715 | _rtXdot->TransferFcn1_CSTATE_ff[0] += BMS_P.TransferFcn1_A_e[0] * |
2716 | BMS_X.TransferFcn1_CSTATE_ff[0]; |
2717 | _rtXdot->TransferFcn1_CSTATE_ff[1] = 0.0; |
2718 | _rtXdot->TransferFcn1_CSTATE_ff[0] += BMS_P.TransferFcn1_A_e[1] * |
2719 | BMS_X.TransferFcn1_CSTATE_ff[1]; |
2720 | _rtXdot->TransferFcn1_CSTATE_ff[2] = 0.0; |
2721 | _rtXdot->TransferFcn1_CSTATE_ff[0] += BMS_P.TransferFcn1_A_e[2] * |
2722 | BMS_X.TransferFcn1_CSTATE_ff[2]; |
2723 | _rtXdot->TransferFcn1_CSTATE_ff[1] += BMS_X.TransferFcn1_CSTATE_ff[0]; |
2724 | _rtXdot->TransferFcn1_CSTATE_ff[2] += BMS_X.TransferFcn1_CSTATE_ff[1]; |
2725 | _rtXdot->TransferFcn1_CSTATE_ff[0] += BMS_B.uDLookupTable_h; |
2726 | |
2727 | /* Derivatives for TransferFcn: '<S54>/Transfer Fcn1' */ |
2728 | _rtXdot->TransferFcn1_CSTATE_o[0] = 0.0; |
2729 | _rtXdot->TransferFcn1_CSTATE_o[0] += BMS_P.TransferFcn1_A_k2[0] * |
2730 | BMS_X.TransferFcn1_CSTATE_o[0]; |
2731 | _rtXdot->TransferFcn1_CSTATE_o[1] = 0.0; |
2732 | _rtXdot->TransferFcn1_CSTATE_o[0] += BMS_P.TransferFcn1_A_k2[1] * |
2733 | BMS_X.TransferFcn1_CSTATE_o[1]; |
2734 | _rtXdot->TransferFcn1_CSTATE_o[2] = 0.0; |
2735 | _rtXdot->TransferFcn1_CSTATE_o[0] += BMS_P.TransferFcn1_A_k2[2] * |
2736 | BMS_X.TransferFcn1_CSTATE_o[2]; |
2737 | _rtXdot->TransferFcn1_CSTATE_o[1] += BMS_X.TransferFcn1_CSTATE_o[0]; |
2738 | _rtXdot->TransferFcn1_CSTATE_o[2] += BMS_X.TransferFcn1_CSTATE_o[1]; |
2739 | _rtXdot->TransferFcn1_CSTATE_o[0] += BMS_B.abs_m; |
2740 | |
2741 | /* Derivatives for TransferFcn: '<S55>/Transfer Fcn4' */ |
2742 | _rtXdot->TransferFcn4_CSTATE_e1[0] = 0.0; |
2743 | _rtXdot->TransferFcn4_CSTATE_e1[0] += BMS_P.TransferFcn4_A_a2[0] * |
2744 | BMS_X.TransferFcn4_CSTATE_e1[0]; |
2745 | _rtXdot->TransferFcn4_CSTATE_e1[1] = 0.0; |
2746 | _rtXdot->TransferFcn4_CSTATE_e1[0] += BMS_P.TransferFcn4_A_a2[1] * |
2747 | BMS_X.TransferFcn4_CSTATE_e1[1]; |
2748 | _rtXdot->TransferFcn4_CSTATE_e1[2] = 0.0; |
2749 | _rtXdot->TransferFcn4_CSTATE_e1[0] += BMS_P.TransferFcn4_A_a2[2] * |
2750 | BMS_X.TransferFcn4_CSTATE_e1[2]; |
2751 | _rtXdot->TransferFcn4_CSTATE_e1[1] += BMS_X.TransferFcn4_CSTATE_e1[0]; |
2752 | _rtXdot->TransferFcn4_CSTATE_e1[2] += BMS_X.TransferFcn4_CSTATE_e1[1]; |
2753 | _rtXdot->TransferFcn4_CSTATE_e1[0] += BMS_B.Product_k; |
2754 | |
2755 | /* Derivatives for TransferFcn: '<S55>/Transfer Fcn1' */ |
2756 | _rtXdot->TransferFcn1_CSTATE_e = 0.0; |
2757 | _rtXdot->TransferFcn1_CSTATE_e += BMS_P.TransferFcn1_A_i * |
2758 | BMS_X.TransferFcn1_CSTATE_e; |
2759 | _rtXdot->TransferFcn1_CSTATE_e += BMS_B.TransferFcn4_j; |
2760 | |
2761 | /* Derivatives for Integrator: '<S56>/Integrator' */ |
2762 | _rtXdot->Integrator_CSTATE_l = BMS_B.Gain4_d; |
2763 | |
2764 | /* Derivatives for TransferFcn: '<S56>/Transfer Fcn1' */ |
2765 | _rtXdot->TransferFcn1_CSTATE_gz[0] = 0.0; |
2766 | _rtXdot->TransferFcn1_CSTATE_gz[0] += BMS_P.TransferFcn1_A_gz[0] * |
2767 | BMS_X.TransferFcn1_CSTATE_gz[0]; |
2768 | _rtXdot->TransferFcn1_CSTATE_gz[1] = 0.0; |
2769 | _rtXdot->TransferFcn1_CSTATE_gz[0] += BMS_P.TransferFcn1_A_gz[1] * |
2770 | BMS_X.TransferFcn1_CSTATE_gz[1]; |
2771 | _rtXdot->TransferFcn1_CSTATE_gz[2] = 0.0; |
2772 | _rtXdot->TransferFcn1_CSTATE_gz[0] += BMS_P.TransferFcn1_A_gz[2] * |
2773 | BMS_X.TransferFcn1_CSTATE_gz[2]; |
2774 | _rtXdot->TransferFcn1_CSTATE_gz[1] += BMS_X.TransferFcn1_CSTATE_gz[0]; |
2775 | _rtXdot->TransferFcn1_CSTATE_gz[2] += BMS_X.TransferFcn1_CSTATE_gz[1]; |
2776 | _rtXdot->TransferFcn1_CSTATE_gz[0] += BMS_B.uDLookupTable_hx; |
2777 | |
2778 | /* Derivatives for TransferFcn: '<S59>/Transfer Fcn1' */ |
2779 | _rtXdot->TransferFcn1_CSTATE_h[0] = 0.0; |
2780 | _rtXdot->TransferFcn1_CSTATE_h[0] += BMS_P.TransferFcn1_A_hj[0] * |
2781 | BMS_X.TransferFcn1_CSTATE_h[0]; |
2782 | _rtXdot->TransferFcn1_CSTATE_h[1] = 0.0; |
2783 | _rtXdot->TransferFcn1_CSTATE_h[0] += BMS_P.TransferFcn1_A_hj[1] * |
2784 | BMS_X.TransferFcn1_CSTATE_h[1]; |
2785 | _rtXdot->TransferFcn1_CSTATE_h[2] = 0.0; |
2786 | _rtXdot->TransferFcn1_CSTATE_h[0] += BMS_P.TransferFcn1_A_hj[2] * |
2787 | BMS_X.TransferFcn1_CSTATE_h[2]; |
2788 | _rtXdot->TransferFcn1_CSTATE_h[1] += BMS_X.TransferFcn1_CSTATE_h[0]; |
2789 | _rtXdot->TransferFcn1_CSTATE_h[2] += BMS_X.TransferFcn1_CSTATE_h[1]; |
2790 | _rtXdot->TransferFcn1_CSTATE_h[0] += BMS_B.abs_jn; |
2791 | |
2792 | /* Derivatives for TransferFcn: '<S60>/Transfer Fcn4' */ |
2793 | _rtXdot->TransferFcn4_CSTATE_eg[0] = 0.0; |
2794 | _rtXdot->TransferFcn4_CSTATE_eg[0] += BMS_P.TransferFcn4_A_j[0] * |
2795 | BMS_X.TransferFcn4_CSTATE_eg[0]; |
2796 | _rtXdot->TransferFcn4_CSTATE_eg[1] = 0.0; |
2797 | _rtXdot->TransferFcn4_CSTATE_eg[0] += BMS_P.TransferFcn4_A_j[1] * |
2798 | BMS_X.TransferFcn4_CSTATE_eg[1]; |
2799 | _rtXdot->TransferFcn4_CSTATE_eg[2] = 0.0; |
2800 | _rtXdot->TransferFcn4_CSTATE_eg[0] += BMS_P.TransferFcn4_A_j[2] * |
2801 | BMS_X.TransferFcn4_CSTATE_eg[2]; |
2802 | _rtXdot->TransferFcn4_CSTATE_eg[1] += BMS_X.TransferFcn4_CSTATE_eg[0]; |
2803 | _rtXdot->TransferFcn4_CSTATE_eg[2] += BMS_X.TransferFcn4_CSTATE_eg[1]; |
2804 | _rtXdot->TransferFcn4_CSTATE_eg[0] += BMS_B.Product_d; |
2805 | |
2806 | /* Derivatives for TransferFcn: '<S60>/Transfer Fcn1' */ |
2807 | _rtXdot->TransferFcn1_CSTATE_p = 0.0; |
2808 | _rtXdot->TransferFcn1_CSTATE_p += BMS_P.TransferFcn1_A_ii * |
2809 | BMS_X.TransferFcn1_CSTATE_p; |
2810 | _rtXdot->TransferFcn1_CSTATE_p += BMS_B.TransferFcn4_a; |
2811 | |
2812 | /* Derivatives for Integrator: '<S61>/Integrator' */ |
2813 | _rtXdot->Integrator_CSTATE_fq = BMS_B.Gain4_hb; |
2814 | |
2815 | /* Derivatives for TransferFcn: '<S61>/Transfer Fcn1' */ |
2816 | _rtXdot->TransferFcn1_CSTATE_p5[0] = 0.0; |
2817 | _rtXdot->TransferFcn1_CSTATE_p5[0] += BMS_P.TransferFcn1_A_he[0] * |
2818 | BMS_X.TransferFcn1_CSTATE_p5[0]; |
2819 | _rtXdot->TransferFcn1_CSTATE_p5[1] = 0.0; |
2820 | _rtXdot->TransferFcn1_CSTATE_p5[0] += BMS_P.TransferFcn1_A_he[1] * |
2821 | BMS_X.TransferFcn1_CSTATE_p5[1]; |
2822 | _rtXdot->TransferFcn1_CSTATE_p5[2] = 0.0; |
2823 | _rtXdot->TransferFcn1_CSTATE_p5[0] += BMS_P.TransferFcn1_A_he[2] * |
2824 | BMS_X.TransferFcn1_CSTATE_p5[2]; |
2825 | _rtXdot->TransferFcn1_CSTATE_p5[1] += BMS_X.TransferFcn1_CSTATE_p5[0]; |
2826 | _rtXdot->TransferFcn1_CSTATE_p5[2] += BMS_X.TransferFcn1_CSTATE_p5[1]; |
2827 | _rtXdot->TransferFcn1_CSTATE_p5[0] += BMS_B.uDLookupTable_e; |
2828 | |
2829 | /* Derivatives for TransferFcn: '<S64>/Transfer Fcn1' */ |
2830 | _rtXdot->TransferFcn1_CSTATE_op[0] = 0.0; |
2831 | _rtXdot->TransferFcn1_CSTATE_op[0] += BMS_P.TransferFcn1_A_nn[0] * |
2832 | BMS_X.TransferFcn1_CSTATE_op[0]; |
2833 | _rtXdot->TransferFcn1_CSTATE_op[1] = 0.0; |
2834 | _rtXdot->TransferFcn1_CSTATE_op[0] += BMS_P.TransferFcn1_A_nn[1] * |
2835 | BMS_X.TransferFcn1_CSTATE_op[1]; |
2836 | _rtXdot->TransferFcn1_CSTATE_op[2] = 0.0; |
2837 | _rtXdot->TransferFcn1_CSTATE_op[0] += BMS_P.TransferFcn1_A_nn[2] * |
2838 | BMS_X.TransferFcn1_CSTATE_op[2]; |
2839 | _rtXdot->TransferFcn1_CSTATE_op[1] += BMS_X.TransferFcn1_CSTATE_op[0]; |
2840 | _rtXdot->TransferFcn1_CSTATE_op[2] += BMS_X.TransferFcn1_CSTATE_op[1]; |
2841 | _rtXdot->TransferFcn1_CSTATE_op[0] += BMS_B.abs_ms; |
2842 | |
2843 | /* Derivatives for TransferFcn: '<S65>/Transfer Fcn4' */ |
2844 | _rtXdot->TransferFcn4_CSTATE_p[0] = 0.0; |
2845 | _rtXdot->TransferFcn4_CSTATE_p[0] += BMS_P.TransferFcn4_A_e[0] * |
2846 | BMS_X.TransferFcn4_CSTATE_p[0]; |
2847 | _rtXdot->TransferFcn4_CSTATE_p[1] = 0.0; |
2848 | _rtXdot->TransferFcn4_CSTATE_p[0] += BMS_P.TransferFcn4_A_e[1] * |
2849 | BMS_X.TransferFcn4_CSTATE_p[1]; |
2850 | _rtXdot->TransferFcn4_CSTATE_p[2] = 0.0; |
2851 | _rtXdot->TransferFcn4_CSTATE_p[0] += BMS_P.TransferFcn4_A_e[2] * |
2852 | BMS_X.TransferFcn4_CSTATE_p[2]; |
2853 | _rtXdot->TransferFcn4_CSTATE_p[1] += BMS_X.TransferFcn4_CSTATE_p[0]; |
2854 | _rtXdot->TransferFcn4_CSTATE_p[2] += BMS_X.TransferFcn4_CSTATE_p[1]; |
2855 | _rtXdot->TransferFcn4_CSTATE_p[0] += BMS_B.Product_bf; |
2856 | |
2857 | /* Derivatives for TransferFcn: '<S65>/Transfer Fcn1' */ |
2858 | _rtXdot->TransferFcn1_CSTATE_on = 0.0; |
2859 | _rtXdot->TransferFcn1_CSTATE_on += BMS_P.TransferFcn1_A_o * |
2860 | BMS_X.TransferFcn1_CSTATE_on; |
2861 | _rtXdot->TransferFcn1_CSTATE_on += BMS_B.TransferFcn4_ad; |
2862 | |
2863 | /* Derivatives for Integrator: '<S66>/Integrator' */ |
2864 | _rtXdot->Integrator_CSTATE_c = BMS_B.Gain4_g; |
2865 | |
2866 | /* Derivatives for TransferFcn: '<S66>/Transfer Fcn1' */ |
2867 | _rtXdot->TransferFcn1_CSTATE_bi[0] = 0.0; |
2868 | _rtXdot->TransferFcn1_CSTATE_bi[0] += BMS_P.TransferFcn1_A_ht[0] * |
2869 | BMS_X.TransferFcn1_CSTATE_bi[0]; |
2870 | _rtXdot->TransferFcn1_CSTATE_bi[1] = 0.0; |
2871 | _rtXdot->TransferFcn1_CSTATE_bi[0] += BMS_P.TransferFcn1_A_ht[1] * |
2872 | BMS_X.TransferFcn1_CSTATE_bi[1]; |
2873 | _rtXdot->TransferFcn1_CSTATE_bi[2] = 0.0; |
2874 | _rtXdot->TransferFcn1_CSTATE_bi[0] += BMS_P.TransferFcn1_A_ht[2] * |
2875 | BMS_X.TransferFcn1_CSTATE_bi[2]; |
2876 | _rtXdot->TransferFcn1_CSTATE_bi[1] += BMS_X.TransferFcn1_CSTATE_bi[0]; |
2877 | _rtXdot->TransferFcn1_CSTATE_bi[2] += BMS_X.TransferFcn1_CSTATE_bi[1]; |
2878 | _rtXdot->TransferFcn1_CSTATE_bi[0] += BMS_B.uDLookupTable_n; |
2879 | |
2880 | /* Derivatives for TransferFcn: '<S69>/Transfer Fcn1' */ |
2881 | _rtXdot->TransferFcn1_CSTATE_d[0] = 0.0; |
2882 | _rtXdot->TransferFcn1_CSTATE_d[0] += BMS_P.TransferFcn1_A_hf[0] * |
2883 | BMS_X.TransferFcn1_CSTATE_d[0]; |
2884 | _rtXdot->TransferFcn1_CSTATE_d[1] = 0.0; |
2885 | _rtXdot->TransferFcn1_CSTATE_d[0] += BMS_P.TransferFcn1_A_hf[1] * |
2886 | BMS_X.TransferFcn1_CSTATE_d[1]; |
2887 | _rtXdot->TransferFcn1_CSTATE_d[2] = 0.0; |
2888 | _rtXdot->TransferFcn1_CSTATE_d[0] += BMS_P.TransferFcn1_A_hf[2] * |
2889 | BMS_X.TransferFcn1_CSTATE_d[2]; |
2890 | _rtXdot->TransferFcn1_CSTATE_d[1] += BMS_X.TransferFcn1_CSTATE_d[0]; |
2891 | _rtXdot->TransferFcn1_CSTATE_d[2] += BMS_X.TransferFcn1_CSTATE_d[1]; |
2892 | _rtXdot->TransferFcn1_CSTATE_d[0] += BMS_B.abs_b; |
2893 | |
2894 | /* Derivatives for TransferFcn: '<S70>/Transfer Fcn4' */ |
2895 | _rtXdot->TransferFcn4_CSTATE_mg[0] = 0.0; |
2896 | _rtXdot->TransferFcn4_CSTATE_mg[0] += BMS_P.TransferFcn4_A_ae[0] * |
2897 | BMS_X.TransferFcn4_CSTATE_mg[0]; |
2898 | _rtXdot->TransferFcn4_CSTATE_mg[1] = 0.0; |
2899 | _rtXdot->TransferFcn4_CSTATE_mg[0] += BMS_P.TransferFcn4_A_ae[1] * |
2900 | BMS_X.TransferFcn4_CSTATE_mg[1]; |
2901 | _rtXdot->TransferFcn4_CSTATE_mg[2] = 0.0; |
2902 | _rtXdot->TransferFcn4_CSTATE_mg[0] += BMS_P.TransferFcn4_A_ae[2] * |
2903 | BMS_X.TransferFcn4_CSTATE_mg[2]; |
2904 | _rtXdot->TransferFcn4_CSTATE_mg[1] += BMS_X.TransferFcn4_CSTATE_mg[0]; |
2905 | _rtXdot->TransferFcn4_CSTATE_mg[2] += BMS_X.TransferFcn4_CSTATE_mg[1]; |
2906 | _rtXdot->TransferFcn4_CSTATE_mg[0] += BMS_B.Product_h; |
2907 | |
2908 | /* Derivatives for TransferFcn: '<S70>/Transfer Fcn1' */ |
2909 | _rtXdot->TransferFcn1_CSTATE_hp = 0.0; |
2910 | _rtXdot->TransferFcn1_CSTATE_hp += BMS_P.TransferFcn1_A_c * |
2911 | BMS_X.TransferFcn1_CSTATE_hp; |
2912 | _rtXdot->TransferFcn1_CSTATE_hp += BMS_B.TransferFcn4_c; |
2913 | |
2914 | /* Derivatives for Integrator: '<S71>/Integrator' */ |
2915 | _rtXdot->Integrator_CSTATE_e = BMS_B.Gain4_c; |
2916 | |
2917 | /* Derivatives for TransferFcn: '<S71>/Transfer Fcn1' */ |
2918 | _rtXdot->TransferFcn1_CSTATE_ao[0] = 0.0; |
2919 | _rtXdot->TransferFcn1_CSTATE_ao[0] += BMS_P.TransferFcn1_A_l[0] * |
2920 | BMS_X.TransferFcn1_CSTATE_ao[0]; |
2921 | _rtXdot->TransferFcn1_CSTATE_ao[1] = 0.0; |
2922 | _rtXdot->TransferFcn1_CSTATE_ao[0] += BMS_P.TransferFcn1_A_l[1] * |
2923 | BMS_X.TransferFcn1_CSTATE_ao[1]; |
2924 | _rtXdot->TransferFcn1_CSTATE_ao[2] = 0.0; |
2925 | _rtXdot->TransferFcn1_CSTATE_ao[0] += BMS_P.TransferFcn1_A_l[2] * |
2926 | BMS_X.TransferFcn1_CSTATE_ao[2]; |
2927 | _rtXdot->TransferFcn1_CSTATE_ao[1] += BMS_X.TransferFcn1_CSTATE_ao[0]; |
2928 | _rtXdot->TransferFcn1_CSTATE_ao[2] += BMS_X.TransferFcn1_CSTATE_ao[1]; |
2929 | _rtXdot->TransferFcn1_CSTATE_ao[0] += BMS_B.uDLookupTable_i; |
2930 | } |
2931 | |
2932 | /* Model initialize function */ |
2933 | void BMS_initialize(void) |
2934 | { |
2935 | /* Registration code */ |
2936 | |
2937 | /* initialize non-finites */ |
2938 | rt_InitInfAndNaN(sizeof(real_T)); |
2939 | |
2940 | /* initialize real-time model */ |
2941 | (void) memset((void *)BMS_M, 0, |
2942 | sizeof(RT_MODEL_BMS_T)); |
2943 | |
2944 | { |
2945 | /* Setup solver object */ |
2946 | rtsiSetSimTimeStepPtr(&BMS_M->solverInfo, &BMS_M->Timing.simTimeStep); |
2947 | rtsiSetTPtr(&BMS_M->solverInfo, &rtmGetTPtr(BMS_M)); |
2948 | rtsiSetStepSizePtr(&BMS_M->solverInfo, &BMS_M->Timing.stepSize0); |
2949 | rtsiSetdXPtr(&BMS_M->solverInfo, &BMS_M->derivs); |
2950 | rtsiSetContStatesPtr(&BMS_M->solverInfo, (real_T **) &BMS_M->contStates); |
2951 | rtsiSetNumContStatesPtr(&BMS_M->solverInfo, &BMS_M->Sizes.numContStates); |
2952 | rtsiSetNumPeriodicContStatesPtr(&BMS_M->solverInfo, |
2953 | &BMS_M->Sizes.numPeriodicContStates); |
2954 | rtsiSetPeriodicContStateIndicesPtr(&BMS_M->solverInfo, |
2955 | &BMS_M->periodicContStateIndices); |
2956 | rtsiSetPeriodicContStateRangesPtr(&BMS_M->solverInfo, |
2957 | &BMS_M->periodicContStateRanges); |
2958 | rtsiSetErrorStatusPtr(&BMS_M->solverInfo, (&rtmGetErrorStatus(BMS_M))); |
2959 | rtsiSetRTModelPtr(&BMS_M->solverInfo, BMS_M); |
2960 | } |
2961 | |
2962 | rtsiSetSimTimeStep(&BMS_M->solverInfo, MAJOR_TIME_STEP); |
2963 | BMS_M->intgData.y = BMS_M->odeY; |
2964 | BMS_M->intgData.f[0] = BMS_M->odeF[0]; |
2965 | BMS_M->intgData.f[1] = BMS_M->odeF[1]; |
2966 | BMS_M->intgData.f[2] = BMS_M->odeF[2]; |
2967 | BMS_M->intgData.f[3] = BMS_M->odeF[3]; |
2968 | BMS_M->contStates = ((X_BMS_T *) &BMS_X); |
2969 | rtsiSetSolverData(&BMS_M->solverInfo, (void *)&BMS_M->intgData); |
2970 | rtsiSetSolverName(&BMS_M->solverInfo,"ode4"); |
2971 | rtmSetTPtr(BMS_M, &BMS_M->Timing.tArray[0]); |
2972 | rtmSetTFinal(BMS_M, -1); |
2973 | BMS_M->Timing.stepSize0 = 0.0005; |
2974 | |
2975 | /* Setup for data logging */ |
2976 | { |
2977 | static RTWLogInfo rt_DataLoggingInfo; |
2978 | rt_DataLoggingInfo.loggingInterval = NULL; |
2979 | BMS_M->rtwLogInfo = &rt_DataLoggingInfo; |
2980 | } |
2981 | |
2982 | /* Setup for data logging */ |
2983 | { |
2984 | rtliSetLogXSignalInfo(BMS_M->rtwLogInfo, (NULL)); |
2985 | rtliSetLogXSignalPtrs(BMS_M->rtwLogInfo, (NULL)); |
2986 | rtliSetLogT(BMS_M->rtwLogInfo, "tout"); |
2987 | rtliSetLogX(BMS_M->rtwLogInfo, ""); |
2988 | rtliSetLogXFinal(BMS_M->rtwLogInfo, ""); |
2989 | rtliSetLogVarNameModifier(BMS_M->rtwLogInfo, "rt_"); |
2990 | rtliSetLogFormat(BMS_M->rtwLogInfo, 4); |
2991 | rtliSetLogMaxRows(BMS_M->rtwLogInfo, 0); |
2992 | rtliSetLogDecimation(BMS_M->rtwLogInfo, 1); |
2993 | rtliSetLogY(BMS_M->rtwLogInfo, ""); |
2994 | rtliSetLogYSignalInfo(BMS_M->rtwLogInfo, (NULL)); |
2995 | rtliSetLogYSignalPtrs(BMS_M->rtwLogInfo, (NULL)); |
2996 | } |
2997 | |
2998 | /* block I/O */ |
2999 | (void) memset(((void *) &BMS_B), 0, |
3000 | sizeof(B_BMS_T)); |
3001 | |
3002 | /* states (continuous) */ |
3003 | { |
3004 | (void) memset((void *)&BMS_X, 0, |
3005 | sizeof(X_BMS_T)); |
3006 | } |
3007 | |
3008 | /* states (dwork) */ |
3009 | (void) memset((void *)&BMS_DW, 0, |
3010 | sizeof(DW_BMS_T)); |
3011 | |
3012 | /* external inputs */ |
3013 | (void)memset(&BMS_U, 0, sizeof(ExtU_BMS_T)); |
3014 | |
3015 | /* external outputs */ |
3016 | (void) memset((void *)&BMS_Y, 0, |
3017 | sizeof(ExtY_BMS_T)); |
3018 | |
3019 | /* Initialize DataMapInfo substructure containing ModelMap for C API */ |
3020 | BMS_InitializeDataMapInfo(); |
3021 | |
3022 | /* Matfile logging */ |
3023 | rt_StartDataLoggingWithStartTime(BMS_M->rtwLogInfo, 0.0, rtmGetTFinal(BMS_M), |
3024 | BMS_M->Timing.stepSize0, (&rtmGetErrorStatus(BMS_M))); |
3025 | |
3026 | { |
3027 | int32_T i; |
3028 | |
3029 | /* InitializeConditions for Memory: '<Root>/Memory' */ |
3030 | BMS_DW.Memory_PreviousInput = BMS_P.Memory_InitialCondition; |
3031 | |
3032 | /* InitializeConditions for Memory: '<Root>/Memory1' */ |
3033 | BMS_DW.Memory1_PreviousInput = BMS_P.Memory1_InitialCondition; |
3034 | |
3035 | /* InitializeConditions for Memory: '<Root>/Memory2' */ |
3036 | BMS_DW.Memory2_PreviousInput = BMS_P.Memory2_InitialCondition; |
3037 | |
3038 | /* InitializeConditions for Memory: '<Root>/Memory3' */ |
3039 | BMS_DW.Memory3_PreviousInput = BMS_P.Memory3_InitialCondition; |
3040 | |
3041 | /* InitializeConditions for Memory: '<Root>/Memory4' */ |
3042 | BMS_DW.Memory4_PreviousInput = BMS_P.Memory4_InitialCondition; |
3043 | |
3044 | /* InitializeConditions for Memory: '<Root>/Memory5' */ |
3045 | BMS_DW.Memory5_PreviousInput = BMS_P.Memory5_InitialCondition; |
3046 | |
3047 | /* InitializeConditions for Memory: '<Root>/Memory6' */ |
3048 | BMS_DW.Memory6_PreviousInput = BMS_P.Memory6_InitialCondition; |
3049 | |
3050 | /* InitializeConditions for Memory: '<Root>/Memory7' */ |
3051 | BMS_DW.Memory7_PreviousInput = BMS_P.Memory7_InitialCondition; |
3052 | |
3053 | /* InitializeConditions for Memory: '<Root>/Memory8' */ |
3054 | BMS_DW.Memory8_PreviousInput = BMS_P.Memory8_InitialCondition; |
3055 | |
3056 | /* InitializeConditions for Memory: '<Root>/Memory10' */ |
3057 | BMS_DW.Memory10_PreviousInput = BMS_P.Memory10_InitialCondition; |
3058 | |
3059 | /* InitializeConditions for Integrator: '<S32>/Integrator' */ |
3060 | BMS_X.Integrator_CSTATE = BMS_P.SOCestimator_SOC_init; |
3061 | |
3062 | /* InitializeConditions for Integrator: '<S37>/Integrator' */ |
3063 | BMS_X.Integrator_CSTATE_k = BMS_P.SOCestimator_SOC_init_a; |
3064 | |
3065 | /* InitializeConditions for Integrator: '<S42>/Integrator' */ |
3066 | BMS_X.Integrator_CSTATE_g = BMS_P.SOCestimator_SOC_init_p; |
3067 | |
3068 | /* InitializeConditions for Integrator: '<S47>/Integrator' */ |
3069 | BMS_X.Integrator_CSTATE_f = BMS_P.SOCestimator_SOC_init_b; |
3070 | |
3071 | /* InitializeConditions for Integrator: '<S52>/Integrator' */ |
3072 | BMS_X.Integrator_CSTATE_h = BMS_P.SOCestimator_SOC_init_f; |
3073 | |
3074 | /* InitializeConditions for Integrator: '<S57>/Integrator' */ |
3075 | BMS_X.Integrator_CSTATE_a = BMS_P.SOCestimator_SOC_init_n; |
3076 | |
3077 | /* InitializeConditions for Integrator: '<S62>/Integrator' */ |
3078 | BMS_X.Integrator_CSTATE_n = BMS_P.SOCestimator_SOC_init_ab; |
3079 | |
3080 | /* InitializeConditions for Integrator: '<S67>/Integrator' */ |
3081 | BMS_X.Integrator_CSTATE_b = BMS_P.SOCestimator_SOC_init_g; |
3082 | for (i = 0; i < 10; i++) { |
3083 | /* InitializeConditions for Delay: '<S3>/Delay' */ |
3084 | BMS_DW.Delay_DSTATE[i] = BMS_P.Delay_InitialCondition; |
3085 | |
3086 | /* InitializeConditions for Delay: '<S3>/Delay1' */ |
3087 | BMS_DW.Delay1_DSTATE[i] = BMS_P.Delay1_InitialCondition; |
3088 | |
3089 | /* InitializeConditions for Delay: '<S3>/Delay2' */ |
3090 | BMS_DW.Delay2_DSTATE[i] = BMS_P.Delay2_InitialCondition; |
3091 | |
3092 | /* InitializeConditions for Delay: '<S3>/Delay3' */ |
3093 | BMS_DW.Delay3_DSTATE[i] = BMS_P.Delay3_InitialCondition; |
3094 | } |
3095 | |
3096 | /* InitializeConditions for Integrator: '<S33>/Integrator6' */ |
3097 | BMS_X.Integrator6_CSTATE = BMS_P.Integrator6_IC; |
3098 | |
3099 | /* InitializeConditions for Integrator: '<S38>/Integrator6' */ |
3100 | BMS_X.Integrator6_CSTATE_h = BMS_P.Integrator6_IC_i; |
3101 | |
3102 | /* InitializeConditions for Integrator: '<S43>/Integrator6' */ |
3103 | BMS_X.Integrator6_CSTATE_d = BMS_P.Integrator6_IC_l; |
3104 | |
3105 | /* InitializeConditions for Integrator: '<S48>/Integrator6' */ |
3106 | BMS_X.Integrator6_CSTATE_g = BMS_P.Integrator6_IC_a; |
3107 | |
3108 | /* InitializeConditions for Integrator: '<S53>/Integrator6' */ |
3109 | BMS_X.Integrator6_CSTATE_a = BMS_P.Integrator6_IC_p; |
3110 | |
3111 | /* InitializeConditions for Integrator: '<S58>/Integrator6' */ |
3112 | BMS_X.Integrator6_CSTATE_f = BMS_P.Integrator6_IC_pg; |
3113 | |
3114 | /* InitializeConditions for Integrator: '<S63>/Integrator6' */ |
3115 | BMS_X.Integrator6_CSTATE_hq = BMS_P.Integrator6_IC_n; |
3116 | |
3117 | /* InitializeConditions for Integrator: '<S68>/Integrator6' */ |
3118 | BMS_X.Integrator6_CSTATE_b = BMS_P.Integrator6_IC_d; |
3119 | |
3120 | /* InitializeConditions for Integrator: '<S33>/Integrator3' */ |
3121 | BMS_X.Integrator3_CSTATE = BMS_P.Integrator3_IC; |
3122 | |
3123 | /* InitializeConditions for Integrator: '<S38>/Integrator3' */ |
3124 | BMS_X.Integrator3_CSTATE_i = BMS_P.Integrator3_IC_n; |
3125 | |
3126 | /* InitializeConditions for Integrator: '<S43>/Integrator3' */ |
3127 | BMS_X.Integrator3_CSTATE_h = BMS_P.Integrator3_IC_d; |
3128 | |
3129 | /* InitializeConditions for Integrator: '<S48>/Integrator3' */ |
3130 | BMS_X.Integrator3_CSTATE_hr = BMS_P.Integrator3_IC_dr; |
3131 | |
3132 | /* InitializeConditions for Integrator: '<S53>/Integrator3' */ |
3133 | BMS_X.Integrator3_CSTATE_d = BMS_P.Integrator3_IC_h; |
3134 | |
3135 | /* InitializeConditions for Integrator: '<S58>/Integrator3' */ |
3136 | BMS_X.Integrator3_CSTATE_f = BMS_P.Integrator3_IC_a; |
3137 | |
3138 | /* InitializeConditions for Integrator: '<S63>/Integrator3' */ |
3139 | BMS_X.Integrator3_CSTATE_dt = BMS_P.Integrator3_IC_i; |
3140 | |
3141 | /* InitializeConditions for Integrator: '<S68>/Integrator3' */ |
3142 | BMS_X.Integrator3_CSTATE_o = BMS_P.Integrator3_IC_j; |
3143 | |
3144 | /* InitializeConditions for TransferFcn: '<S34>/Transfer Fcn1' */ |
3145 | BMS_X.TransferFcn1_CSTATE[0] = 0.0; |
3146 | |
3147 | /* InitializeConditions for TransferFcn: '<S35>/Transfer Fcn4' */ |
3148 | BMS_X.TransferFcn4_CSTATE[0] = 0.0; |
3149 | |
3150 | /* InitializeConditions for TransferFcn: '<S34>/Transfer Fcn1' */ |
3151 | BMS_X.TransferFcn1_CSTATE[1] = 0.0; |
3152 | |
3153 | /* InitializeConditions for TransferFcn: '<S35>/Transfer Fcn4' */ |
3154 | BMS_X.TransferFcn4_CSTATE[1] = 0.0; |
3155 | |
3156 | /* InitializeConditions for TransferFcn: '<S34>/Transfer Fcn1' */ |
3157 | BMS_X.TransferFcn1_CSTATE[2] = 0.0; |
3158 | |
3159 | /* InitializeConditions for TransferFcn: '<S35>/Transfer Fcn4' */ |
3160 | BMS_X.TransferFcn4_CSTATE[2] = 0.0; |
3161 | |
3162 | /* InitializeConditions for TransferFcn: '<S35>/Transfer Fcn1' */ |
3163 | BMS_X.TransferFcn1_CSTATE_j = 0.0; |
3164 | |
3165 | /* InitializeConditions for Integrator: '<S36>/Integrator' */ |
3166 | BMS_X.Integrator_CSTATE_n5 = BMS_P.Integrator_IC; |
3167 | |
3168 | /* InitializeConditions for TransferFcn: '<S36>/Transfer Fcn1' */ |
3169 | BMS_X.TransferFcn1_CSTATE_a[0] = 0.0; |
3170 | |
3171 | /* InitializeConditions for TransferFcn: '<S39>/Transfer Fcn1' */ |
3172 | BMS_X.TransferFcn1_CSTATE_l[0] = 0.0; |
3173 | |
3174 | /* InitializeConditions for TransferFcn: '<S40>/Transfer Fcn4' */ |
3175 | BMS_X.TransferFcn4_CSTATE_e[0] = 0.0; |
3176 | |
3177 | /* InitializeConditions for TransferFcn: '<S36>/Transfer Fcn1' */ |
3178 | BMS_X.TransferFcn1_CSTATE_a[1] = 0.0; |
3179 | |
3180 | /* InitializeConditions for TransferFcn: '<S39>/Transfer Fcn1' */ |
3181 | BMS_X.TransferFcn1_CSTATE_l[1] = 0.0; |
3182 | |
3183 | /* InitializeConditions for TransferFcn: '<S40>/Transfer Fcn4' */ |
3184 | BMS_X.TransferFcn4_CSTATE_e[1] = 0.0; |
3185 | |
3186 | /* InitializeConditions for TransferFcn: '<S36>/Transfer Fcn1' */ |
3187 | BMS_X.TransferFcn1_CSTATE_a[2] = 0.0; |
3188 | |
3189 | /* InitializeConditions for TransferFcn: '<S39>/Transfer Fcn1' */ |
3190 | BMS_X.TransferFcn1_CSTATE_l[2] = 0.0; |
3191 | |
3192 | /* InitializeConditions for TransferFcn: '<S40>/Transfer Fcn4' */ |
3193 | BMS_X.TransferFcn4_CSTATE_e[2] = 0.0; |
3194 | |
3195 | /* InitializeConditions for TransferFcn: '<S40>/Transfer Fcn1' */ |
3196 | BMS_X.TransferFcn1_CSTATE_g = 0.0; |
3197 | |
3198 | /* InitializeConditions for Integrator: '<S41>/Integrator' */ |
3199 | BMS_X.Integrator_CSTATE_nm = BMS_P.Integrator_IC_k; |
3200 | |
3201 | /* InitializeConditions for TransferFcn: '<S41>/Transfer Fcn1' */ |
3202 | BMS_X.TransferFcn1_CSTATE_b[0] = 0.0; |
3203 | |
3204 | /* InitializeConditions for TransferFcn: '<S44>/Transfer Fcn1' */ |
3205 | BMS_X.TransferFcn1_CSTATE_c[0] = 0.0; |
3206 | |
3207 | /* InitializeConditions for TransferFcn: '<S45>/Transfer Fcn4' */ |
3208 | BMS_X.TransferFcn4_CSTATE_h[0] = 0.0; |
3209 | |
3210 | /* InitializeConditions for TransferFcn: '<S41>/Transfer Fcn1' */ |
3211 | BMS_X.TransferFcn1_CSTATE_b[1] = 0.0; |
3212 | |
3213 | /* InitializeConditions for TransferFcn: '<S44>/Transfer Fcn1' */ |
3214 | BMS_X.TransferFcn1_CSTATE_c[1] = 0.0; |
3215 | |
3216 | /* InitializeConditions for TransferFcn: '<S45>/Transfer Fcn4' */ |
3217 | BMS_X.TransferFcn4_CSTATE_h[1] = 0.0; |
3218 | |
3219 | /* InitializeConditions for TransferFcn: '<S41>/Transfer Fcn1' */ |
3220 | BMS_X.TransferFcn1_CSTATE_b[2] = 0.0; |
3221 | |
3222 | /* InitializeConditions for TransferFcn: '<S44>/Transfer Fcn1' */ |
3223 | BMS_X.TransferFcn1_CSTATE_c[2] = 0.0; |
3224 | |
3225 | /* InitializeConditions for TransferFcn: '<S45>/Transfer Fcn4' */ |
3226 | BMS_X.TransferFcn4_CSTATE_h[2] = 0.0; |
3227 | |
3228 | /* InitializeConditions for TransferFcn: '<S45>/Transfer Fcn1' */ |
3229 | BMS_X.TransferFcn1_CSTATE_f = 0.0; |
3230 | |
3231 | /* InitializeConditions for Integrator: '<S46>/Integrator' */ |
3232 | BMS_X.Integrator_CSTATE_kc = BMS_P.Integrator_IC_l; |
3233 | |
3234 | /* InitializeConditions for TransferFcn: '<S46>/Transfer Fcn1' */ |
3235 | BMS_X.TransferFcn1_CSTATE_n[0] = 0.0; |
3236 | |
3237 | /* InitializeConditions for TransferFcn: '<S49>/Transfer Fcn1' */ |
3238 | BMS_X.TransferFcn1_CSTATE_am[0] = 0.0; |
3239 | |
3240 | /* InitializeConditions for TransferFcn: '<S50>/Transfer Fcn4' */ |
3241 | BMS_X.TransferFcn4_CSTATE_m[0] = 0.0; |
3242 | |
3243 | /* InitializeConditions for TransferFcn: '<S46>/Transfer Fcn1' */ |
3244 | BMS_X.TransferFcn1_CSTATE_n[1] = 0.0; |
3245 | |
3246 | /* InitializeConditions for TransferFcn: '<S49>/Transfer Fcn1' */ |
3247 | BMS_X.TransferFcn1_CSTATE_am[1] = 0.0; |
3248 | |
3249 | /* InitializeConditions for TransferFcn: '<S50>/Transfer Fcn4' */ |
3250 | BMS_X.TransferFcn4_CSTATE_m[1] = 0.0; |
3251 | |
3252 | /* InitializeConditions for TransferFcn: '<S46>/Transfer Fcn1' */ |
3253 | BMS_X.TransferFcn1_CSTATE_n[2] = 0.0; |
3254 | |
3255 | /* InitializeConditions for TransferFcn: '<S49>/Transfer Fcn1' */ |
3256 | BMS_X.TransferFcn1_CSTATE_am[2] = 0.0; |
3257 | |
3258 | /* InitializeConditions for TransferFcn: '<S50>/Transfer Fcn4' */ |
3259 | BMS_X.TransferFcn4_CSTATE_m[2] = 0.0; |
3260 | |
3261 | /* InitializeConditions for TransferFcn: '<S50>/Transfer Fcn1' */ |
3262 | BMS_X.TransferFcn1_CSTATE_c1 = 0.0; |
3263 | |
3264 | /* InitializeConditions for Integrator: '<S51>/Integrator' */ |
3265 | BMS_X.Integrator_CSTATE_fh = BMS_P.Integrator_IC_kj; |
3266 | |
3267 | /* InitializeConditions for TransferFcn: '<S51>/Transfer Fcn1' */ |
3268 | BMS_X.TransferFcn1_CSTATE_ff[0] = 0.0; |
3269 | |
3270 | /* InitializeConditions for TransferFcn: '<S54>/Transfer Fcn1' */ |
3271 | BMS_X.TransferFcn1_CSTATE_o[0] = 0.0; |
3272 | |
3273 | /* InitializeConditions for TransferFcn: '<S55>/Transfer Fcn4' */ |
3274 | BMS_X.TransferFcn4_CSTATE_e1[0] = 0.0; |
3275 | |
3276 | /* InitializeConditions for TransferFcn: '<S51>/Transfer Fcn1' */ |
3277 | BMS_X.TransferFcn1_CSTATE_ff[1] = 0.0; |
3278 | |
3279 | /* InitializeConditions for TransferFcn: '<S54>/Transfer Fcn1' */ |
3280 | BMS_X.TransferFcn1_CSTATE_o[1] = 0.0; |
3281 | |
3282 | /* InitializeConditions for TransferFcn: '<S55>/Transfer Fcn4' */ |
3283 | BMS_X.TransferFcn4_CSTATE_e1[1] = 0.0; |
3284 | |
3285 | /* InitializeConditions for TransferFcn: '<S51>/Transfer Fcn1' */ |
3286 | BMS_X.TransferFcn1_CSTATE_ff[2] = 0.0; |
3287 | |
3288 | /* InitializeConditions for TransferFcn: '<S54>/Transfer Fcn1' */ |
3289 | BMS_X.TransferFcn1_CSTATE_o[2] = 0.0; |
3290 | |
3291 | /* InitializeConditions for TransferFcn: '<S55>/Transfer Fcn4' */ |
3292 | BMS_X.TransferFcn4_CSTATE_e1[2] = 0.0; |
3293 | |
3294 | /* InitializeConditions for TransferFcn: '<S55>/Transfer Fcn1' */ |
3295 | BMS_X.TransferFcn1_CSTATE_e = 0.0; |
3296 | |
3297 | /* InitializeConditions for Integrator: '<S56>/Integrator' */ |
3298 | BMS_X.Integrator_CSTATE_l = BMS_P.Integrator_IC_i; |
3299 | |
3300 | /* InitializeConditions for TransferFcn: '<S56>/Transfer Fcn1' */ |
3301 | BMS_X.TransferFcn1_CSTATE_gz[0] = 0.0; |
3302 | |
3303 | /* InitializeConditions for TransferFcn: '<S59>/Transfer Fcn1' */ |
3304 | BMS_X.TransferFcn1_CSTATE_h[0] = 0.0; |
3305 | |
3306 | /* InitializeConditions for TransferFcn: '<S60>/Transfer Fcn4' */ |
3307 | BMS_X.TransferFcn4_CSTATE_eg[0] = 0.0; |
3308 | |
3309 | /* InitializeConditions for TransferFcn: '<S56>/Transfer Fcn1' */ |
3310 | BMS_X.TransferFcn1_CSTATE_gz[1] = 0.0; |
3311 | |
3312 | /* InitializeConditions for TransferFcn: '<S59>/Transfer Fcn1' */ |
3313 | BMS_X.TransferFcn1_CSTATE_h[1] = 0.0; |
3314 | |
3315 | /* InitializeConditions for TransferFcn: '<S60>/Transfer Fcn4' */ |
3316 | BMS_X.TransferFcn4_CSTATE_eg[1] = 0.0; |
3317 | |
3318 | /* InitializeConditions for TransferFcn: '<S56>/Transfer Fcn1' */ |
3319 | BMS_X.TransferFcn1_CSTATE_gz[2] = 0.0; |
3320 | |
3321 | /* InitializeConditions for TransferFcn: '<S59>/Transfer Fcn1' */ |
3322 | BMS_X.TransferFcn1_CSTATE_h[2] = 0.0; |
3323 | |
3324 | /* InitializeConditions for TransferFcn: '<S60>/Transfer Fcn4' */ |
3325 | BMS_X.TransferFcn4_CSTATE_eg[2] = 0.0; |
3326 | |
3327 | /* InitializeConditions for TransferFcn: '<S60>/Transfer Fcn1' */ |
3328 | BMS_X.TransferFcn1_CSTATE_p = 0.0; |
3329 | |
3330 | /* InitializeConditions for Integrator: '<S61>/Integrator' */ |
3331 | BMS_X.Integrator_CSTATE_fq = BMS_P.Integrator_IC_k5; |
3332 | |
3333 | /* InitializeConditions for TransferFcn: '<S61>/Transfer Fcn1' */ |
3334 | BMS_X.TransferFcn1_CSTATE_p5[0] = 0.0; |
3335 | |
3336 | /* InitializeConditions for TransferFcn: '<S64>/Transfer Fcn1' */ |
3337 | BMS_X.TransferFcn1_CSTATE_op[0] = 0.0; |
3338 | |
3339 | /* InitializeConditions for TransferFcn: '<S65>/Transfer Fcn4' */ |
3340 | BMS_X.TransferFcn4_CSTATE_p[0] = 0.0; |
3341 | |
3342 | /* InitializeConditions for TransferFcn: '<S61>/Transfer Fcn1' */ |
3343 | BMS_X.TransferFcn1_CSTATE_p5[1] = 0.0; |
3344 | |
3345 | /* InitializeConditions for TransferFcn: '<S64>/Transfer Fcn1' */ |
3346 | BMS_X.TransferFcn1_CSTATE_op[1] = 0.0; |
3347 | |
3348 | /* InitializeConditions for TransferFcn: '<S65>/Transfer Fcn4' */ |
3349 | BMS_X.TransferFcn4_CSTATE_p[1] = 0.0; |
3350 | |
3351 | /* InitializeConditions for TransferFcn: '<S61>/Transfer Fcn1' */ |
3352 | BMS_X.TransferFcn1_CSTATE_p5[2] = 0.0; |
3353 | |
3354 | /* InitializeConditions for TransferFcn: '<S64>/Transfer Fcn1' */ |
3355 | BMS_X.TransferFcn1_CSTATE_op[2] = 0.0; |
3356 | |
3357 | /* InitializeConditions for TransferFcn: '<S65>/Transfer Fcn4' */ |
3358 | BMS_X.TransferFcn4_CSTATE_p[2] = 0.0; |
3359 | |
3360 | /* InitializeConditions for TransferFcn: '<S65>/Transfer Fcn1' */ |
3361 | BMS_X.TransferFcn1_CSTATE_on = 0.0; |
3362 | |
3363 | /* InitializeConditions for Integrator: '<S66>/Integrator' */ |
3364 | BMS_X.Integrator_CSTATE_c = BMS_P.Integrator_IC_o; |
3365 | |
3366 | /* InitializeConditions for TransferFcn: '<S66>/Transfer Fcn1' */ |
3367 | BMS_X.TransferFcn1_CSTATE_bi[0] = 0.0; |
3368 | |
3369 | /* InitializeConditions for TransferFcn: '<S69>/Transfer Fcn1' */ |
3370 | BMS_X.TransferFcn1_CSTATE_d[0] = 0.0; |
3371 | |
3372 | /* InitializeConditions for TransferFcn: '<S70>/Transfer Fcn4' */ |
3373 | BMS_X.TransferFcn4_CSTATE_mg[0] = 0.0; |
3374 | |
3375 | /* InitializeConditions for TransferFcn: '<S66>/Transfer Fcn1' */ |
3376 | BMS_X.TransferFcn1_CSTATE_bi[1] = 0.0; |
3377 | |
3378 | /* InitializeConditions for TransferFcn: '<S69>/Transfer Fcn1' */ |
3379 | BMS_X.TransferFcn1_CSTATE_d[1] = 0.0; |
3380 | |
3381 | /* InitializeConditions for TransferFcn: '<S70>/Transfer Fcn4' */ |
3382 | BMS_X.TransferFcn4_CSTATE_mg[1] = 0.0; |
3383 | |
3384 | /* InitializeConditions for TransferFcn: '<S66>/Transfer Fcn1' */ |
3385 | BMS_X.TransferFcn1_CSTATE_bi[2] = 0.0; |
3386 | |
3387 | /* InitializeConditions for TransferFcn: '<S69>/Transfer Fcn1' */ |
3388 | BMS_X.TransferFcn1_CSTATE_d[2] = 0.0; |
3389 | |
3390 | /* InitializeConditions for TransferFcn: '<S70>/Transfer Fcn4' */ |
3391 | BMS_X.TransferFcn4_CSTATE_mg[2] = 0.0; |
3392 | |
3393 | /* InitializeConditions for TransferFcn: '<S70>/Transfer Fcn1' */ |
3394 | BMS_X.TransferFcn1_CSTATE_hp = 0.0; |
3395 | |
3396 | /* InitializeConditions for Integrator: '<S71>/Integrator' */ |
3397 | BMS_X.Integrator_CSTATE_e = BMS_P.Integrator_IC_e; |
3398 | |
3399 | /* InitializeConditions for TransferFcn: '<S71>/Transfer Fcn1' */ |
3400 | BMS_X.TransferFcn1_CSTATE_ao[0] = 0.0; |
3401 | BMS_X.TransferFcn1_CSTATE_ao[1] = 0.0; |
3402 | BMS_X.TransferFcn1_CSTATE_ao[2] = 0.0; |
3403 | } |
3404 | } |
3405 | |
3406 | /* Model terminate function */ |
3407 | void BMS_terminate(void) |
3408 | { |
3409 | /* (no terminate code required) */ |
3410 | } |
3411 | |