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) */
23B_BMS_T BMS_B;
24
25/* Continuous states */
26X_BMS_T BMS_X;
27
28/* Block states (default storage) */
29DW_BMS_T BMS_DW;
30
31/* External inputs (root inport signals with default storage) */
32ExtU_BMS_T BMS_U;
33
34/* External outputs (root outports fed by signals with default storage) */
35ExtY_BMS_T BMS_Y;
36
37/* Real-time model */
38RT_MODEL_BMS_T BMS_M_;
39RT_MODEL_BMS_T *const BMS_M = &BMS_M_;
40
41/* Forward declaration for local functions */
42static int32_T BMS_thirdOfFive(const real_T v[8], int32_T ia, int32_T ib);
43static 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);
45real_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
144real_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 */
203static 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 */
280void 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' */
286static 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' */
382static 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 */
530void 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 */
2338void 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>' */
2446void 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 */
2933void 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 */
3407void BMS_terminate(void)
3408{
3409 /* (no terminate code required) */
3410}
3411