/* 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);
}
}
_SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 2U, 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_event2EventCounter++;
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, 3U,
chartInstance->c41_sfEvent);
c41_f_out = (CV_TRANSITION_EVAL(3U, (int32_T)_SFD_CCP_CALL(3U, 0, *c41_v
>= 138.0 != 0U, chartInstance->c41_sfEvent)) != 0);
if (c41_f_out) {
_SFD_CT_CALL(TRANSITION_ACTIVE_TAG, 3U, 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_event3EventCounter++;
chartInstance->c41_is_c41_heart_model = c41_IN_state;
_SFD_CS_CALL(STATE_ACTIVE_TAG, 0U, chartInstance->c41_sfEvent);
chartInstance->c41_tp_state = 1U;
}
}
}
_SFD_CS_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c41_sfEvent);
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 38U, chartInstance->c41_sfEvent);
if (chartInstance->c41_event1EventCounter > 0U) {
*c41_event1 = !*c41_event1;
chartInstance->c41_event1EventCounter--;
}
if (chartInstance->c41_event2EventCounter > 0U) {
*c41_event2 = !*c41_event2;
chartInstance->c41_event2EventCounter--;
}
if (chartInstance->c41_event3EventCounter > 0U) {
*c41_event3 = !*c41_event3;
chartInstance->c41_event3EventCounter--;
}
sf_debug_check_for_state_inconsistency(_heart_modelMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void disable_c2_hapticsSimBlk_pd(SFc2_hapticsSimBlk_pdInstanceStruct
*chartInstance)
{
_sfTime_ = (real_T)ssGetT(chartInstance->S);
}
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_T
jzxguy1xyo ; 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);
}
for (c5_cbits = 0; c5_cbits < 64; c5_cbits++) {
chartInstance->c5_prev_out[c5_cbits] = c5_out[c5_cbits];
(*c5_b_out)[c5_cbits] = c5_out[c5_cbits];
}
}
/* 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;
c6_e_x = c6_d_x;
c6_e_y = c6_d_y;
c6_eml_scalar_eg(chartInstance);
c6_b_xk = c6_e_x;
c6_b_yk = c6_e_y;
c6_f_x = c6_b_xk;
c6_f_y = c6_b_yk;
c6_eml_scalar_eg(chartInstance);
c6_u_ctrl_out = muDoubleScalarMin(c6_f_x, c6_f_y);
CV_EML_FOR(0, 1, 0, 0);
_SFD_EML_CALL(0U, chartInstance->c6_sfEvent, -19);
_SFD_SYMBOL_SCOPE_POP();
*c6_b_u_ctrl_out = c6_u_ctrl_out;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 5U, chartInstance->c6_sfEvent);
_SFD_CHECK_FOR_STATE_INCONSISTENCY(_TTR_mdlMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
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();
c3_b_a3 = *c3_a3();
c3_b_a4 = *c3_a4();
c3_b_a5 = *c3_a5();
c3_b_t_sim = *c3_t_sim();
c3_b_t_end = *c3_t_end();
sf_debug_push_symbol_scope(13U, 0U);
sf_debug_symbol_scope_add_symbol("Q", 0, 1U, 3U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 1, &c3_Q, 0);
sf_debug_symbol_scope_add_symbol("T", 0, 2U, 3U, 6U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 1, &c3_T, 0);
sf_debug_symbol_scope_add_symbol("qapp", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U,
0, 0U, 0, &c3_b_qapp, 0);
sf_debug_symbol_scope_add_symbol("qap", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 0, &c3_b_qap, 0);
sf_debug_symbol_scope_add_symbol("qa", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 0, &c3_b_qa, 0);
sf_debug_symbol_scope_add_symbol("t_end", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U,
0, 0U, 0, &c3_b_t_end, 0);
sf_debug_symbol_scope_add_symbol("t_sim", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U,
0, 0U, 0, &c3_b_t_sim, 0);
sf_debug_symbol_scope_add_symbol("a5", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 0, &c3_b_a5, 0);
sf_debug_symbol_scope_add_symbol("a4", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 0, &c3_b_a4, 0);
sf_debug_symbol_scope_add_symbol("a3", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 0, &c3_b_a3, 0);
sf_debug_symbol_scope_add_symbol("a2", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 0, &c3_b_a2, 0);
sf_debug_symbol_scope_add_symbol("a1", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 0, &c3_b_a1, 0);
sf_debug_symbol_scope_add_symbol("a0", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 0, &c3_b_a0, 0);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,4);
if(CV_EML_IF(0, 0, c3_b_t_sim >= c3_b_t_end)) {
/* This block supports an embeddable subset of the MATLAB language. */
/* See the help menu for details. */
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,5);
c3_b_t_sim = c3_b_t_end;
}
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,7);
c3_a = c3_b_t_sim;
c3_b_a = c3_a;
c3_b = 5.0;
c3_k = 1.0;
c3_b_k = c3_k;
c3_x = c3_b_a;
c3_xk = c3_x;
c3_ak = c3_xk;
c3_b_x = c3_b;
c3_b_xk = c3_b_x;
c3_bk = c3_b_xk;
if(c3_ak < 0.0) {
c3_c_x = c3_bk;
c3_y = floor(c3_c_x);
if(c3_y != c3_bk) {
sf_mex_call("error", 0U, 1U, 15,
"Domain error. To compute complex results, make at least one input complex, e.g. \'power(complex(a),b)\'.");
}
}
_SFD_EML_ARRAY_BOUNDS_CHECK("y", (int32_T)_SFD_INTEGER_CHECK("k", c3_b_k), 1,
1, 1);
c3_b_y = pow(c3_ak, c3_bk);
c3_c = c3_b_y;
c3_A = c3_c;
c3_B = 20.0;
c3_d_x = c3_A;
c3_c_y = c3_B;
c3_z = c3_d_x / c3_c_y;
c3_d_y = c3_z;
c3_b_A = c3_mpower(c3_b_t_sim);
c3_b_B = 12.0;
c3_e_x = c3_b_A;
c3_e_y = c3_b_B;
c3_b_z = c3_e_x / c3_e_y;
c3_f_y = c3_b_z;
c3_c_A = c3_b_mpower(c3_b_t_sim);
c3_c_B = 6.0;
c3_f_x = c3_c_A;
c3_g_y = c3_c_B;
c3_c_z = c3_f_x / c3_g_y;
c3_h_y = c3_c_z;
c3_d_A = c3_c_mpower(c3_b_t_sim);
c3_d_B = 2.0;
c3_g_x = c3_d_A;
c3_i_y = c3_d_B;
c3_d_z = c3_g_x / c3_i_y;
c3_j_y = c3_d_z;
c3_e_A = c3_mpower(c3_b_t_sim);
c3_e_B = 4.0;
c3_h_x = c3_e_A;
c3_k_y = c3_e_B;
c3_e_z = c3_h_x / c3_k_y;
c3_l_y = c3_e_z;
c3_f_A = c3_b_mpower(c3_b_t_sim);
c3_f_B = 3.0;
c3_i_x = c3_f_A;
c3_m_y = c3_f_B;
c3_f_z = c3_i_x / c3_m_y;
c3_n_y = c3_f_z;
c3_g_A = c3_c_mpower(c3_b_t_sim);
c3_g_B = 2.0;
c3_j_x = c3_g_A;
c3_o_y = c3_g_B;
c3_g_z = c3_j_x / c3_o_y;
c3_p_y = c3_g_z;
c3_q_y[0][0] = c3_d_y;
c3_q_y[1][0] = c3_f_y;
c3_q_y[2][0] = c3_h_y;
c3_q_y[3][0] = c3_j_y;
c3_q_y[4][0] = c3_b_t_sim;
c3_q_y[5][0] = 1.0;
c3_r_y[0][0] = c3_l_y;
c3_r_y[1][0] = c3_n_y;
c3_r_y[2][0] = c3_p_y;
c3_r_y[3][0] = c3_b_t_sim;
c3_r_y[4][0] = 1.0;
c3_r_y[5][0] = 0.0;
c3_em_dv0[0][0] = c3_b_mpower(c3_b_t_sim);
c3_em_dv0[1][0] = c3_c_mpower(c3_b_t_sim);
c3_em_dv0[2][0] = c3_b_t_sim;
c3_em_dv0[3][0] = 1.0;
c3_em_dv0[4][0] = 0.0;
c3_em_dv0[5][0] = 0.0;
for(c3_em_i0 = 0; c3_em_i0 < 6; c3_em_i0 = c3_em_i0 + 1) {
c3_T[c3_em_i0][0] = c3_q_y[c3_em_i0][0];
}
for(c3_em_i1 = 0; c3_em_i1 < 6; c3_em_i1 = c3_em_i1 + 1) {
c3_T[c3_em_i1][1] = c3_r_y[c3_em_i1][0];
}
for(c3_em_i2 = 0; c3_em_i2 < 6; c3_em_i2 = c3_em_i2 + 1) {
c3_T[c3_em_i2][2] = c3_em_dv0[c3_em_i2][0];
}
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,10);
c3_c_a0[0] = c3_b_a0;
c3_c_a0[1] = c3_b_a1;
c3_c_a0[2] = c3_b_a2;
c3_c_a0[3] = c3_b_a3;
c3_c_a0[4] = c3_b_a4;
c3_c_a0[5] = c3_b_a5;
for(c3_em_i3 = 0; c3_em_i3 < 3; c3_em_i3 = c3_em_i3 + 1) {
c3_Q[c3_em_i3] = 0.0;
for(c3_em_i4 = 0; c3_em_i4 < 6; c3_em_i4 = c3_em_i4 + 1) {
c3_Q[c3_em_i3] = c3_Q[c3_em_i3] + c3_T[c3_em_i4][c3_em_i3] *
c3_c_a0[c3_em_i4];
}
}
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,12);
c3_b_qa = c3_Q[0];
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,13);
c3_b_qap = c3_Q[1];
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,14);
c3_b_qapp = c3_Q[2];
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,-14);
sf_debug_pop_symbol_scope();
*c3_qa() = c3_b_qa;
*c3_qap() = c3_b_qap;
*c3_qapp() = c3_b_qapp;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,2);
_sfEvent_ = c3_previousEvent;
sf_debug_check_for_state_inconsistency(_MPC_frameworkMachineNumber_,
chartInstance.chartNumber, chartInstance.instanceNumber);
}
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);
for(c2_em_i0 = 0; c2_em_i0 < 2; c2_em_i0 = c2_em_i0 + 1) {
_SFD_DATA_RANGE_CHECK((real_T)c2_CentroidCoords()[c2_em_i0], 1U);
}
for(c2_em_i1 = 0; c2_em_i1 < 10; c2_em_i1 = c2_em_i1 + 1) {
for(c2_em_i2 = 0; c2_em_i2 < 2; c2_em_i2 = c2_em_i2 + 1) {
_SFD_DATA_RANGE_CHECK((real_T)c2_CentroidArray()[(c2_em_i1 << 1) +
c2_em_i2], 5U);
}
}
for(c2_em_i3 = 0; c2_em_i3 < 4; c2_em_i3 = c2_em_i3 + 1) {
_SFD_DATA_RANGE_CHECK((real_T)c2_LineVector()[c2_em_i3], 2U);
}
_SFD_DATA_RANGE_CHECK(*c2_booleof(), 3U);
for(c2_em_i4 = 0; c2_em_i4 < 2; c2_em_i4 = c2_em_i4 + 1) {
_SFD_DATA_RANGE_CHECK((real_T)c2_StartCoords()[c2_em_i4], 6U);
}
for(c2_em_i5 = 0; c2_em_i5 < 2; c2_em_i5 = c2_em_i5 + 1) {
_SFD_DATA_RANGE_CHECK((real_T)c2_VidSize()[c2_em_i5], 0U);
}
_SFD_DATA_RANGE_CHECK((real_T)*c2_CentroidCol(), 4U);
c2_previousEvent = _sfEvent_;
_sfEvent_ = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG,1);
for(c2_em_i6 = 0; c2_em_i6 < 10; c2_em_i6 = c2_em_i6 + 1) {
for(c2_em_i7 = 0; c2_em_i7 < 2; c2_em_i7 = c2_em_i7 + 1) {
c2_b_CentroidArray[c2_em_i6][c2_em_i7] = c2_CentroidArray()[(c2_em_i6 <<
1) + c2_em_i7];
}
}
c2_b_booleof = *c2_booleof();
for(c2_em_i8 = 0; c2_em_i8 < 2; c2_em_i8 = c2_em_i8 + 1) {
c2_b_StartCoords[c2_em_i8] = c2_StartCoords()[c2_em_i8];
c2_b_VidSize[c2_em_i8] = c2_VidSize()[c2_em_i8];
}
sf_debug_push_symbol_scope(15U, 0U);
sf_debug_symbol_scope_add_symbol("LastCentroid", 5, 1U, 2U, 0U, 0U, 1.0, 0,
0.0, 0U, 0, 0U, 1, &chartInstance.c2_LastCentroid, 0);
sf_debug_symbol_scope_add_symbol("centroid", 5, 1U, 2U, 0U, 0U, 1.0, 0, 0.0,
0U, 0, 0U, 1, &c2_centroid, 0);
sf_debug_symbol_scope_add_symbol("i", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 0, &c2_i, 0);
sf_debug_symbol_scope_add_symbol("m", 5, 0U, 0U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 0, &c2_m, 0);
sf_debug_symbol_scope_add_symbol("myvector", 5, 2U, 1U, 10U, 0U, 1.0, 0, 0.0,
0U, 0, 0U, 1, &c2_myvector, 0);
sf_debug_symbol_scope_add_symbol("ally", 5, 2U, 1U, 10U, 0U, 1.0, 0, 0.0, 0U,
0, 0U, 1, &c2_ally, 0);
sf_debug_symbol_scope_add_symbol("allx", 5, 2U, 1U, 10U, 0U, 1.0, 0, 0.0, 0U,
0, 0U, 1, &c2_allx, 0);
sf_debug_symbol_scope_add_symbol("z", 5, 1U, 2U, 0U, 0U, 1.0, 0, 0.0, 0U, 0,
0U, 1, &c2_z, 0);
sf_debug_symbol_scope_add_symbol("CentroidCol", 5, 0U, 0U, 0U, 0U, 1.0, 0,
0.0, 0U, 0, 0U, 0, &c2_b_CentroidCol, 0);
sf_debug_symbol_scope_add_symbol("LineVector", 5, 2U, 1U, 4U, 0U, 1.0, 0, 0.0,
0U, 0, 0U, 1, &c2_b_LineVector, 0);
sf_debug_symbol_scope_add_symbol("CentroidCoords", 5, 1U, 2U, 0U, 0U, 1.0, 0,
0.0, 0U, 0, 0U, 1, &c2_b_CentroidCoords, 0);
sf_debug_symbol_scope_add_symbol("VidSize", 5, 1U, 2U, 0U, 0U, 1.0, 0, 0.0,
0U, 0, 0U, 1, &c2_b_VidSize, 0);
sf_debug_symbol_scope_add_symbol("StartCoords", 5, 1U, 2U, 0U, 0U, 1.0, 0,
0.0, 0U, 0, 0U, 1, &c2_b_StartCoords, 0);
sf_debug_symbol_scope_add_symbol("booleof", 0, 0U, 0U, 0U, 0U, 1.0, 0, 0.0,
0U, 0, 0U, 0, &c2_b_booleof, 0);
sf_debug_symbol_scope_add_symbol("CentroidArray", 5, 2U, 2U, 10U, 0U, 1.0, 0,
0.0, 0U, 0, 0U, 1, &c2_b_CentroidArray, 0);
CV_EML_FCN(0, 0);
/* This block supports an embeddable subset of the MATLAB language. */
/* See the help menu for details. */
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,6);
if(CV_EML_COND(0, 0, !chartInstance.c2_LastCentroid_not_empty)) {
} else {
c2_r = true;
if(CV_EML_COND(0, 1, c2_b_booleof == (real_T)c2_r)) {
} else {
CV_EML_MCDC(0, 0, false);
CV_EML_IF(0, 0, false);
goto label_1;
}
}
CV_EML_MCDC(0, 0, true);
CV_EML_IF(0, 0, true);
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,7);
for(c2_em_i9 = 0; c2_em_i9 < 2; c2_em_i9 = c2_em_i9 + 1) {
chartInstance.c2_LastCentroid[c2_em_i9] = c2_b_StartCoords[c2_em_i9];
}
chartInstance.c2_LastCentroid_not_empty = true;
label_1:;
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,10);
for(c2_em_i10 = 0; c2_em_i10 < 2; c2_em_i10 = c2_em_i10 + 1) {
c2_z[c2_em_i10] = chartInstance.c2_LastCentroid[c2_em_i10];
}
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,12);
for(c2_em_i11 = 0; c2_em_i11 < 10; c2_em_i11 = c2_em_i11 + 1) {
c2_c_CentroidArray[c2_em_i11][0] = c2_b_CentroidArray[c2_em_i11][0];
}
c2_b_z = c2_z[0];
for(c2_em_i12 = 0; c2_em_i12 < 10; c2_em_i12 = c2_em_i12 + 1) {
c2_em_u0 = (uint32_T)c2_c_CentroidArray[c2_em_i12][0];
c2_em_u1 = c2_em_u0 - (uint32_T)c2_b_z;
if(c2_em_u1 > c2_em_u0) {
c2_em_u1 = 0U;
}
c2_em_u2 = c2_em_u1;
if(c2_em_u2 > 65535U) {
c2_em_u3 = MAX_uint16_T;
} else {
c2_em_u3 = (uint16_T)c2_em_u2;
}
c2_allx[c2_em_i12][0] = c2_em_u3;
}
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,13);
for(c2_em_i13 = 0; c2_em_i13 < 10; c2_em_i13 = c2_em_i13 + 1) {
c2_d_CentroidArray[c2_em_i13][0] = c2_b_CentroidArray[c2_em_i13][1];
}
c2_c_z = c2_z[1];
for(c2_em_i14 = 0; c2_em_i14 < 10; c2_em_i14 = c2_em_i14 + 1) {
c2_em_u4 = (uint32_T)c2_d_CentroidArray[c2_em_i14][0];
c2_em_u5 = c2_em_u4 - (uint32_T)c2_c_z;
if(c2_em_u5 > c2_em_u4) {
c2_em_u5 = 0U;
}
c2_em_u6 = c2_em_u5;
if(c2_em_u6 > 65535U) {
c2_em_u7 = MAX_uint16_T;
} else {
c2_em_u7 = (uint16_T)c2_em_u6;
}
c2_ally[c2_em_i14][0] = c2_em_u7;
}
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,14);
for(c2_em_i15 = 0; c2_em_i15 < 10; c2_em_i15 = c2_em_i15 + 1) {
c2_b_allx[c2_em_i15][0] = c2_allx[c2_em_i15][0];
}
c2_power((uint16_T *)c2_b_allx, 2.0, (uint16_T *)c2_em_uv0);
for(c2_em_i16 = 0; c2_em_i16 < 10; c2_em_i16 = c2_em_i16 + 1) {
c2_b_ally[c2_em_i16][0] = c2_ally[c2_em_i16][0];
}
c2_power((uint16_T *)c2_b_ally, 2.0, (uint16_T *)c2_em_uv1);
for(c2_em_i17 = 0; c2_em_i17 < 10; c2_em_i17 = c2_em_i17 + 1) {
c2_em_u8 = (uint32_T)c2_em_uv0[c2_em_i17][0] +
(uint32_T)c2_em_uv1[c2_em_i17][0];
if(c2_em_u8 > 65535U) {
c2_em_u9 = MAX_uint16_T;
} else {
c2_em_u9 = (uint16_T)c2_em_u8;
}
c2_myvector[c2_em_i17][0] = c2_em_u9;
}
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,15);
for(c2_em_i18 = 0; c2_em_i18 < 10; c2_em_i18 = c2_em_i18 + 1) {
c2_x[c2_em_i18][0] = c2_myvector[c2_em_i18][0];
c2_b_x[c2_em_i18][0] = c2_x[c2_em_i18][0];
}
c2_jstart = 1.0;
c2_minval = (*(uint16_T (*)[10])&c2_b_x)[0];
c2_indx = c2_jstart;
c2_j1 = 2.0;
while(c2_j1 <= 10.0) {
c2_b_j1 = c2_j1;
c2_a = (*(uint16_T
(*)[10])&c2_b_x)[(int32_T)_SFD_EML_ARRAY_BOUNDS_CHECK("x",
(int32_T)_SFD_INTEGER_CHECK("j1", c2_b_j1), 1, 10, 1)
- 1];
c2_b = c2_minval;
c2_p = (c2_a < c2_b);
if(c2_p) {
c2_minval = (*(uint16_T
(*)[10])&c2_b_x)[(int32_T)_SFD_EML_ARRAY_BOUNDS_CHECK("x",
(int32_T)_SFD_INTEGER_CHECK("j1", c2_b_j1), 1, 10
, 1) - 1];
c2_indx = c2_b_j1;
}
c2_j1 = c2_j1 + 1.0;
sf_mex_listen_for_ctrl_c(chartInstance.S);
}
c2_b_minval = c2_minval;
c2_b_indx = c2_indx;
c2_m = c2_b_minval;
c2_i = c2_b_indx;
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,16);
for(c2_em_i19 = 0; c2_em_i19 < 2; c2_em_i19 = c2_em_i19 + 1) {
c2_centroid[c2_em_i19] =
c2_b_CentroidArray[(int32_T)_SFD_EML_ARRAY_BOUNDS_CHECK("CentroidArray",
(int32_T)_SFD_INTEGER_CHECK("i",
c2_i), 1, 10, 2) - 1][c2_em_iv0[c2_em_i19][0]];
}
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,18);
if(CV_EML_COND(0, 2, (real_T)(*(uint16_T
(*)[10])&c2_myvector)[(int32_T)_SFD_EML_ARRAY_BOUNDS_CHECK("myvector",
(int32_T)
_SFD_INTEGER_CHECK("i", c2_i), 1, 10, 1) - 1] < 10000.0) && CV_EML_COND(0,
3, (real_T)c2_centroid[0] > 0.0) && CV_EML_COND(0, 4, (
real_T)c2_centroid[1] > 10.0)) {
CV_EML_MCDC(0, 1, true);
CV_EML_IF(0, 1, true);
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,19);
for(c2_em_i20 = 0; c2_em_i20 < 2; c2_em_i20 = c2_em_i20 + 1) {
chartInstance.c2_LastCentroid[c2_em_i20] = c2_centroid[c2_em_i20];
}
chartInstance.c2_LastCentroid_not_empty = true;
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,20);
for(c2_em_i21 = 0; c2_em_i21 < 2; c2_em_i21 = c2_em_i21 + 1) {
c2_b_CentroidCoords[c2_em_i21] = c2_centroid[c2_em_i21];
}
} else {
CV_EML_MCDC(0, 1, false);
CV_EML_IF(0, 1, false);
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,22);
for(c2_em_i22 = 0; c2_em_i22 < 2; c2_em_i22 = c2_em_i22 + 1) {
c2_b_CentroidCoords[c2_em_i22] = c2_z[c2_em_i22];
}
}
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,25);
c2_A = c2_b_VidSize[1];
c2_B = 2.0;
c2_c_x = c2_A;
c2_y = c2_B;
c2_d_x = c2_c_x;
c2_b_y = c2_y;
c2_k = 1.0;
c2_b_k = c2_k;
_SFD_EML_ARRAY_BOUNDS_CHECK("y", (int32_T)_SFD_INTEGER_CHECK("k", c2_b_k), 1,
1, 1);
if(c2_b_y == 0.0) {
sf_mex_call("warning", 0U, 1U, 15, "Divide by zero.");
}
c2_e_x = c2_d_x;
c2_c_y = c2_b_y;
c2_c_k = 1.0;
c2_d_k = c2_c_k;
c2_f_x = c2_e_x;
c2_xk = c2_f_x;
c2_b_xk = (real_T)c2_xk;
c2_g_x = c2_c_y;
c2_c_xk = c2_g_x;
c2_yk = c2_c_xk;
c2_zk = c2_b_xk / c2_yk;
_SFD_EML_ARRAY_BOUNDS_CHECK("z", (int32_T)_SFD_INTEGER_CHECK("k", c2_d_k), 1,
1, 1);
c2_em_d0 = c2_zk;
c2_em_d1 = c2_em_d0 < 0.0 ? ceil(c2_em_d0 - 0.5) : floor(c2_em_d0 + 0.5);
c2_d_z = (uint16_T)(c2_em_d1 <= 65535.0 ? c2_em_d1 >= 0.0 ? c2_em_d1 : 0.0 :
65535.0);
c2_e_z = c2_d_z;
c2_f_z = c2_e_z;
c2_d_y = c2_f_z;
c2_b_LineVector[0][0] = c2_b_VidSize[0];
c2_b_LineVector[1][0] = c2_d_y;
c2_b_LineVector[2][0] = c2_b_CentroidCoords[0];
c2_b_LineVector[3][0] = c2_b_CentroidCoords[1];
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,26);
c2_b_CentroidCol = c2_b_CentroidCoords[1];
_SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,-26);
sf_debug_pop_symbol_scope();
for(c2_em_i23 = 0; c2_em_i23 < 2; c2_em_i23 = c2_em_i23 + 1) {
c2_CentroidCoords()[c2_em_i23] = c2_b_CentroidCoords[c2_em_i23];
}
for(c2_em_i24 = 0; c2_em_i24 < 4; c2_em_i24 = c2_em_i24 + 1) {
c2_LineVector()[c2_em_i24] = c2_b_LineVector[c2_em_i24][0];
}
*c2_CentroidCol() = c2_b_CentroidCol;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,1);
_sfEvent_ = c2_previousEvent;
sf_debug_check_for_state_inconsistency(_object_tracker_intensityMachineNumber_,
chartInstance.chartNumber, chartInstance.
instanceNumber);
}
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),
ssGetNumSampleTimes(S),
(boolean_T *)&ssGetStopRequested(S));
if (ssGetStopRequested(S)) goto EXIT_POINT;
}
/* Start the model */
now = time(NULL);
if(gblVerboseFlag) {
(void)printf("\n** Starting model @ %s", ctime(&now));
}
/* Enable logging in the MdlStart method */
ssSetLogOutput(S,TRUE);
/* Enable -i option to load inport data file */
result = rt_RapidReadInportsMatFile(gblInportFileName, &matFileFormat);
if (result!= NULL) {
ssSetErrorStatus(S,result);
GOTO_EXIT_IF_ERROR("Error starting model: %s\n", ssGetErrorStatus(S));
}
MdlStart();
ssSetLogOutput(S,FALSE);
calledMdlStart = TRUE;
GOTO_EXIT_IF_ERROR("Error starting model: %s\n", ssGetErrorStatus(S));
result = rt_RapidCheckRemappings();
ssSetErrorStatus(S,result);
GOTO_EXIT_IF_ERROR("Error: %s\n", ssGetErrorStatus(S));
/* Create solver data */
rsimCreateSolverData(S, gblSlvrJacPatternFileName);
GOTO_EXIT_IF_ERROR("Error creating solver data: %s\n", ssGetErrorStatus(S));
ssSetFirstInitCondCalled(S);
/*********************
* Execute the model *
*********************/
/* Install Signal and Run time limit handlers */
rsimInstallAllHandlers(S,WriteResultsToMatFile,gblTimeLimit);
gblInstalledSigHandlers = TRUE;
GOTO_EXIT_IF_ERROR("Error: %s\n", ssGetErrorStatus(S));
while ( ((ssGetTFinal(S)-ssGetT(S)) > (fabs(ssGetT(S))*DBL_EPSILON)) ) {
if (gblExtModeEnabled) {
rtExtModePauseIfNeeded(ssGetRTWExtModeInfo(S),
ssGetNumSampleTimes(S),
(boolean_T *)&ssGetStopRequested(S));
}
if (ssGetStopRequested(S)) break;
if (gbl_raccel_isMultitasking) {
rsimOneStepMT(S);
} else {
rsimOneStepST(S);
}
if (ssGetErrorStatus(S)) break;
}
if (ssGetErrorStatus(S) == NULL && !ssGetStopRequested(S)) {
/* Do a major step at the final time */
if (gbl_raccel_isMultitasking) {
rsimOneStepMT(S);
} else {
rsimOutputLogUpdate(S);
}
}
EXIT_POINT:
/********************
* Cleanup and exit *
********************/
if (ssGetErrorStatus(S) != NULL) {
if (errorPrefix) {
(void)fprintf(stderr, errorPrefix, ssGetErrorStatus(S));
} else {
(void)fprintf(stderr, "Error: %s\n", ssGetErrorStatus(S));
}
}
if (gblInstalledSigHandlers) {
rsimUninstallNonfatalHandlers();
gblInstalledSigHandlers = FALSE;
}
if (dataLoggingActive){
WriteResultsToMatFile(S);
}
rsimTerminateEngine(S,0);
if (initializedExtMode) {
rtExtModeShutdown(ssGetNumSampleTimes(S));
}
if (calledMdlStart) {
MdlTerminate();
}
#ifdef RACCEL_PARALLEL_FOREACH
rt_ParallelForEachClearScheduler(parforSchedulerInit);
#endif
rt_RapidFreeGbls(matFileFormat);
return ssGetErrorStatus(S) ? EXIT_FAILURE : EXIT_SUCCESS;
} /* end main */
