自学教程：C++ ssGetT函数代码示例

/* Function: mdlOutputs ======================================================= **/static void mdlOutputs(SimStruct *S, int_T tid){    const uint32_T   *set_BaudRate  = (const uint32_T*) ssGetInputPortSignal(S,0);    const int16_T   *data_send  = (const int16_T*) ssGetInputPortSignal(S,1);    int16_T        *data_out  = (int16_T *)ssGetOutputPortRealSignal(S,0);    int16_T        *data_new_flag  = (int16_T *)ssGetOutputPortRealSignal(S,1);    real_T        *HL_Status  = (real_T *)ssGetOutputPortRealSignal(S,2);    int16_T        *realTime  = (int16_T *)ssGetOutputPortRealSignal(S,3);       real_T             t_previousSimTime = ssGetRWorkValue(S,0);   time_T            t_SimTime = ssGetT(S);   real_T             t_diff = 0.0;   real_T             dt;   real_T             t_current=getTime();   real_T             t_0=t_current;   real_T             t_previous=t_current;   real_T             t_elapsed;   real_T        *y0  = (real_T *)ssGetOutputPortRealSignal(S,0);   real_T       t_pre=ssGetRWorkValue(S,1);   real_T       t_pre0=ssGetRWorkValue(S,2);   real_T       t_term=ssGetRWorkValue(S,3);   real_T       t_realTime=t_current-t_pre0;   /* Desired Delta time */   dt = (t_SimTime - t_previousSimTime) ;   /* Get clock time at the beginning of this step*/      if(t_0-t_pre>(dt+0.001))  {	printf("Warning:It is slower than the real time::%f/r/n",t_0-t_pre); }  t_pre= t_0;      /* Store current time to be used in next time step*/       /* %%%-SFUNWIZ_wrapper_Outputs_Changes_BEGIN --- EDIT HERE TO _END *///static int FTDIopen=0;if (openFtdi==0){    openFtdi = open_ftdi(*set_BaudRate, "Quad_USB2", 5, 15);}if (openFtdi == 1){        *data_new_flag = read_ftdi (data_out, HL_Status);       while (t_realTime<t_term-dt/2){/*(t_diff<dt){*/        t_current =  getTime();        t_realTime=t_current-t_pre0;                /* Look for wrapup */        if (t_current<t_previous){            t_elapsed = t_previous - t_0;            t_0 = getTime() - t_elapsed;        }        t_diff = t_current - t_0;        t_previous = t_current;   }    send_ftdi (data_send);}else{    *data_new_flag = -1;}     /* Wait to reach the desired time */   while (t_realTime<t_term){/*(t_diff<dt){*/        t_current =  getTime();        t_realTime=t_current-t_pre0;                /* Look for wrapup */        if (t_current<t_previous){            t_elapsed = t_previous - t_0;            t_0 = getTime() - t_elapsed;        }        t_diff = t_current - t_0;        t_previous = t_current;   } ssSetRWorkValue(S, 0, t_SimTime); ssSetRWorkValue(S,1,t_pre); ssSetRWorkValue(S,3,t_realTime+dt); *realTime=t_0-t_pre0;//    Quadlinux_Com_Outputs_wrapper(set_BaudRate, data_send, data_out, data_new_flag, HL_Status, bytes_sent);}

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 disable_c3_controller1(SFc3_controller1InstanceStruct *chartInstance){  _sfTime_ = (real_T)ssGetT(chartInstance->S);}

static void disable_c7_ekffede(SFc7_ekffedeInstanceStruct *chartInstance){  _sfTime_ = (real_T)ssGetT(chartInstance->S);}

/* Function Definitions */static void initialize_c6_TTR_mdl(SFc6_TTR_mdlInstanceStruct *chartInstance){  chartInstance->c6_sfEvent = CALL_EVENT;  _sfTime_ = (real_T)ssGetT(chartInstance->S);  chartInstance->c6_is_active_c6_TTR_mdl = 0U;}

/* Function Definitions */static void initialize_c2_MPC_framework(void){  _sfTime_ = (real_T)ssGetT(chartInstance.S);  chartInstance.c2_is_active_c2_MPC_framework = 0U;}

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_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 enable_c12_ekffedepre(SFc12_ekffedepreInstanceStruct *chartInstance){  _sfTime_ = (real_T)ssGetT(chartInstance->S);}

static void sf_c41_heart_model(SFc41_heart_modelInstanceStruct *chartInstance){  boolean_T c41_out;  boolean_T c41_b_out;  boolean_T c41_c_out;  boolean_T c41_temp;  boolean_T c41_d_out;  boolean_T c41_e_out;  boolean_T c41_f_out;  real_T *c41_v;  boolean_T *c41_event1;  boolean_T *c41_event2;  boolean_T *c41_event3;  c41_event3 = (boolean_T *)ssGetOutputPortSignal(chartInstance->S, 3);  c41_event2 = (boolean_T *)ssGetOutputPortSignal(chartInstance->S, 2);  c41_event1 = (boolean_T *)ssGetOutputPortSignal(chartInstance->S, 1);  c41_v = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);  c41_set_sim_state_side_effects_c41_heart_model(chartInstance);  _sfTime_ = (real_T)ssGetT(chartInstance->S);  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 38U, chartInstance->c41_sfEvent);  _SFD_DATA_RANGE_CHECK(*c41_v, 0U);  chartInstance->c41_sfEvent = CALL_EVENT;  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 38U, chartInstance->c41_sfEvent);  if (chartInstance->c41_is_active_c41_heart_model == 0) {    _SFD_CC_CALL(CHART_ENTER_ENTRY_FUNCTION_TAG, 38U, chartInstance->c41_sfEvent);    chartInstance->c41_is_active_c41_heart_model = 1U;    _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 38U, chartInstance->c41_sfEvent);    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 0U,                 chartInstance->c41_sfEvent);    _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 0U, chartInstance->c41_sfEvent);    chartInstance->c41_is_c41_heart_model = c41_IN_state;    _SFD_CS_CALL(STATE_ACTIVE_TAG, 0U, chartInstance->c41_sfEvent);    chartInstance->c41_tp_state = 1U;  } else {    _SFD_CS_CALL(STATE_ENTER_DURING_FUNCTION_TAG, 0U, chartInstance->c41_sfEvent);    _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 1U,                 chartInstance->c41_sfEvent);    c41_out = (CV_TRANSITION_EVAL(1U, (int32_T)_SFD_CCP_CALL(1U, 0, *c41_v <      20.0 != 0U, chartInstance->c41_sfEvent)) != 0);    if (c41_out) {      if (sf_debug_transition_conflict_check_enabled()) {        unsigned int transitionList[3];        unsigned int numTransitions = 1;        transitionList[0] = 1;        sf_debug_transition_conflict_check_begin();        c41_b_out = ((*c41_v >= 20.0) && (*c41_v < 138.0));        if (c41_b_out) {          transitionList[numTransitions] = 2;          numTransitions++;        }        c41_c_out = (*c41_v >= 138.0);        if (c41_c_out) {          transitionList[numTransitions] = 3;          numTransitions++;        }        sf_debug_transition_conflict_check_end();        if (numTransitions > 1) {          _SFD_TRANSITION_CONFLICT(&(transitionList[0]),numTransitions);        }      }      _SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 1U, chartInstance->c41_sfEvent);      chartInstance->c41_tp_state = 0U;      chartInstance->c41_is_c41_heart_model = c41_IN_NO_ACTIVE_CHILD;      _SFD_CS_CALL(STATE_INACTIVE_TAG, 0U, chartInstance->c41_sfEvent);      chartInstance->c41_event1EventCounter++;      chartInstance->c41_is_c41_heart_model = c41_IN_state;      _SFD_CS_CALL(STATE_ACTIVE_TAG, 0U, chartInstance->c41_sfEvent);      chartInstance->c41_tp_state = 1U;    } else {      _SFD_CT_CALL(TRANSITION_BEFORE_PROCESSING_TAG, 2U,                   chartInstance->c41_sfEvent);      c41_temp = (_SFD_CCP_CALL(2U, 0, *c41_v >= 20.0 != 0U,        chartInstance->c41_sfEvent) != 0);      if (c41_temp) {        c41_temp = (_SFD_CCP_CALL(2U, 1, *c41_v < 138.0 != 0U,          chartInstance->c41_sfEvent) != 0);      }      c41_d_out = (CV_TRANSITION_EVAL(2U, (int32_T)c41_temp) != 0);      if (c41_d_out) {        if (sf_debug_transition_conflict_check_enabled()) {          unsigned int transitionList[2];          unsigned int numTransitions = 1;          transitionList[0] = 2;          sf_debug_transition_conflict_check_begin();          c41_e_out = (*c41_v >= 138.0);          if (c41_e_out) {            transitionList[numTransitions] = 3;            numTransitions++;          }          sf_debug_transition_conflict_check_end();          if (numTransitions > 1) {            _SFD_TRANSITION_CONFLICT(&(transitionList[0]),numTransitions);          }        }//.........这里部分代码省略.........

static void disable_c41_heart_model(SFc41_heart_modelInstanceStruct  *chartInstance){  _sfTime_ = (real_T)ssGetT(chartInstance->S);}

static void disable_c2_DSHMHittingSecondORder  (SFc2_DSHMHittingSecondORderInstanceStruct *chartInstance){  _sfTime_ = (real_T)ssGetT(chartInstance->S);}

static void sf_c2_DSHMHittingSecondORder  (SFc2_DSHMHittingSecondORderInstanceStruct *chartInstance){  real_T c2_hoistedGlobal;  real_T c2_b_hoistedGlobal;  real_T c2_c_hoistedGlobal;  real_T c2_accel;  real_T c2_u;  real_T c2_gain;  uint32_T c2_debug_family_var_map[6];  real_T c2_nargin = 3.0;  real_T c2_nargout = 1.0;  real_T c2_y;  real_T c2_x;  real_T c2_b_x;  real_T c2_b_y;  real_T c2_a;  real_T c2_b;  real_T *c2_b_accel;  real_T *c2_b_u;  real_T *c2_c_y;  real_T *c2_b_gain;  c2_b_gain = (real_T *)ssGetInputPortSignal(chartInstance->S, 2);  c2_c_y = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);  c2_b_u = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);  c2_b_accel = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);  _SFD_SYMBOL_SCOPE_PUSH(0U, 0U);  _sfTime_ = (real_T)ssGetT(chartInstance->S);  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 0U, chartInstance->c2_sfEvent);  _SFD_DATA_RANGE_CHECK(*c2_b_accel, 0U);  _SFD_DATA_RANGE_CHECK(*c2_b_u, 1U);  _SFD_DATA_RANGE_CHECK(*c2_c_y, 2U);  _SFD_DATA_RANGE_CHECK(*c2_b_gain, 3U);  chartInstance->c2_sfEvent = CALL_EVENT;  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0U, chartInstance->c2_sfEvent);  c2_hoistedGlobal = *c2_b_accel;  c2_b_hoistedGlobal = *c2_b_u;  c2_c_hoistedGlobal = *c2_b_gain;  c2_accel = c2_hoistedGlobal;  c2_u = c2_b_hoistedGlobal;  c2_gain = c2_c_hoistedGlobal;  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 6U, 6U, c2_debug_family_names,    c2_debug_family_var_map);  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c2_nargin, 0U, c2_sf_marshallOut,    c2_sf_marshallIn);  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c2_nargout, 1U, c2_sf_marshallOut,    c2_sf_marshallIn);  _SFD_SYMBOL_SCOPE_ADD_EML(&c2_accel, 2U, c2_sf_marshallOut);  _SFD_SYMBOL_SCOPE_ADD_EML(&c2_u, 3U, c2_sf_marshallOut);  _SFD_SYMBOL_SCOPE_ADD_EML(&c2_gain, 4U, c2_sf_marshallOut);  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c2_y, 5U, c2_sf_marshallOut,    c2_sf_marshallIn);  CV_EML_FCN(0, 0);  _SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 4);  c2_x = c2_accel;  c2_b_x = c2_x;  c2_b_y = muDoubleScalarAbs(c2_b_x);  if (CV_EML_IF(0, 1, 0, c2_b_y < 0.0001)) {    _SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 5);    c2_y = 0.0;  } else {    _SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 7);    c2_a = c2_u;    c2_b = c2_gain;    c2_y = c2_a * c2_b;  }  _SFD_EML_CALL(0U, chartInstance->c2_sfEvent, -7);  _SFD_SYMBOL_SCOPE_POP();  *c2_c_y = c2_y;  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c2_sfEvent);  _SFD_SYMBOL_SCOPE_POP();  _SFD_CHECK_FOR_STATE_INCONSISTENCY(_DSHMHittingSecondORderMachineNumber_,    chartInstance->chartNumber, chartInstance->instanceNumber);}

