static void sf_c3_ErdMond(SFc3_ErdMondInstanceStruct *chartInstance)
{
int32_T c3_i2;
int32_T c3_i3;
int32_T c3_i4;
real_T c3_xAktuell[2];
uint32_T c3_debug_family_var_map[16];
real_T c3_xE[2];
real_T c3_eSE[2];
real_T c3_xM[2];
real_T c3_vSM[2];
real_T c3_rSM;
real_T c3_eSM[2];
real_T c3_r;
real_T c3_mE;
real_T c3_mM;
real_T c3_G;
real_T c3_F_SE[2];
real_T c3_F_SM[2];
real_T c3_nargin = 1.0;
real_T c3_nargout = 1.0;
real_T c3_a[2];
int32_T c3_i5;
real_T c3_A[2];
int32_T c3_i6;
real_T c3_b_xAktuell[2];
real_T c3_B;
real_T c3_y;
real_T c3_b_y;
int32_T c3_i7;
int32_T c3_i8;
int32_T c3_i9;
int32_T c3_i10;
int32_T c3_i11;
int32_T c3_i12;
real_T c3_b_vSM[2];
int32_T c3_i13;
int32_T c3_i14;
real_T c3_c_vSM[2];
real_T c3_b_B;
real_T c3_c_y;
real_T c3_d_y;
int32_T c3_i15;
int32_T c3_i16;
real_T c3_c_xAktuell[2];
real_T c3_c_B;
real_T c3_e_y;
real_T c3_f_y;
real_T c3_g_y;
real_T c3_b_a;
int32_T c3_i17;
int32_T c3_i18;
real_T c3_d_B;
real_T c3_h_y;
real_T c3_i_y;
real_T c3_j_y;
real_T c3_c_a;
int32_T c3_i19;
int32_T c3_i20;
int32_T c3_i21;
int32_T c3_i22;
real_T (*c3_d_a)[2];
real_T (*c3_d_xAktuell)[2];
c3_d_a = (real_T (*)[2])ssGetOutputPortSignal(chartInstance->S, 1);
c3_d_xAktuell = (real_T (*)[2])ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 2U, chartInstance->c3_sfEvent);
for (c3_i2 = 0; c3_i2 < 2; c3_i2++) {
_SFD_DATA_RANGE_CHECK((*c3_d_xAktuell)[c3_i2], 0U);
}
for (c3_i3 = 0; c3_i3 < 2; c3_i3++) {
_SFD_DATA_RANGE_CHECK((*c3_d_a)[c3_i3], 1U);
}
chartInstance->c3_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 2U, chartInstance->c3_sfEvent);
for (c3_i4 = 0; c3_i4 < 2; c3_i4++) {
c3_xAktuell[c3_i4] = (*c3_d_xAktuell)[c3_i4];
}
sf_debug_symbol_scope_push_eml(0U, 16U, 16U, c3_debug_family_names,
c3_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(c3_xE, 0U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(c3_eSE, 1U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(c3_xM, 2U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(c3_vSM, 3U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c3_rSM, 4U, c3_b_sf_marshallOut,
c3_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(c3_eSM, 5U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c3_r, 6U, c3_b_sf_marshallOut,
c3_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c3_mE, 7U, c3_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c3_mM, 8U, c3_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c3_G, 9U, c3_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(c3_F_SE, 10U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(c3_F_SM, 11U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c3_nargin, 12U, c3_b_sf_marshallOut,
c3_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c3_nargout, 13U, c3_b_sf_marshallOut,
c3_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c3_xAktuell, 14U, c3_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(c3_a, 15U, c3_sf_marshallOut,
c3_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 4);
for (c3_i5 = 0; c3_i5 < 2; c3_i5++) {
c3_A[c3_i5] = c3_xAktuell[c3_i5];
}
for (c3_i6 = 0; c3_i6 < 2; c3_i6++) {
c3_b_xAktuell[c3_i6] = c3_xAktuell[c3_i6];
}
c3_B = c3_norm(chartInstance, c3_b_xAktuell);
c3_y = c3_B;
c3_b_y = c3_y;
for (c3_i7 = 0; c3_i7 < 2; c3_i7++) {
c3_xE[c3_i7] = c3_A[c3_i7] / c3_b_y;
}
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 5);
for (c3_i8 = 0; c3_i8 < 2; c3_i8++) {
c3_A[c3_i8] = c3_xE[c3_i8];
}
for (c3_i9 = 0; c3_i9 < 2; c3_i9++) {
c3_eSE[c3_i9] = -c3_A[c3_i9];
}
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 7);
for (c3_i10 = 0; c3_i10 < 2; c3_i10++) {
c3_xM[c3_i10] = -3.8E+8 * (real_T)c3_i10;
}
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 8);
for (c3_i11 = 0; c3_i11 < 2; c3_i11++) {
c3_vSM[c3_i11] = c3_xM[c3_i11] - c3_xAktuell[c3_i11];
}
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 9);
for (c3_i12 = 0; c3_i12 < 2; c3_i12++) {
c3_b_vSM[c3_i12] = c3_vSM[c3_i12];
}
c3_rSM = c3_norm(chartInstance, c3_b_vSM);
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 10);
for (c3_i13 = 0; c3_i13 < 2; c3_i13++) {
c3_A[c3_i13] = c3_vSM[c3_i13];
}
for (c3_i14 = 0; c3_i14 < 2; c3_i14++) {
c3_c_vSM[c3_i14] = c3_vSM[c3_i14];
}
c3_b_B = c3_norm(chartInstance, c3_c_vSM);
c3_c_y = c3_b_B;
c3_d_y = c3_c_y;
for (c3_i15 = 0; c3_i15 < 2; c3_i15++) {
c3_eSM[c3_i15] = c3_A[c3_i15] / c3_d_y;
}
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 12);
for (c3_i16 = 0; c3_i16 < 2; c3_i16++) {
c3_c_xAktuell[c3_i16] = c3_xAktuell[c3_i16];
}
c3_r = c3_norm(chartInstance, c3_c_xAktuell);
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 14);
c3_mE = 5.9736000000000006E+24;
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 15);
c3_mM = 7.348E+22;
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 16);
c3_G = 6.6743E-11;
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 18);
c3_c_B = c3_mpower(chartInstance, c3_r);
c3_e_y = c3_c_B;
c3_f_y = c3_e_y;
c3_g_y = 3.986959848E+14 / c3_f_y;
c3_b_a = c3_g_y;
for (c3_i17 = 0; c3_i17 < 2; c3_i17++) {
c3_A[c3_i17] = c3_eSE[c3_i17];
}
for (c3_i18 = 0; c3_i18 < 2; c3_i18++) {
c3_F_SE[c3_i18] = c3_b_a * c3_A[c3_i18];
}
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 19);
c3_d_B = c3_mpower(chartInstance, c3_rSM);
c3_h_y = c3_d_B;
c3_i_y = c3_h_y;
c3_j_y = 4.904275639999999E+12 / c3_i_y;
c3_c_a = c3_j_y;
for (c3_i19 = 0; c3_i19 < 2; c3_i19++) {
c3_A[c3_i19] = c3_eSM[c3_i19];
}
for (c3_i20 = 0; c3_i20 < 2; c3_i20++) {
c3_F_SM[c3_i20] = c3_c_a * c3_A[c3_i20];
}
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 21);
for (c3_i21 = 0; c3_i21 < 2; c3_i21++) {
c3_a[c3_i21] = c3_F_SE[c3_i21] + c3_F_SM[c3_i21];
}
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, -21);
sf_debug_symbol_scope_pop();
for (c3_i22 = 0; c3_i22 < 2; c3_i22++) {
(*c3_d_a)[c3_i22] = c3_a[c3_i22];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 2U, chartInstance->c3_sfEvent);
sf_debug_check_for_state_inconsistency(_ErdMondMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void c2_chartstep_c2_Quadsim(SFc2_QuadsimInstanceStruct *chartInstance)
{
int32_T c2_i4;
real_T c2_Xin[16];
uint32_T c2_debug_family_var_map[40];
real_T c2_arm_l;
real_T c2_craft_m;
real_T c2_Ixx;
real_T c2_Iyy;
real_T c2_Izz;
real_T c2_b;
real_T c2_d;
real_T c2_g;
real_T c2_X_dot;
real_T c2_Y_dot;
real_T c2_Z_dot;
real_T c2_Roll_dot;
real_T c2_Pitch_dot;
real_T c2_Yaw_dot;
real_T c2_X;
real_T c2_Y;
real_T c2_Z;
real_T c2_Roll;
real_T c2_Pitch;
real_T c2_Yaw;
real_T c2_F;
real_T c2_R;
real_T c2_B;
real_T c2_L;
real_T c2_TF;
real_T c2_TR;
real_T c2_TB;
real_T c2_TL;
real_T c2_D;
real_T c2_X_ddot;
real_T c2_Y_ddot;
real_T c2_z_craft_component;
real_T c2_Z_ddot;
real_T c2_Roll_ddot;
real_T c2_Pitch_ddot;
real_T c2_Yaw_ddot;
real_T c2_nargin = 1.0;
real_T c2_nargout = 1.0;
real_T c2_Xout[12];
real_T c2_b_b;
real_T c2_c_b;
real_T c2_d_b;
real_T c2_e_b;
real_T c2_f_b;
real_T c2_x;
real_T c2_b_x;
real_T c2_c_x;
real_T c2_d_x;
real_T c2_a;
real_T c2_g_b;
real_T c2_y;
real_T c2_e_x;
real_T c2_f_x;
real_T c2_b_a;
real_T c2_h_b;
real_T c2_b_y;
real_T c2_g_x;
real_T c2_h_x;
real_T c2_i_x;
real_T c2_j_x;
real_T c2_c_a;
real_T c2_i_b;
real_T c2_c_y;
real_T c2_j_b;
real_T c2_d_y;
real_T c2_d_a;
real_T c2_k_b;
real_T c2_k_x;
real_T c2_l_x;
real_T c2_m_x;
real_T c2_n_x;
real_T c2_e_a;
real_T c2_l_b;
real_T c2_e_y;
real_T c2_o_x;
real_T c2_p_x;
real_T c2_f_a;
real_T c2_m_b;
real_T c2_f_y;
real_T c2_q_x;
real_T c2_r_x;
real_T c2_s_x;
real_T c2_t_x;
real_T c2_g_a;
real_T c2_n_b;
real_T c2_g_y;
real_T c2_o_b;
real_T c2_h_y;
real_T c2_h_a;
real_T c2_p_b;
real_T c2_u_x;
real_T c2_v_x;
real_T c2_q_b;
real_T c2_i_y;
real_T c2_w_x;
real_T c2_x_x;
real_T c2_i_a;
real_T c2_r_b;
real_T c2_j_y;
real_T c2_j_a;
real_T c2_s_b;
real_T c2_t_b;
real_T c2_u_b;
real_T c2_A;
real_T c2_y_x;
real_T c2_ab_x;
int32_T c2_i5;
real_T (*c2_b_Xout)[12];
real_T (*c2_b_Xin)[16];
c2_b_Xin = (real_T (*)[16])ssGetInputPortSignal(chartInstance->S, 0);
c2_b_Xout = (real_T (*)[12])ssGetOutputPortSignal(chartInstance->S, 1);
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
for (c2_i4 = 0; c2_i4 < 16; c2_i4++) {
c2_Xin[c2_i4] = (*c2_b_Xin)[c2_i4];
}
sf_debug_symbol_scope_push_eml(0U, 40U, 40U, c2_debug_family_names,
c2_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c2_arm_l, 0U, c2_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_craft_m, 1U, c2_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_Ixx, 2U, c2_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_Iyy, 3U, c2_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_Izz, 4U, c2_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_b, 5U, c2_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_d, 6U, c2_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c2_g, 7U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_X_dot, 8U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Y_dot, 9U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Z_dot, 10U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Roll_dot, 11U,
c2_c_sf_marshallOut, c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Pitch_dot, 12U,
c2_c_sf_marshallOut, c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Yaw_dot, 13U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_X, 14U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Y, 15U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Z, 16U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Roll, 17U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Pitch, 18U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Yaw, 19U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_F, 20U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_R, 21U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_B, 22U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_L, 23U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_TF, 24U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_TR, 25U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_TB, 26U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_TL, 27U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_D, 28U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_X_ddot, 29U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Y_ddot, 30U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_z_craft_component, 31U,
c2_c_sf_marshallOut, c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Z_ddot, 32U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Roll_ddot, 33U,
c2_c_sf_marshallOut, c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Pitch_ddot, 34U,
c2_c_sf_marshallOut, c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_Yaw_ddot, 35U,
c2_c_sf_marshallOut, c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_nargin, 36U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_nargout, 37U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c2_Xin, 38U, c2_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(c2_Xout, 39U, c2_sf_marshallOut,
c2_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 3);
c2_arm_l = 0.23;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 4);
c2_craft_m = 0.95;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 5);
c2_Ixx = 0.0075;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 6);
c2_Iyy = 0.0075;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 7);
c2_Izz = 0.013000000000000001;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 8);
c2_b = 3.1299999999999995E-5;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 9);
c2_d = 7.5E-7;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 10);
c2_g = 9.81;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 13);
c2_X_dot = c2_Xin[0];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 14);
c2_Y_dot = c2_Xin[1];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 15);
c2_Z_dot = c2_Xin[2];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 16);
c2_Roll_dot = c2_Xin[3];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 17);
c2_Pitch_dot = c2_Xin[4];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 18);
c2_Yaw_dot = c2_Xin[5];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 19);
c2_X = c2_Xin[6];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 20);
c2_Y = c2_Xin[7];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 21);
c2_Z = c2_Xin[8];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 22);
c2_Roll = c2_Xin[9];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 23);
c2_Pitch = c2_Xin[10];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 24);
c2_Yaw = c2_Xin[11];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 33);
c2_F = c2_Xin[12];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 34);
c2_R = c2_Xin[13];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 35);
c2_B = c2_Xin[14];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 36);
c2_L = c2_Xin[15];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 39);
c2_b_b = c2_mpower(chartInstance, c2_F);
c2_TF = 3.1299999999999995E-5 * c2_b_b;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 40);
c2_c_b = c2_mpower(chartInstance, c2_R);
c2_TR = 3.1299999999999995E-5 * c2_c_b;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 41);
c2_d_b = c2_mpower(chartInstance, c2_B);
c2_TB = 3.1299999999999995E-5 * c2_d_b;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 42);
c2_e_b = c2_mpower(chartInstance, c2_L);
c2_TL = 3.1299999999999995E-5 * c2_e_b;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 43);
c2_f_b = ((-c2_F + c2_R) - c2_B) + c2_L;
c2_D = 7.5E-7 * c2_f_b;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 56);
c2_x = c2_Roll;
c2_b_x = c2_x;
c2_b_x = muDoubleScalarCos(c2_b_x);
c2_c_x = c2_Pitch;
c2_d_x = c2_c_x;
c2_d_x = muDoubleScalarSin(c2_d_x);
c2_a = c2_b_x;
c2_g_b = c2_d_x;
c2_y = c2_a * c2_g_b;
c2_e_x = c2_Yaw;
c2_f_x = c2_e_x;
c2_f_x = muDoubleScalarCos(c2_f_x);
c2_b_a = c2_y;
c2_h_b = c2_f_x;
c2_b_y = c2_b_a * c2_h_b;
c2_g_x = c2_Roll;
c2_h_x = c2_g_x;
c2_h_x = muDoubleScalarSin(c2_h_x);
c2_i_x = c2_Yaw;
c2_j_x = c2_i_x;
c2_j_x = muDoubleScalarSin(c2_j_x);
c2_c_a = c2_h_x;
c2_i_b = c2_j_x;
c2_c_y = c2_c_a * c2_i_b;
c2_j_b = c2_b_y + c2_c_y;
c2_d_y = 1.0526315789473684 * c2_j_b;
c2_d_a = c2_d_y;
c2_k_b = ((c2_TF + c2_TR) + c2_TB) + c2_TL;
c2_X_ddot = c2_d_a * c2_k_b;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 57);
c2_k_x = c2_Roll;
c2_l_x = c2_k_x;
c2_l_x = muDoubleScalarCos(c2_l_x);
c2_m_x = c2_Pitch;
c2_n_x = c2_m_x;
c2_n_x = muDoubleScalarSin(c2_n_x);
c2_e_a = c2_l_x;
c2_l_b = c2_n_x;
c2_e_y = c2_e_a * c2_l_b;
c2_o_x = c2_Yaw;
c2_p_x = c2_o_x;
c2_p_x = muDoubleScalarSin(c2_p_x);
c2_f_a = c2_e_y;
c2_m_b = c2_p_x;
c2_f_y = c2_f_a * c2_m_b;
c2_q_x = c2_Roll;
c2_r_x = c2_q_x;
c2_r_x = muDoubleScalarSin(c2_r_x);
c2_s_x = c2_Yaw;
c2_t_x = c2_s_x;
c2_t_x = muDoubleScalarCos(c2_t_x);
c2_g_a = c2_r_x;
c2_n_b = c2_t_x;
c2_g_y = c2_g_a * c2_n_b;
c2_o_b = c2_f_y + c2_g_y;
c2_h_y = 1.0526315789473684 * c2_o_b;
c2_h_a = c2_h_y;
c2_p_b = ((c2_TF + c2_TR) + c2_TB) + c2_TL;
c2_Y_ddot = c2_h_a * c2_p_b;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 58);
c2_u_x = c2_Roll;
c2_v_x = c2_u_x;
c2_v_x = muDoubleScalarCos(c2_v_x);
c2_q_b = c2_v_x;
c2_i_y = 1.0526315789473684 * c2_q_b;
c2_w_x = c2_Pitch;
c2_x_x = c2_w_x;
c2_x_x = muDoubleScalarCos(c2_x_x);
c2_i_a = c2_i_y;
c2_r_b = c2_x_x;
c2_j_y = c2_i_a * c2_r_b;
c2_j_a = c2_j_y;
c2_s_b = ((c2_TF + c2_TR) + c2_TB) + c2_TL;
c2_z_craft_component = c2_j_a * c2_s_b;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 59);
c2_Z_ddot = c2_z_craft_component - c2_g;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 60);
c2_t_b = -c2_TR + c2_TL;
c2_Roll_ddot = 30.666666666666668 * c2_t_b;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 61);
c2_u_b = c2_TF - c2_TB;
c2_Pitch_ddot = 30.666666666666668 * c2_u_b;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 62);
c2_A = c2_D;
c2_y_x = c2_A;
c2_ab_x = c2_y_x;
c2_Yaw_ddot = c2_ab_x / 0.013000000000000001;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 65);
c2_Xout[0] = c2_X_ddot;
c2_Xout[1] = c2_Y_ddot;
c2_Xout[2] = c2_Z_ddot;
c2_Xout[3] = c2_Roll_ddot;
c2_Xout[4] = c2_Pitch_ddot;
c2_Xout[5] = c2_Yaw_ddot;
c2_Xout[6] = c2_X_dot;
c2_Xout[7] = c2_Y_dot;
c2_Xout[8] = c2_Z_dot;
c2_Xout[9] = c2_Roll_dot;
c2_Xout[10] = c2_Pitch_dot;
c2_Xout[11] = c2_Yaw_dot;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, -65);
sf_debug_symbol_scope_pop();
for (c2_i5 = 0; c2_i5 < 12; c2_i5++) {
(*c2_b_Xout)[c2_i5] = c2_Xout[c2_i5];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
}
static void sf_c2_SATest(SFc2_SATestInstanceStruct *chartInstance)
{
int32_T c2_previousEvent;
real_T c2_hoistedGlobal;
real_T c2_b_hoistedGlobal;
real_T c2_c_hoistedGlobal;
real_T c2_d_hoistedGlobal;
real_T c2_d1;
real_T c2_d2;
real_T c2_d3;
real_T c2_d4;
uint32_T c2_debug_family_var_map[8];
real_T c2_nargin = 4.0;
real_T c2_nargout = 1.0;
real_T c2_i;
real_T *c2_b_d1;
real_T *c2_b_i;
real_T *c2_b_d2;
real_T *c2_b_d3;
real_T *c2_b_d4;
c2_b_d4 = (real_T *)ssGetInputPortSignal(chartInstance->S, 3);
c2_b_d3 = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
c2_b_d2 = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c2_b_i = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c2_b_d1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 0);
_SFD_DATA_RANGE_CHECK(*c2_b_d1, 0U);
_SFD_DATA_RANGE_CHECK(*c2_b_i, 1U);
_SFD_DATA_RANGE_CHECK(*c2_b_d2, 2U);
_SFD_DATA_RANGE_CHECK(*c2_b_d3, 3U);
_SFD_DATA_RANGE_CHECK(*c2_b_d4, 4U);
c2_previousEvent = _sfEvent_;
_sfEvent_ = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0);
c2_hoistedGlobal = *c2_b_d1;
c2_b_hoistedGlobal = *c2_b_d2;
c2_c_hoistedGlobal = *c2_b_d3;
c2_d_hoistedGlobal = *c2_b_d4;
c2_d1 = c2_hoistedGlobal;
c2_d2 = c2_b_hoistedGlobal;
c2_d3 = c2_c_hoistedGlobal;
c2_d4 = c2_d_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 8U, 8U, c2_debug_family_names,
c2_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c2_nargin, c2_b_sf_marshall, 0U);
sf_debug_symbol_scope_add_eml(&c2_nargout, c2_b_sf_marshall, 1U);
sf_debug_symbol_scope_add_eml(&c2_d1, c2_b_sf_marshall, 2U);
sf_debug_symbol_scope_add_eml(&c2_d2, c2_b_sf_marshall, 3U);
sf_debug_symbol_scope_add_eml(&c2_d3, c2_b_sf_marshall, 4U);
sf_debug_symbol_scope_add_eml(&c2_d4, c2_b_sf_marshall, 5U);
sf_debug_symbol_scope_add_eml(&c2_i, c2_b_sf_marshall, 6U);
sf_debug_symbol_scope_add_eml(&chartInstance->c2_j, c2_sf_marshall, 7U);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0, 6);
if (CV_EML_IF(0, 0, !chartInstance->c2_j_not_empty)) {
_SFD_EML_CALL(0, 7);
chartInstance->c2_j = 1.0;
chartInstance->c2_j_not_empty = TRUE;
}
_SFD_EML_CALL(0, 10);
if (CV_EML_COND(0, 0, chartInstance->c2_j == 1.0)) {
if (CV_EML_COND(0, 1, c2_d1 < 20.0)) {
CV_EML_MCDC(0, 0, TRUE);
CV_EML_IF(0, 1, TRUE);
_SFD_EML_CALL(0, 11);
chartInstance->c2_j = chartInstance->c2_j + 1.0;
goto label_1;
}
}
CV_EML_MCDC(0, 0, FALSE);
CV_EML_IF(0, 1, FALSE);
label_1:
;
_SFD_EML_CALL(0, 14);
if (CV_EML_COND(0, 2, chartInstance->c2_j == 2.0)) {
if (CV_EML_COND(0, 3, c2_d2 < 20.0)) {
CV_EML_MCDC(0, 1, TRUE);
CV_EML_IF(0, 2, TRUE);
_SFD_EML_CALL(0, 15);
chartInstance->c2_j = chartInstance->c2_j + 1.0;
goto label_2;
}
}
CV_EML_MCDC(0, 1, FALSE);
CV_EML_IF(0, 2, FALSE);
label_2:
;
_SFD_EML_CALL(0, 18);
if (CV_EML_COND(0, 4, chartInstance->c2_j == 3.0)) {
if (CV_EML_COND(0, 5, c2_d3 < 20.0)) {
CV_EML_MCDC(0, 2, TRUE);
CV_EML_IF(0, 3, TRUE);
_SFD_EML_CALL(0, 19);
chartInstance->c2_j = chartInstance->c2_j + 1.0;
goto label_3;
}
}
CV_EML_MCDC(0, 2, FALSE);
CV_EML_IF(0, 3, FALSE);
label_3:
;
_SFD_EML_CALL(0, 22);
if (CV_EML_COND(0, 6, chartInstance->c2_j == 4.0)) {
if (CV_EML_COND(0, 7, c2_d4 < 20.0)) {
CV_EML_MCDC(0, 3, TRUE);
CV_EML_IF(0, 4, TRUE);
_SFD_EML_CALL(0, 23);
chartInstance->c2_j = 1.0;
goto label_4;
}
}
CV_EML_MCDC(0, 3, FALSE);
CV_EML_IF(0, 4, FALSE);
label_4:
;
_SFD_EML_CALL(0, 26);
c2_i = chartInstance->c2_j;
_SFD_EML_CALL(0, -26);
sf_debug_symbol_scope_pop();
*c2_b_i = c2_i;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0);
_sfEvent_ = c2_previousEvent;
sf_debug_check_for_state_inconsistency(_SATestMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c25_BuckBoost1(SFc25_BuckBoost1InstanceStruct *chartInstance)
{
real_T c25_hoistedGlobal;
real_T c25_b_hoistedGlobal;
real_T c25_Ts;
real_T c25_TimeCNT_k1;
uint32_T c25_debug_family_var_map[7];
real_T c25_Tsimulation;
real_T c25_CNT_Ts;
real_T c25_nargin = 2.0;
real_T c25_nargout = 1.0;
real_T c25_TimeCNT_k;
real_T c25_A;
real_T c25_x;
real_T c25_b_x;
real_T c25_y;
real_T *c25_b_TimeCNT_k1;
real_T *c25_b_Ts;
real_T *c25_b_TimeCNT_k;
c25_b_TimeCNT_k = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c25_b_TimeCNT_k1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c25_b_Ts = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 7U, chartInstance->c25_sfEvent);
_SFD_DATA_RANGE_CHECK(*c25_b_Ts, 0U);
_SFD_DATA_RANGE_CHECK(*c25_b_TimeCNT_k1, 1U);
_SFD_DATA_RANGE_CHECK(*c25_b_TimeCNT_k, 2U);
chartInstance->c25_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 7U, chartInstance->c25_sfEvent);
c25_hoistedGlobal = *c25_b_Ts;
c25_b_hoistedGlobal = *c25_b_TimeCNT_k1;
c25_Ts = c25_hoistedGlobal;
c25_TimeCNT_k1 = c25_b_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 7U, 7U, c25_debug_family_names,
c25_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c25_Tsimulation, 0U, c25_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c25_CNT_Ts, 1U, c25_sf_marshallOut,
c25_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c25_nargin, 2U, c25_sf_marshallOut,
c25_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c25_nargout, 3U, c25_sf_marshallOut,
c25_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c25_Ts, 4U, c25_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c25_TimeCNT_k1, 5U, c25_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c25_TimeCNT_k, 6U,
c25_sf_marshallOut, c25_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c25_sfEvent, 3);
c25_Tsimulation = 1.0E-6;
_SFD_EML_CALL(0U, chartInstance->c25_sfEvent, 4);
c25_A = c25_Ts;
c25_x = c25_A;
c25_b_x = c25_x;
c25_y = c25_b_x / 1.0E-6;
c25_CNT_Ts = c25_y - 1.0;
_SFD_EML_CALL(0U, chartInstance->c25_sfEvent, 6);
if (CV_EML_IF(0, 1, 0, c25_TimeCNT_k1 >= c25_CNT_Ts)) {
_SFD_EML_CALL(0U, chartInstance->c25_sfEvent, 7);
c25_TimeCNT_k = 0.0;
} else {
_SFD_EML_CALL(0U, chartInstance->c25_sfEvent, 9);
c25_TimeCNT_k = c25_TimeCNT_k1 + 1.0;
}
_SFD_EML_CALL(0U, chartInstance->c25_sfEvent, -9);
sf_debug_symbol_scope_pop();
*c25_b_TimeCNT_k = c25_TimeCNT_k;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 7U, chartInstance->c25_sfEvent);
sf_debug_check_for_state_inconsistency(_BuckBoost1MachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c3_controller1(SFc3_controller1InstanceStruct *chartInstance)
{
int32_T c3_previousEvent;
real_T c3_hoistedGlobal;
real_T c3_u;
uint32_T c3_debug_family_var_map[5];
real_T c3_T;
real_T c3_nargin = 1.0;
real_T c3_nargout = 1.0;
real_T c3_y;
real_T c3_x;
real_T c3_b_x;
real_T c3_b_y;
real_T c3_c_x;
real_T c3_d_x;
real_T c3_c_y;
real_T c3_b;
real_T c3_d_y;
real_T c3_A;
real_T c3_B;
real_T c3_e_x;
real_T c3_e_y;
real_T c3_f_x;
real_T c3_f_y;
real_T c3_g_x;
real_T c3_g_y;
real_T *c3_b_u;
real_T *c3_h_y;
c3_h_y = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c3_b_u = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 2);
_SFD_DATA_RANGE_CHECK(*c3_b_u, 0U);
_SFD_DATA_RANGE_CHECK(*c3_h_y, 1U);
c3_previousEvent = _sfEvent_;
_sfEvent_ = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 2);
c3_hoistedGlobal = *c3_b_u;
c3_u = c3_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 5U, 5U, c3_debug_family_names,
c3_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c3_T, c3_sf_marshall, 0U);
sf_debug_symbol_scope_add_eml(&c3_nargin, c3_sf_marshall, 1U);
sf_debug_symbol_scope_add_eml(&c3_nargout, c3_sf_marshall, 2U);
sf_debug_symbol_scope_add_eml(&c3_u, c3_sf_marshall, 3U);
sf_debug_symbol_scope_add_eml(&c3_y, c3_sf_marshall, 4U);
CV_EML_FCN(0, 0);
/* hard limit cutoff function. */
_SFD_EML_CALL(0, 4);
c3_T = 100.0;
_SFD_EML_CALL(0, 5);
c3_x = c3_u;
c3_b_x = c3_x;
c3_b_y = muDoubleScalarAbs(c3_b_x);
if (CV_EML_IF(0, 0, c3_b_y > c3_T)) {
_SFD_EML_CALL(0, 6);
c3_c_x = c3_u;
c3_d_x = c3_c_x;
c3_c_y = muDoubleScalarAbs(c3_d_x);
c3_b = c3_c_y;
c3_d_y = 100.0 * c3_b;
c3_A = c3_d_y;
c3_B = c3_u;
c3_e_x = c3_A;
c3_e_y = c3_B;
c3_f_x = c3_e_x;
c3_f_y = c3_e_y;
c3_g_x = c3_f_x;
c3_g_y = c3_f_y;
c3_u = c3_g_x / c3_g_y;
}
_SFD_EML_CALL(0, 8);
c3_y = c3_u;
_SFD_EML_CALL(0, -8);
sf_debug_symbol_scope_pop();
*c3_h_y = c3_y;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 2);
_sfEvent_ = c3_previousEvent;
sf_debug_check_for_state_inconsistency(_controller1MachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c1_motor_control_with_off_the_shelf_SVPWM
(SFc1_motor_control_with_off_the_shelf_SVPWMInstanceStruct *chartInstance)
{
real_T c1_hoistedGlobal;
real_T c1_b_hoistedGlobal;
real_T c1_Tdes;
real_T c1_w;
uint32_T c1_debug_family_var_map[13];
real_T c1_L;
real_T c1_R;
real_T c1_Ke;
real_T c1_Kt;
real_T c1_Ides;
real_T c1_bemf;
real_T c1_ZL;
real_T c1_nargin = 2.0;
real_T c1_nargout = 2.0;
real_T c1_Vd;
real_T c1_Vq;
real_T c1_A;
real_T c1_x;
real_T c1_b_x;
real_T c1_b;
real_T c1_b_b;
real_T c1_a;
real_T c1_y;
real_T c1_b_a;
real_T c1_c_b;
real_T *c1_b_Vq;
real_T *c1_b_Vd;
real_T *c1_b_w;
real_T *c1_b_Tdes;
c1_b_Vq = (real_T *)ssGetOutputPortSignal(chartInstance->S, 2);
c1_b_w = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c1_b_Vd = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c1_b_Tdes = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
_SFD_DATA_RANGE_CHECK(*c1_b_Tdes, 0U);
_SFD_DATA_RANGE_CHECK(*c1_b_Vd, 1U);
_SFD_DATA_RANGE_CHECK(*c1_b_w, 2U);
_SFD_DATA_RANGE_CHECK(*c1_b_Vq, 3U);
chartInstance->c1_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
c1_hoistedGlobal = *c1_b_Tdes;
c1_b_hoistedGlobal = *c1_b_w;
c1_Tdes = c1_hoistedGlobal;
c1_w = c1_b_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 13U, 13U, c1_debug_family_names,
c1_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c1_L, 0U, c1_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c1_R, 1U, c1_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c1_Ke, 2U, c1_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c1_Kt, 3U, c1_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c1_Ides, 4U, c1_sf_marshallOut,
c1_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_bemf, 5U, c1_sf_marshallOut,
c1_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_ZL, 6U, c1_sf_marshallOut,
c1_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_nargin, 7U, c1_sf_marshallOut,
c1_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_nargout, 8U, c1_sf_marshallOut,
c1_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c1_Tdes, 9U, c1_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c1_w, 10U, c1_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c1_Vd, 11U, c1_sf_marshallOut,
c1_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_Vq, 12U, c1_sf_marshallOut,
c1_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 7);
c1_L = 0.0019399999999999999;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 8);
c1_R = 28.2;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 9);
c1_Ke = 0.018095917050234851;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 10);
c1_Kt = 1810.0;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 13);
c1_A = c1_Tdes;
c1_x = c1_A;
c1_b_x = c1_x;
c1_Ides = c1_b_x / 1810.0;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 16);
c1_b = c1_w;
c1_bemf = 0.018095917050234851 * c1_b;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 19);
c1_b_b = c1_w;
c1_ZL = 0.0019399999999999999 * c1_b_b;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 21);
c1_a = c1_Ides;
c1_y = c1_a * 28.2;
c1_Vq = c1_bemf + c1_y;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 22);
c1_b_a = -c1_ZL;
c1_c_b = c1_Ides;
c1_Vd = c1_b_a * c1_c_b;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, -22);
sf_debug_symbol_scope_pop();
*c1_b_Vd = c1_Vd;
*c1_b_Vq = c1_Vq;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
sf_debug_check_for_state_inconsistency
(_motor_control_with_off_the_shelf_SVPWMMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c9_testing_control_with_estimate
(SFc9_testing_control_with_estimateInstanceStruct *chartInstance)
{
real_T c9_hoistedGlobal;
real_T c9_b_hoistedGlobal;
real_T c9_c_hoistedGlobal;
real_T c9_d_hoistedGlobal;
real_T c9_s1;
real_T c9_dc1;
real_T c9_s2;
real_T c9_dc2;
uint32_T c9_debug_family_var_map[10];
real_T c9_dc[3];
real_T c9_nargin = 4.0;
real_T c9_nargout = 3.0;
real_T c9_Va;
real_T c9_Vb;
real_T c9_Vc;
int32_T c9_i0;
int32_T c9_i1;
real_T c9_u[3];
const mxArray *c9_y = NULL;
int32_T c9_i2;
real_T c9_b_u[3];
const mxArray *c9_b_y = NULL;
real_T c9_a;
real_T c9_b_a;
real_T c9_c_a;
real_T *c9_b_s1;
real_T *c9_b_Va;
real_T *c9_b_dc1;
real_T *c9_b_s2;
real_T *c9_b_dc2;
real_T *c9_b_Vb;
real_T *c9_b_Vc;
c9_b_Vc = (real_T *)ssGetOutputPortSignal(chartInstance->S, 3);
c9_b_Vb = (real_T *)ssGetOutputPortSignal(chartInstance->S, 2);
c9_b_dc2 = (real_T *)ssGetInputPortSignal(chartInstance->S, 3);
c9_b_s2 = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
c9_b_dc1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c9_b_Va = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c9_b_s1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 5U, chartInstance->c9_sfEvent);
_SFD_DATA_RANGE_CHECK(*c9_b_s1, 0U);
_SFD_DATA_RANGE_CHECK(*c9_b_Va, 1U);
_SFD_DATA_RANGE_CHECK(*c9_b_dc1, 2U);
_SFD_DATA_RANGE_CHECK(*c9_b_s2, 3U);
_SFD_DATA_RANGE_CHECK(*c9_b_dc2, 4U);
_SFD_DATA_RANGE_CHECK(*c9_b_Vb, 5U);
_SFD_DATA_RANGE_CHECK(*c9_b_Vc, 6U);
chartInstance->c9_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 5U, chartInstance->c9_sfEvent);
c9_hoistedGlobal = *c9_b_s1;
c9_b_hoistedGlobal = *c9_b_dc1;
c9_c_hoistedGlobal = *c9_b_s2;
c9_d_hoistedGlobal = *c9_b_dc2;
c9_s1 = c9_hoistedGlobal;
c9_dc1 = c9_b_hoistedGlobal;
c9_s2 = c9_c_hoistedGlobal;
c9_dc2 = c9_d_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 10U, 10U, c9_debug_family_names,
c9_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(c9_dc, 0U, c9_b_sf_marshallOut,
c9_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c9_nargin, 1U, c9_sf_marshallOut,
c9_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c9_nargout, 2U, c9_sf_marshallOut,
c9_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c9_s1, 3U, c9_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c9_dc1, 4U, c9_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c9_s2, 5U, c9_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c9_dc2, 6U, c9_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c9_Va, 7U, c9_sf_marshallOut,
c9_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c9_Vb, 8U, c9_sf_marshallOut,
c9_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c9_Vc, 9U, c9_sf_marshallOut,
c9_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 10);
for (c9_i0 = 0; c9_i0 < 3; c9_i0++) {
c9_dc[c9_i0] = 0.0;
}
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 12);
switch ((int32_T)_SFD_INTEGER_CHECK("s1", c9_s1)) {
case 1:
CV_EML_SWITCH(0, 1, 0, 1);
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 15);
if (CV_EML_IF(0, 1, 0, c9_s2 == 2.0)) {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 16);
c9_dc[0] = c9_dc1 + c9_dc2;
c9_dc[1] = c9_dc2;
c9_dc[2] = 0.0;
} else {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 18);
c9_dc[0] = c9_dc1 + c9_dc2;
c9_dc[1] = 0.0;
c9_dc[2] = c9_dc2;
}
break;
case 2:
CV_EML_SWITCH(0, 1, 0, 2);
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 21);
if (CV_EML_IF(0, 1, 1, c9_s2 == 3.0)) {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 22);
c9_dc[0] = c9_dc1;
c9_dc[1] = c9_dc1 + c9_dc2;
c9_dc[2] = 0.0;
} else {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 24);
c9_dc[0] = c9_dc1 + c9_dc2;
c9_dc[1] = c9_dc1;
c9_dc[2] = 0.0;
}
break;
case 3:
CV_EML_SWITCH(0, 1, 0, 3);
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 27);
if (CV_EML_IF(0, 1, 2, c9_s2 == 4.0)) {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 28);
c9_dc[0] = 0.0;
c9_dc[1] = c9_dc1 + c9_dc2;
c9_dc[2] = c9_dc2;
} else {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 30);
c9_dc[0] = c9_dc2;
c9_dc[1] = c9_dc1 + c9_dc2;
c9_dc[2] = 0.0;
}
break;
case 4:
CV_EML_SWITCH(0, 1, 0, 4);
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 33);
if (CV_EML_IF(0, 1, 3, c9_s2 == 5.0)) {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 34);
c9_dc[0] = 0.0;
c9_dc[1] = c9_dc1;
c9_dc[2] = c9_dc1 + c9_dc2;
} else {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 36);
c9_dc[0] = 0.0;
c9_dc[1] = c9_dc1 + c9_dc2;
c9_dc[2] = c9_dc1;
sf_mex_printf("%s =\\n", "dc");
for (c9_i1 = 0; c9_i1 < 3; c9_i1++) {
c9_u[c9_i1] = c9_dc[c9_i1];
}
c9_y = NULL;
sf_mex_assign(&c9_y, sf_mex_create("y", c9_u, 0, 0U, 1U, 0U, 2, 1, 3),
FALSE);
sf_mex_call_debug("disp", 0U, 1U, 14, c9_y);
}
break;
case 5:
CV_EML_SWITCH(0, 1, 0, 5);
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 39);
if (CV_EML_IF(0, 1, 4, c9_s2 == 6.0)) {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 40);
c9_dc[0] = c9_dc2;
c9_dc[1] = 0.0;
c9_dc[2] = c9_dc1 + c9_dc2;
} else {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 42);
c9_dc[0] = 0.0;
c9_dc[1] = c9_dc2;
c9_dc[2] = c9_dc1 + c9_dc2;
}
break;
case 6:
CV_EML_SWITCH(0, 1, 0, 6);
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 46);
if (CV_EML_IF(0, 1, 5, c9_s2 == 1.0)) {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 47);
c9_dc[0] = c9_dc1 + c9_dc2;
c9_dc[1] = 0.0;
c9_dc[2] = c9_dc1;
} else {
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 49);
c9_dc[0] = c9_dc1;
c9_dc[1] = 0.0;
c9_dc[2] = c9_dc1 + c9_dc2;
sf_mex_printf("%s =\\n", "dc");
for (c9_i2 = 0; c9_i2 < 3; c9_i2++) {
c9_b_u[c9_i2] = c9_dc[c9_i2];
}
c9_b_y = NULL;
sf_mex_assign(&c9_b_y, sf_mex_create("y", c9_b_u, 0, 0U, 1U, 0U, 2, 1, 3),
FALSE);
sf_mex_call_debug("disp", 0U, 1U, 14, c9_b_y);
}
break;
default:
CV_EML_SWITCH(0, 1, 0, 0);
break;
}
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 54);
c9_a = c9_dc[0];
c9_Va = c9_a * 12.0;
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 55);
c9_b_a = c9_dc[1];
c9_Vb = c9_b_a * 12.0;
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 56);
c9_c_a = c9_dc[2];
c9_Vc = c9_c_a * 12.0;
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, -56);
sf_debug_symbol_scope_pop();
*c9_b_Va = c9_Va;
*c9_b_Vb = c9_Vb;
*c9_b_Vc = c9_Vc;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 5U, chartInstance->c9_sfEvent);
sf_debug_check_for_state_inconsistency
(_testing_control_with_estimateMachineNumber_, chartInstance->chartNumber,
chartInstance->instanceNumber);
}
static void sf_c12_ekffedepre(SFc12_ekffedepreInstanceStruct *chartInstance)
{
int32_T c12_i2;
int32_T c12_i3;
int32_T c12_i4;
real_T c12_Q_bias[3];
uint32_T c12_debug_family_var_map[4];
real_T c12_nargin = 1.0;
real_T c12_nargout = 1.0;
real_T c12_y[9];
int32_T c12_i5;
real_T c12_v[3];
int32_T c12_i6;
int32_T c12_j;
int32_T c12_b_j;
int32_T c12_a;
int32_T c12_c;
int32_T c12_i7;
real_T (*c12_b_y)[9];
real_T (*c12_b_Q_bias)[3];
c12_b_y = (real_T (*)[9])ssGetOutputPortSignal(chartInstance->S, 1);
c12_b_Q_bias = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 11U, chartInstance->c12_sfEvent);
for (c12_i2 = 0; c12_i2 < 3; c12_i2++) {
_SFD_DATA_RANGE_CHECK((*c12_b_Q_bias)[c12_i2], 0U);
}
for (c12_i3 = 0; c12_i3 < 9; c12_i3++) {
_SFD_DATA_RANGE_CHECK((*c12_b_y)[c12_i3], 1U);
}
chartInstance->c12_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 11U, chartInstance->c12_sfEvent);
for (c12_i4 = 0; c12_i4 < 3; c12_i4++) {
c12_Q_bias[c12_i4] = (*c12_b_Q_bias)[c12_i4];
}
sf_debug_symbol_scope_push_eml(0U, 4U, 4U, c12_debug_family_names,
c12_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c12_nargin, 0U, c12_c_sf_marshallOut,
c12_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c12_nargout, 1U,
c12_c_sf_marshallOut, c12_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c12_Q_bias, 2U, c12_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(c12_y, 3U, c12_sf_marshallOut,
c12_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c12_sfEvent, 4);
for (c12_i5 = 0; c12_i5 < 3; c12_i5++) {
c12_v[c12_i5] = c12_Q_bias[c12_i5];
}
for (c12_i6 = 0; c12_i6 < 9; c12_i6++) {
c12_y[c12_i6] = 0.0;
}
for (c12_j = 1; c12_j < 4; c12_j++) {
c12_b_j = c12_j;
c12_a = c12_b_j;
c12_c = c12_a;
c12_y[(_SFD_EML_ARRAY_BOUNDS_CHECK("", (int32_T)_SFD_INTEGER_CHECK("",
(real_T)c12_b_j), 1, 3, 1, 0) + 3 * (_SFD_EML_ARRAY_BOUNDS_CHECK("",
(int32_T)_SFD_INTEGER_CHECK("", (real_T)c12_c), 1, 3, 2, 0) - 1)) -
1] = c12_v[_SFD_EML_ARRAY_BOUNDS_CHECK("", (int32_T)_SFD_INTEGER_CHECK("",
(real_T)c12_b_j), 1, 3, 1, 0) - 1];
}
_SFD_EML_CALL(0U, chartInstance->c12_sfEvent, -4);
sf_debug_symbol_scope_pop();
for (c12_i7 = 0; c12_i7 < 9; c12_i7++) {
(*c12_b_y)[c12_i7] = c12_y[c12_i7];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 11U, chartInstance->c12_sfEvent);
sf_debug_check_for_state_inconsistency(_ekffedepreMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c2_Leda(SFc2_LedaInstanceStruct *chartInstance)
{
real_T c2_hoistedGlobal;
real_T c2_nota;
uint32_T c2_debug_family_var_map[4];
real_T c2_nargin = 1.0;
real_T c2_nargout = 0.0;
int32_T c2_i2;
int32_T c2_i;
real_T c2_b_i;
real_T c2_u;
const mxArray *c2_y = NULL;
int32_T c2_i3;
static char_T c2_cv0[4] = { '.', 'j', 'p', 'g' };
char_T c2_b_u[4];
const mxArray *c2_b_y = NULL;
static real_T c2_dv1[435483];
int32_T c2_c_i;
int32_T c2_i4;
int32_T c2_i5;
int32_T c2_i6;
int32_T c2_i7;
static real_T c2_b_hoistedGlobal[33096708];
int32_T c2_b_nota;
int32_T c2_i8;
int32_T c2_i9;
int32_T c2_i10;
static real_T c2_c_u[435483];
const mxArray *c2_c_y = NULL;
real_T *c2_c_nota;
c2_c_nota = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
_SFD_DATA_RANGE_CHECK(*c2_c_nota, 0U);
chartInstance->c2_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
c2_hoistedGlobal = *c2_c_nota;
c2_nota = c2_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 4U, 4U, c2_debug_family_names,
c2_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c2_nargin, 0U, c2_b_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_nargout, 1U, c2_b_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c2_nota, 2U, c2_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(chartInstance->c2_pent, 3U,
c2_sf_marshallOut, c2_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 3);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 4);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 9);
if (CV_EML_IF(0, 1, 0, !chartInstance->c2_pent_not_empty)) {
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 10);
for (c2_i2 = 0; c2_i2 < 33096708; c2_i2++) {
chartInstance->c2_pent[c2_i2] = 0.0;
}
chartInstance->c2_pent_not_empty = TRUE;
c2_i = 0;
while (c2_i < 73) {
c2_b_i = 4.0 + (real_T)c2_i;
CV_EML_FOR(0, 1, 0, 1);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 13);
c2_u = c2_b_i;
c2_y = NULL;
sf_mex_assign(&c2_y, sf_mex_create("y", &c2_u, 0, 0U, 0U, 0U, 0), FALSE);
for (c2_i3 = 0; c2_i3 < 4; c2_i3++) {
c2_b_u[c2_i3] = c2_cv0[c2_i3];
}
c2_b_y = NULL;
sf_mex_assign(&c2_b_y, sf_mex_create("y", c2_b_u, 10, 0U, 1U, 0U, 2, 1, 4),
FALSE);
c2_d_emlrt_marshallIn(chartInstance, sf_mex_call_debug("imread", 1U, 1U,
14, sf_mex_call_debug("horzcat", 1U, 2U, 14, sf_mex_call_debug("num2str",
1U, 1U, 14, c2_y), 14, c2_b_y)), "imread", c2_dv1);
c2_c_i = _SFD_EML_ARRAY_BOUNDS_CHECK("pent", (int32_T)_SFD_INTEGER_CHECK(
"i", c2_b_i), 1, 76, 4, 0) - 1;
for (c2_i4 = 0; c2_i4 < 3; c2_i4++) {
for (c2_i5 = 0; c2_i5 < 381; c2_i5++) {
for (c2_i6 = 0; c2_i6 < 381; c2_i6++) {
chartInstance->c2_pent[((c2_i6 + 381 * c2_i5) + 145161 * c2_i4) +
435483 * c2_c_i] = c2_dv1[(c2_i6 + 381 * c2_i5) + 145161 * c2_i4];
}
}
}
c2_i++;
sf_mex_listen_for_ctrl_c(chartInstance->S);
}
CV_EML_FOR(0, 1, 0, 0);
}
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 19);
if (CV_EML_IF(0, 1, 1, c2_nota < 4.0)) {
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 20);
c2_nota = 4.0;
}
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 22);
if (CV_EML_IF(0, 1, 2, c2_nota > 76.0)) {
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 23);
c2_nota = 76.0;
}
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 26);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 32);
for (c2_i7 = 0; c2_i7 < 33096708; c2_i7++) {
c2_b_hoistedGlobal[c2_i7] = chartInstance->c2_pent[c2_i7];
}
c2_b_nota = _SFD_EML_ARRAY_BOUNDS_CHECK("pent", (int32_T)_SFD_INTEGER_CHECK(
"nota", c2_nota), 1, 76, 4, 0) - 1;
for (c2_i8 = 0; c2_i8 < 3; c2_i8++) {
for (c2_i9 = 0; c2_i9 < 381; c2_i9++) {
for (c2_i10 = 0; c2_i10 < 381; c2_i10++) {
c2_c_u[(c2_i10 + 381 * c2_i9) + 145161 * c2_i8] = c2_b_hoistedGlobal
[((c2_i10 + 381 * c2_i9) + 145161 * c2_i8) + 435483 * c2_b_nota];
}
}
}
c2_c_y = NULL;
sf_mex_assign(&c2_c_y, sf_mex_create("y", c2_c_u, 0, 0U, 1U, 0U, 3, 381, 381,
3), FALSE);
sf_mex_call_debug("imshow", 0U, 1U, 14, c2_c_y);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, -32);
sf_debug_symbol_scope_pop();
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
sf_debug_check_for_state_inconsistency(_LedaMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c11_kinematics(SFc11_kinematicsInstanceStruct *chartInstance)
{
int32_T c11_i2;
int32_T c11_i3;
int32_T c11_i4;
int32_T c11_i5;
real_T c11_body_velocity[6];
int32_T c11_i6;
real_T c11_euler_angles_vehicle[3];
uint32_T c11_debug_family_var_map[6];
const mxArray *c11_J = NULL;
real_T c11_nargin = 2.0;
real_T c11_nargout = 1.0;
real_T c11_vehicle_rates[6];
int32_T c11_i7;
real_T c11_u[3];
const mxArray *c11_y = NULL;
int32_T c11_i8;
int32_T c11_i9;
real_T c11_b_u[6];
const mxArray *c11_b_y = NULL;
real_T c11_dv1[6];
int32_T c11_i10;
int32_T c11_i11;
real_T (*c11_b_vehicle_rates)[6];
real_T (*c11_b_euler_angles_vehicle)[3];
real_T (*c11_b_body_velocity)[6];
c11_b_euler_angles_vehicle = (real_T (*)[3])ssGetInputPortSignal
(chartInstance->S, 1);
c11_b_vehicle_rates = (real_T (*)[6])ssGetOutputPortSignal(chartInstance->S, 1);
c11_b_body_velocity = (real_T (*)[6])ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 8U, chartInstance->c11_sfEvent);
for (c11_i2 = 0; c11_i2 < 6; c11_i2++) {
_SFD_DATA_RANGE_CHECK((*c11_b_body_velocity)[c11_i2], 0U);
}
for (c11_i3 = 0; c11_i3 < 6; c11_i3++) {
_SFD_DATA_RANGE_CHECK((*c11_b_vehicle_rates)[c11_i3], 1U);
}
for (c11_i4 = 0; c11_i4 < 3; c11_i4++) {
_SFD_DATA_RANGE_CHECK((*c11_b_euler_angles_vehicle)[c11_i4], 2U);
}
chartInstance->c11_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 8U, chartInstance->c11_sfEvent);
for (c11_i5 = 0; c11_i5 < 6; c11_i5++) {
c11_body_velocity[c11_i5] = (*c11_b_body_velocity)[c11_i5];
}
for (c11_i6 = 0; c11_i6 < 3; c11_i6++) {
c11_euler_angles_vehicle[c11_i6] = (*c11_b_euler_angles_vehicle)[c11_i6];
}
sf_debug_symbol_scope_push_eml(0U, 6U, 6U, c11_debug_family_names,
c11_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c11_J, 0U, c11_d_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c11_nargin, 1U, c11_c_sf_marshallOut,
c11_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c11_nargout, 2U,
c11_c_sf_marshallOut, c11_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c11_body_velocity, 3U, c11_sf_marshallOut);
sf_debug_symbol_scope_add_eml(c11_euler_angles_vehicle, 4U,
c11_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(c11_vehicle_rates, 5U,
c11_sf_marshallOut, c11_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c11_sfEvent, 3);
_SFD_EML_CALL(0U, chartInstance->c11_sfEvent, 4);
for (c11_i7 = 0; c11_i7 < 3; c11_i7++) {
c11_u[c11_i7] = c11_euler_angles_vehicle[c11_i7];
}
c11_y = NULL;
sf_mex_assign(&c11_y, sf_mex_create("y", c11_u, 0, 0U, 1U, 0U, 1, 3), FALSE);
sf_mex_assign(&c11_J, sf_mex_call_debug("analytical_jacobian", 1U, 1U, 14,
c11_y), FALSE);
_SFD_EML_CALL(0U, chartInstance->c11_sfEvent, 6);
for (c11_i8 = 0; c11_i8 < 6; c11_i8++) {
c11_vehicle_rates[c11_i8] = 0.0;
}
_SFD_EML_CALL(0U, chartInstance->c11_sfEvent, 7);
for (c11_i9 = 0; c11_i9 < 6; c11_i9++) {
c11_b_u[c11_i9] = c11_body_velocity[c11_i9];
}
c11_b_y = NULL;
sf_mex_assign(&c11_b_y, sf_mex_create("y", c11_b_u, 0, 0U, 1U, 0U, 1, 6),
FALSE);
c11_b_emlrt_marshallIn(chartInstance, sf_mex_call_debug("mtimes", 1U, 2U, 14,
sf_mex_dup(c11_J), 14, c11_b_y), "mtimes", c11_dv1);
for (c11_i10 = 0; c11_i10 < 6; c11_i10++) {
c11_vehicle_rates[c11_i10] = c11_dv1[c11_i10];
}
_SFD_EML_CALL(0U, chartInstance->c11_sfEvent, -7);
sf_debug_symbol_scope_pop();
sf_mex_destroy(&c11_J);
for (c11_i11 = 0; c11_i11 < 6; c11_i11++) {
(*c11_b_vehicle_rates)[c11_i11] = c11_vehicle_rates[c11_i11];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 8U, chartInstance->c11_sfEvent);
sf_debug_check_for_state_inconsistency(_kinematicsMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c14_test(SFc14_testInstanceStruct *chartInstance)
{
real_T c14_hoistedGlobal;
real_T c14_u;
uint32_T c14_debug_family_var_map[7];
real_T c14_a1;
real_T c14_a2;
real_T c14_k3;
real_T c14_nargin = 1.0;
real_T c14_nargout = 1.0;
real_T c14_y;
real_T c14_x;
real_T c14_b_x;
real_T c14_b_y;
real_T c14_c_x;
real_T c14_d_x;
real_T c14_A;
real_T c14_e_x;
real_T c14_f_x;
real_T c14_g_x;
real_T c14_h_x;
real_T c14_c_y;
real_T c14_i_x;
real_T c14_j_x;
real_T c14_b_A;
real_T c14_k_x;
real_T c14_l_x;
real_T c14_m_x;
real_T c14_n_x;
real_T c14_o_x;
real_T c14_p_x;
real_T c14_d_y;
real_T c14_a;
real_T c14_b;
real_T c14_b_a;
real_T c14_b_b;
real_T c14_e_y;
real_T c14_c_a;
real_T c14_c_b;
real_T c14_f_y;
real_T *c14_b_u;
real_T *c14_g_y;
c14_g_y = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c14_b_u = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 12U, chartInstance->c14_sfEvent);
_SFD_DATA_RANGE_CHECK(*c14_b_u, 0U);
_SFD_DATA_RANGE_CHECK(*c14_g_y, 1U);
chartInstance->c14_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 12U, chartInstance->c14_sfEvent);
c14_hoistedGlobal = *c14_b_u;
c14_u = c14_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 7U, 7U, c14_debug_family_names,
c14_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c14_a1, 0U, c14_sf_marshallOut,
c14_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c14_a2, 1U, c14_sf_marshallOut,
c14_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c14_k3, 2U, c14_sf_marshallOut,
c14_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c14_nargin, 3U, c14_sf_marshallOut,
c14_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c14_nargout, 4U, c14_sf_marshallOut,
c14_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c14_u, 5U, c14_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c14_y, 6U, c14_sf_marshallOut,
c14_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 3);
c14_x = c14_u;
c14_b_x = c14_x;
c14_b_y = muDoubleScalarAbs(c14_b_x);
c14_c_x = c14_b_y - 3.1415926535897931;
c14_d_x = c14_c_x;
c14_d_x = muDoubleScalarSign(c14_d_x);
c14_A = 1.0 - c14_d_x;
c14_e_x = c14_A;
c14_f_x = c14_e_x;
c14_a1 = c14_f_x / 2.0;
_SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 4);
c14_g_x = c14_u;
c14_h_x = c14_g_x;
c14_c_y = muDoubleScalarAbs(c14_h_x);
c14_i_x = c14_c_y - 3.1415926535897931;
c14_j_x = c14_i_x;
c14_j_x = muDoubleScalarSign(c14_j_x);
c14_b_A = 1.0 + c14_j_x;
c14_k_x = c14_b_A;
c14_l_x = c14_k_x;
c14_a2 = c14_l_x / 2.0;
_SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 5);
c14_m_x = c14_u;
c14_n_x = c14_m_x;
c14_n_x = muDoubleScalarSign(c14_n_x);
c14_o_x = c14_u;
c14_p_x = c14_o_x;
c14_d_y = muDoubleScalarAbs(c14_p_x);
c14_a = -c14_n_x;
c14_b = 6.2831853071795862 - c14_d_y;
c14_k3 = c14_a * c14_b;
_SFD_EML_CALL(0U, chartInstance->c14_sfEvent, 6);
c14_b_a = c14_a1;
c14_b_b = c14_u;
c14_e_y = c14_b_a * c14_b_b;
c14_c_a = c14_a2;
c14_c_b = c14_k3;
c14_f_y = c14_c_a * c14_c_b;
c14_y = c14_e_y + c14_f_y;
_SFD_EML_CALL(0U, chartInstance->c14_sfEvent, -6);
sf_debug_symbol_scope_pop();
*c14_g_y = c14_y;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 12U, chartInstance->c14_sfEvent);
sf_debug_check_for_state_inconsistency(_testMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c20_ekffede(SFc20_ekffedeInstanceStruct *chartInstance)
{
int32_T c20_i0;
real_T c20_hoistedGlobal;
real_T c20_b_hoistedGlobal;
int32_T c20_i1;
real_T c20_mag[3];
real_T c20_phi;
real_T c20_theta;
uint32_T c20_debug_family_var_map[8];
real_T c20_mn;
real_T c20_me;
real_T c20_nargin = 3.0;
real_T c20_nargout = 1.0;
real_T c20_psi;
real_T c20_x;
real_T c20_b_x;
real_T c20_a;
real_T c20_b;
real_T c20_y;
real_T c20_c_x;
real_T c20_d_x;
real_T c20_e_x;
real_T c20_f_x;
real_T c20_b_a;
real_T c20_b_b;
real_T c20_b_y;
real_T c20_c_a;
real_T c20_c_b;
real_T c20_c_y;
real_T c20_g_x;
real_T c20_h_x;
real_T c20_i_x;
real_T c20_j_x;
real_T c20_d_a;
real_T c20_d_b;
real_T c20_d_y;
real_T c20_e_a;
real_T c20_e_b;
real_T c20_e_y;
real_T c20_k_x;
real_T c20_l_x;
real_T c20_f_a;
real_T c20_f_b;
real_T c20_f_y;
real_T c20_m_x;
real_T c20_n_x;
real_T c20_g_a;
real_T c20_g_b;
real_T c20_g_y;
real_T c20_h_y;
real_T c20_o_x;
real_T c20_i_y;
real_T c20_p_x;
real_T c20_r;
real_T *c20_b_psi;
real_T *c20_b_phi;
real_T *c20_b_theta;
real_T (*c20_b_mag)[3];
c20_b_theta = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
c20_b_phi = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c20_b_psi = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c20_b_mag = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 19U, chartInstance->c20_sfEvent);
for (c20_i0 = 0; c20_i0 < 3; c20_i0++) {
_SFD_DATA_RANGE_CHECK((*c20_b_mag)[c20_i0], 0U);
}
_SFD_DATA_RANGE_CHECK(*c20_b_psi, 1U);
_SFD_DATA_RANGE_CHECK(*c20_b_phi, 2U);
_SFD_DATA_RANGE_CHECK(*c20_b_theta, 3U);
chartInstance->c20_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 19U, chartInstance->c20_sfEvent);
c20_hoistedGlobal = *c20_b_phi;
c20_b_hoistedGlobal = *c20_b_theta;
for (c20_i1 = 0; c20_i1 < 3; c20_i1++) {
c20_mag[c20_i1] = (*c20_b_mag)[c20_i1];
}
c20_phi = c20_hoistedGlobal;
c20_theta = c20_b_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 8U, 8U, c20_debug_family_names,
c20_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c20_mn, 0U, c20_sf_marshallOut,
c20_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c20_me, 1U, c20_sf_marshallOut,
c20_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c20_nargin, 2U, c20_sf_marshallOut,
c20_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c20_nargout, 3U, c20_sf_marshallOut,
c20_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c20_mag, 4U, c20_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c20_phi, 5U, c20_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c20_theta, 6U, c20_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c20_psi, 7U, c20_sf_marshallOut,
c20_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c20_sfEvent, 3);
c20_x = c20_theta;
c20_b_x = c20_x;
c20_b_x = muDoubleScalarCos(c20_b_x);
c20_a = c20_b_x;
c20_b = c20_mag[0];
c20_y = c20_a * c20_b;
c20_c_x = c20_phi;
c20_d_x = c20_c_x;
c20_d_x = muDoubleScalarSin(c20_d_x);
c20_e_x = c20_theta;
c20_f_x = c20_e_x;
c20_f_x = muDoubleScalarSin(c20_f_x);
c20_b_a = c20_d_x;
c20_b_b = c20_f_x;
c20_b_y = c20_b_a * c20_b_b;
c20_c_a = c20_b_y;
c20_c_b = c20_mag[1];
c20_c_y = c20_c_a * c20_c_b;
c20_g_x = c20_phi;
c20_h_x = c20_g_x;
c20_h_x = muDoubleScalarCos(c20_h_x);
c20_i_x = c20_theta;
c20_j_x = c20_i_x;
c20_j_x = muDoubleScalarSin(c20_j_x);
c20_d_a = c20_h_x;
c20_d_b = c20_j_x;
c20_d_y = c20_d_a * c20_d_b;
c20_e_a = c20_d_y;
c20_e_b = c20_mag[2];
c20_e_y = c20_e_a * c20_e_b;
c20_mn = (c20_y + c20_c_y) + c20_e_y;
_SFD_EML_CALL(0U, chartInstance->c20_sfEvent, 7);
c20_k_x = c20_phi;
c20_l_x = c20_k_x;
c20_l_x = muDoubleScalarCos(c20_l_x);
c20_f_a = c20_l_x;
c20_f_b = c20_mag[1];
c20_f_y = c20_f_a * c20_f_b;
c20_m_x = c20_phi;
c20_n_x = c20_m_x;
c20_n_x = muDoubleScalarSin(c20_n_x);
c20_g_a = -c20_n_x;
c20_g_b = c20_mag[2];
c20_g_y = c20_g_a * c20_g_b;
c20_me = c20_f_y + c20_g_y;
_SFD_EML_CALL(0U, chartInstance->c20_sfEvent, 10);
c20_h_y = c20_me;
c20_o_x = c20_mn;
c20_i_y = c20_h_y;
c20_p_x = c20_o_x;
c20_r = muDoubleScalarAtan2(c20_i_y, c20_p_x);
c20_psi = -c20_r;
_SFD_EML_CALL(0U, chartInstance->c20_sfEvent, -10);
sf_debug_symbol_scope_pop();
*c20_b_psi = c20_psi;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 19U, chartInstance->c20_sfEvent);
sf_debug_check_for_state_inconsistency(_ekffedeMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void c2_chartstep_c2_Batman_Code(SFc2_Batman_CodeInstanceStruct
*chartInstance)
{
int32_T c2_i5;
uint32_T c2_msg[2];
int32_T c2_i6;
uint16_T c2_cell_voltages_in[12];
uint32_T c2_debug_family_var_map[9];
uint16_T c2_x1;
uint16_T c2_x2;
uint16_T c2_x3;
uint16_T c2_x4;
real_T c2_nargin = 2.0;
real_T c2_nargout = 1.0;
uint16_T c2_cell_voltages_out[12];
uint32_T c2_a;
uint32_T c2_a1;
uint32_T c2_c;
uint32_T c2_b;
uint32_T c2_b_c;
uint32_T c2_u0;
uint32_T c2_b_a;
uint32_T c2_b_a1;
uint32_T c2_c_c;
uint32_T c2_b_b;
uint32_T c2_d_c;
uint32_T c2_u1;
uint32_T c2_c_a;
uint32_T c2_c_a1;
uint32_T c2_e_c;
uint32_T c2_c_b;
uint32_T c2_f_c;
uint32_T c2_u2;
uint32_T c2_d_a;
uint32_T c2_d_a1;
uint32_T c2_g_c;
uint32_T c2_d_b;
uint32_T c2_h_c;
uint32_T c2_u3;
int32_T c2_i7;
int32_T c2_i8;
uint16_T (*c2_b_cell_voltages_out)[12];
uint16_T (*c2_b_cell_voltages_in)[12];
uint32_T (*c2_b_msg)[2];
c2_b_cell_voltages_out = (uint16_T (*)[12])ssGetOutputPortSignal
(chartInstance->S, 1);
c2_b_cell_voltages_in = (uint16_T (*)[12])ssGetInputPortSignal
(chartInstance->S, 1);
c2_b_msg = (uint32_T (*)[2])ssGetInputPortSignal(chartInstance->S, 0);
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0U, chartInstance->c2_sfEvent);
for (c2_i5 = 0; c2_i5 < 2; c2_i5++) {
c2_msg[c2_i5] = (*c2_b_msg)[c2_i5];
}
for (c2_i6 = 0; c2_i6 < 12; c2_i6++) {
c2_cell_voltages_in[c2_i6] = (*c2_b_cell_voltages_in)[c2_i6];
}
sf_debug_symbol_scope_push_eml(0U, 9U, 9U, c2_debug_family_names,
c2_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c2_x1, 0U, c2_d_sf_marshallOut,
c2_c_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_x2, 1U, c2_d_sf_marshallOut,
c2_c_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_x3, 2U, c2_d_sf_marshallOut,
c2_c_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_x4, 3U, c2_d_sf_marshallOut,
c2_c_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_nargin, 4U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_nargout, 5U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c2_msg, 6U, c2_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml(c2_cell_voltages_in, 7U, c2_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(c2_cell_voltages_out, 8U,
c2_sf_marshallOut, c2_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 5);
c2_a = c2_msg[0];
c2_a1 = c2_a;
c2_c = c2_a1;
c2_b = c2_c;
c2_b_c = c2_b & 65535U;
c2_u0 = c2_b_c;
if (c2_u0 > 65535U) {
c2_u0 = 65535U;
}
c2_x1 = (uint16_T)c2_u0;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 6);
c2_b_a = c2_msg[0];
c2_b_a1 = c2_b_a;
c2_c_c = c2_b_a1 >> 16U;
c2_b_b = c2_c_c;
c2_d_c = c2_b_b & 65535U;
c2_u1 = c2_d_c;
if (c2_u1 > 65535U) {
c2_u1 = 65535U;
}
c2_x2 = (uint16_T)c2_u1;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 7);
c2_c_a = c2_msg[1];
c2_c_a1 = c2_c_a;
c2_e_c = c2_c_a1;
c2_c_b = c2_e_c;
c2_f_c = c2_c_b & 65535U;
c2_u2 = c2_f_c;
if (c2_u2 > 65535U) {
c2_u2 = 65535U;
}
c2_x3 = (uint16_T)c2_u2;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 8);
c2_d_a = c2_msg[1];
c2_d_a1 = c2_d_a;
c2_g_c = c2_d_a1 >> 16U;
c2_d_b = c2_g_c;
c2_h_c = c2_d_b & 65535U;
c2_u3 = c2_h_c;
if (c2_u3 > 65535U) {
c2_u3 = 65535U;
}
c2_x4 = (uint16_T)c2_u3;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 11);
c2_cell_voltages_in[4] = c2_x1;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 12);
c2_cell_voltages_in[5] = c2_x2;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 13);
c2_cell_voltages_in[6] = c2_x3;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 14);
c2_cell_voltages_in[7] = c2_x4;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 17);
for (c2_i7 = 0; c2_i7 < 12; c2_i7++) {
c2_cell_voltages_out[c2_i7] = c2_cell_voltages_in[c2_i7];
}
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, -17);
sf_debug_symbol_scope_pop();
for (c2_i8 = 0; c2_i8 < 12; c2_i8++) {
(*c2_b_cell_voltages_out)[c2_i8] = c2_cell_voltages_out[c2_i8];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c2_sfEvent);
}
static void sf_c2_car_model(SFc2_car_modelInstanceStruct *chartInstance)
{
int32_T c2_i3;
int32_T c2_i4;
int32_T c2_i5;
int32_T c2_i6;
int32_T c2_i7;
int32_T c2_previousEvent;
int32_T c2_i8;
real_T c2_hoistedGlobal[4];
int32_T c2_i9;
real_T c2_b_hoistedGlobal[3];
int32_T c2_i10;
real_T c2_c_hoistedGlobal[2];
int32_T c2_i11;
real_T c2_d_hoistedGlobal[2];
int32_T c2_i12;
real_T c2_X[4];
int32_T c2_i13;
real_T c2_u[3];
int32_T c2_i14;
real_T c2_f_F[2];
int32_T c2_i15;
real_T c2_f_R[2];
uint32_T c2_debug_family_var_map[26];
real_T c2_m;
real_T c2_Iz;
real_T c2_l_F;
real_T c2_l_R;
real_T c2_Vx;
real_T c2_Vy;
real_T c2_r;
real_T c2_psi;
real_T c2_f_Fx;
real_T c2_f_Rx;
real_T c2_delta;
real_T c2_f_Fy;
real_T c2_f_Fz;
real_T c2_f_Ry;
real_T c2_f_Rz;
real_T c2_dVx;
real_T c2_dVy;
real_T c2_dr;
real_T c2_dpsi;
real_T c2_nargin = 4.0;
real_T c2_nargout = 1.0;
real_T c2_dX[4];
real_T c2_x;
real_T c2_b_x;
real_T c2_c_x;
real_T c2_a;
real_T c2_b;
real_T c2_y;
real_T c2_d_x;
real_T c2_e_x;
real_T c2_f_x;
real_T c2_b_a;
real_T c2_b_b;
real_T c2_b_y;
real_T c2_c_b;
real_T c2_c_y;
real_T c2_c_a;
real_T c2_d_b;
real_T c2_d_y;
real_T c2_g_x;
real_T c2_h_x;
real_T c2_i_x;
real_T c2_d_a;
real_T c2_e_b;
real_T c2_e_y;
real_T c2_j_x;
real_T c2_k_x;
real_T c2_l_x;
real_T c2_e_a;
real_T c2_f_b;
real_T c2_f_y;
real_T c2_g_b;
real_T c2_g_y;
real_T c2_f_a;
real_T c2_h_b;
real_T c2_h_y;
real_T c2_m_x;
real_T c2_n_x;
real_T c2_o_x;
real_T c2_g_a;
real_T c2_i_b;
real_T c2_i_y;
real_T c2_p_x;
real_T c2_q_x;
real_T c2_r_x;
real_T c2_h_a;
real_T c2_j_b;
real_T c2_j_y;
real_T c2_i_a;
real_T c2_k_y;
real_T c2_j_a;
real_T c2_l_y;
real_T c2_k_b;
real_T c2_b_dVx[4];
int32_T c2_i16;
int32_T c2_i17;
real_T (*c2_b_dX)[4];
real_T (*c2_b_f_R)[2];
real_T (*c2_b_f_F)[2];
real_T (*c2_b_u)[3];
real_T (*c2_b_X)[4];
c2_b_dX = (real_T (*)[4])ssGetOutputPortSignal(chartInstance->S, 1);
c2_b_f_R = (real_T (*)[2])ssGetInputPortSignal(chartInstance->S, 3);
c2_b_f_F = (real_T (*)[2])ssGetInputPortSignal(chartInstance->S, 2);
c2_b_u = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 1);
c2_b_X = (real_T (*)[4])ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG,1);
for (c2_i3 = 0; c2_i3 < 4; c2_i3 = c2_i3 + 1) {
_SFD_DATA_RANGE_CHECK((*c2_b_X)[c2_i3], 0U);
}
for (c2_i4 = 0; c2_i4 < 3; c2_i4 = c2_i4 + 1) {
_SFD_DATA_RANGE_CHECK((*c2_b_u)[c2_i4], 1U);
}
for (c2_i5 = 0; c2_i5 < 2; c2_i5 = c2_i5 + 1) {
_SFD_DATA_RANGE_CHECK((*c2_b_f_F)[c2_i5], 2U);
}
for (c2_i6 = 0; c2_i6 < 2; c2_i6 = c2_i6 + 1) {
_SFD_DATA_RANGE_CHECK((*c2_b_f_R)[c2_i6], 3U);
}
for (c2_i7 = 0; c2_i7 < 4; c2_i7 = c2_i7 + 1) {
_SFD_DATA_RANGE_CHECK((*c2_b_dX)[c2_i7], 4U);
}
c2_previousEvent = _sfEvent_;
_sfEvent_ = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG,1);
for (c2_i8 = 0; c2_i8 < 4; c2_i8 = c2_i8 + 1) {
c2_hoistedGlobal[c2_i8] = (*c2_b_X)[c2_i8];
}
for (c2_i9 = 0; c2_i9 < 3; c2_i9 = c2_i9 + 1) {
c2_b_hoistedGlobal[c2_i9] = (*c2_b_u)[c2_i9];
}
for (c2_i10 = 0; c2_i10 < 2; c2_i10 = c2_i10 + 1) {
c2_c_hoistedGlobal[c2_i10] = (*c2_b_f_F)[c2_i10];
}
for (c2_i11 = 0; c2_i11 < 2; c2_i11 = c2_i11 + 1) {
c2_d_hoistedGlobal[c2_i11] = (*c2_b_f_R)[c2_i11];
}
for (c2_i12 = 0; c2_i12 < 4; c2_i12 = c2_i12 + 1) {
c2_X[c2_i12] = c2_hoistedGlobal[c2_i12];
}
for (c2_i13 = 0; c2_i13 < 3; c2_i13 = c2_i13 + 1) {
c2_u[c2_i13] = c2_b_hoistedGlobal[c2_i13];
}
for (c2_i14 = 0; c2_i14 < 2; c2_i14 = c2_i14 + 1) {
c2_f_F[c2_i14] = c2_c_hoistedGlobal[c2_i14];
}
for (c2_i15 = 0; c2_i15 < 2; c2_i15 = c2_i15 + 1) {
c2_f_R[c2_i15] = c2_d_hoistedGlobal[c2_i15];
}
sf_debug_symbol_scope_push_eml(0U, 26U, 26U, c2_debug_family_names,
c2_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c2_m, c2_d_sf_marshall, 0U);
sf_debug_symbol_scope_add_eml(&c2_Iz, c2_d_sf_marshall, 1U);
sf_debug_symbol_scope_add_eml(&c2_l_F, c2_d_sf_marshall, 2U);
sf_debug_symbol_scope_add_eml(&c2_l_R, c2_d_sf_marshall, 3U);
sf_debug_symbol_scope_add_eml(&c2_Vx, c2_d_sf_marshall, 4U);
sf_debug_symbol_scope_add_eml(&c2_Vy, c2_d_sf_marshall, 5U);
sf_debug_symbol_scope_add_eml(&c2_r, c2_d_sf_marshall, 6U);
sf_debug_symbol_scope_add_eml(&c2_psi, c2_d_sf_marshall, 7U);
sf_debug_symbol_scope_add_eml(&c2_f_Fx, c2_d_sf_marshall, 8U);
sf_debug_symbol_scope_add_eml(&c2_f_Rx, c2_d_sf_marshall, 9U);
sf_debug_symbol_scope_add_eml(&c2_delta, c2_d_sf_marshall, 10U);
sf_debug_symbol_scope_add_eml(&c2_f_Fy, c2_d_sf_marshall, 11U);
sf_debug_symbol_scope_add_eml(&c2_f_Fz, c2_d_sf_marshall, 12U);
sf_debug_symbol_scope_add_eml(&c2_f_Ry, c2_d_sf_marshall, 13U);
sf_debug_symbol_scope_add_eml(&c2_f_Rz, c2_d_sf_marshall, 14U);
sf_debug_symbol_scope_add_eml(&c2_dVx, c2_d_sf_marshall, 15U);
sf_debug_symbol_scope_add_eml(&c2_dVy, c2_d_sf_marshall, 16U);
sf_debug_symbol_scope_add_eml(&c2_dr, c2_d_sf_marshall, 17U);
sf_debug_symbol_scope_add_eml(&c2_dpsi, c2_d_sf_marshall, 18U);
sf_debug_symbol_scope_add_eml(&c2_nargin, c2_d_sf_marshall, 19U);
sf_debug_symbol_scope_add_eml(&c2_nargout, c2_d_sf_marshall, 20U);
sf_debug_symbol_scope_add_eml(&c2_X, c2_sf_marshall, 21U);
sf_debug_symbol_scope_add_eml(&c2_u, c2_c_sf_marshall, 22U);
sf_debug_symbol_scope_add_eml(&c2_f_F, c2_b_sf_marshall, 23U);
sf_debug_symbol_scope_add_eml(&c2_f_R, c2_b_sf_marshall, 24U);
sf_debug_symbol_scope_add_eml(&c2_dX, c2_sf_marshall, 25U);
CV_EML_FCN(0, 0);
/* m = param.m; */
/* Iz = param.Iz; */
/* l_F = param.l_F; */
/* l_R = param.l_R; */
/* B = param.B; */
/* C = param.C; */
/* mu = param.mu; */
/* delta_max = param.delta_max; */
_SFD_EML_CALL(0,13);
c2_m = 1450.0;
_SFD_EML_CALL(0,14);
c2_Iz = 2740.0;
_SFD_EML_CALL(0,15);
c2_l_F = 1.1;
_SFD_EML_CALL(0,16);
c2_l_R = 1.6;
_SFD_EML_CALL(0,18);
c2_Vx = c2_X[0];
_SFD_EML_CALL(0,19);
c2_Vy = c2_X[1];
_SFD_EML_CALL(0,20);
c2_r = c2_X[2];
_SFD_EML_CALL(0,21);
c2_psi = c2_X[3];
_SFD_EML_CALL(0,23);
c2_f_Fx = c2_u[0];
_SFD_EML_CALL(0,24);
c2_f_Rx = c2_u[1];
_SFD_EML_CALL(0,25);
c2_delta = c2_u[2];
_SFD_EML_CALL(0,27);
c2_f_Fy = c2_f_F[0];
_SFD_EML_CALL(0,28);
c2_f_Fz = c2_f_F[1];
_SFD_EML_CALL(0,30);
c2_f_Ry = c2_f_R[0];
_SFD_EML_CALL(0,31);
c2_f_Rz = c2_f_R[1];
_SFD_EML_CALL(0,34);
c2_x = c2_delta;
c2_b_x = c2_x;
c2_c_x = c2_b_x;
c2_b_x = c2_c_x;
c2_b_x = muDoubleScalarCos(c2_b_x);
c2_a = c2_f_Fx;
c2_b = c2_b_x;
c2_y = c2_a * c2_b;
c2_d_x = c2_delta;
c2_e_x = c2_d_x;
c2_f_x = c2_e_x;
c2_e_x = c2_f_x;
c2_e_x = muDoubleScalarSin(c2_e_x);
c2_b_a = c2_f_Fy;
c2_b_b = c2_e_x;
c2_b_y = c2_b_a * c2_b_b;
c2_c_b = (c2_y - c2_b_y) + c2_f_Rx;
c2_c_y = 6.8965517241379305E-004 * c2_c_b;
c2_c_a = c2_Vy;
c2_d_b = c2_r;
c2_d_y = c2_c_a * c2_d_b;
c2_dVx = c2_c_y + c2_d_y;
_SFD_EML_CALL(0,35);
c2_g_x = c2_delta;
c2_h_x = c2_g_x;
c2_i_x = c2_h_x;
c2_h_x = c2_i_x;
c2_h_x = muDoubleScalarSin(c2_h_x);
c2_d_a = c2_f_Fx;
c2_e_b = c2_h_x;
c2_e_y = c2_d_a * c2_e_b;
c2_j_x = c2_delta;
c2_k_x = c2_j_x;
c2_l_x = c2_k_x;
c2_k_x = c2_l_x;
c2_k_x = muDoubleScalarCos(c2_k_x);
c2_e_a = c2_f_Fy;
c2_f_b = c2_k_x;
c2_f_y = c2_e_a * c2_f_b;
c2_g_b = (c2_e_y + c2_f_y) + c2_f_Ry;
c2_g_y = 6.8965517241379305E-004 * c2_g_b;
c2_f_a = c2_Vx;
c2_h_b = c2_r;
c2_h_y = c2_f_a * c2_h_b;
c2_dVy = c2_g_y - c2_h_y;
_SFD_EML_CALL(0,36);
c2_m_x = c2_delta;
c2_n_x = c2_m_x;
c2_o_x = c2_n_x;
c2_n_x = c2_o_x;
c2_n_x = muDoubleScalarCos(c2_n_x);
c2_g_a = c2_f_Fy;
c2_i_b = c2_n_x;
c2_i_y = c2_g_a * c2_i_b;
c2_p_x = c2_delta;
c2_q_x = c2_p_x;
c2_r_x = c2_q_x;
c2_q_x = c2_r_x;
c2_q_x = muDoubleScalarSin(c2_q_x);
c2_h_a = c2_f_Fx;
c2_j_b = c2_q_x;
c2_j_y = c2_h_a * c2_j_b;
c2_i_a = c2_i_y + c2_j_y;
c2_k_y = c2_i_a * 1.1;
c2_j_a = c2_f_Ry;
c2_l_y = c2_j_a * 1.6;
c2_k_b = c2_k_y - c2_l_y;
c2_dr = 3.6496350364963501E-004 * c2_k_b;
_SFD_EML_CALL(0,37);
c2_dpsi = c2_r;
_SFD_EML_CALL(0,39);
c2_b_dVx[0] = c2_dVx;
c2_b_dVx[1] = c2_dVy;
c2_b_dVx[2] = c2_dr;
c2_b_dVx[3] = c2_dpsi;
for (c2_i16 = 0; c2_i16 < 4; c2_i16 = c2_i16 + 1) {
c2_dX[c2_i16] = c2_b_dVx[c2_i16];
}
_SFD_EML_CALL(0,-39);
sf_debug_symbol_scope_pop();
for (c2_i17 = 0; c2_i17 < 4; c2_i17 = c2_i17 + 1) {
(*c2_b_dX)[c2_i17] = c2_dX[c2_i17];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,1);
_sfEvent_ = c2_previousEvent;
sf_debug_check_for_state_inconsistency(_car_modelMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void c5_chartstep_c5_testing_Control(SFc5_testing_ControlInstanceStruct
*chartInstance)
{
real_T c5_hoistedGlobal;
real_T c5_lambda;
uint32_T c5_debug_family_var_map[5];
boolean_T c5_positiveInput;
real_T c5_nargin = 1.0;
real_T c5_nargout = 1.0;
real_T c5_lambda1;
real_T c5_x;
real_T c5_xk;
real_T c5_b_x;
real_T c5_c_x;
real_T c5_d_x;
real_T c5_e_x;
real_T c5_f_x;
real_T c5_y;
real_T c5_g_x;
real_T c5_b_y;
real_T c5_b;
real_T c5_c_y;
real_T c5_h_x;
real_T c5_i_x;
real_T c5_dv0[1];
boolean_T c5_b0;
boolean_T c5_b_positiveInput;
boolean_T c5_j_x;
boolean_T c5_k_x;
int32_T c5_k;
int32_T c5_tmp_sizes[2];
int32_T c5_iv0[2];
int32_T c5_i0;
int32_T c5_i1;
int32_T c5_loop_ub;
int32_T c5_i2;
int32_T c5_tmp_data[1];
int32_T c5_i3;
int32_T c5_b_tmp_sizes[2];
int32_T c5_b_tmp_data[1];
int32_T c5_b_loop_ub;
int32_T c5_i4;
real_T *c5_b_lambda1;
real_T *c5_b_lambda;
c5_b_lambda1 = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c5_b_lambda = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 2U, chartInstance->c5_sfEvent);
c5_hoistedGlobal = *c5_b_lambda;
c5_lambda = c5_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 5U, 5U, c5_debug_family_names,
c5_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c5_positiveInput, 0U,
c5_b_sf_marshallOut, c5_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c5_nargin, 1U, c5_sf_marshallOut,
c5_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c5_nargout, 2U, c5_sf_marshallOut,
c5_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c5_lambda, 3U, c5_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c5_lambda1, 4U, c5_sf_marshallOut,
c5_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c5_sfEvent, 15);
c5_positiveInput = (c5_lambda > 0.0);
_SFD_EML_CALL(0U, chartInstance->c5_sfEvent, 16);
c5_x = c5_lambda;
c5_xk = c5_x;
c5_b_x = c5_xk;
c5_c_x = c5_b_x;
c5_lambda = c5_c_x / 6.2831853071795862;
c5_d_x = c5_lambda;
c5_e_x = c5_d_x;
c5_e_x = muDoubleScalarRound(c5_e_x);
c5_f_x = c5_lambda - c5_e_x;
c5_y = muDoubleScalarAbs(c5_f_x);
c5_g_x = c5_lambda;
c5_b_y = muDoubleScalarAbs(c5_g_x);
c5_b = c5_b_y;
c5_c_y = 2.2204460492503131E-16 * c5_b;
if (c5_y <= c5_c_y) {
c5_lambda = 0.0;
} else {
c5_h_x = c5_lambda;
c5_i_x = c5_h_x;
c5_i_x = muDoubleScalarFloor(c5_i_x);
c5_lambda = (c5_lambda - c5_i_x) * 6.2831853071795862;
}
_SFD_EML_CALL(0U, chartInstance->c5_sfEvent, 17);
c5_dv0[0] = c5_lambda;
c5_b0 = (c5_lambda == 0.0);
c5_b_positiveInput = c5_positiveInput;
c5_j_x = (c5_b0 && c5_b_positiveInput);
c5_k_x = c5_j_x;
c5_k = 0;
if (c5_k_x) {
c5_k = 1;
}
c5_tmp_sizes[0] = 1;
c5_iv0[0] = 1;
c5_iv0[1] = c5_k;
c5_tmp_sizes[1] = c5_iv0[1];
c5_i0 = c5_tmp_sizes[0];
c5_i1 = c5_tmp_sizes[1];
c5_loop_ub = c5_k - 1;
for (c5_i2 = 0; c5_i2 <= c5_loop_ub; c5_i2++) {
c5_tmp_data[c5_i2] = 0;
}
for (c5_i3 = 0; c5_i3 < 2; c5_i3++) {
c5_b_tmp_sizes[c5_i3] = c5_tmp_sizes[c5_i3];
}
if (c5_j_x) {
_SFD_EML_ARRAY_BOUNDS_CHECK("", 1, 1, c5_b_tmp_sizes[1], 1, 0);
c5_b_tmp_data[0] = 1;
}
c5_b_loop_ub = c5_b_tmp_sizes[0] * c5_b_tmp_sizes[1] - 1;
for (c5_i4 = 0; c5_i4 <= c5_b_loop_ub; c5_i4++) {
c5_dv0[c5_b_tmp_data[c5_i4] - 1] = 6.2831853071795862;
}
c5_lambda = c5_dv0[0];
_SFD_EML_CALL(0U, chartInstance->c5_sfEvent, 18);
c5_lambda1 = c5_lambda;
_SFD_EML_CALL(0U, chartInstance->c5_sfEvent, -18);
sf_debug_symbol_scope_pop();
*c5_b_lambda1 = c5_lambda1;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 2U, chartInstance->c5_sfEvent);
}
static void c1_chartstep_c1_Qmod(SFc1_QmodInstanceStruct *chartInstance)
{
real_T c1_hoistedGlobal;
real_T c1_b_hoistedGlobal;
real_T c1_c_hoistedGlobal;
int32_T c1_i5;
real_T c1_T[4];
real_T c1_k;
real_T c1_m;
real_T c1_g;
int32_T c1_i6;
real_T c1_R[9];
uint32_T c1_debug_family_var_map[9];
real_T c1_Thrust[3];
real_T c1_nargin = 5.0;
real_T c1_nargout = 1.0;
real_T c1_y[3];
real_T c1_a;
real_T c1_b;
real_T c1_b_y;
real_T c1_A;
real_T c1_B;
real_T c1_x;
real_T c1_c_y;
real_T c1_b_x;
real_T c1_d_y;
real_T c1_e_y;
int32_T c1_i7;
real_T c1_b_a[9];
int32_T c1_i8;
real_T c1_b_b[3];
int32_T c1_i9;
real_T c1_f_y[3];
int32_T c1_i10;
int32_T c1_i11;
real_T c1_dv1[3];
int32_T c1_i12;
int32_T c1_i13;
real_T *c1_b_k;
real_T *c1_b_m;
real_T *c1_b_g;
real_T (*c1_g_y)[3];
real_T (*c1_b_R)[9];
real_T (*c1_b_T)[4];
c1_b_R = (real_T (*)[9])ssGetInputPortSignal(chartInstance->S, 4);
c1_g_y = (real_T (*)[3])ssGetOutputPortSignal(chartInstance->S, 1);
c1_b_g = (real_T *)ssGetInputPortSignal(chartInstance->S, 3);
c1_b_m = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
c1_b_k = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c1_b_T = (real_T (*)[4])ssGetInputPortSignal(chartInstance->S, 0);
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
c1_hoistedGlobal = *c1_b_k;
c1_b_hoistedGlobal = *c1_b_m;
c1_c_hoistedGlobal = *c1_b_g;
for (c1_i5 = 0; c1_i5 < 4; c1_i5++) {
c1_T[c1_i5] = (*c1_b_T)[c1_i5];
}
c1_k = c1_hoistedGlobal;
c1_m = c1_b_hoistedGlobal;
c1_g = c1_c_hoistedGlobal;
for (c1_i6 = 0; c1_i6 < 9; c1_i6++) {
c1_R[c1_i6] = (*c1_b_R)[c1_i6];
}
sf_debug_symbol_scope_push_eml(0U, 9U, 9U, c1_debug_family_names,
c1_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(c1_Thrust, 0U, c1_sf_marshallOut,
c1_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_nargin, 1U, c1_c_sf_marshallOut,
c1_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_nargout, 2U, c1_c_sf_marshallOut,
c1_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c1_T, 3U, c1_d_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c1_k, 4U, c1_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c1_m, 5U, c1_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c1_g, 6U, c1_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml(c1_R, 7U, c1_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(c1_y, 8U, c1_sf_marshallOut,
c1_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 5);
c1_a = c1_k;
c1_b = ((c1_T[0] + c1_T[1]) + c1_T[2]) + c1_T[3];
c1_b_y = c1_a * c1_b;
c1_A = c1_b_y;
c1_B = c1_m;
c1_x = c1_A;
c1_c_y = c1_B;
c1_b_x = c1_x;
c1_d_y = c1_c_y;
c1_e_y = c1_b_x / c1_d_y;
c1_Thrust[0] = 0.0;
c1_Thrust[1] = 0.0;
c1_Thrust[2] = c1_e_y;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 7);
for (c1_i7 = 0; c1_i7 < 9; c1_i7++) {
c1_b_a[c1_i7] = c1_R[c1_i7];
}
for (c1_i8 = 0; c1_i8 < 3; c1_i8++) {
c1_b_b[c1_i8] = c1_Thrust[c1_i8];
}
c1_eml_scalar_eg(chartInstance);
c1_eml_scalar_eg(chartInstance);
for (c1_i9 = 0; c1_i9 < 3; c1_i9++) {
c1_f_y[c1_i9] = 0.0;
c1_i10 = 0;
for (c1_i11 = 0; c1_i11 < 3; c1_i11++) {
c1_f_y[c1_i9] += c1_b_a[c1_i10 + c1_i9] * c1_b_b[c1_i11];
c1_i10 += 3;
}
}
c1_dv1[0] = 0.0;
c1_dv1[1] = 0.0;
c1_dv1[2] = -c1_g;
for (c1_i12 = 0; c1_i12 < 3; c1_i12++) {
c1_y[c1_i12] = c1_f_y[c1_i12] - c1_dv1[c1_i12];
}
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, -7);
sf_debug_symbol_scope_pop();
for (c1_i13 = 0; c1_i13 < 3; c1_i13++) {
(*c1_g_y)[c1_i13] = c1_y[c1_i13];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
}
static void c16_chartstep_c16_ekffede(SFc16_ekffedeInstanceStruct *chartInstance)
{
int32_T c16_i5;
real_T c16_gyro[3];
int32_T c16_i6;
real_T c16_quat[4];
uint32_T c16_debug_family_var_map[6];
real_T c16_omega[16];
real_T c16_nargin = 2.0;
real_T c16_nargout = 1.0;
real_T c16_quat_dot[4];
int32_T c16_i7;
real_T c16_b[16];
int32_T c16_i8;
int32_T c16_i9;
real_T c16_b_b[4];
int32_T c16_i10;
int32_T c16_i11;
int32_T c16_i12;
real_T c16_C[4];
int32_T c16_i13;
int32_T c16_i14;
int32_T c16_i15;
int32_T c16_i16;
int32_T c16_i17;
int32_T c16_i18;
int32_T c16_i19;
real_T (*c16_b_quat_dot)[4];
real_T (*c16_b_quat)[4];
real_T (*c16_b_gyro)[3];
c16_b_quat = (real_T (*)[4])ssGetInputPortSignal(chartInstance->S, 1);
c16_b_quat_dot = (real_T (*)[4])ssGetOutputPortSignal(chartInstance->S, 1);
c16_b_gyro = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 0);
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 15U, chartInstance->c16_sfEvent);
for (c16_i5 = 0; c16_i5 < 3; c16_i5++) {
c16_gyro[c16_i5] = (*c16_b_gyro)[c16_i5];
}
for (c16_i6 = 0; c16_i6 < 4; c16_i6++) {
c16_quat[c16_i6] = (*c16_b_quat)[c16_i6];
}
sf_debug_symbol_scope_push_eml(0U, 6U, 6U, c16_debug_family_names,
c16_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(c16_omega, 0U, c16_d_sf_marshallOut,
c16_c_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c16_nargin, 1U, c16_c_sf_marshallOut,
c16_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c16_nargout, 2U,
c16_c_sf_marshallOut, c16_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c16_gyro, 3U, c16_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml(c16_quat, 4U, c16_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(c16_quat_dot, 5U, c16_sf_marshallOut,
c16_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c16_sfEvent, 2);
c16_omega[0] = 0.0;
c16_omega[4] = -c16_gyro[0];
c16_omega[8] = -c16_gyro[1];
c16_omega[12] = -c16_gyro[2];
c16_omega[1] = c16_gyro[0];
c16_omega[5] = 0.0;
c16_omega[9] = c16_gyro[2];
c16_omega[13] = -c16_gyro[1];
c16_omega[2] = c16_gyro[1];
c16_omega[6] = -c16_gyro[2];
c16_omega[10] = 0.0;
c16_omega[14] = c16_gyro[0];
c16_omega[3] = c16_gyro[2];
c16_omega[7] = c16_gyro[1];
c16_omega[11] = -c16_gyro[0];
c16_omega[15] = 0.0;
_SFD_EML_CALL(0U, chartInstance->c16_sfEvent, 7);
for (c16_i7 = 0; c16_i7 < 16; c16_i7++) {
c16_b[c16_i7] = c16_omega[c16_i7];
}
for (c16_i8 = 0; c16_i8 < 16; c16_i8++) {
c16_b[c16_i8] *= 0.5;
}
for (c16_i9 = 0; c16_i9 < 4; c16_i9++) {
c16_b_b[c16_i9] = c16_quat[c16_i9];
}
c16_eml_scalar_eg(chartInstance);
c16_eml_scalar_eg(chartInstance);
for (c16_i10 = 0; c16_i10 < 4; c16_i10++) {
c16_quat_dot[c16_i10] = 0.0;
}
for (c16_i11 = 0; c16_i11 < 4; c16_i11++) {
c16_quat_dot[c16_i11] = 0.0;
}
for (c16_i12 = 0; c16_i12 < 4; c16_i12++) {
c16_C[c16_i12] = c16_quat_dot[c16_i12];
}
for (c16_i13 = 0; c16_i13 < 4; c16_i13++) {
c16_quat_dot[c16_i13] = c16_C[c16_i13];
}
for (c16_i14 = 0; c16_i14 < 4; c16_i14++) {
c16_C[c16_i14] = c16_quat_dot[c16_i14];
}
for (c16_i15 = 0; c16_i15 < 4; c16_i15++) {
c16_quat_dot[c16_i15] = c16_C[c16_i15];
}
for (c16_i16 = 0; c16_i16 < 4; c16_i16++) {
c16_quat_dot[c16_i16] = 0.0;
c16_i17 = 0;
for (c16_i18 = 0; c16_i18 < 4; c16_i18++) {
c16_quat_dot[c16_i16] += c16_b[c16_i17 + c16_i16] * c16_b_b[c16_i18];
c16_i17 += 4;
}
}
_SFD_EML_CALL(0U, chartInstance->c16_sfEvent, -7);
sf_debug_symbol_scope_pop();
for (c16_i19 = 0; c16_i19 < 4; c16_i19++) {
(*c16_b_quat_dot)[c16_i19] = c16_quat_dot[c16_i19];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 15U, chartInstance->c16_sfEvent);
}
static void sf_c7_ekffede(SFc7_ekffedeInstanceStruct *chartInstance)
{
real_T c7_hoistedGlobal;
real_T c7_b_hoistedGlobal;
real_T c7_c_hoistedGlobal;
real_T c7_d_hoistedGlobal;
real_T c7_e_hoistedGlobal;
real_T c7_sfasamento;
real_T c7_ampiezza;
real_T c7_frequenza;
real_T c7_noise;
real_T c7_t;
uint32_T c7_debug_family_var_map[8];
real_T c7_nargin = 5.0;
real_T c7_nargout = 1.0;
real_T c7_wave;
real_T c7_b;
real_T c7_y;
real_T c7_a;
real_T c7_b_b;
real_T c7_b_y;
real_T c7_x;
real_T c7_b_x;
real_T c7_b_a;
real_T c7_c_b;
real_T c7_c_y;
real_T *c7_b_sfasamento;
real_T *c7_b_wave;
real_T *c7_b_ampiezza;
real_T *c7_b_frequenza;
real_T *c7_b_noise;
real_T *c7_b_t;
c7_b_t = (real_T *)ssGetInputPortSignal(chartInstance->S, 4);
c7_b_noise = (real_T *)ssGetInputPortSignal(chartInstance->S, 3);
c7_b_frequenza = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
c7_b_ampiezza = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c7_b_wave = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c7_b_sfasamento = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 6U, chartInstance->c7_sfEvent);
_SFD_DATA_RANGE_CHECK(*c7_b_sfasamento, 0U);
_SFD_DATA_RANGE_CHECK(*c7_b_wave, 1U);
_SFD_DATA_RANGE_CHECK(*c7_b_ampiezza, 2U);
_SFD_DATA_RANGE_CHECK(*c7_b_frequenza, 3U);
_SFD_DATA_RANGE_CHECK(*c7_b_noise, 4U);
_SFD_DATA_RANGE_CHECK(*c7_b_t, 5U);
chartInstance->c7_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 6U, chartInstance->c7_sfEvent);
c7_hoistedGlobal = *c7_b_sfasamento;
c7_b_hoistedGlobal = *c7_b_ampiezza;
c7_c_hoistedGlobal = *c7_b_frequenza;
c7_d_hoistedGlobal = *c7_b_noise;
c7_e_hoistedGlobal = *c7_b_t;
c7_sfasamento = c7_hoistedGlobal;
c7_ampiezza = c7_b_hoistedGlobal;
c7_frequenza = c7_c_hoistedGlobal;
c7_noise = c7_d_hoistedGlobal;
c7_t = c7_e_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 8U, 8U, c7_debug_family_names,
c7_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c7_nargin, 0U, c7_sf_marshallOut,
c7_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c7_nargout, 1U, c7_sf_marshallOut,
c7_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c7_sfasamento, 2U, c7_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c7_ampiezza, 3U, c7_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c7_frequenza, 4U, c7_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c7_noise, 5U, c7_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c7_t, 6U, c7_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c7_wave, 7U, c7_sf_marshallOut,
c7_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c7_sfEvent, 4);
c7_b = c7_frequenza;
c7_y = 6.2831853071795862 * c7_b;
c7_a = c7_y;
c7_b_b = c7_t;
c7_b_y = c7_a * c7_b_b;
c7_x = c7_sfasamento + c7_b_y;
c7_b_x = c7_x;
c7_b_x = muDoubleScalarSin(c7_b_x);
c7_b_a = c7_ampiezza;
c7_c_b = c7_b_x;
c7_c_y = c7_b_a * c7_c_b;
c7_wave = c7_c_y + c7_noise;
_SFD_EML_CALL(0U, chartInstance->c7_sfEvent, -4);
sf_debug_symbol_scope_pop();
*c7_b_wave = c7_wave;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 6U, chartInstance->c7_sfEvent);
sf_debug_check_for_state_inconsistency(_ekffedeMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c9_QPSK_Transmit_v12d(SFc9_QPSK_Transmit_v12dInstanceStruct
*chartInstance)
{
creal_T c9_d_in;
uint32_T c9_debug_family_var_map[5];
const mxArray *c9_fm = NULL;
real_T c9_nargin = 1.0;
real_T c9_nargout = 1.0;
cint16_T c9_d_out;
creal_T c9_varargin_1;
real_T c9_d0;
real_T c9_d1;
int16_T c9_i0;
cint16_T c9_b_varargin_1;
real_T c9_d2;
real_T c9_d3;
int16_T c9_i1;
const mxArray *c9_T = NULL;
const mxArray *c9_F = NULL;
const mxArray *c9_ERR = NULL;
const mxArray *c9_val = NULL;
const mxArray *c9_isautoscaled = NULL;
const mxArray *c9_pvpairsetdata = NULL;
const mxArray *c9_isfimathlocal = NULL;
cint16_T *c9_b_d_out;
creal_T *c9_b_d_in;
c9_b_d_out = (cint16_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c9_b_d_in = (creal_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 1U, chartInstance->c9_sfEvent);
chartInstance->c9_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 1U, chartInstance->c9_sfEvent);
c9_d_in.re = c9_b_d_in->re;
c9_d_in.im = c9_b_d_in->im;
sf_debug_symbol_scope_push_eml(0U, 5U, 5U, c9_debug_family_names,
c9_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c9_fm, 0U, c9_d_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c9_nargin, 1U, c9_c_sf_marshallOut,
c9_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c9_nargout, 2U, c9_c_sf_marshallOut,
c9_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c9_d_in, 3U, c9_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c9_d_out, 4U, c9_sf_marshallOut,
c9_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 3);
c9_fm = c9_eml_mx;
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, 5);
c9_varargin_1 = c9_d_in;
c9_d0 = muDoubleScalarFloor(c9_varargin_1.re * 2048.0);
if (muDoubleScalarIsNaN(c9_d0) || muDoubleScalarIsInf(c9_d0)) {
c9_d1 = 0.0;
} else {
c9_d1 = muDoubleScalarRem(c9_d0, 4096.0);
}
c9_i0 = (int16_T)muDoubleScalarFloor(c9_d1);
if ((int16_T)(c9_i0 & 2048) != 0) {
c9_b_varargin_1.re = (int16_T)(c9_i0 | -2048);
} else {
c9_b_varargin_1.re = (int16_T)(c9_i0 & 2047);
}
c9_d2 = muDoubleScalarFloor(c9_varargin_1.im * 2048.0);
if (muDoubleScalarIsNaN(c9_d2) || muDoubleScalarIsInf(c9_d2)) {
c9_d3 = 0.0;
} else {
c9_d3 = muDoubleScalarRem(c9_d2, 4096.0);
}
c9_i1 = (int16_T)muDoubleScalarFloor(c9_d3);
if ((int16_T)(c9_i1 & 2048) != 0) {
c9_b_varargin_1.im = (int16_T)(c9_i1 | -2048);
} else {
c9_b_varargin_1.im = (int16_T)(c9_i1 & 2047);
}
c9_d_out = c9_b_varargin_1;
sf_mex_destroy(&c9_T);
sf_mex_destroy(&c9_F);
sf_mex_destroy(&c9_ERR);
sf_mex_destroy(&c9_val);
sf_mex_destroy(&c9_isautoscaled);
sf_mex_destroy(&c9_pvpairsetdata);
sf_mex_destroy(&c9_isfimathlocal);
_SFD_EML_CALL(0U, chartInstance->c9_sfEvent, -5);
sf_debug_symbol_scope_pop();
c9_b_d_out->re = c9_d_out.re;
c9_b_d_out->im = c9_d_out.im;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 1U, chartInstance->c9_sfEvent);
sf_debug_check_for_state_inconsistency(_QPSK_Transmit_v12dMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c2_chooseTapB(SFc2_chooseTapBInstanceStruct *chartInstance)
{
int32_T c2_previousEvent;
real_T c2_hoistedGlobal;
real_T c2_ave;
uint32_T c2_debug_family_var_map[4];
real_T c2_nargin = 1.0;
real_T c2_nargout = 1.0;
real_T c2_tap;
real_T *c2_b_ave;
real_T *c2_b_tap;
c2_b_tap = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c2_b_ave = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 0);
_SFD_DATA_RANGE_CHECK(*c2_b_ave, 0U);
_SFD_DATA_RANGE_CHECK(*c2_b_tap, 1U);
c2_previousEvent = _sfEvent_;
_sfEvent_ = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0);
c2_hoistedGlobal = *c2_b_ave;
c2_ave = c2_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 4U, 4U, c2_debug_family_names,
c2_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c2_nargin, c2_sf_marshall, 0U);
sf_debug_symbol_scope_add_eml(&c2_nargout, c2_sf_marshall, 1U);
sf_debug_symbol_scope_add_eml(&c2_ave, c2_sf_marshall, 2U);
sf_debug_symbol_scope_add_eml(&c2_tap, c2_sf_marshall, 3U);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0, 4);
if (CV_EML_IF(0, 0, c2_ave >= 60.0)) {
_SFD_EML_CALL(0, 5);
c2_tap = 4.0;
} else {
_SFD_EML_CALL(0, 6);
if (CV_EML_COND(0, 0, c2_ave < 60.0)) {
if (CV_EML_COND(0, 1, c2_ave > 20.0)) {
CV_EML_MCDC(0, 0, TRUE);
CV_EML_IF(0, 1, TRUE);
_SFD_EML_CALL(0, 7);
c2_tap = 3.0;
goto label_1;
}
}
CV_EML_MCDC(0, 0, FALSE);
CV_EML_IF(0, 1, FALSE);
_SFD_EML_CALL(0, 8);
if (CV_EML_COND(0, 2, c2_ave <= 20.0)) {
if (CV_EML_COND(0, 3, c2_ave >= -20.0)) {
CV_EML_MCDC(0, 1, TRUE);
CV_EML_IF(0, 2, TRUE);
_SFD_EML_CALL(0, 9);
c2_tap = 2.0;
goto label_2;
}
}
CV_EML_MCDC(0, 1, FALSE);
CV_EML_IF(0, 2, FALSE);
_SFD_EML_CALL(0, 10);
if (CV_EML_COND(0, 4, c2_ave < -20.0)) {
if (CV_EML_COND(0, 5, c2_ave > -60.0)) {
CV_EML_MCDC(0, 2, TRUE);
CV_EML_IF(0, 3, TRUE);
_SFD_EML_CALL(0, 11);
c2_tap = 1.0;
goto label_3;
}
}
CV_EML_MCDC(0, 2, FALSE);
CV_EML_IF(0, 3, FALSE);
_SFD_EML_CALL(0, 13);
c2_tap = 0.0;
label_3:
;
label_2:
;
label_1:
;
}
_SFD_EML_CALL(0, -13);
sf_debug_symbol_scope_pop();
*c2_b_tap = c2_tap;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0);
_sfEvent_ = c2_previousEvent;
sf_debug_check_for_state_inconsistency(_chooseTapBMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void c6_chartstep_c6_motor_control_with_homebrew_SVPWM
(SFc6_motor_control_with_homebrew_SVPWMInstanceStruct *chartInstance)
{
real_T c6_hoistedGlobal;
real_T c6_b_hoistedGlobal;
real_T c6_c_hoistedGlobal;
real_T c6_Xd;
real_T c6_Xq;
real_T c6_theta;
uint32_T c6_debug_family_var_map[11];
real_T c6_c;
real_T c6_s;
real_T c6_ipm[4];
real_T c6_xab[2];
real_T c6_nargin = 3.0;
real_T c6_nargout = 2.0;
real_T c6_Xalpha;
real_T c6_Xbeta;
real_T c6_x;
real_T c6_b_x;
real_T c6_c_x;
real_T c6_d_x;
int32_T c6_i0;
real_T c6_a[4];
real_T c6_b_Xd[2];
int32_T c6_i1;
real_T c6_b[2];
int32_T c6_i2;
int32_T c6_i3;
int32_T c6_i4;
real_T c6_C[2];
int32_T c6_i5;
int32_T c6_i6;
int32_T c6_i7;
int32_T c6_i8;
int32_T c6_i9;
int32_T c6_i10;
real_T *c6_c_Xd;
real_T *c6_b_Xq;
real_T *c6_b_theta;
real_T *c6_b_Xalpha;
real_T *c6_b_Xbeta;
c6_b_Xbeta = (real_T *)ssGetOutputPortSignal(chartInstance->S, 2);
c6_b_theta = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
c6_b_Xq = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c6_b_Xalpha = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c6_c_Xd = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 5U, chartInstance->c6_sfEvent);
c6_hoistedGlobal = *c6_c_Xd;
c6_b_hoistedGlobal = *c6_b_Xq;
c6_c_hoistedGlobal = *c6_b_theta;
c6_Xd = c6_hoistedGlobal;
c6_Xq = c6_b_hoistedGlobal;
c6_theta = c6_c_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 11U, 11U, c6_debug_family_names,
c6_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c6_c, 0U, c6_sf_marshallOut,
c6_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c6_s, 1U, c6_sf_marshallOut,
c6_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(c6_ipm, 2U, c6_c_sf_marshallOut,
c6_c_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(c6_xab, 3U, c6_b_sf_marshallOut,
c6_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c6_nargin, 4U, c6_sf_marshallOut,
c6_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c6_nargout, 5U, c6_sf_marshallOut,
c6_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c6_Xd, 6U, c6_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c6_Xq, 7U, c6_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c6_theta, 8U, c6_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c6_Xalpha, 9U, c6_sf_marshallOut,
c6_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c6_Xbeta, 10U, c6_sf_marshallOut,
c6_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 5);
c6_x = c6_theta;
c6_c = c6_x;
c6_b_x = c6_c;
c6_c = c6_b_x;
c6_c = muDoubleScalarCos(c6_c);
_SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 6);
c6_c_x = c6_theta;
c6_s = c6_c_x;
c6_d_x = c6_s;
c6_s = c6_d_x;
c6_s = muDoubleScalarSin(c6_s);
_SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 8);
c6_ipm[0] = c6_c;
c6_ipm[2] = -c6_s;
c6_ipm[1] = c6_s;
c6_ipm[3] = c6_c;
_SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 10);
for (c6_i0 = 0; c6_i0 < 4; c6_i0++) {
c6_a[c6_i0] = c6_ipm[c6_i0];
}
c6_b_Xd[0] = c6_Xd;
c6_b_Xd[1] = c6_Xq;
for (c6_i1 = 0; c6_i1 < 2; c6_i1++) {
c6_b[c6_i1] = c6_b_Xd[c6_i1];
}
c6_eml_scalar_eg(chartInstance);
c6_eml_scalar_eg(chartInstance);
for (c6_i2 = 0; c6_i2 < 2; c6_i2++) {
c6_xab[c6_i2] = 0.0;
}
for (c6_i3 = 0; c6_i3 < 2; c6_i3++) {
c6_xab[c6_i3] = 0.0;
}
for (c6_i4 = 0; c6_i4 < 2; c6_i4++) {
c6_C[c6_i4] = c6_xab[c6_i4];
}
for (c6_i5 = 0; c6_i5 < 2; c6_i5++) {
c6_xab[c6_i5] = c6_C[c6_i5];
}
for (c6_i6 = 0; c6_i6 < 2; c6_i6++) {
c6_C[c6_i6] = c6_xab[c6_i6];
}
for (c6_i7 = 0; c6_i7 < 2; c6_i7++) {
c6_xab[c6_i7] = c6_C[c6_i7];
}
for (c6_i8 = 0; c6_i8 < 2; c6_i8++) {
c6_xab[c6_i8] = 0.0;
c6_i9 = 0;
for (c6_i10 = 0; c6_i10 < 2; c6_i10++) {
c6_xab[c6_i8] += c6_a[c6_i9 + c6_i8] * c6_b[c6_i10];
c6_i9 += 2;
}
}
_SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 12);
c6_Xalpha = c6_xab[0];
_SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 13);
c6_Xbeta = c6_xab[1];
_SFD_EML_CALL(0U, chartInstance->c6_sfEvent, -13);
sf_debug_symbol_scope_pop();
*c6_b_Xalpha = c6_Xalpha;
*c6_b_Xbeta = c6_Xbeta;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 5U, chartInstance->c6_sfEvent);
}
static void sf_c2_kinematics(SFc2_kinematicsInstanceStruct *chartInstance)
{
int32_T c2_i2;
int32_T c2_i3;
int32_T c2_i4;
real_T c2_q[6];
uint32_T c2_debug_family_var_map[5];
real_T c2_newq[6];
int32_T c2_newq_sizes[2];
real_T c2_newq_data[6];
real_T c2_nargin = 1.0;
real_T c2_nargout = 1.0;
real_T c2_Jacobian_body[72];
int32_T c2_i5;
int32_T c2_i6;
int32_T c2_b_newq;
int32_T c2_c_newq;
int32_T c2_i7;
int32_T c2_u_sizes[2];
int32_T c2_u;
int32_T c2_b_u;
int32_T c2_loop_ub;
int32_T c2_i8;
real_T c2_u_data[6];
const mxArray *c2_y = NULL;
real_T c2_dv1[72];
int32_T c2_i9;
int32_T c2_i10;
real_T (*c2_b_Jacobian_body)[72];
real_T (*c2_b_q)[6];
c2_b_Jacobian_body = (real_T (*)[72])ssGetOutputPortSignal(chartInstance->S, 1);
c2_b_q = (real_T (*)[6])ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
for (c2_i2 = 0; c2_i2 < 6; c2_i2++) {
_SFD_DATA_RANGE_CHECK((*c2_b_q)[c2_i2], 0U);
}
for (c2_i3 = 0; c2_i3 < 72; c2_i3++) {
_SFD_DATA_RANGE_CHECK((*c2_b_Jacobian_body)[c2_i3], 1U);
}
chartInstance->c2_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
for (c2_i4 = 0; c2_i4 < 6; c2_i4++) {
c2_q[c2_i4] = (*c2_b_q)[c2_i4];
}
sf_debug_symbol_scope_push_eml(0U, 5U, 6U, c2_debug_family_names,
c2_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(c2_newq, MAX_uint32_T,
c2_e_sf_marshallOut, c2_d_sf_marshallIn);
sf_debug_symbol_scope_add_eml_dyn_importable(c2_newq_data, (const int32_T *)
&c2_newq_sizes, NULL, 0, -1, (void *)c2_d_sf_marshallOut, (void *)
c2_c_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_nargin, 1U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_nargout, 2U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c2_q, 3U, c2_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(c2_Jacobian_body, 4U,
c2_sf_marshallOut, c2_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 4);
for (c2_i5 = 0; c2_i5 < 72; c2_i5++) {
c2_Jacobian_body[c2_i5] = 0.0;
}
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 5);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 6);
for (c2_i6 = 0; c2_i6 < 6; c2_i6++) {
c2_newq[c2_i6] = 0.0;
}
sf_debug_symbol_switch(0U, 0U);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 7);
c2_newq_sizes[0] = 6;
c2_newq_sizes[1] = 1;
c2_b_newq = c2_newq_sizes[0];
c2_c_newq = c2_newq_sizes[1];
for (c2_i7 = 0; c2_i7 < 6; c2_i7++) {
c2_newq_data[c2_i7] = c2_q[c2_i7];
}
sf_debug_symbol_switch(0U, 1U);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 8);
c2_u_sizes[0] = 6;
c2_u_sizes[1] = 1;
c2_u = c2_u_sizes[0];
c2_b_u = c2_u_sizes[1];
c2_loop_ub = c2_newq_sizes[0] * c2_newq_sizes[1] - 1;
for (c2_i8 = 0; c2_i8 <= c2_loop_ub; c2_i8++) {
c2_u_data[c2_i8] = c2_newq_data[c2_i8];
}
c2_y = NULL;
sf_mex_assign(&c2_y, sf_mex_create("y", c2_u_data, 0, 0U, 1U, 0U, 2,
c2_u_sizes[0], c2_u_sizes[1]), FALSE);
c2_d_emlrt_marshallIn(chartInstance, sf_mex_call_debug("body_jacobian", 1U, 1U,
14, c2_y), "body_jacobian", c2_dv1);
for (c2_i9 = 0; c2_i9 < 72; c2_i9++) {
c2_Jacobian_body[c2_i9] = c2_dv1[c2_i9];
}
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, -8);
sf_debug_symbol_scope_pop();
for (c2_i10 = 0; c2_i10 < 72; c2_i10++) {
(*c2_b_Jacobian_body)[c2_i10] = c2_Jacobian_body[c2_i10];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
sf_debug_check_for_state_inconsistency(_kinematicsMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c10_dynamics_kinematics(SFc10_dynamics_kinematicsInstanceStruct
*chartInstance)
{
int32_T c10_i2;
int32_T c10_i3;
int32_T c10_i4;
real_T c10_q[6];
uint32_T c10_debug_family_var_map[4];
real_T c10_nargin = 1.0;
real_T c10_nargout = 1.0;
real_T c10_M[144];
int32_T c10_i5;
int32_T c10_i6;
real_T c10_u[6];
const mxArray *c10_y = NULL;
real_T c10_dv1[144];
int32_T c10_i7;
int32_T c10_i8;
real_T (*c10_b_M)[144];
real_T (*c10_b_q)[6];
c10_b_q = (real_T (*)[6])ssGetInputPortSignal(chartInstance->S, 0);
c10_b_M = (real_T (*)[144])ssGetOutputPortSignal(chartInstance->S, 1);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 9U, chartInstance->c10_sfEvent);
for (c10_i2 = 0; c10_i2 < 144; c10_i2++) {
_SFD_DATA_RANGE_CHECK((*c10_b_M)[c10_i2], 0U);
}
for (c10_i3 = 0; c10_i3 < 6; c10_i3++) {
_SFD_DATA_RANGE_CHECK((*c10_b_q)[c10_i3], 1U);
}
chartInstance->c10_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 9U, chartInstance->c10_sfEvent);
for (c10_i4 = 0; c10_i4 < 6; c10_i4++) {
c10_q[c10_i4] = (*c10_b_q)[c10_i4];
}
sf_debug_symbol_scope_push_eml(0U, 4U, 4U, c10_debug_family_names,
c10_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c10_nargin, 0U, c10_c_sf_marshallOut,
c10_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c10_nargout, 1U,
c10_c_sf_marshallOut, c10_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c10_q, 2U, c10_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(c10_M, 3U, c10_sf_marshallOut,
c10_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c10_sfEvent, 3);
_SFD_EML_CALL(0U, chartInstance->c10_sfEvent, 4);
for (c10_i5 = 0; c10_i5 < 144; c10_i5++) {
c10_M[c10_i5] = 0.0;
}
_SFD_EML_CALL(0U, chartInstance->c10_sfEvent, 5);
for (c10_i6 = 0; c10_i6 < 6; c10_i6++) {
c10_u[c10_i6] = c10_q[c10_i6];
}
c10_y = NULL;
sf_mex_assign(&c10_y, sf_mex_create("y", c10_u, 0, 0U, 1U, 0U, 1, 6), FALSE);
c10_b_emlrt_marshallIn(chartInstance, sf_mex_call_debug("getInertia", 1U, 1U,
14, c10_y), "getInertia", c10_dv1);
for (c10_i7 = 0; c10_i7 < 144; c10_i7++) {
c10_M[c10_i7] = c10_dv1[c10_i7];
}
_SFD_EML_CALL(0U, chartInstance->c10_sfEvent, -5);
sf_debug_symbol_scope_pop();
for (c10_i8 = 0; c10_i8 < 144; c10_i8++) {
(*c10_b_M)[c10_i8] = c10_M[c10_i8];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 9U, chartInstance->c10_sfEvent);
sf_debug_check_for_state_inconsistency(_dynamics_kinematicsMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c1_my_demo_ref(SFc1_my_demo_refInstanceStruct *chartInstance)
{
int32_T c1_i0;
real_T c1_hoistedGlobal;
real_T c1_b_hoistedGlobal;
real_T c1_x;
real_T c1_y;
int32_T c1_i1;
real_T c1_fpath[170];
uint32_T c1_debug_family_var_map[13];
real_T c1_dmin;
real_T c1_xx[85];
real_T c1_yy[85];
real_T c1_d;
real_T c1_nargin = 3.0;
real_T c1_nargout = 3.0;
real_T c1_x_g;
real_T c1_y_g;
real_T c1_stop;
int32_T c1_i2;
int32_T c1_i3;
real_T c1_c_hoistedGlobal;
real_T c1_d_hoistedGlobal;
real_T c1_b_x;
real_T c1_c_x;
real_T *c1_b_x_g;
real_T *c1_b_y_g;
real_T *c1_d_x;
real_T *c1_b_y;
real_T *c1_b_stop;
real_T (*c1_b_fpath)[170];
boolean_T guard1 = FALSE;
boolean_T guard2 = FALSE;
c1_b_stop = (real_T *)ssGetOutputPortSignal(chartInstance->S, 3);
c1_b_fpath = (real_T (*)[170])ssGetInputPortSignal(chartInstance->S, 2);
c1_b_y = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c1_d_x = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
c1_b_y_g = (real_T *)ssGetOutputPortSignal(chartInstance->S, 2);
c1_b_x_g = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
_SFD_DATA_RANGE_CHECK(*c1_b_x_g, 0U);
_SFD_DATA_RANGE_CHECK(*c1_b_y_g, 1U);
_SFD_DATA_RANGE_CHECK(*c1_d_x, 2U);
_SFD_DATA_RANGE_CHECK(*c1_b_y, 3U);
for (c1_i0 = 0; c1_i0 < 170; c1_i0++) {
_SFD_DATA_RANGE_CHECK((*c1_b_fpath)[c1_i0], 4U);
}
_SFD_DATA_RANGE_CHECK(*c1_b_stop, 5U);
chartInstance->c1_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
c1_hoistedGlobal = *c1_d_x;
c1_b_hoistedGlobal = *c1_b_y;
c1_x = c1_hoistedGlobal;
c1_y = c1_b_hoistedGlobal;
for (c1_i1 = 0; c1_i1 < 170; c1_i1++) {
c1_fpath[c1_i1] = (*c1_b_fpath)[c1_i1];
}
sf_debug_symbol_scope_push_eml(0U, 13U, 13U, c1_debug_family_names,
c1_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c1_dmin, 0U, c1_b_sf_marshallOut,
c1_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(c1_xx, 1U, c1_d_sf_marshallOut,
c1_c_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(c1_yy, 2U, c1_d_sf_marshallOut,
c1_c_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_d, 3U, c1_b_sf_marshallOut,
c1_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_nargin, 4U, c1_b_sf_marshallOut,
c1_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_nargout, 5U, c1_b_sf_marshallOut,
c1_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c1_x, 6U, c1_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c1_y, 7U, c1_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml(c1_fpath, 8U, c1_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c1_x_g, 9U, c1_b_sf_marshallOut,
c1_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_y_g, 10U, c1_b_sf_marshallOut,
c1_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c1_stop, 11U, c1_b_sf_marshallOut,
c1_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&chartInstance->c1_i, 12U,
c1_sf_marshallOut, c1_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 6);
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 7);
if (CV_EML_IF(0, 1, 0, !chartInstance->c1_i_not_empty)) {
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 8);
chartInstance->c1_i = 1.0;
chartInstance->c1_i_not_empty = TRUE;
}
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 12);
c1_stop = 0.0;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 13);
c1_dmin = 0.1;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 26);
for (c1_i2 = 0; c1_i2 < 85; c1_i2++) {
c1_xx[c1_i2] = c1_fpath[c1_i2];
}
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 27);
for (c1_i3 = 0; c1_i3 < 85; c1_i3++) {
c1_yy[c1_i3] = c1_fpath[c1_i3 + 85];
}
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 29);
c1_c_hoistedGlobal = chartInstance->c1_i;
c1_d_hoistedGlobal = chartInstance->c1_i;
c1_b_x = c1_mpower(chartInstance, c1_x - c1_xx[_SFD_EML_ARRAY_BOUNDS_CHECK(
"xx", (int32_T)_SFD_INTEGER_CHECK("i", c1_c_hoistedGlobal), 1, 85, 1, 0) - 1])
+ c1_mpower(chartInstance, c1_y - c1_yy[_SFD_EML_ARRAY_BOUNDS_CHECK("yy",
(int32_T)_SFD_INTEGER_CHECK("i", c1_d_hoistedGlobal), 1, 85, 1, 0) - 1]);
c1_d = c1_b_x;
if (c1_d < 0.0) {
c1_eml_error(chartInstance);
}
c1_c_x = c1_d;
c1_d = c1_c_x;
c1_d = muDoubleScalarSqrt(c1_d);
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 31);
guard2 = FALSE;
if (CV_EML_COND(0, 1, 0, c1_d < c1_dmin)) {
if (CV_EML_COND(0, 1, 1, chartInstance->c1_i < 85.0)) {
CV_EML_MCDC(0, 1, 0, TRUE);
CV_EML_IF(0, 1, 1, TRUE);
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 32);
chartInstance->c1_i++;
} else {
guard2 = TRUE;
}
} else {
guard2 = TRUE;
}
if (guard2 == TRUE) {
CV_EML_MCDC(0, 1, 0, FALSE);
CV_EML_IF(0, 1, 1, FALSE);
}
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 36);
c1_x_g = c1_xx[_SFD_EML_ARRAY_BOUNDS_CHECK("xx", (int32_T)_SFD_INTEGER_CHECK(
"i", chartInstance->c1_i), 1, 85, 1, 0) - 1];
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 37);
c1_y_g = c1_yy[_SFD_EML_ARRAY_BOUNDS_CHECK("yy", (int32_T)_SFD_INTEGER_CHECK(
"i", chartInstance->c1_i), 1, 85, 1, 0) - 1];
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 40);
guard1 = FALSE;
if (CV_EML_COND(0, 1, 2, c1_d < c1_dmin)) {
if (CV_EML_COND(0, 1, 3, chartInstance->c1_i == 85.0)) {
CV_EML_MCDC(0, 1, 1, TRUE);
CV_EML_IF(0, 1, 2, TRUE);
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 41);
c1_stop = 1.0;
} else {
guard1 = TRUE;
}
} else {
guard1 = TRUE;
}
if (guard1 == TRUE) {
CV_EML_MCDC(0, 1, 1, FALSE);
CV_EML_IF(0, 1, 2, FALSE);
}
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, -41);
sf_debug_symbol_scope_pop();
*c1_b_x_g = c1_x_g;
*c1_b_y_g = c1_y_g;
*c1_b_stop = c1_stop;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
sf_debug_check_for_state_inconsistency(_my_demo_refMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c2_TischMal2(SFc2_TischMal2InstanceStruct *chartInstance)
{
real_T c2_hoistedGlobal;
real_T c2_b_hoistedGlobal;
real_T c2_c_hoistedGlobal;
real_T c2_d_hoistedGlobal;
real_T c2_e_hoistedGlobal;
real_T c2_f_hoistedGlobal;
real_T c2_g_hoistedGlobal;
real_T c2_m1;
real_T c2_c1;
real_T c2_d;
real_T c2_x1;
real_T c2_x1P;
real_T c2_x2P;
real_T c2_u;
uint32_T c2_debug_family_var_map[11];
real_T c2_g;
real_T c2_nargin = 7.0;
real_T c2_nargout = 1.0;
real_T c2_x1PP;
real_T c2_a;
real_T c2_b;
real_T c2_y;
real_T c2_b_b;
real_T c2_b_y;
real_T c2_b_a;
real_T c2_c_b;
real_T c2_c_y;
real_T c2_d_b;
real_T c2_d_y;
real_T c2_c_a;
real_T c2_e_y;
real_T c2_A;
real_T c2_B;
real_T c2_x;
real_T c2_f_y;
real_T c2_b_x;
real_T c2_g_y;
real_T *c2_b_u;
real_T *c2_b_x2P;
real_T *c2_b_x1P;
real_T *c2_b_x1;
real_T *c2_b_d;
real_T *c2_b_c1;
real_T *c2_b_m1;
real_T *c2_b_x1PP;
c2_b_x1PP = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c2_b_u = (real_T *)ssGetInputPortSignal(chartInstance->S, 6);
c2_b_x2P = (real_T *)ssGetInputPortSignal(chartInstance->S, 5);
c2_b_x1P = (real_T *)ssGetInputPortSignal(chartInstance->S, 4);
c2_b_x1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 3);
c2_b_d = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
c2_b_c1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c2_b_m1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
_SFD_DATA_RANGE_CHECK(*c2_b_m1, 0U);
_SFD_DATA_RANGE_CHECK(*c2_b_c1, 1U);
_SFD_DATA_RANGE_CHECK(*c2_b_d, 2U);
_SFD_DATA_RANGE_CHECK(*c2_b_x1, 3U);
_SFD_DATA_RANGE_CHECK(*c2_b_x1P, 4U);
_SFD_DATA_RANGE_CHECK(*c2_b_x2P, 5U);
_SFD_DATA_RANGE_CHECK(*c2_b_u, 6U);
_SFD_DATA_RANGE_CHECK(*c2_b_x1PP, 7U);
chartInstance->c2_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
c2_hoistedGlobal = *c2_b_m1;
c2_b_hoistedGlobal = *c2_b_c1;
c2_c_hoistedGlobal = *c2_b_d;
c2_d_hoistedGlobal = *c2_b_x1;
c2_e_hoistedGlobal = *c2_b_x1P;
c2_f_hoistedGlobal = *c2_b_x2P;
c2_g_hoistedGlobal = *c2_b_u;
c2_m1 = c2_hoistedGlobal;
c2_c1 = c2_b_hoistedGlobal;
c2_d = c2_c_hoistedGlobal;
c2_x1 = c2_d_hoistedGlobal;
c2_x1P = c2_e_hoistedGlobal;
c2_x2P = c2_f_hoistedGlobal;
c2_u = c2_g_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 11U, 11U, c2_debug_family_names,
c2_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c2_g, 0U, c2_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c2_nargin, 1U, c2_sf_marshallOut,
c2_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_nargout, 2U, c2_sf_marshallOut,
c2_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c2_m1, 3U, c2_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_c1, 4U, c2_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_d, 5U, c2_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_x1, 6U, c2_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_x1P, 7U, c2_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_x2P, 8U, c2_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c2_u, 9U, c2_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c2_x1PP, 10U, c2_sf_marshallOut,
c2_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 4);
c2_g = -9.81;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 5);
c2_a = -c2_c1;
c2_b = c2_x1 - c2_u;
c2_y = c2_a * c2_b;
c2_b_b = c2_y;
c2_b_y = 2.0 * c2_b_b;
c2_b_a = c2_d;
c2_c_b = c2_x2P - c2_x1P;
c2_c_y = c2_b_a * c2_c_b;
c2_d_b = c2_c_y;
c2_d_y = 2.0 * c2_d_b;
c2_c_a = c2_m1;
c2_e_y = c2_c_a * -9.81;
c2_A = (c2_b_y + c2_d_y) + c2_e_y;
c2_B = c2_m1;
c2_x = c2_A;
c2_f_y = c2_B;
c2_b_x = c2_x;
c2_g_y = c2_f_y;
c2_x1PP = c2_b_x / c2_g_y;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, -5);
sf_debug_symbol_scope_pop();
*c2_b_x1PP = c2_x1PP;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
sf_debug_check_for_state_inconsistency(_TischMal2MachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c3_canudas_goal3(SFc3_canudas_goal3InstanceStruct *chartInstance)
{
int32_T c3_i0;
int32_T c3_i1;
real_T c3_hoistedGlobal;
real_T c3_b_hoistedGlobal;
real_T c3_c_hoistedGlobal;
real_T c3_d_hoistedGlobal;
int32_T c3_i2;
real_T c3_z[2];
real_T c3_thetad;
real_T c3_r;
int32_T c3_i3;
real_T c3_qe[3];
real_T c3_k1;
real_T c3_k2;
uint32_T c3_debug_family_var_map[13];
real_T c3_b;
real_T c3_b1;
real_T c3_b2;
real_T c3_nargin = 6.0;
real_T c3_nargout = 2.0;
real_T c3_w;
real_T c3_v;
real_T c3_A;
real_T c3_B;
real_T c3_x;
real_T c3_y;
real_T c3_b_x;
real_T c3_b_y;
real_T c3_c_x;
real_T c3_d_x;
real_T c3_b_A;
real_T c3_b_B;
real_T c3_e_x;
real_T c3_c_y;
real_T c3_f_x;
real_T c3_d_y;
real_T c3_e_y;
real_T c3_a;
real_T c3_b_b;
real_T c3_f_y;
real_T c3_g_x;
real_T c3_h_x;
real_T c3_c_B;
real_T c3_g_y;
real_T c3_h_y;
real_T c3_i_y;
real_T c3_b_a;
real_T c3_c_b;
real_T c3_j_y;
real_T c3_c_A;
real_T c3_i_x;
real_T c3_j_x;
real_T c3_k_y;
real_T c3_d_B;
real_T c3_l_y;
real_T c3_m_y;
real_T c3_n_y;
real_T c3_c_a;
real_T c3_d_b;
real_T c3_o_y;
real_T c3_k_x;
real_T c3_l_x;
real_T c3_d_a;
real_T c3_p_y;
real_T c3_e_a;
real_T c3_e_b;
real_T c3_q_y;
real_T c3_f_a;
real_T c3_f_b;
real_T c3_r_y;
real_T c3_d_A;
real_T c3_e_B;
real_T c3_m_x;
real_T c3_s_y;
real_T c3_n_x;
real_T c3_t_y;
real_T c3_u_y;
real_T c3_o_x;
real_T c3_p_x;
real_T c3_g_a;
real_T c3_v_y;
real_T c3_h_a;
real_T c3_g_b;
real_T c3_w_y;
real_T c3_e_A;
real_T c3_f_B;
real_T c3_q_x;
real_T c3_x_y;
real_T c3_r_x;
real_T c3_y_y;
real_T c3_ab_y;
real_T c3_i_a;
real_T c3_h_b;
real_T c3_bb_y;
real_T c3_j_a;
real_T c3_i_b;
real_T c3_k_a;
real_T c3_j_b;
real_T c3_cb_y;
real_T c3_l_a;
real_T c3_k_b;
real_T c3_db_y;
real_T *c3_b_v;
real_T *c3_b_w;
real_T *c3_b_k2;
real_T *c3_b_k1;
real_T *c3_b_r;
real_T *c3_b_thetad;
real_T (*c3_b_qe)[3];
real_T (*c3_b_z)[2];
c3_b_k2 = (real_T *)ssGetInputPortSignal(chartInstance->S, 5);
c3_b_k1 = (real_T *)ssGetInputPortSignal(chartInstance->S, 4);
c3_b_qe = (real_T (*)[3])ssGetInputPortSignal(chartInstance->S, 3);
c3_b_v = (real_T *)ssGetOutputPortSignal(chartInstance->S, 2);
c3_b_r = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
c3_b_thetad = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c3_b_z = (real_T (*)[2])ssGetInputPortSignal(chartInstance->S, 0);
c3_b_w = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 2U, chartInstance->c3_sfEvent);
_SFD_DATA_RANGE_CHECK(*c3_b_w, 0U);
for (c3_i0 = 0; c3_i0 < 2; c3_i0++) {
_SFD_DATA_RANGE_CHECK((*c3_b_z)[c3_i0], 1U);
}
_SFD_DATA_RANGE_CHECK(*c3_b_thetad, 2U);
_SFD_DATA_RANGE_CHECK(*c3_b_r, 3U);
_SFD_DATA_RANGE_CHECK(*c3_b_v, 4U);
for (c3_i1 = 0; c3_i1 < 3; c3_i1++) {
_SFD_DATA_RANGE_CHECK((*c3_b_qe)[c3_i1], 5U);
}
_SFD_DATA_RANGE_CHECK(*c3_b_k1, 6U);
_SFD_DATA_RANGE_CHECK(*c3_b_k2, 7U);
chartInstance->c3_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 2U, chartInstance->c3_sfEvent);
c3_hoistedGlobal = *c3_b_thetad;
c3_b_hoistedGlobal = *c3_b_r;
c3_c_hoistedGlobal = *c3_b_k1;
c3_d_hoistedGlobal = *c3_b_k2;
for (c3_i2 = 0; c3_i2 < 2; c3_i2++) {
c3_z[c3_i2] = (*c3_b_z)[c3_i2];
}
c3_thetad = c3_hoistedGlobal;
c3_r = c3_b_hoistedGlobal;
for (c3_i3 = 0; c3_i3 < 3; c3_i3++) {
c3_qe[c3_i3] = (*c3_b_qe)[c3_i3];
}
c3_k1 = c3_c_hoistedGlobal;
c3_k2 = c3_d_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 13U, 13U, c3_debug_family_names,
c3_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c3_b, 0U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c3_b1, 1U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c3_b2, 2U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c3_nargin, 3U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c3_nargout, 4U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c3_z, 5U, c3_c_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c3_thetad, 6U, c3_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c3_r, 7U, c3_sf_marshallOut);
sf_debug_symbol_scope_add_eml(c3_qe, 8U, c3_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c3_k1, 9U, c3_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c3_k2, 10U, c3_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c3_w, 11U, c3_sf_marshallOut,
c3_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c3_v, 12U, c3_sf_marshallOut,
c3_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 4);
c3_A = c3_qe[1];
c3_B = c3_qe[0];
c3_x = c3_A;
c3_y = c3_B;
c3_b_x = c3_x;
c3_b_y = c3_y;
c3_b = c3_b_x / c3_b_y;
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 5);
c3_c_x = c3_qe[2];
c3_d_x = c3_c_x;
c3_d_x = muDoubleScalarCos(c3_d_x);
c3_b_A = c3_thetad;
c3_b_B = c3_b;
c3_e_x = c3_b_A;
c3_c_y = c3_b_B;
c3_f_x = c3_e_x;
c3_d_y = c3_c_y;
c3_e_y = c3_f_x / c3_d_y;
c3_a = c3_d_x;
c3_b_b = c3_e_y - 1.0;
c3_f_y = c3_a * c3_b_b;
c3_g_x = c3_qe[2];
c3_h_x = c3_g_x;
c3_h_x = muDoubleScalarSin(c3_h_x);
c3_c_B = c3_mpower(chartInstance, c3_b);
c3_g_y = c3_c_B;
c3_h_y = c3_g_y;
c3_i_y = 1.0 / c3_h_y;
c3_b_a = c3_thetad;
c3_c_b = 1.0 - c3_i_y;
c3_j_y = c3_b_a * c3_c_b;
c3_c_A = c3_j_y;
c3_i_x = c3_c_A;
c3_j_x = c3_i_x;
c3_k_y = c3_j_x / 2.0;
c3_d_B = c3_b;
c3_l_y = c3_d_B;
c3_m_y = c3_l_y;
c3_n_y = 1.0 / c3_m_y;
c3_c_a = c3_h_x;
c3_d_b = c3_k_y + c3_n_y;
c3_o_y = c3_c_a * c3_d_b;
c3_b1 = c3_f_y + c3_o_y;
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 6);
c3_k_x = c3_qe[2];
c3_l_x = c3_k_x;
c3_l_x = muDoubleScalarCos(c3_l_x);
c3_d_a = c3_l_x;
c3_p_y = c3_d_a * 2.0;
c3_e_a = c3_p_y;
c3_e_b = c3_b;
c3_q_y = c3_e_a * c3_e_b;
c3_f_a = 1.0 + c3_mpower(chartInstance, c3_b);
c3_f_b = c3_qe[0];
c3_r_y = c3_f_a * c3_f_b;
c3_d_A = c3_q_y;
c3_e_B = c3_r_y;
c3_m_x = c3_d_A;
c3_s_y = c3_e_B;
c3_n_x = c3_m_x;
c3_t_y = c3_s_y;
c3_u_y = c3_n_x / c3_t_y;
c3_o_x = c3_qe[2];
c3_p_x = c3_o_x;
c3_p_x = muDoubleScalarSin(c3_p_x);
c3_g_a = c3_p_x;
c3_v_y = c3_g_a * 2.0;
c3_h_a = 1.0 + c3_mpower(chartInstance, c3_b);
c3_g_b = c3_qe[0];
c3_w_y = c3_h_a * c3_g_b;
c3_e_A = c3_v_y;
c3_f_B = c3_w_y;
c3_q_x = c3_e_A;
c3_x_y = c3_f_B;
c3_r_x = c3_q_x;
c3_y_y = c3_x_y;
c3_ab_y = c3_r_x / c3_y_y;
c3_b2 = c3_u_y - c3_ab_y;
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 8);
c3_i_a = -c3_k1;
c3_h_b = c3_b1;
c3_bb_y = c3_i_a * c3_h_b;
c3_j_a = c3_bb_y;
c3_i_b = c3_z[0];
c3_v = c3_j_a * c3_i_b;
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 9);
c3_k_a = -c3_b2;
c3_j_b = c3_v;
c3_cb_y = c3_k_a * c3_j_b;
c3_l_a = c3_k2;
c3_k_b = c3_z[1];
c3_db_y = c3_l_a * c3_k_b;
c3_w = c3_cb_y - c3_db_y;
_SFD_EML_CALL(0U, chartInstance->c3_sfEvent, -9);
sf_debug_symbol_scope_pop();
*c3_b_w = c3_w;
*c3_b_v = c3_v;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 2U, chartInstance->c3_sfEvent);
sf_debug_check_for_state_inconsistency(_canudas_goal3MachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c8_WorkstationModel(SFc8_WorkstationModelInstanceStruct
*chartInstance)
{
real_T c8_hoistedGlobal;
real_T c8_b_hoistedGlobal;
real_T c8_CustomerClass;
real_T c8_JobClass;
uint32_T c8_debug_family_var_map[7];
boolean_T c8_aVarTruthTableCondition_1;
boolean_T c8_aVarTruthTableCondition_2;
real_T c8_nargin = 2.0;
real_T c8_nargout = 1.0;
real_T c8_QueueRoute;
real_T *c8_b_CustomerClass;
real_T *c8_b_QueueRoute;
real_T *c8_b_JobClass;
boolean_T guard1 = FALSE;
boolean_T guard2 = FALSE;
boolean_T guard3 = FALSE;
c8_b_JobClass = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c8_b_QueueRoute = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c8_b_CustomerClass = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 7U, chartInstance->c8_sfEvent);
_SFD_DATA_RANGE_CHECK(*c8_b_CustomerClass, 0U);
_SFD_DATA_RANGE_CHECK(*c8_b_QueueRoute, 1U);
_SFD_DATA_RANGE_CHECK(*c8_b_JobClass, 2U);
chartInstance->c8_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 7U, chartInstance->c8_sfEvent);
c8_hoistedGlobal = *c8_b_CustomerClass;
c8_b_hoistedGlobal = *c8_b_JobClass;
c8_CustomerClass = c8_hoistedGlobal;
c8_JobClass = c8_b_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 7U, 7U, c8_debug_family_names,
c8_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c8_aVarTruthTableCondition_1, 0U,
c8_b_sf_marshallOut, c8_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c8_aVarTruthTableCondition_2, 1U,
c8_b_sf_marshallOut, c8_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c8_nargin, 2U, c8_sf_marshallOut,
c8_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c8_nargout, 3U, c8_sf_marshallOut,
c8_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c8_CustomerClass, 4U, c8_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c8_JobClass, 5U, c8_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c8_QueueRoute, 6U, c8_sf_marshallOut,
c8_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 3);
c8_aVarTruthTableCondition_1 = FALSE;
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 4);
c8_aVarTruthTableCondition_2 = FALSE;
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 9);
c8_aVarTruthTableCondition_1 = (c8_CustomerClass == 1.0);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 13);
c8_aVarTruthTableCondition_2 = (c8_JobClass == 1.0);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 15);
guard1 = FALSE;
if (CV_EML_COND(0, 1, 0, c8_aVarTruthTableCondition_1)) {
if (CV_EML_COND(0, 1, 1, c8_aVarTruthTableCondition_2)) {
CV_EML_MCDC(0, 1, 0, TRUE);
CV_EML_IF(0, 1, 0, TRUE);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 16);
CV_EML_FCN(0, 1);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 29);
c8_QueueRoute = 1.0;
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, -29);
} else {
guard1 = TRUE;
}
} else {
guard1 = TRUE;
}
if (guard1 == TRUE) {
CV_EML_MCDC(0, 1, 0, FALSE);
CV_EML_IF(0, 1, 0, FALSE);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 17);
guard2 = FALSE;
if (CV_EML_COND(0, 1, 2, c8_aVarTruthTableCondition_1)) {
if (!CV_EML_COND(0, 1, 3, c8_aVarTruthTableCondition_2)) {
CV_EML_MCDC(0, 1, 1, TRUE);
CV_EML_IF(0, 1, 1, TRUE);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 18);
CV_EML_FCN(0, 2);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 35);
c8_QueueRoute = 2.0;
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, -35);
} else {
guard2 = TRUE;
}
} else {
guard2 = TRUE;
}
if (guard2 == TRUE) {
CV_EML_MCDC(0, 1, 1, FALSE);
CV_EML_IF(0, 1, 1, FALSE);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 19);
guard3 = FALSE;
if (!CV_EML_COND(0, 1, 4, c8_aVarTruthTableCondition_1)) {
if (CV_EML_COND(0, 1, 5, c8_aVarTruthTableCondition_2)) {
CV_EML_MCDC(0, 1, 2, TRUE);
CV_EML_IF(0, 1, 2, TRUE);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 20);
CV_EML_FCN(0, 3);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 41);
c8_QueueRoute = 3.0;
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, -41);
} else {
guard3 = TRUE;
}
} else {
guard3 = TRUE;
}
if (guard3 == TRUE) {
CV_EML_MCDC(0, 1, 2, FALSE);
CV_EML_IF(0, 1, 2, FALSE);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 22);
CV_EML_FCN(0, 4);
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, 47);
c8_QueueRoute = 4.0;
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, -47);
}
}
}
_SFD_EML_CALL(0U, chartInstance->c8_sfEvent, -22);
sf_debug_symbol_scope_pop();
*c8_b_QueueRoute = c8_QueueRoute;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 7U, chartInstance->c8_sfEvent);
sf_debug_check_for_state_inconsistency(_WorkstationModelMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void c19_chartstep_c19_Array(SFc19_ArrayInstanceStruct *chartInstance)
{
real_T c19_hoistedGlobal;
real_T c19_b_hoistedGlobal;
real_T c19_c_hoistedGlobal;
real_T c19_V;
real_T c19_Radiacion;
real_T c19_Temp;
uint32_T c19_debug_family_var_map[23];
real_T c19_q;
real_T c19_K;
real_T c19_n;
real_T c19_T;
real_T c19_Rs;
real_T c19_Rp;
real_T c19_Vt;
real_T c19_Ns;
real_T c19_Vc;
real_T c19_Isc;
real_T c19_Alfa;
real_T c19_Iph;
real_T c19_Voc_ref;
real_T c19_Beta;
real_T c19_Voc;
real_T c19_Io;
real_T c19_Ir;
real_T c19_nargin = 3.0;
real_T c19_nargout = 1.0;
real_T c19_I;
real_T c19_b;
real_T c19_y;
real_T c19_A;
real_T c19_x;
real_T c19_b_x;
real_T c19_c_x;
real_T c19_d_x;
real_T c19_b_b;
real_T c19_b_y;
real_T c19_b_A;
real_T c19_e_x;
real_T c19_f_x;
real_T c19_c_y;
real_T c19_c_b;
real_T c19_d_y;
real_T c19_a;
real_T c19_d_b;
real_T c19_e_b;
real_T c19_e_y;
real_T c19_f_b;
real_T c19_c_A;
real_T c19_B;
real_T c19_g_x;
real_T c19_f_y;
real_T c19_h_x;
real_T c19_g_y;
real_T c19_h_y;
real_T c19_i_x;
real_T c19_j_x;
real_T c19_b_B;
real_T c19_i_y;
real_T c19_j_y;
int32_T c19_i;
real_T c19_k_x;
real_T c19_k_y;
real_T c19_l_x;
real_T c19_l_y;
real_T c19_z;
real_T c19_m_x;
real_T c19_n_x;
real_T c19_d_A;
real_T c19_o_x;
real_T c19_p_x;
real_T c19_m_y;
real_T c19_n_y;
real_T c19_o_y;
real_T c19_b_z;
real_T c19_b_a;
real_T c19_g_b;
real_T c19_p_y;
real_T c19_q_x;
real_T c19_q_y;
real_T c19_r_x;
real_T c19_r_y;
real_T c19_c_z;
real_T c19_s_x;
real_T c19_t_x;
real_T c19_u_x;
real_T c19_s_y;
real_T c19_v_x;
real_T c19_t_y;
real_T c19_d_z;
real_T *c19_b_Temp;
real_T *c19_b_Radiacion;
real_T *c19_b_V;
real_T *c19_b_I;
c19_b_Temp = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);
c19_b_Radiacion = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c19_b_I = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c19_b_V = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 18U, chartInstance->c19_sfEvent);
c19_hoistedGlobal = *c19_b_V;
c19_b_hoistedGlobal = *c19_b_Radiacion;
c19_c_hoistedGlobal = *c19_b_Temp;
c19_V = c19_hoistedGlobal;
c19_Radiacion = c19_b_hoistedGlobal;
c19_Temp = c19_c_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 23U, 23U, c19_debug_family_names,
c19_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c19_q, 0U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c19_K, 1U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c19_n, 2U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c19_T, 3U, c19_sf_marshallOut,
c19_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c19_Rs, 4U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c19_Rp, 5U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c19_Vt, 6U, c19_sf_marshallOut,
c19_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c19_Ns, 7U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c19_Vc, 8U, c19_sf_marshallOut,
c19_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c19_Isc, 9U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c19_Alfa, 10U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c19_Iph, 11U, c19_sf_marshallOut,
c19_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c19_Voc_ref, 12U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c19_Beta, 13U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c19_Voc, 14U, c19_sf_marshallOut,
c19_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c19_Io, 15U, c19_sf_marshallOut,
c19_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c19_Ir, 16U, c19_sf_marshallOut,
c19_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c19_nargin, 17U, c19_sf_marshallOut,
c19_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c19_nargout, 18U, c19_sf_marshallOut,
c19_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c19_V, 19U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c19_Radiacion, 20U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml(&c19_Temp, 21U, c19_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c19_I, 22U, c19_sf_marshallOut,
c19_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 3);
c19_q = 1.602176E-19;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 5);
c19_K = 1.3806488E-23;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 7);
c19_n = 1.3;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 9);
c19_T = 273.15 + c19_Temp;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 11);
c19_Rs = 0.015;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 13);
c19_Rp = 100.0;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 15);
c19_b = c19_T;
c19_y = 1.79484344E-23 * c19_b;
c19_A = c19_y;
c19_x = c19_A;
c19_b_x = c19_x;
c19_Vt = c19_b_x / 1.602176E-19;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 16);
c19_Ns = 36.0;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 17);
c19_c_x = c19_V;
c19_d_x = c19_c_x;
c19_Vc = c19_d_x / 36.0;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 19);
c19_Isc = 5.433;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 20);
c19_Alfa = 0.00037;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 22);
c19_b_b = c19_Radiacion;
c19_b_y = 5.433 * c19_b_b;
c19_b_A = c19_b_y;
c19_e_x = c19_b_A;
c19_f_x = c19_e_x;
c19_c_y = c19_f_x / 1000.0;
c19_c_b = c19_Temp - 25.0;
c19_d_y = 0.00037 * c19_c_b;
c19_a = c19_c_y;
c19_d_b = 1.0 + c19_d_y;
c19_Iph = c19_a * c19_d_b;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 24);
c19_Voc_ref = 0.6166666666666667;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 25);
c19_Beta = -0.0034000000000000002;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 26);
c19_e_b = c19_Temp - 25.0;
c19_e_y = -0.0034000000000000002 * c19_e_b;
c19_f_b = 1.0 + c19_e_y;
c19_Voc = 0.6166666666666667 * c19_f_b;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 32);
c19_c_A = c19_Voc;
c19_B = c19_Vt;
c19_g_x = c19_c_A;
c19_f_y = c19_B;
c19_h_x = c19_g_x;
c19_g_y = c19_f_y;
c19_h_y = c19_h_x / c19_g_y;
c19_i_x = c19_h_y;
c19_j_x = c19_i_x;
c19_j_x = muDoubleScalarExp(c19_j_x);
c19_b_B = c19_j_x - 1.0;
c19_i_y = c19_b_B;
c19_j_y = c19_i_y;
c19_Io = 5.433 / c19_j_y;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 33);
c19_Ir = c19_Io;
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 36);
c19_I = 0.0;
c19_i = 0;
while (c19_i < 50) {
CV_EML_FOR(0, 1, 0, 1);
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, 38);
c19_k_x = c19_Vc + c19_I * c19_Rs;
c19_k_y = c19_Vt;
c19_l_x = c19_k_x;
c19_l_y = c19_k_y;
c19_z = c19_l_x / c19_l_y;
c19_m_x = c19_z;
c19_n_x = c19_m_x;
c19_n_x = muDoubleScalarExp(c19_n_x);
c19_d_A = c19_Vc + c19_I * c19_Rs;
c19_o_x = c19_d_A;
c19_p_x = c19_o_x;
c19_m_y = c19_p_x / 100.0;
c19_n_y = c19_Vt;
c19_o_y = c19_n_y;
c19_b_z = 0.015 / c19_o_y;
c19_b_a = c19_Ir;
c19_g_b = c19_b_z;
c19_p_y = c19_b_a * c19_g_b;
c19_q_x = c19_Vc + c19_I * c19_Rs;
c19_q_y = c19_Vt;
c19_r_x = c19_q_x;
c19_r_y = c19_q_y;
c19_c_z = c19_r_x / c19_r_y;
c19_s_x = c19_c_z;
c19_t_x = c19_s_x;
c19_t_x = muDoubleScalarExp(c19_t_x);
c19_u_x = ((c19_Iph - c19_I) - c19_Ir * (c19_n_x - 1.0)) + c19_m_y;
c19_s_y = (-1.0 - c19_p_y * c19_t_x) - 0.00015;
c19_v_x = c19_u_x;
c19_t_y = c19_s_y;
c19_d_z = c19_v_x / c19_t_y;
c19_I -= c19_d_z;
c19_i++;
sf_mex_listen_for_ctrl_c(chartInstance->S);
}
CV_EML_FOR(0, 1, 0, 0);
_SFD_EML_CALL(0U, chartInstance->c19_sfEvent, -38);
sf_debug_symbol_scope_pop();
*c19_b_I = c19_I;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 18U, chartInstance->c19_sfEvent);
}
static void c2_chartstep_c2_gesamtmodell(SFc2_gesamtmodellInstanceStruct
*chartInstance)
{
int32_T c2_i4;
real_T c2_u[4];
uint32_T c2_debug_family_var_map[9];
real_T c2_T;
real_T c2_phi;
real_T c2_theta;
real_T c2_psi;
real_T c2_Mt[9];
real_T c2_nargin = 1.0;
real_T c2_nargout = 1.0;
real_T c2_y[3];
real_T c2_x;
real_T c2_b_x;
real_T c2_c_x;
real_T c2_d_x;
real_T c2_a;
real_T c2_b;
real_T c2_b_y;
real_T c2_e_x;
real_T c2_f_x;
real_T c2_g_x;
real_T c2_h_x;
real_T c2_b_a;
real_T c2_b_b;
real_T c2_c_y;
real_T c2_i_x;
real_T c2_j_x;
real_T c2_c_a;
real_T c2_c_b;
real_T c2_d_y;
real_T c2_k_x;
real_T c2_l_x;
real_T c2_m_x;
real_T c2_n_x;
real_T c2_d_a;
real_T c2_d_b;
real_T c2_e_y;
real_T c2_o_x;
real_T c2_p_x;
real_T c2_q_x;
real_T c2_r_x;
real_T c2_e_a;
real_T c2_e_b;
real_T c2_f_y;
real_T c2_s_x;
real_T c2_t_x;
real_T c2_f_a;
real_T c2_f_b;
real_T c2_g_y;
real_T c2_u_x;
real_T c2_v_x;
real_T c2_w_x;
real_T c2_x_x;
real_T c2_g_a;
real_T c2_g_b;
real_T c2_h_y;
real_T c2_y_x;
real_T c2_ab_x;
real_T c2_bb_x;
real_T c2_cb_x;
real_T c2_h_a;
real_T c2_h_b;
real_T c2_i_y;
real_T c2_db_x;
real_T c2_eb_x;
real_T c2_fb_x;
real_T c2_gb_x;
real_T c2_i_a;
real_T c2_i_b;
real_T c2_j_y;
real_T c2_hb_x;
real_T c2_ib_x;
real_T c2_j_a;
real_T c2_j_b;
real_T c2_k_y;
real_T c2_jb_x;
real_T c2_kb_x;
real_T c2_lb_x;
real_T c2_mb_x;
real_T c2_k_a;
real_T c2_k_b;
real_T c2_l_y;
real_T c2_nb_x;
real_T c2_ob_x;
real_T c2_pb_x;
real_T c2_qb_x;
real_T c2_l_a;
real_T c2_l_b;
real_T c2_m_y;
real_T c2_rb_x;
real_T c2_sb_x;
real_T c2_m_a;
real_T c2_m_b;
real_T c2_n_y;
real_T c2_tb_x;
real_T c2_ub_x;
real_T c2_vb_x;
real_T c2_wb_x;
real_T c2_n_a;
real_T c2_n_b;
real_T c2_o_y;
real_T c2_xb_x;
real_T c2_yb_x;
real_T c2_ac_x;
real_T c2_bc_x;
real_T c2_cc_x;
real_T c2_dc_x;
real_T c2_o_a;
real_T c2_o_b;
real_T c2_p_y;
real_T c2_ec_x;
real_T c2_fc_x;
real_T c2_gc_x;
real_T c2_hc_x;
real_T c2_p_a;
real_T c2_p_b;
real_T c2_q_y;
int32_T c2_i5;
real_T c2_q_a[9];
real_T c2_q_b[3];
int32_T c2_i6;
int32_T c2_i7;
int32_T c2_i8;
real_T c2_C[3];
int32_T c2_i9;
int32_T c2_i10;
int32_T c2_i11;
int32_T c2_i12;
int32_T c2_i13;
int32_T c2_i14;
int32_T c2_i15;
real_T (*c2_r_y)[3];
real_T (*c2_b_u)[4];
c2_r_y = (real_T (*)[3])ssGetOutputPortSignal(chartInstance->S, 1);
c2_b_u = (real_T (*)[4])ssGetInputPortSignal(chartInstance->S, 0);
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
for (c2_i4 = 0; c2_i4 < 4; c2_i4++) {
c2_u[c2_i4] = (*c2_b_u)[c2_i4];
}
sf_debug_symbol_scope_push_eml(0U, 9U, 9U, c2_debug_family_names,
c2_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c2_T, 0U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_phi, 1U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_theta, 2U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_psi, 3U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(c2_Mt, 4U, c2_d_sf_marshallOut,
c2_c_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_nargin, 5U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c2_nargout, 6U, c2_c_sf_marshallOut,
c2_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml(c2_u, 7U, c2_b_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(c2_y, 8U, c2_sf_marshallOut,
c2_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 2);
c2_T = c2_u[0];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 3);
c2_phi = c2_u[1];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 4);
c2_theta = c2_u[2];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 5);
c2_psi = c2_u[3];
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 7);
c2_x = c2_theta;
c2_b_x = c2_x;
c2_b_x = muDoubleScalarCos(c2_b_x);
c2_c_x = c2_psi;
c2_d_x = c2_c_x;
c2_d_x = muDoubleScalarCos(c2_d_x);
c2_a = c2_b_x;
c2_b = c2_d_x;
c2_b_y = c2_a * c2_b;
c2_e_x = c2_phi;
c2_f_x = c2_e_x;
c2_f_x = muDoubleScalarSin(c2_f_x);
c2_g_x = c2_theta;
c2_h_x = c2_g_x;
c2_h_x = muDoubleScalarSin(c2_h_x);
c2_b_a = c2_f_x;
c2_b_b = c2_h_x;
c2_c_y = c2_b_a * c2_b_b;
c2_i_x = c2_psi;
c2_j_x = c2_i_x;
c2_j_x = muDoubleScalarCos(c2_j_x);
c2_c_a = c2_c_y;
c2_c_b = c2_j_x;
c2_d_y = c2_c_a * c2_c_b;
c2_k_x = c2_phi;
c2_l_x = c2_k_x;
c2_l_x = muDoubleScalarCos(c2_l_x);
c2_m_x = c2_psi;
c2_n_x = c2_m_x;
c2_n_x = muDoubleScalarSin(c2_n_x);
c2_d_a = c2_l_x;
c2_d_b = c2_n_x;
c2_e_y = c2_d_a * c2_d_b;
c2_o_x = c2_phi;
c2_p_x = c2_o_x;
c2_p_x = muDoubleScalarCos(c2_p_x);
c2_q_x = c2_theta;
c2_r_x = c2_q_x;
c2_r_x = muDoubleScalarSin(c2_r_x);
c2_e_a = c2_p_x;
c2_e_b = c2_r_x;
c2_f_y = c2_e_a * c2_e_b;
c2_s_x = c2_psi;
c2_t_x = c2_s_x;
c2_t_x = muDoubleScalarCos(c2_t_x);
c2_f_a = c2_f_y;
c2_f_b = c2_t_x;
c2_g_y = c2_f_a * c2_f_b;
c2_u_x = c2_phi;
c2_v_x = c2_u_x;
c2_v_x = muDoubleScalarSin(c2_v_x);
c2_w_x = c2_psi;
c2_x_x = c2_w_x;
c2_x_x = muDoubleScalarSin(c2_x_x);
c2_g_a = c2_v_x;
c2_g_b = c2_x_x;
c2_h_y = c2_g_a * c2_g_b;
c2_y_x = c2_theta;
c2_ab_x = c2_y_x;
c2_ab_x = muDoubleScalarCos(c2_ab_x);
c2_bb_x = c2_psi;
c2_cb_x = c2_bb_x;
c2_cb_x = muDoubleScalarSin(c2_cb_x);
c2_h_a = c2_ab_x;
c2_h_b = c2_cb_x;
c2_i_y = c2_h_a * c2_h_b;
c2_db_x = c2_phi;
c2_eb_x = c2_db_x;
c2_eb_x = muDoubleScalarSin(c2_eb_x);
c2_fb_x = c2_theta;
c2_gb_x = c2_fb_x;
c2_gb_x = muDoubleScalarSin(c2_gb_x);
c2_i_a = c2_eb_x;
c2_i_b = c2_gb_x;
c2_j_y = c2_i_a * c2_i_b;
c2_hb_x = c2_psi;
c2_ib_x = c2_hb_x;
c2_ib_x = muDoubleScalarSin(c2_ib_x);
c2_j_a = c2_j_y;
c2_j_b = c2_ib_x;
c2_k_y = c2_j_a * c2_j_b;
c2_jb_x = c2_phi;
c2_kb_x = c2_jb_x;
c2_kb_x = muDoubleScalarCos(c2_kb_x);
c2_lb_x = c2_psi;
c2_mb_x = c2_lb_x;
c2_mb_x = muDoubleScalarCos(c2_mb_x);
c2_k_a = c2_kb_x;
c2_k_b = c2_mb_x;
c2_l_y = c2_k_a * c2_k_b;
c2_nb_x = c2_phi;
c2_ob_x = c2_nb_x;
c2_ob_x = muDoubleScalarCos(c2_ob_x);
c2_pb_x = c2_theta;
c2_qb_x = c2_pb_x;
c2_qb_x = muDoubleScalarSin(c2_qb_x);
c2_l_a = c2_ob_x;
c2_l_b = c2_qb_x;
c2_m_y = c2_l_a * c2_l_b;
c2_rb_x = c2_psi;
c2_sb_x = c2_rb_x;
c2_sb_x = muDoubleScalarSin(c2_sb_x);
c2_m_a = c2_m_y;
c2_m_b = c2_sb_x;
c2_n_y = c2_m_a * c2_m_b;
c2_tb_x = c2_phi;
c2_ub_x = c2_tb_x;
c2_ub_x = muDoubleScalarSin(c2_ub_x);
c2_vb_x = c2_psi;
c2_wb_x = c2_vb_x;
c2_wb_x = muDoubleScalarCos(c2_wb_x);
c2_n_a = c2_ub_x;
c2_n_b = c2_wb_x;
c2_o_y = c2_n_a * c2_n_b;
c2_xb_x = c2_theta;
c2_yb_x = c2_xb_x;
c2_yb_x = muDoubleScalarSin(c2_yb_x);
c2_ac_x = c2_phi;
c2_bc_x = c2_ac_x;
c2_bc_x = muDoubleScalarSin(c2_bc_x);
c2_cc_x = c2_theta;
c2_dc_x = c2_cc_x;
c2_dc_x = muDoubleScalarCos(c2_dc_x);
c2_o_a = c2_bc_x;
c2_o_b = c2_dc_x;
c2_p_y = c2_o_a * c2_o_b;
c2_ec_x = c2_phi;
c2_fc_x = c2_ec_x;
c2_fc_x = muDoubleScalarCos(c2_fc_x);
c2_gc_x = c2_theta;
c2_hc_x = c2_gc_x;
c2_hc_x = muDoubleScalarCos(c2_hc_x);
c2_p_a = c2_fc_x;
c2_p_b = c2_hc_x;
c2_q_y = c2_p_a * c2_p_b;
c2_Mt[0] = c2_b_y;
c2_Mt[3] = c2_d_y - c2_e_y;
c2_Mt[6] = c2_g_y + c2_h_y;
c2_Mt[1] = c2_i_y;
c2_Mt[4] = c2_k_y + c2_l_y;
c2_Mt[7] = c2_n_y - c2_o_y;
c2_Mt[2] = -c2_yb_x;
c2_Mt[5] = c2_p_y;
c2_Mt[8] = c2_q_y;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 10);
for (c2_i5 = 0; c2_i5 < 9; c2_i5++) {
c2_q_a[c2_i5] = c2_Mt[c2_i5];
}
c2_q_b[0] = 0.0;
c2_q_b[1] = 0.0;
c2_q_b[2] = c2_T;
c2_eml_scalar_eg(chartInstance);
c2_eml_scalar_eg(chartInstance);
for (c2_i6 = 0; c2_i6 < 3; c2_i6++) {
c2_y[c2_i6] = 0.0;
}
for (c2_i7 = 0; c2_i7 < 3; c2_i7++) {
c2_y[c2_i7] = 0.0;
}
for (c2_i8 = 0; c2_i8 < 3; c2_i8++) {
c2_C[c2_i8] = c2_y[c2_i8];
}
for (c2_i9 = 0; c2_i9 < 3; c2_i9++) {
c2_y[c2_i9] = c2_C[c2_i9];
}
for (c2_i10 = 0; c2_i10 < 3; c2_i10++) {
c2_C[c2_i10] = c2_y[c2_i10];
}
for (c2_i11 = 0; c2_i11 < 3; c2_i11++) {
c2_y[c2_i11] = c2_C[c2_i11];
}
for (c2_i12 = 0; c2_i12 < 3; c2_i12++) {
c2_y[c2_i12] = 0.0;
c2_i13 = 0;
for (c2_i14 = 0; c2_i14 < 3; c2_i14++) {
c2_y[c2_i12] += c2_q_a[c2_i13 + c2_i12] * c2_q_b[c2_i14];
c2_i13 += 3;
}
}
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, -10);
sf_debug_symbol_scope_pop();
for (c2_i15 = 0; c2_i15 < 3; c2_i15++) {
(*c2_r_y)[c2_i15] = c2_y[c2_i15];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
}
