1 /*
2 * File: bh_f14.c
3 *
4 * Code generated for Simulink model 'bh_f14'.
5 *
6 * Model version : 1.18
7 * Simulink Coder version : 8.10 (R2016a) 10-Feb-2016
8 * C/C++ source code generated on : Wed Jun 22 07:56:08 2016
9 *
10 * Target selection: ert.tlc
11 * Embedded hardware selection: 32-bit Generic
12 * Code generation objectives: Unspecified
13 * Validation result: Not run
14 */
15
16 #include "bh_f14.h"
17 #include "bh_f14_private.h"
18
19 static void rate_scheduler(RT_MODEL_bh_f14_T *const bh_f14_M);
20
21 /*
22 * This function updates active task flag for each subrate.
23 * The function is called at model base rate, hence the
24 * generated code self-manages all its subrates.
25 */
26 static void rate_scheduler(RT_MODEL_bh_f14_T *const bh_f14_M)
27 {
28 /* Compute which subrates run during the next base time step. Subrates
29 * are an integer multiple of the base rate counter. Therefore, the subtask
30 * counter is reset when it reaches its limit (zero means run).
31 */
32 (bh_f14_M->Timing.TaskCounters.TID[2])++;
33 if ((bh_f14_M->Timing.TaskCounters.TID[2]) > 9) {/* Sample time: [0.1s, 0.0s] */
34 bh_f14_M->Timing.TaskCounters.TID[2] = 0;
35 }
36 }
37
38 /*
39 * This function updates continuous states using the ODE4 fixed-step
40 * solver algorithm
41 */
42 static void rt_ertODEUpdateContinuousStates(RTWSolverInfo *si ,
43 RT_MODEL_bh_f14_T *const bh_f14_M, real_T bh_f14_U_u, real_T
44 *bh_f14_Y_alpharad, real_T *bh_f14_Y_NzPilotg)
45 {
46 time_T t = rtsiGetT(si);
47 time_T tnew = rtsiGetSolverStopTime(si);
48 time_T h = rtsiGetStepSize(si);
49 real_T *x = rtsiGetContStates(si);
50 ODE4_IntgData *id = (ODE4_IntgData *)rtsiGetSolverData(si);
51 real_T *y = id->y;
52 real_T *f0 = id->f[0];
53 real_T *f1 = id->f[1];
54 real_T *f2 = id->f[2];
55 real_T *f3 = id->f[3];
56 real_T temp;
57 int_T i;
58 int_T nXc = 10;
59 rtsiSetSimTimeStep(si,MINOR_TIME_STEP);
60
61 /* Save the state values at time t in y, we'll use x as ynew. */
62 (void) memcpy(y, x,
63 (uint_T)nXc*sizeof(real_T));
64
65 /* Assumes that rtsiSetT and ModelOutputs are up-to-date */
66 /* f0 = f(t,y) */
67 rtsiSetdX(si, f0);
68 bh_f14_derivatives(bh_f14_M);
69
70 /* f1 = f(t + (h/2), y + (h/2)*f0) */
71 temp = 0.5 * h;
72 for (i = 0; i < nXc; i++) {
73 x[i] = y[i] + (temp*f0[i]);
74 }
75
76 rtsiSetT(si, t + temp);
77 rtsiSetdX(si, f1);
78 bh_f14_step(bh_f14_M, bh_f14_U_u, bh_f14_Y_alpharad, bh_f14_Y_NzPilotg);
79 bh_f14_derivatives(bh_f14_M);
80
81 /* f2 = f(t + (h/2), y + (h/2)*f1) */
82 for (i = 0; i < nXc; i++) {
83 x[i] = y[i] + (temp*f1[i]);
84 }
85
86 rtsiSetdX(si, f2);
87 bh_f14_step(bh_f14_M, bh_f14_U_u, bh_f14_Y_alpharad, bh_f14_Y_NzPilotg);
88 bh_f14_derivatives(bh_f14_M);
89
90 /* f3 = f(t + h, y + h*f2) */
91 for (i = 0; i < nXc; i++) {
92 x[i] = y[i] + (h*f2[i]);
93 }
94
95 rtsiSetT(si, tnew);
96 rtsiSetdX(si, f3);
97 bh_f14_step(bh_f14_M, bh_f14_U_u, bh_f14_Y_alpharad, bh_f14_Y_NzPilotg);
98 bh_f14_derivatives(bh_f14_M);
99
100 /* tnew = t + h
101 ynew = y + (h/6)*(f0 + 2*f1 + 2*f2 + 2*f3) */
102 temp = h / 6.0;
103 for (i = 0; i < nXc; i++) {
104 x[i] = y[i] + temp*(f0[i] + 2.0*f1[i] + 2.0*f2[i] + f3[i]);
105 }
106
107 rtsiSetSimTimeStep(si,MAJOR_TIME_STEP);
108 }
109
110 real_T rt_urand_Upu32_Yd_f_pw_snf(uint32_T *u)
111 {
112 uint32_T lo;
113 uint32_T hi;
114
115 /* Uniform random number generator (random number between 0 and 1)
116
117 #define IA 16807 magic multiplier = 7^5
118 #define IM 2147483647 modulus = 2^31-1
119 #define IQ 127773 IM div IA
120 #define IR 2836 IM modulo IA
121 #define S 4.656612875245797e-10 reciprocal of 2^31-1
122 test = IA * (seed % IQ) - IR * (seed/IQ)
123 seed = test < 0 ? (test + IM) : test
124 return (seed*S)
125 */
126 lo = *u % 127773U * 16807U;
127 hi = *u / 127773U * 2836U;
128 if (lo < hi) {
129 *u = 2147483647U - (hi - lo);
130 } else {
131 *u = lo - hi;
132 }
133
134 return (real_T)*u * 4.6566128752457969E-10;
135 }
136
137 real_T rt_nrand_Upu32_Yd_f_pw_snf(uint32_T *u)
138 {
139 real_T y;
140 real_T sr;
141 real_T si;
142
143 /* Normal (Gaussian) random number generator */
144 do {
145 sr = 2.0 * rt_urand_Upu32_Yd_f_pw_snf(u) - 1.0;
146 si = 2.0 * rt_urand_Upu32_Yd_f_pw_snf(u) - 1.0;
147 si = sr * sr + si * si;
148 } while (si > 1.0);
149
150 y = sqrt(-2.0 * log(si) / si) * sr;
151 return y;
152 }
153
154 /* Model step function */
155 void bh_f14_step(RT_MODEL_bh_f14_T *const bh_f14_M, real_T bh_f14_U_u, real_T
156 *bh_f14_Y_alpharad, real_T *bh_f14_Y_NzPilotg)
157 {
158 B_bh_f14_T *bh_f14_B = ((B_bh_f14_T *) bh_f14_M->ModelData.blockIO);
159 DW_bh_f14_T *bh_f14_DW = ((DW_bh_f14_T *) bh_f14_M->ModelData.dwork);
160 X_bh_f14_T *bh_f14_X = ((X_bh_f14_T *) bh_f14_M->ModelData.contStates);
161 if (rtmIsMajorTimeStep(bh_f14_M)) {
162 /* set solver stop time */
163 rtsiSetSolverStopTime(&bh_f14_M->solverInfo,((bh_f14_M->Timing.clockTick0+1)*
164 bh_f14_M->Timing.stepSize0));
165 } /* end MajorTimeStep */
166
167 /* Update absolute time of base rate at minor time step */
168 if (rtmIsMinorTimeStep(bh_f14_M)) {
169 bh_f14_M->Timing.t[0] = rtsiGetT(&bh_f14_M->solverInfo);
170 }
171
172 {
173 real_T *lastU;
174 real_T rtb_Actuator;
175 real_T rtb_AlphasensorLowpassFilter;
176
177 /* TransferFcn: '<S3>/Transfer Fcn.2' */
178 bh_f14_B->TransferFcn2 = 0.0;
179 bh_f14_B->TransferFcn2 += 1.0 * bh_f14_X->TransferFcn2_CSTATE;
180
181 /* Gain: '<Root>/Gain5' */
182 bh_f14_B->Gain5 = 0.001450536698578474 * bh_f14_B->TransferFcn2;
183
184 /* Outport: '<Root>/alpha (rad)' */
185 *bh_f14_Y_alpharad = bh_f14_B->Gain5;
186
187 /* Derivative: '<S2>/Derivative' */
188 if ((bh_f14_DW->TimeStampA >= bh_f14_M->Timing.t[0]) &&
189 (bh_f14_DW->TimeStampB >= bh_f14_M->Timing.t[0])) {
190 rtb_AlphasensorLowpassFilter = 0.0;
191 } else {
192 rtb_Actuator = bh_f14_DW->TimeStampA;
193 lastU = &bh_f14_DW->LastUAtTimeA;
194 if (bh_f14_DW->TimeStampA < bh_f14_DW->TimeStampB) {
195 if (bh_f14_DW->TimeStampB < bh_f14_M->Timing.t[0]) {
196 rtb_Actuator = bh_f14_DW->TimeStampB;
197 lastU = &bh_f14_DW->LastUAtTimeB;
198 }
199 } else {
200 if (bh_f14_DW->TimeStampA >= bh_f14_M->Timing.t[0]) {
201 rtb_Actuator = bh_f14_DW->TimeStampB;
202 lastU = &bh_f14_DW->LastUAtTimeB;
203 }
204 }
205
206 rtb_AlphasensorLowpassFilter = (bh_f14_B->TransferFcn2 - *lastU) /
207 (bh_f14_M->Timing.t[0] - rtb_Actuator);
208 }
209
210 /* End of Derivative: '<S2>/Derivative' */
211
212 /* TransferFcn: '<S3>/Transfer Fcn.1' */
213 bh_f14_B->TransferFcn1 = 0.0;
214 bh_f14_B->TransferFcn1 += 1.0 * bh_f14_X->TransferFcn1_CSTATE;
215
216 /* Derivative: '<S2>/Derivative1' */
217 if ((bh_f14_DW->TimeStampA_o >= bh_f14_M->Timing.t[0]) &&
218 (bh_f14_DW->TimeStampB_h >= bh_f14_M->Timing.t[0])) {
219 rtb_Actuator = 0.0;
220 } else {
221 rtb_Actuator = bh_f14_DW->TimeStampA_o;
222 lastU = &bh_f14_DW->LastUAtTimeA_i;
223 if (bh_f14_DW->TimeStampA_o < bh_f14_DW->TimeStampB_h) {
224 if (bh_f14_DW->TimeStampB_h < bh_f14_M->Timing.t[0]) {
225 rtb_Actuator = bh_f14_DW->TimeStampB_h;
226 lastU = &bh_f14_DW->LastUAtTimeB_j;
227 }
228 } else {
229 if (bh_f14_DW->TimeStampA_o >= bh_f14_M->Timing.t[0]) {
230 rtb_Actuator = bh_f14_DW->TimeStampB_h;
231 lastU = &bh_f14_DW->LastUAtTimeB_j;
232 }
233 }
234
235 rtb_Actuator = (bh_f14_B->TransferFcn1 - *lastU) / (bh_f14_M->Timing.t[0]
236 - rtb_Actuator);
237 }
238
239 /* End of Derivative: '<S2>/Derivative1' */
240
241 /* Gain: '<S2>/Gain2' incorporates:
242 * Constant: '<S2>/Constant'
243 * Gain: '<S2>/Gain1'
244 * Product: '<S2>/Product'
245 * Sum: '<S2>/Sum1'
246 */
247 bh_f14_B->Gain2 = ((22.8 * rtb_Actuator - rtb_AlphasensorLowpassFilter) +
248 bh_f14_B->TransferFcn1 * 689.4) * 0.031055900621118009;
249
250 /* Outport: '<Root>/Nz Pilot (g)' */
251 *bh_f14_Y_NzPilotg = bh_f14_B->Gain2;
252 if (rtmIsMajorTimeStep(bh_f14_M) &&
253 bh_f14_M->Timing.TaskCounters.TID[1] == 0) {
254 }
255
256 /* SignalGenerator: '<Root>/Pilot' */
257 rtb_Actuator = 0.079577471545947673 * bh_f14_M->Timing.t[0];
258 if (rtb_Actuator - floor(rtb_Actuator) >= 0.5) {
259 rtb_Actuator = 1.0;
260 } else {
261 rtb_Actuator = -1.0;
262 }
263
264 /* End of SignalGenerator: '<Root>/Pilot' */
265
266 /* Sum: '<Root>/Sum1' incorporates:
267 * Inport: '<Root>/u'
268 */
269 bh_f14_B->Sum1 = rtb_Actuator + bh_f14_U_u;
270 if (rtmIsMajorTimeStep(bh_f14_M) &&
271 bh_f14_M->Timing.TaskCounters.TID[1] == 0) {
272 }
273
274 /* TransferFcn: '<Root>/Actuator' */
275 rtb_Actuator = 20.0 * bh_f14_X->Actuator_CSTATE;
276
277 /* Sum: '<S1>/Sum2' incorporates:
278 * Gain: '<S1>/Gain2'
279 * Gain: '<S1>/Gain3'
280 * Sum: '<S1>/Sum1'
281 * TransferFcn: '<S1>/Alpha-sensor Low-pass Filter'
282 * TransferFcn: '<S1>/Pitch Rate Lead Filter'
283 * TransferFcn: '<S1>/Stick Prefilter'
284 */
285 bh_f14_B->Sum2 = 10.0 * bh_f14_X->StickPrefilter_CSTATE - (((-1.173) *
286 bh_f14_X->PitchRateLeadFilter_CSTATE + 1.0 * bh_f14_B->TransferFcn1) *
287 0.8156 + 2.5258903763576663 * bh_f14_X->AlphasensorLowpassFilter_CSTATE *
288 0.677);
289
290 /* Sum: '<S1>/Sum' incorporates:
291 * Gain: '<S1>/Gain'
292 * TransferFcn: '<S1>/Proportional plus integral compensator'
293 */
294 bh_f14_B->Sum = (-1.746) * bh_f14_B->Sum2 + (-3.864) *
295 bh_f14_X->Proportionalplusintegralcompens;
296
297 /* TransferFcn: '<S4>/W-gust model' */
298 bh_f14_B->Wgustmodel = 0.0;
299 bh_f14_B->Wgustmodel += 3.2636985073652349 * bh_f14_X->Wgustmodel_CSTATE[0];
300 bh_f14_B->Wgustmodel += 0.74337115819042854 * bh_f14_X->Wgustmodel_CSTATE[1];
301
302 /* Sum: '<S3>/Sum1' incorporates:
303 * Gain: '<Root>/Gain'
304 * Gain: '<S3>/Gain3'
305 * Gain: '<S3>/Gain5'
306 */
307 bh_f14_B->Sum1_o = ((-63.9979) * rtb_Actuator - (-0.6385) *
308 bh_f14_B->Wgustmodel) + 689.4 * bh_f14_B->TransferFcn1;
309
310 /* Sum: '<S3>/Sum2' incorporates:
311 * Gain: '<Root>/Gain1'
312 * Gain: '<Root>/Gain2'
313 * Gain: '<S3>/Gain4'
314 * Gain: '<S3>/Gain6'
315 * Sum: '<Root>/Sum'
316 * TransferFcn: '<S4>/Q-gust model'
317 */
318 bh_f14_B->Sum2_h = ((-0.00592) * bh_f14_B->TransferFcn2 -
319 (((-0.10355189850799512) * bh_f14_X->Qgustmodel_CSTATE +
320 0.01224696964599171 * bh_f14_B->Wgustmodel) * (-0.6571)
321 + (-0.00592) * bh_f14_B->Wgustmodel)) + (-6.8847) *
322 rtb_Actuator;
323 if (rtmIsMajorTimeStep(bh_f14_M) &&
324 bh_f14_M->Timing.TaskCounters.TID[2] == 0) {
325 /* Gain: '<S5>/Output' incorporates:
326 * RandomNumber: '<S5>/White Noise'
327 */
328 bh_f14_B->Output = 3.1622776601683791 * bh_f14_DW->NextOutput;
329 }
330 }
331
332 if (rtmIsMajorTimeStep(bh_f14_M)) {
333 real_T *lastU;
334
335 /* Update for Derivative: '<S2>/Derivative' */
336 if (bh_f14_DW->TimeStampA == (rtInf)) {
337 bh_f14_DW->TimeStampA = bh_f14_M->Timing.t[0];
338 lastU = &bh_f14_DW->LastUAtTimeA;
339 } else if (bh_f14_DW->TimeStampB == (rtInf)) {
340 bh_f14_DW->TimeStampB = bh_f14_M->Timing.t[0];
341 lastU = &bh_f14_DW->LastUAtTimeB;
342 } else if (bh_f14_DW->TimeStampA < bh_f14_DW->TimeStampB) {
343 bh_f14_DW->TimeStampA = bh_f14_M->Timing.t[0];
344 lastU = &bh_f14_DW->LastUAtTimeA;
345 } else {
346 bh_f14_DW->TimeStampB = bh_f14_M->Timing.t[0];
347 lastU = &bh_f14_DW->LastUAtTimeB;
348 }
349
350 *lastU = bh_f14_B->TransferFcn2;
351
352 /* End of Update for Derivative: '<S2>/Derivative' */
353
354 /* Update for Derivative: '<S2>/Derivative1' */
355 if (bh_f14_DW->TimeStampA_o == (rtInf)) {
356 bh_f14_DW->TimeStampA_o = bh_f14_M->Timing.t[0];
357 lastU = &bh_f14_DW->LastUAtTimeA_i;
358 } else if (bh_f14_DW->TimeStampB_h == (rtInf)) {
359 bh_f14_DW->TimeStampB_h = bh_f14_M->Timing.t[0];
360 lastU = &bh_f14_DW->LastUAtTimeB_j;
361 } else if (bh_f14_DW->TimeStampA_o < bh_f14_DW->TimeStampB_h) {
362 bh_f14_DW->TimeStampA_o = bh_f14_M->Timing.t[0];
363 lastU = &bh_f14_DW->LastUAtTimeA_i;
364 } else {
365 bh_f14_DW->TimeStampB_h = bh_f14_M->Timing.t[0];
366 lastU = &bh_f14_DW->LastUAtTimeB_j;
367 }
368
369 *lastU = bh_f14_B->TransferFcn1;
370
371 /* End of Update for Derivative: '<S2>/Derivative1' */
372 if (rtmIsMajorTimeStep(bh_f14_M) &&
373 bh_f14_M->Timing.TaskCounters.TID[2] == 0) {
374 /* Update for RandomNumber: '<S5>/White Noise' */
375 bh_f14_DW->NextOutput = rt_nrand_Upu32_Yd_f_pw_snf(&bh_f14_DW->RandSeed) *
376 1.0 + 0.0;
377 }
378 } /* end MajorTimeStep */
379
380 if (rtmIsMajorTimeStep(bh_f14_M)) {
381 rt_ertODEUpdateContinuousStates(&bh_f14_M->solverInfo, bh_f14_M, bh_f14_U_u,
382 bh_f14_Y_alpharad, bh_f14_Y_NzPilotg);
383
384 /* Update absolute time for base rate */
385 /* The "clockTick0" counts the number of times the code of this task has
386 * been executed. The absolute time is the multiplication of "clockTick0"
387 * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not
388 * overflow during the application lifespan selected.
389 */
390 ++bh_f14_M->Timing.clockTick0;
391 bh_f14_M->Timing.t[0] = rtsiGetSolverStopTime(&bh_f14_M->solverInfo);
392
393 {
394 /* Update absolute timer for sample time: [0.01s, 0.0s] */
395 /* The "clockTick1" counts the number of times the code of this task has
396 * been executed. The resolution of this integer timer is 0.01, which is the step size
397 * of the task. Size of "clockTick1" ensures timer will not overflow during the
398 * application lifespan selected.
399 */
400 bh_f14_M->Timing.clockTick1++;
401 }
402
403 rate_scheduler(bh_f14_M);
404 } /* end MajorTimeStep */
405 }
406
407 /* Derivatives for root system: '<Root>' */
408 void bh_f14_derivatives(RT_MODEL_bh_f14_T *const bh_f14_M)
409 {
410 B_bh_f14_T *bh_f14_B = ((B_bh_f14_T *) bh_f14_M->ModelData.blockIO);
411 X_bh_f14_T *bh_f14_X = ((X_bh_f14_T *) bh_f14_M->ModelData.contStates);
412 XDot_bh_f14_T *_rtXdot;
413 _rtXdot = ((XDot_bh_f14_T *) bh_f14_M->ModelData.derivs);
414
415 /* Derivatives for TransferFcn: '<S3>/Transfer Fcn.2' */
416 _rtXdot->TransferFcn2_CSTATE = 0.0;
417 _rtXdot->TransferFcn2_CSTATE += (-0.6385) * bh_f14_X->TransferFcn2_CSTATE;
418 _rtXdot->TransferFcn2_CSTATE += bh_f14_B->Sum1_o;
419
420 /* Derivatives for TransferFcn: '<S3>/Transfer Fcn.1' */
421 _rtXdot->TransferFcn1_CSTATE = 0.0;
422 _rtXdot->TransferFcn1_CSTATE += (-0.6571) * bh_f14_X->TransferFcn1_CSTATE;
423 _rtXdot->TransferFcn1_CSTATE += bh_f14_B->Sum2_h;
424
425 /* Derivatives for TransferFcn: '<Root>/Actuator' */
426 _rtXdot->Actuator_CSTATE = 0.0;
427 _rtXdot->Actuator_CSTATE += (-20.0) * bh_f14_X->Actuator_CSTATE;
428 _rtXdot->Actuator_CSTATE += bh_f14_B->Sum;
429
430 /* Derivatives for TransferFcn: '<S1>/Alpha-sensor Low-pass Filter' */
431 _rtXdot->AlphasensorLowpassFilter_CSTATE = 0.0;
432 _rtXdot->AlphasensorLowpassFilter_CSTATE += (-2.5258903763576663) *
433 bh_f14_X->AlphasensorLowpassFilter_CSTATE;
434 _rtXdot->AlphasensorLowpassFilter_CSTATE += bh_f14_B->Gain5;
435
436 /* Derivatives for TransferFcn: '<S1>/Stick Prefilter' */
437 _rtXdot->StickPrefilter_CSTATE = 0.0;
438 _rtXdot->StickPrefilter_CSTATE += (-10.0) * bh_f14_X->StickPrefilter_CSTATE;
439 _rtXdot->StickPrefilter_CSTATE += bh_f14_B->Sum1;
440
441 /* Derivatives for TransferFcn: '<S1>/Pitch Rate Lead Filter' */
442 _rtXdot->PitchRateLeadFilter_CSTATE = 0.0;
443 _rtXdot->PitchRateLeadFilter_CSTATE += (-4.144) *
444 bh_f14_X->PitchRateLeadFilter_CSTATE;
445 _rtXdot->PitchRateLeadFilter_CSTATE += bh_f14_B->TransferFcn1;
446
447 /* Derivatives for TransferFcn: '<S1>/Proportional plus integral compensator' */
448 _rtXdot->Proportionalplusintegralcompens = 0.0;
449 _rtXdot->Proportionalplusintegralcompens += (-0.0) *
450 bh_f14_X->Proportionalplusintegralcompens;
451 _rtXdot->Proportionalplusintegralcompens += bh_f14_B->Sum2;
452
453 /* Derivatives for TransferFcn: '<S4>/W-gust model' */
454 _rtXdot->Wgustmodel_CSTATE[0] = 0.0;
455 _rtXdot->Wgustmodel_CSTATE[0] += (-0.78901688496133815) *
456 bh_f14_X->Wgustmodel_CSTATE[0];
457 _rtXdot->Wgustmodel_CSTATE[1] = 0.0;
458 _rtXdot->Wgustmodel_CSTATE[0] += (-0.15563691118852338) *
459 bh_f14_X->Wgustmodel_CSTATE[1];
460 _rtXdot->Wgustmodel_CSTATE[1] += bh_f14_X->Wgustmodel_CSTATE[0];
461 _rtXdot->Wgustmodel_CSTATE[0] += bh_f14_B->Output;
462
463 /* Derivatives for TransferFcn: '<S4>/Q-gust model' */
464 _rtXdot->Qgustmodel_CSTATE = 0.0;
465 _rtXdot->Qgustmodel_CSTATE += (-8.4553078435926761) *
466 bh_f14_X->Qgustmodel_CSTATE;
467 _rtXdot->Qgustmodel_CSTATE += bh_f14_B->Wgustmodel;
468 }
469
470 /* Model initialize function */
471 void bh_f14_initialize(RT_MODEL_bh_f14_T *const bh_f14_M, real_T *bh_f14_U_u,
472 real_T *bh_f14_Y_alpharad, real_T *bh_f14_Y_NzPilotg)
473 {
474 DW_bh_f14_T *bh_f14_DW = ((DW_bh_f14_T *) bh_f14_M->ModelData.dwork);
475 X_bh_f14_T *bh_f14_X = ((X_bh_f14_T *) bh_f14_M->ModelData.contStates);
476 B_bh_f14_T *bh_f14_B = ((B_bh_f14_T *) bh_f14_M->ModelData.blockIO);
477
478 /* Registration code */
479
480 /* initialize non-finites */
481 rt_InitInfAndNaN(sizeof(real_T));
482
483 {
484 /* Setup solver object */
485 rtsiSetSimTimeStepPtr(&bh_f14_M->solverInfo, &bh_f14_M->Timing.simTimeStep);
486 rtsiSetTPtr(&bh_f14_M->solverInfo, &rtmGetTPtr(bh_f14_M));
487 rtsiSetStepSizePtr(&bh_f14_M->solverInfo, &bh_f14_M->Timing.stepSize0);
488 rtsiSetdXPtr(&bh_f14_M->solverInfo, &bh_f14_M->ModelData.derivs);
489 rtsiSetContStatesPtr(&bh_f14_M->solverInfo, (real_T **)
490 &bh_f14_M->ModelData.contStates);
491 rtsiSetNumContStatesPtr(&bh_f14_M->solverInfo,
492 &bh_f14_M->Sizes.numContStates);
493 rtsiSetNumPeriodicContStatesPtr(&bh_f14_M->solverInfo,
494 &bh_f14_M->Sizes.numPeriodicContStates);
495 rtsiSetPeriodicContStateIndicesPtr(&bh_f14_M->solverInfo,
496 &bh_f14_M->ModelData.periodicContStateIndices);
497 rtsiSetPeriodicContStateRangesPtr(&bh_f14_M->solverInfo,
498 &bh_f14_M->ModelData.periodicContStateRanges);
499 rtsiSetErrorStatusPtr(&bh_f14_M->solverInfo, (&rtmGetErrorStatus(bh_f14_M)));
500 rtsiSetRTModelPtr(&bh_f14_M->solverInfo, bh_f14_M);
501 }
502
503 rtsiSetSimTimeStep(&bh_f14_M->solverInfo, MAJOR_TIME_STEP);
504 bh_f14_M->ModelData.intgData.y = bh_f14_M->ModelData.odeY;
505 bh_f14_M->ModelData.intgData.f[0] = bh_f14_M->ModelData.odeF[0];
506 bh_f14_M->ModelData.intgData.f[1] = bh_f14_M->ModelData.odeF[1];
507 bh_f14_M->ModelData.intgData.f[2] = bh_f14_M->ModelData.odeF[2];
508 bh_f14_M->ModelData.intgData.f[3] = bh_f14_M->ModelData.odeF[3];
509 bh_f14_M->ModelData.contStates = ((X_bh_f14_T *) bh_f14_X);
510 rtsiSetSolverData(&bh_f14_M->solverInfo, (void *)&bh_f14_M->ModelData.intgData);
511 rtsiSetSolverName(&bh_f14_M->solverInfo,"ode4");
512 rtmSetTPtr(bh_f14_M, &bh_f14_M->Timing.tArray[0]);
513 bh_f14_M->Timing.stepSize0 = 0.01;
514
515 /* block I/O */
516 {
517 bh_f14_B->TransferFcn2 = 0.0;
518 bh_f14_B->Gain5 = 0.0;
519 bh_f14_B->TransferFcn1 = 0.0;
520 bh_f14_B->Gain2 = 0.0;
521 bh_f14_B->Sum1 = 0.0;
522 bh_f14_B->Sum2 = 0.0;
523 bh_f14_B->Sum = 0.0;
524 bh_f14_B->Wgustmodel = 0.0;
525 bh_f14_B->Sum1_o = 0.0;
526 bh_f14_B->Sum2_h = 0.0;
527 bh_f14_B->Output = 0.0;
528 }
529
530 /* states (continuous) */
531 {
532 (void) memset((void *)bh_f14_X, 0,
533 sizeof(X_bh_f14_T));
534 }
535
536 /* states (dwork) */
537 (void) memset((void *)bh_f14_DW, 0,
538 sizeof(DW_bh_f14_T));
539 bh_f14_DW->TimeStampA = 0.0;
540 bh_f14_DW->LastUAtTimeA = 0.0;
541 bh_f14_DW->TimeStampB = 0.0;
542 bh_f14_DW->LastUAtTimeB = 0.0;
543 bh_f14_DW->TimeStampA_o = 0.0;
544 bh_f14_DW->LastUAtTimeA_i = 0.0;
545 bh_f14_DW->TimeStampB_h = 0.0;
546 bh_f14_DW->LastUAtTimeB_j = 0.0;
547 bh_f14_DW->NextOutput = 0.0;
548
549 /* external inputs */
550 (*bh_f14_U_u) = 0.0;
551
552 /* external outputs */
553 (*bh_f14_Y_alpharad) = 0.0;
554 (*bh_f14_Y_NzPilotg) = 0.0;
555
556 {
557 uint32_T tseed;
558 int32_T r;
559 int32_T t;
560 real_T tmp;
561
562 /* InitializeConditions for TransferFcn: '<S3>/Transfer Fcn.2' */
563 bh_f14_X->TransferFcn2_CSTATE = 0.0;
564
565 /* InitializeConditions for Derivative: '<S2>/Derivative' */
566 bh_f14_DW->TimeStampA = (rtInf);
567 bh_f14_DW->TimeStampB = (rtInf);
568
569 /* InitializeConditions for TransferFcn: '<S3>/Transfer Fcn.1' */
570 bh_f14_X->TransferFcn1_CSTATE = 0.0;
571
572 /* InitializeConditions for Derivative: '<S2>/Derivative1' */
573 bh_f14_DW->TimeStampA_o = (rtInf);
574 bh_f14_DW->TimeStampB_h = (rtInf);
575
576 /* InitializeConditions for TransferFcn: '<Root>/Actuator' */
577 bh_f14_X->Actuator_CSTATE = 0.0;
578
579 /* InitializeConditions for TransferFcn: '<S1>/Alpha-sensor Low-pass Filter' */
580 bh_f14_X->AlphasensorLowpassFilter_CSTATE = 0.0;
581
582 /* InitializeConditions for TransferFcn: '<S1>/Stick Prefilter' */
583 bh_f14_X->StickPrefilter_CSTATE = 0.0;
584
585 /* InitializeConditions for TransferFcn: '<S1>/Pitch Rate Lead Filter' */
586 bh_f14_X->PitchRateLeadFilter_CSTATE = 0.0;
587
588 /* InitializeConditions for TransferFcn: '<S1>/Proportional plus integral compensator' */
589 bh_f14_X->Proportionalplusintegralcompens = 0.0;
590
591 /* InitializeConditions for TransferFcn: '<S4>/W-gust model' */
592 bh_f14_X->Wgustmodel_CSTATE[0] = 0.0;
593 bh_f14_X->Wgustmodel_CSTATE[1] = 0.0;
594
595 /* InitializeConditions for TransferFcn: '<S4>/Q-gust model' */
596 bh_f14_X->Qgustmodel_CSTATE = 0.0;
597
598 /* InitializeConditions for RandomNumber: '<S5>/White Noise' */
599 tmp = floor(23341.0);
600 if (rtIsNaN(tmp) || rtIsInf(tmp)) {
601 tmp = 0.0;
602 } else {
603 tmp = fmod(tmp, 4.294967296E+9);
604 }
605
606 tseed = tmp < 0.0 ? (uint32_T)-(int32_T)(uint32_T)-tmp : (uint32_T)tmp;
607 r = (int32_T)(tseed >> 16U);
608 t = (int32_T)(tseed & 32768U);
609 tseed = ((((tseed - ((uint32_T)r << 16U)) + t) << 16U) + t) + r;
610 if (tseed < 1U) {
611 tseed = 1144108930U;
612 } else {
613 if (tseed > 2147483646U) {
614 tseed = 2147483646U;
615 }
616 }
617
618 bh_f14_DW->RandSeed = tseed;
619 bh_f14_DW->NextOutput = rt_nrand_Upu32_Yd_f_pw_snf(&bh_f14_DW->RandSeed) *
620 1.0 + 0.0;
621
622 /* End of InitializeConditions for RandomNumber: '<S5>/White Noise' */
623 }
624 }
625
626 /* Model terminate function */
627 void bh_f14_terminate(RT_MODEL_bh_f14_T *const bh_f14_M)
628 {
629 /* (no terminate code required) */
630 UNUSED_PARAMETER(bh_f14_M);
631 }
632
633 /*
634 * File trailer for generated code.
635 *
636 * [EOF]
637 */
638
|