/* Function Definitions */static void initialize_c2_dsm_demo(SFc2_dsm_demoInstanceStruct *chartInstance){  chartInstance->c2_sfEvent = CALL_EVENT;  _sfTime_ = (real_T)ssGetT(chartInstance->S);  chartInstance->c2_is_active_c2_dsm_demo = 0U;}

static void sf_c3_varymultiswarm(SFc3_varymultiswarmInstanceStruct  *chartInstance){  real_T c3_hoistedGlobal;  real_T c3_b_hoistedGlobal;  real_T c3_x;  real_T c3_y;  uint32_T c3_debug_family_var_map[5];  real_T c3_nargin = 2.0;  real_T c3_nargout = 1.0;  real_T c3_z;  real_T c3_b_x;  real_T c3_c_x;  real_T *c3_d_x;  real_T *c3_b_y;  real_T *c3_b_z;  c3_b_z = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);  c3_b_y = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);  c3_d_x = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);  _sfTime_ = (real_T)ssGetT(chartInstance->S);  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 2U, chartInstance->c3_sfEvent);  _SFD_DATA_RANGE_CHECK(*c3_d_x, 0U);  _SFD_DATA_RANGE_CHECK(*c3_b_y, 1U);  _SFD_DATA_RANGE_CHECK(*c3_b_z, 2U);  chartInstance->c3_sfEvent = CALL_EVENT;  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 2U, chartInstance->c3_sfEvent);  c3_hoistedGlobal = *c3_d_x;  c3_b_hoistedGlobal = *c3_b_y;  c3_x = c3_hoistedGlobal;  c3_y = c3_b_hoistedGlobal;  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 5U, 5U, c3_debug_family_names,    c3_debug_family_var_map);  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c3_nargin, 0U, c3_sf_marshallOut,    c3_sf_marshallIn);  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c3_nargout, 1U, c3_sf_marshallOut,    c3_sf_marshallIn);  _SFD_SYMBOL_SCOPE_ADD_EML(&c3_x, 2U, c3_sf_marshallOut);  _SFD_SYMBOL_SCOPE_ADD_EML(&c3_y, 3U, c3_sf_marshallOut);  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c3_z, 4U, c3_sf_marshallOut,    c3_sf_marshallIn);  CV_EML_FCN(0, 0);  _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 3);  c3_b_x = (26.4196 - c3_mpower(chartInstance, c3_x - 1.44)) - c3_mpower    (chartInstance, c3_y - 0.3677);  c3_z = c3_b_x;  if (c3_z < 0.0) {    c3_eml_error(chartInstance);  }  c3_c_x = c3_z;  c3_z = c3_c_x;  c3_z = muDoubleScalarSqrt(c3_z);  _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, 4);  c3_z += 1.6;  _SFD_EML_CALL(0U, chartInstance->c3_sfEvent, -4);  _SFD_SYMBOL_SCOPE_POP();  *c3_b_z = c3_z;  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 2U, chartInstance->c3_sfEvent);  _SFD_CHECK_FOR_STATE_INCONSISTENCY(_varymultiswarmMachineNumber_,    chartInstance->chartNumber, chartInstance->instanceNumber);}

static void disable_c2_dsm_demo(SFc2_dsm_demoInstanceStruct *chartInstance){  _sfTime_ = (real_T)ssGetT(chartInstance->S);}

static void disable_c3_varymultiswarm(SFc3_varymultiswarmInstanceStruct  *chartInstance){  _sfTime_ = (real_T)ssGetT(chartInstance->S);}

void ) { } static void mdlOutputs ( SimStruct * S , int_T tid ) { real_Tjzxguy1xyo ; ZCEventType zcEvent ; boolean_T is1galx1wr ; real_T iden3vpls2 ;real_T kewj0jjgdw ; real_T c3hti1p3uf ; int8_T rtPrevAction ; int8_T rtAction; nmsgyp54ig * _rtB ; bbqvqz25ov * _rtP ; n2g2llwf21 * _rtX ; aa2ep02qn5 *_rtZCE ; pklu3vjy1t * _rtDW ; _rtDW = ( ( pklu3vjy1t * ) ssGetRootDWork ( S )) ; _rtZCE = ( ( aa2ep02qn5 * ) _ssGetPrevZCSigState ( S ) ) ; _rtX = ( (n2g2llwf21 * ) ssGetContStates ( S ) ) ; _rtP = ( ( bbqvqz25ov * )ssGetModelRtp ( S ) ) ; _rtB = ( ( nmsgyp54ig * ) _ssGetModelBlockIO ( S ) ); if ( ssIsSampleHit ( S , 4 , 0 ) ) { _rtB -> jbbkv4upvi = _rtDW ->idaicj53o4 ; } if ( ssIsSampleHit ( S , 1 , 0 ) ) { is1galx1wr = ( _rtB ->jbbkv4upvi != c22ngqieus ( S ) -> pactsh03am ) ; } jzxguy1xyo = ssGetT ( S ); if ( ssIsSampleHit ( S , 1 , 0 ) ) { _rtB -> oojsaunz11 = _rtP -> P_5 ;_rtB -> fmra2cutsa = _rtP -> P_6 ; } _rtB -> fs1ofsmvy2 = muDoubleScalarRem (jzxguy1xyo + _rtB -> oojsaunz11 , _rtB -> fmra2cutsa ) * _rtP -> P_7 ; _rtB-> kdd430tca4 = ( ( 2.0 * _rtB -> fs1ofsmvy2 - 1.0 ) + 1.0 ) * 0.5 ; if (ssIsSampleHit ( S , 1 , 0 ) ) { if ( ssIsMajorTimeStep ( S ) ) { _rtDW ->fiaf5yjt4n = ( _rtB -> jbbkv4upvi >= _rtB -> kdd430tca4 ) ; } _rtB ->bonoh3t2uf = ( is1galx1wr && _rtDW -> fiaf5yjt4n ) ; } _rtB -> puvw0myvhu [ 0] = _rtB -> bonoh3t2uf ; _rtB -> puvw0myvhu [ 1 ] = 0.0 ; _rtB -> puvw0myvhu[ 2 ] = 0.0 ; _rtDW -> lhiprm3wjz [ 0 ] = ! ( _rtB -> puvw0myvhu [ 0 ] ==_rtDW -> lhiprm3wjz [ 1 ] ) ; _rtDW -> lhiprm3wjz [ 1 ] = _rtB -> puvw0myvhu[ 0 ] ; _rtB -> puvw0myvhu [ 3 ] = _rtDW -> lhiprm3wjz [ 0 ] ; if (ssIsSampleHit ( S , 2 , 0 ) ) { ssCallAccelRunBlock ( S , 9 , 15 ,SS_CALL_MDL_OUTPUTS ) ; ssCallAccelRunBlock ( S , 9 , 16 ,SS_CALL_MDL_OUTPUTS ) ; } if ( ssIsSampleHit ( S , 4 , 0 ) ) { _rtB ->ni0skqgprw = _rtB -> mgrpxotnda [ 2 ] ; } if ( ssIsSampleHit ( S , 2 , 0 ) ){ ssCallAccelRunBlock ( S , 9 , 20 , SS_CALL_MDL_OUTPUTS ) ; } if (ssIsSampleHit ( S , 1 , 0 ) ) { zcEvent = rt_ZCFcn ( ANY_ZERO_CROSSING , &_rtZCE -> mpe2yble25 , ( _rtB -> fs1ofsmvy2 - _rtP -> P_11 ) ) ; if ( _rtDW-> oosqu0tl1h == 0 ) { if ( zcEvent != NO_ZCEVENT ) { _rtB -> dgvfzxjzqp = !( _rtB -> dgvfzxjzqp != 0.0 ) ; _rtDW -> oosqu0tl1h = 1 ; } else if ( _rtB ->dgvfzxjzqp == 1.0 ) { if ( _rtB -> fs1ofsmvy2 != _rtP -> P_11 ) { _rtB ->dgvfzxjzqp = 0.0 ; } } else { if ( _rtB -> fs1ofsmvy2 == _rtP -> P_11 ) {_rtB -> dgvfzxjzqp = 1.0 ; } } } else { if ( _rtB -> fs1ofsmvy2 != _rtP ->P_11 ) { _rtB -> dgvfzxjzqp = 0.0 ; } _rtDW -> oosqu0tl1h = 0 ; } } if (ssIsSampleHit ( S , 2 , 0 ) ) { ssCallAccelRunBlock ( S , 9 , 23 ,SS_CALL_MDL_OUTPUTS ) ; ssCallAccelRunBlock ( S , 9 , 33 ,SS_CALL_MDL_OUTPUTS ) ; iden3vpls2 = _rtP -> P_13 * _rtB -> mgrpxotnda [ 8 ]; } if ( ssIsSampleHit ( S , 4 , 0 ) ) { _rtB -> gp5orjzg5t = _rtB ->mgrpxotnda [ 2 ] ; } if ( ssIsSampleHit ( S , 2 , 0 ) ) { kewj0jjgdw = (iden3vpls2 - _rtB -> gp5orjzg5t ) * _rtB -> nzunlww04y ; } if ( ssIsSampleHit( S , 4 , 0 ) ) { _rtB -> jw2hkpsksy = _rtB -> gp5orjzg5t * _rtB ->dvca5kgoqr ; _rtB -> elobzetbdp = _rtB -> mgrpxotnda [ 8 ] ; } if (ssIsSampleHit ( S , 2 , 0 ) ) { c3hti1p3uf = ( kewj0jjgdw + _rtB ->jw2hkpsksy ) - _rtB -> elobzetbdp ; if ( ssIsSampleHit ( S , 4 , 0 ) ) { _rtB-> bc5lqmbcwx = _rtB -> mgrpxotnda [ 9 ] ; } } if ( ssIsSampleHit ( S , 4 , 0) ) { _rtB -> bpiny53cki = _rtB -> elobzetbdp + _rtB -> bc5lqmbcwx ; } if (ssIsSampleHit ( S , 2 , 0 ) ) { iden3vpls2 = c3hti1p3uf / _rtB -> bpiny53cki+ _rtB -> idha0n310x ; if ( iden3vpls2 > _rtP -> P_16 ) { _rtB -> ccrq35nhp3= _rtP -> P_16 ; } else if ( iden3vpls2 < _rtP -> P_17 ) { _rtB -> ccrq35nhp3= _rtP -> P_17 ; } else { _rtB -> ccrq35nhp3 = iden3vpls2 ; } } if (ssIsSampleHit ( S , 4 , 0 ) ) { _rtB -> pvzuuxenvc = _rtB -> ccrq35nhp3 ; }if ( ssIsSampleHit ( S , 2 , 0 ) ) { _rtB -> ii04l1a0ic = ( _rtB ->mgrpxotnda [ 9 ] + _rtB -> mgrpxotnda [ 8 ] ) - _rtB -> mgrpxotnda [ 6 ] ;ssCallAccelRunBlock ( S , 9 , 51 , SS_CALL_MDL_OUTPUTS ) ; rtPrevAction =_rtDW -> dcumqbbyun ; if ( ssIsMajorTimeStep ( S ) ) { if ( _rtB ->mgrpxotnda [ 9 ] < 90.199999999999989 ) { rtAction = 0 ; } else { rtAction =1 ; } _rtDW -> dcumqbbyun = rtAction ; } else { rtAction = _rtDW ->dcumqbbyun ; } if ( rtPrevAction != rtAction ) { switch ( rtPrevAction ) {case 0 : ssSetSolverNeedsReset ( S ) ; break ; case 1 : ssSetSolverNeedsReset( S ) ; break ; case 2 : ssSetSolverNeedsReset ( S ) ; break ; } } switch (rtAction ) { case 0 : if ( rtAction != rtPrevAction ) { if ( ssGetTaskTime (S , 2 ) != ssGetTStart ( S ) ) { ssSetSolverNeedsReset ( S ) ; } } _rtB ->kx5rgsvmx3 = _rtP -> P_0 * _rtB -> mgrpxotnda [ 8 ] ; if ( ssIsMajorTimeStep( S ) ) { srUpdateBC ( _rtDW -> o5k0zwtbn4 ) ; } break ; case 1 : if (rtAction != rtPrevAction ) { if ( ssGetTaskTime ( S , 2 ) != ssGetTStart ( S) ) { ssSetSolverNeedsReset ( S ) ; } } _rtB -> kx5rgsvmx3 = _rtP -> P_1 ; if( ssIsMajorTimeStep ( S ) ) { srUpdateBC ( _rtDW -> ihoovge3z4 ) ; } break ;case 2 : if ( rtAction != rtPrevAction ) { if ( ssGetTaskTime ( S , 2 ) !=ssGetTStart ( S ) ) { ssSetSolverNeedsReset ( S ) ; } } _rtB -> pvzuuxenvc =_rtP -> P_2 ; if ( ssIsMajorTimeStep ( S ) ) { srUpdateBC ( _rtDW ->gunoszsdaf ) ; } break ; } } bemu4fk2sq ( S , _rtB -> kwjevd5eqt , 0.0 , &_rtB -> bemu4fk2sq4 , & _rtDW -> bemu4fk2sq4 , ( mvw1gbh0c1 * ) & _rtP ->bemu4fk2sq4 , & ( ( npjij2cecc * ) ssGetContStateDisabled ( S ) ) ->bemu4fk2sq4 ) ; cqabclhqip ( S , _rtB -> donhz1jhkq , 0.0 , & _rtB ->cqabclhqip4 , & _rtDW -> cqabclhqip4 , ( nneyi35s1a * ) & _rtP -> cqabclhqip4, & _rtX -> cqabclhqip4 , & ( ( npjij2cecc * ) ssGetContStateDisabled ( S ) )-> cqabclhqip4 ) ; bemu4fk2sq ( S , _rtB -> jwapqatga5 , 0.0 , & _rtB ->n1qdzssqu3 , & _rtDW -> n1qdzssqu3 , ( mvw1gbh0c1 * ) & _rtP -> n1qdzssqu3 ,& ( ( npjij2cecc * ) ssGetContStateDisabled ( S ) ) -> n1qdzssqu3 ) ;cqabclhqip ( S , _rtB -> p5ierutvgv , 0.0 , & _rtB -> nfugx5ih43 , & _rtDW ->nfugx5ih43 , ( nneyi35s1a * ) & _rtP -> nfugx5ih43 , & _rtX -> nfugx5ih43 , &( ( npjij2cecc * ) ssGetContStateDisabled ( S ) ) -> nfugx5ih43 ) ;UNUSED_PARAMETER ( tid ) ; } static void mdlOutputsTID5 ( SimStruct * S ,

static void sf_c5_YCbCrTesting(SFc5_YCbCrTestingInstanceStruct *chartInstance){  int32_T c5_cbits;  uint32_T c5_in[20];  real32_T c5_out[64];  int32_T c5_b_cbits;  real_T c5_inpos;  uint32_T c5_Temp;  uint32_T c5_run;  uint32_T c5_val;  uint32_T c5_b_Temp;  real_T c5_i;  boolean_T c5_exitg1;  uint32_T c5_b_run;  real_T c5_b_inpos;  real_T c5_flag;  uint32_T c5_b_val;  int32_T c5_j;  real32_T (*c5_b_out)[64];  uint32_T (*c5_b_in)[20];  c5_b_out = (real32_T (*)[64])ssGetOutputPortSignal(chartInstance->S, 1);  c5_b_in = (uint32_T (*)[20])ssGetInputPortSignal(chartInstance->S, 0);  _sfTime_ = (real_T)ssGetT(chartInstance->S);  for (c5_cbits = 0; c5_cbits < 20; c5_cbits++) {    c5_in[c5_cbits] = (*c5_b_in)[c5_cbits];  }  chartInstance->c5_prev_out_not_empty = TRUE;  for (c5_cbits = 0; c5_cbits < 64; c5_cbits++) {    c5_out[c5_cbits] = chartInstance->c5_prev_out[c5_cbits];  }  c5_b_cbits = 0;  c5_inpos = 2.0;  c5_Temp = 0U;  c5_run = 0U;  c5_val = 0U;  if (((*c5_b_in)[0] & 2147483648U) != 0U) {    c5_b_Temp = MAX_uint32_T - (*c5_b_in)[0];    if (c5_b_Temp > 2147483647U) {      c5_b_Temp = 2147483647U;    }    c5_out[0] = (real32_T)(-(int32_T)c5_b_Temp - 1);  } else {    c5_b_Temp = (*c5_b_in)[0];    if (c5_b_Temp > 2147483647U) {      c5_b_Temp = 2147483647U;    }    c5_out[0] = (real32_T)c5_b_Temp;  }  c5_i = 2.0;  c5_exitg1 = 0U;  while ((c5_exitg1 == 0U) && (c5_i <= 64.0)) {    c5_getbits(chartInstance, c5_b_cbits, c5_inpos, c5_Temp, c5_in, c5_run, 4.0,               &c5_flag, &c5_cbits, &c5_b_inpos, &c5_b_Temp, &c5_b_run);    c5_run = c5_b_run;    if ((!(c5_flag != 0.0)) || (c5_b_run == 15U)) {      c5_exitg1 = 1U;    } else {      c5_getbits(chartInstance, c5_cbits, c5_b_inpos, c5_b_Temp, c5_in, c5_val,                 8.0, &c5_flag, &c5_b_cbits, &c5_inpos, &c5_Temp, &c5_b_val);      c5_val = c5_b_val;      if (!(c5_flag != 0.0)) {        c5_exitg1 = 1U;      } else {        c5_flag = (real_T)c5_b_run + c5_i;        c5_flag = muDoubleScalarFloor(c5_flag + 0.5);        if (c5_flag < 4.294967296E+9) {          c5_b_Temp = (uint32_T)c5_flag;        } else {          c5_b_Temp = MAX_uint32_T;        }        if (c5_b_Temp > 64U) {          c5_cbits = 64;        } else {          c5_cbits = (int32_T)c5_b_Temp;        }        c5_j = (int32_T)c5_i;        while ((uint32_T)c5_j <= (uint32_T)c5_cbits) {          c5_out[c5_j - 1] = (real32_T)c5_b_val - 128.0F;          c5_j = (int32_T)((uint32_T)c5_j + 1U);          sf_mex_listen_for_ctrl_c(chartInstance->S);        }        c5_i = (c5_i + (real_T)c5_b_run) + 1.0;        sf_mex_listen_for_ctrl_c(chartInstance->S);      }    }  }  while (c5_i <= 64.0) {    c5_out[(int32_T)c5_i - 1] = 0.0F;    c5_i++;    sf_mex_listen_for_ctrl_c(chartInstance->S);  }//.........这里部分代码省略.........

/* Function Definitions */static void initialize_c7_ekffede(SFc7_ekffedeInstanceStruct *chartInstance){  chartInstance->c7_sfEvent = CALL_EVENT;  _sfTime_ = (real_T)ssGetT(chartInstance->S);  chartInstance->c7_is_active_c7_ekffede = 0U;}

static void disable_c5_YCbCrTesting(SFc5_YCbCrTestingInstanceStruct  *chartInstance){  _sfTime_ = (real_T)ssGetT(chartInstance->S);}

static void sf_c6_TTR_mdl(SFc6_TTR_mdlInstanceStruct *chartInstance){  int32_T c6_i0;  real_T c6_hoistedGlobal;  real_T c6_u_ctrl;  int32_T c6_i1;  real_T c6_U_bounds[2];  uint32_T c6_debug_family_var_map[6];  real_T c6_i;  real_T c6_nargin = 2.0;  real_T c6_nargout = 1.0;  real_T c6_u_ctrl_out;  real_T c6_varargin_1;  real_T c6_varargin_2;  real_T c6_b_varargin_2;  real_T c6_varargin_3;  real_T c6_x;  real_T c6_y;  real_T c6_b_x;  real_T c6_b_y;  real_T c6_xk;  real_T c6_yk;  real_T c6_c_x;  real_T c6_c_y;  real_T c6_b_varargin_1;  real_T c6_c_varargin_2;  real_T c6_d_varargin_2;  real_T c6_b_varargin_3;  real_T c6_d_x;  real_T c6_d_y;  real_T c6_e_x;  real_T c6_e_y;  real_T c6_b_xk;  real_T c6_b_yk;  real_T c6_f_x;  real_T c6_f_y;  real_T *c6_b_u_ctrl;  real_T *c6_b_u_ctrl_out;  real_T (*c6_b_U_bounds)[2];  c6_b_U_bounds = (real_T (*)[2])ssGetInputPortSignal(chartInstance->S, 1);  c6_b_u_ctrl_out = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);  c6_b_u_ctrl = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);  _sfTime_ = (real_T)ssGetT(chartInstance->S);  _SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 5U, chartInstance->c6_sfEvent);  _SFD_DATA_RANGE_CHECK(*c6_b_u_ctrl, 0U);  _SFD_DATA_RANGE_CHECK(*c6_b_u_ctrl_out, 1U);  for (c6_i0 = 0; c6_i0 < 2; c6_i0++) {    _SFD_DATA_RANGE_CHECK((*c6_b_U_bounds)[c6_i0], 2U);  }  chartInstance->c6_sfEvent = CALL_EVENT;  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 5U, chartInstance->c6_sfEvent);  c6_hoistedGlobal = *c6_b_u_ctrl;  c6_u_ctrl = c6_hoistedGlobal;  for (c6_i1 = 0; c6_i1 < 2; c6_i1++) {    c6_U_bounds[c6_i1] = (*c6_b_U_bounds)[c6_i1];  }  _SFD_SYMBOL_SCOPE_PUSH_EML(0U, 6U, 6U, c6_debug_family_names,    c6_debug_family_var_map);  _SFD_SYMBOL_SCOPE_ADD_EML(&c6_i, 0U, c6_sf_marshallOut);  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c6_nargin, 1U, c6_sf_marshallOut,    c6_sf_marshallIn);  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c6_nargout, 2U, c6_sf_marshallOut,    c6_sf_marshallIn);  _SFD_SYMBOL_SCOPE_ADD_EML(&c6_u_ctrl, 3U, c6_sf_marshallOut);  _SFD_SYMBOL_SCOPE_ADD_EML(c6_U_bounds, 4U, c6_b_sf_marshallOut);  _SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c6_u_ctrl_out, 5U, c6_sf_marshallOut,    c6_sf_marshallIn);  CV_EML_FCN(0, 0);  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 9);  c6_u_ctrl_out = c6_u_ctrl;  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 11);  CV_EML_IF(0, 1, 0, FALSE);  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 17);  c6_i = 1.0;  CV_EML_FOR(0, 1, 0, 1);  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 18);  c6_varargin_1 = c6_u_ctrl;  c6_varargin_2 = c6_U_bounds[0];  c6_b_varargin_2 = c6_varargin_1;  c6_varargin_3 = c6_varargin_2;  c6_x = c6_b_varargin_2;  c6_y = c6_varargin_3;  c6_b_x = c6_x;  c6_b_y = c6_y;  c6_eml_scalar_eg(chartInstance);  c6_xk = c6_b_x;  c6_yk = c6_b_y;  c6_c_x = c6_xk;  c6_c_y = c6_yk;  c6_eml_scalar_eg(chartInstance);  c6_u_ctrl_out = muDoubleScalarMax(c6_c_x, c6_c_y);  _SFD_EML_CALL(0U, chartInstance->c6_sfEvent, 19);  c6_b_varargin_1 = c6_u_ctrl;  c6_c_varargin_2 = c6_U_bounds[1];  c6_d_varargin_2 = c6_b_varargin_1;  c6_b_varargin_3 = c6_c_varargin_2;  c6_d_x = c6_d_varargin_2;  c6_d_y = c6_b_varargin_3;//.........这里部分代码省略.........

static void sf_c3_MPC_framework(void){  uint8_T c3_previousEvent;  real_T c3_b_a0;  real_T c3_b_a1;  real_T c3_b_a2;  real_T c3_b_a3;  real_T c3_b_a4;  real_T c3_b_a5;  real_T c3_b_t_sim;  real_T c3_b_t_end;  real_T c3_Q[3];  real_T c3_T[6][3];  real_T c3_b_qapp;  real_T c3_b_qap;  real_T c3_b_qa;  real_T c3_a;  real_T c3_b_a;  real_T c3_b;  real_T c3_k;  real_T c3_b_k;  real_T c3_x;  real_T c3_xk;  real_T c3_ak;  real_T c3_b_x;  real_T c3_b_xk;  real_T c3_bk;  real_T c3_c_x;  real_T c3_y;  real_T c3_b_y;  real_T c3_c;  real_T c3_A;  real_T c3_B;  real_T c3_d_x;  real_T c3_c_y;  real_T c3_z;  real_T c3_d_y;  real_T c3_b_A;  real_T c3_b_B;  real_T c3_e_x;  real_T c3_e_y;  real_T c3_b_z;  real_T c3_f_y;  real_T c3_c_A;  real_T c3_c_B;  real_T c3_f_x;  real_T c3_g_y;  real_T c3_c_z;  real_T c3_h_y;  real_T c3_d_A;  real_T c3_d_B;  real_T c3_g_x;  real_T c3_i_y;  real_T c3_d_z;  real_T c3_j_y;  real_T c3_e_A;  real_T c3_e_B;  real_T c3_h_x;  real_T c3_k_y;  real_T c3_e_z;  real_T c3_l_y;  real_T c3_f_A;  real_T c3_f_B;  real_T c3_i_x;  real_T c3_m_y;  real_T c3_f_z;  real_T c3_n_y;  real_T c3_g_A;  real_T c3_g_B;  real_T c3_j_x;  real_T c3_o_y;  real_T c3_g_z;  real_T c3_p_y;  real_T c3_q_y[6][1];  real_T c3_r_y[6][1];  real_T c3_em_dv0[6][1];  int32_T c3_em_i0;  int32_T c3_em_i1;  int32_T c3_em_i2;  real_T c3_c_a0[6];  int32_T c3_em_i3;  int32_T c3_em_i4;  _sfTime_ = (real_T)ssGetT(chartInstance.S);  _SFD_DATA_RANGE_CHECK(*c3_a0(), 7U);  _SFD_DATA_RANGE_CHECK(*c3_a1(), 6U);  _SFD_DATA_RANGE_CHECK(*c3_a2(), 2U);  _SFD_DATA_RANGE_CHECK(*c3_a3(), 10U);  _SFD_DATA_RANGE_CHECK(*c3_a4(), 8U);  _SFD_DATA_RANGE_CHECK(*c3_a5(), 1U);  _SFD_DATA_RANGE_CHECK(*c3_t_sim(), 4U);  _SFD_DATA_RANGE_CHECK(*c3_qa(), 9U);  _SFD_DATA_RANGE_CHECK(*c3_qap(), 3U);  _SFD_DATA_RANGE_CHECK(*c3_qapp(), 0U);  _SFD_DATA_RANGE_CHECK(*c3_t_end(), 5U);  c3_previousEvent = _sfEvent_;  _sfEvent_ = CALL_EVENT;  _SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG,2);  c3_b_a0 = *c3_a0();  c3_b_a1 = *c3_a1();  c3_b_a2 = *c3_a2();//.........这里部分代码省略.........

static void disable_c6_TTR_mdl(SFc6_TTR_mdlInstanceStruct *chartInstance){  _sfTime_ = (real_T)ssGetT(chartInstance->S);}

/* Function Definitions */static void initialize_c2_object_tracker_intensity(void){  _sfTime_ = (real_T)ssGetT(chartInstance.S);  chartInstance.c2_LastCentroid_not_empty = false;  chartInstance.c2_is_active_c2_object_tracker_intensity = 0U;}

/* Function Definitions */static void initialize_c3_controller1(SFc3_controller1InstanceStruct  *chartInstance){  _sfTime_ = (real_T)ssGetT(chartInstance->S);  chartInstance->c3_is_active_c3_controller1 = 0U;}

static void sf_c2_object_tracker_intensity(void){  int32_T c2_em_i0;  int32_T c2_em_i1;  int32_T c2_em_i2;  int32_T c2_em_i3;  int32_T c2_em_i4;  int32_T c2_em_i5;  uint8_T c2_previousEvent;  int32_T c2_em_i6;  int32_T c2_em_i7;  uint16_T c2_b_CentroidArray[10][2];  real_T c2_b_booleof;  int32_T c2_em_i8;  uint16_T c2_b_StartCoords[2];  uint16_T c2_b_VidSize[2];  uint16_T c2_centroid[2];  real_T c2_i;  uint16_T c2_m;  uint16_T c2_myvector[10][1];  uint16_T c2_ally[10][1];  uint16_T c2_allx[10][1];  uint16_T c2_z[2];  uint16_T c2_b_CentroidCol;  uint16_T c2_b_LineVector[4][1];  uint16_T c2_b_CentroidCoords[2];  boolean_T c2_r;  int32_T c2_em_i9;  int32_T c2_em_i10;  int32_T c2_em_i11;  uint16_T c2_c_CentroidArray[10][1];  uint16_T c2_b_z;  int32_T c2_em_i12;  uint32_T c2_em_u0;  uint32_T c2_em_u1;  uint32_T c2_em_u2;  uint16_T c2_em_u3;  int32_T c2_em_i13;  uint16_T c2_d_CentroidArray[10][1];  uint16_T c2_c_z;  int32_T c2_em_i14;  uint32_T c2_em_u4;  uint32_T c2_em_u5;  uint32_T c2_em_u6;  uint16_T c2_em_u7;  int32_T c2_em_i15;  uint16_T c2_b_allx[10][1];  uint16_T c2_em_uv0[10][1];  int32_T c2_em_i16;  uint16_T c2_b_ally[10][1];  uint16_T c2_em_uv1[10][1];  int32_T c2_em_i17;  uint32_T c2_em_u8;  uint16_T c2_em_u9;  int32_T c2_em_i18;  uint16_T c2_x[10][1];  uint16_T c2_b_x[10][1];  real_T c2_jstart;  uint16_T c2_minval;  real_T c2_indx;  real_T c2_j1;  real_T c2_b_j1;  uint16_T c2_a;  uint16_T c2_b;  boolean_T c2_p;  uint16_T c2_b_minval;  real_T c2_b_indx;  int32_T c2_em_i19;  static int32_T c2_em_iv0[2][1] = { { 0 }, { 1 } };  int32_T c2_em_i20;  int32_T c2_em_i21;  int32_T c2_em_i22;  uint16_T c2_A;  real_T c2_B;  uint16_T c2_c_x;  real_T c2_y;  uint16_T c2_d_x;  real_T c2_b_y;  real_T c2_k;  real_T c2_b_k;  uint16_T c2_e_x;  real_T c2_c_y;  real_T c2_c_k;  real_T c2_d_k;  uint16_T c2_f_x;  uint16_T c2_xk;  real_T c2_b_xk;  real_T c2_g_x;  real_T c2_c_xk;  real_T c2_yk;  real_T c2_zk;  real_T c2_em_d0;  real_T c2_em_d1;  uint16_T c2_d_z;  uint16_T c2_e_z;  uint16_T c2_f_z;  uint16_T c2_d_y;  int32_T c2_em_i23;  int32_T c2_em_i24;  _sfTime_ = (real_T)ssGetT(chartInstance.S);//.........这里部分代码省略.........

static void enable_c16_Final_Project_v3b(SFc16_Final_Project_v3bInstanceStruct  *chartInstance){  _sfTime_ = (real_T)ssGetT(chartInstance->S);}

/* Function: main ============================================================== * *      Execute model on a generic target such as a workstation. */int_T main(int_T argc, char_T *argv[]){    SimStruct  *S                 = NULL;    boolean_T  calledMdlStart     = FALSE;    boolean_T  dataLoggingActive  = FALSE;    boolean_T  initializedExtMode = FALSE;    const char *result;    const char *program;    time_t     now;    int matFileFormat;    const char *errorPrefix       = NULL;    void *parforSchedulerInit     = NULL;    program = argv[0];    gblInstalledSigHandlers = FALSE;    /* No re-defining of data types allowed. */    if ((sizeof(real_T)   != 8) ||        (sizeof(real32_T) != 4) ||        (sizeof(int8_T)   != 1) ||        (sizeof(uint8_T)  != 1) ||        (sizeof(int16_T)  != 2) ||        (sizeof(uint16_T) != 2) ||        (sizeof(int32_T)  != 4) ||        (sizeof(uint32_T) != 4) ||        (sizeof(boolean_T)!= 1)) {        ERROR_EXIT("Error: %s/n", "Re-defining data types such as REAL_T is not supported by RSIM");    }    rt_InitInfAndNaN(sizeof(real_T));    /* Parse arguments */    gblErrorStatus = ParseArgs(argc, argv);    ERROR_EXIT("Error parsing input arguments: %s/n", gblErrorStatus);    /* Initialize the model */    S = raccel_register_model();    ERROR_EXIT("Error during model registration: %s/n", ssGetErrorStatus(S));    ssClearFirstInitCondCalled(S);    /* Override StopTime */    if (gblFinalTimeChanged) ssSetTFinal(S,gblFinalTime);    MdlInitializeSizes();    MdlInitializeSampleTimes();    /* We don't have GOTO_EXIT_IF_ERROR here as engine is not initialized        via rsimInitializeEngine */    rt_RapidReadMatFileAndUpdateParams(S);    ERROR_EXIT("Error reading parameter data from mat-file: %s/n",              ssGetErrorStatus(S));    /* load solver options */    rsimLoadSolverOpts(S);    ERROR_EXIT("Error loading solver options: %s/n", ssGetErrorStatus(S));# if defined(DEBUG_SOLVER)    rsimEnableDebugOutput(sizeof(struct SimStruct_tag),                          sizeof(struct _ssMdlInfo));# endif#ifdef RACCEL_PARALLEL_FOREACH    parforSchedulerInit = rt_ParallelForEachInitScheduler(S, RACCEL_PARFOREACH_NUM_THREADS, RACCEL_NUM_PARFOREACH_SS);#endif    rsimInitializeEngine(S);    ERROR_EXIT("Error initializing RSIM engine: %s/n", ssGetErrorStatus(S));    /* initialize external model */    if (gblExtModeEnabled) {        rtExtModeCheckInit(ssGetNumSampleTimes(S));        initializedExtMode = TRUE;           }    raccel_setup_MMIStateLog(S);    if (ssIsVariableStepSolver(S)) {        (void)rt_StartDataLoggingWithStartTime(ssGetRTWLogInfo(S),                                               ssGetTStart(S),                                               ssGetTFinal(S),                                               0.0,                                               &ssGetErrorStatus(S));    } else {        (void)rt_StartDataLoggingWithStartTime(ssGetRTWLogInfo(S),                                               ssGetTStart(S),                                               ssGetTFinal(S),                                               ssGetStepSize(S),                                               &ssGetErrorStatus(S));    }    GOTO_EXIT_IF_ERROR("Error starting data logging: %s/n",                        ssGetErrorStatus(S));    dataLoggingActive = TRUE;    if (gblExtModeEnabled) {        /* If -w flag is specified wait here for connect signal from host */        rtExtModeWaitForStartPkt(ssGetRTWExtModeInfo(S),//.........这里部分代码省略.........