/* Function Definitions */
static boolean_T b_MACLayerTransmitter(testMACTransmitterStackData *SD, const
emlrtStack *sp, comm_AGC *ObjAGC, comm_SDRuReceiver *ObjSDRuReceiver,
comm_SDRuTransmitter *ObjSDRuTransmitter, commcodegen_CRCDetector *ObjDetect,
OFDMDemodulator_1 *ObjPreambleDemod, OFDMDemodulator_1 *ObjDataDemod, const
c_struct_T *estimate, const e_struct_T *tx, const real_T messageBits_data[563],
char_T previousMessage_data[77], int32_T previousMessage_size[2])
{
boolean_T msgStatus;
int32_T tries;
int32_T state;
real_T decisions[10];
real_T destNodeID;
int16_T i36;
comm_SDRuTransmitter *obj;
boolean_T flag;
boolean_T exitg1;
comm_AGC *b_ObjAGC;
comm_SDRuReceiver *b_ObjSDRuReceiver;
commcodegen_CRCDetector *b_ObjDetect;
OFDMDemodulator_1 *b_ObjPreambleDemod;
OFDMDemodulator_1 *b_ObjDataDemod;
int32_T originNodeID;
real_T timeouts;
int32_T Response_size[2];
int32_T exitg10;
boolean_T guard1 = FALSE;
static const char_T b[7] = { 'T', 'i', 'm', 'e', 'o', 'u', 't' };
char_T Response_data[80];
int32_T messageBits_size[2];
real_T b_messageBits_data[563];
int8_T sza[2];
int32_T exitg16;
int32_T exitg15;
static const char_T cv343[7] = { 'T', 'i', 'm', 'e', 'o', 'u', 't' };
int32_T exitg14;
int32_T exitg13;
static const char_T cv344[9] = { 'C', 'R', 'C', ' ', 'E', 'r', 'r', 'o', 'r' };
int8_T szb[2];
int32_T exitg12;
int32_T exitg11;
int32_T loop_ub;
static const char_T b_b[9] = { 'D', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e' };
char_T b_Response_data[80];
int32_T exitg9;
int32_T exitg8;
boolean_T b_guard1 = FALSE;
int32_T exitg7;
int32_T exitg6;
static const char_T cv345[9] = { 'D', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e' };
int32_T exitg5;
int32_T exitg4;
int32_T exitg3;
int32_T exitg2;
static const char_T cv346[3] = { 'A', 'C', 'K' };
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
/* %Objects */
/* %Structs */
/* %Values/Vectors */
/* % This function is called when the node wants to transmit something */
/* % Sense spectrum and wait until it is unoccupied */
for (tries = 0; tries < 4; tries++) {
/* try only so many times */
for (state = 0; state < 10; state++) {
st.site = &xl_emlrtRSI;
SpectrumSenseP25(SD, &st, ObjAGC, ObjSDRuReceiver, decisions);
destNodeID = muDoubleScalarRound(decisions[state]);
if (destNodeID < 32768.0) {
if (destNodeID >= -32768.0) {
i36 = (int16_T)destNodeID;
} else {
i36 = MIN_int16_T;
}
} else if (destNodeID >= 32768.0) {
i36 = MAX_int16_T;
} else {
i36 = 0;
}
st.site = &yl_emlrtRSI;
d_fprintf(&st, (int16_T)(1 + state), i36);
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* if occupied */
/* fprintf('MAC| Spectrum occupied, listening...\n'); */
/* %Recover signal and/or wait */
/* lookingForACK = false; */
/* %MACLayerReceiver(PHY,lookingForACK); */
/* else% Yay we can transmit now */
/* break; */
/* end */
/* if tries >=4 */
/* fprintf('MAC| Spectrum Busy, try again later\n'); */
/* return; */
/* end */
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
msgStatus = FALSE;
/* Adjust offset for node */
st.site = &am_emlrtRSI;
f_fprintf(&st, 1, tx->offsetTable[0]);
st.site = &bm_emlrtRSI;
obj = ObjSDRuTransmitter;
b_st.site = &gb_emlrtRSI;
obj->CenterFrequency = 2.24E+9 + tx->offsetTable[0];
c_st.site = &ck_emlrtRSI;
b_st.site = &gb_emlrtRSI;
if (obj->isInitialized && (!obj->isReleased)) {
flag = TRUE;
} else {
flag = FALSE;
}
if (flag) {
obj->TunablePropsChanged = TRUE;
obj->tunablePropertyChanged[1] = TRUE;
}
/* % Spectrum clear, send message */
tries = 0;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (tries < 4)) {
/* Send message */
/* %originator */
/* %destination */
st.site = &cm_emlrtRSI;
PHYTransmit(SD, &st, ObjSDRuTransmitter, ObjSDRuReceiver, tx->nodeNum);
/* Listen for acknowledgement */
/* fprintf('###########################################\n'); */
st.site = &dm_emlrtRSI;
h_fprintf(&st);
/* Call Receiver */
/* %Objects */
/* %Structs */
/* %Values/Vectors */
st.site = &em_emlrtRSI;
b_ObjAGC = ObjAGC;
b_ObjSDRuReceiver = ObjSDRuReceiver;
obj = ObjSDRuTransmitter;
b_ObjDetect = ObjDetect;
b_ObjPreambleDemod = ObjPreambleDemod;
b_ObjDataDemod = ObjDataDemod;
/* %Objects */
/* %Structs */
/* %Values/Vectors */
/* This function is called when the node is just listening to the spectrum */
/* waiting for a message to be transmitted to them */
/* % Listen to the spectrum */
/* previousMessage will be updated for next run */
/* %Objects */
/* %Structs */
/* %Values/Vectors */
b_st.site = &rt_emlrtRSI;
/* %Objects */
/* %Structs */
/* %Values/Vectors */
/* Initialize values */
originNodeID = -1;
destNodeID = -1.0;
/* 0 = Call PHY Receiver */
/* 1 = Timeout */
/* 2 = Corrupt Message */
/* 3 = Message Reception Successfull */
/* Duplicates are checked at the last stage */
state = 0;
/* Initial state */
timeouts = 0.0;
/* Counter */
/* Message string holder */
emlrtDimSizeGeqCheckFastR2012b(80, 0, &y_emlrtECI, &b_st);
Response_size[0] = 1;
Response_size[1] = 0;
/* Run system */
do {
exitg10 = 0;
/* %% Process Messages */
guard1 = FALSE;
switch (state) {
case 0:
/* Wait for message */
if (timeouts > 10.0) {
emlrtDimSizeGeqCheckFastR2012b(80, 7, &db_emlrtECI, &b_st);
Response_size[0] = 1;
Response_size[1] = 7;
for (state = 0; state < 7; state++) {
Response_data[state] = b[state];
}
exitg10 = 1;
} else {
/* Call Physical Layer */
/* %Objects */
/* %Structs */
/* %Values/Vectors */
SD->f15.estimate = *estimate;
messageBits_size[0] = 1;
messageBits_size[1] = 563;
memcpy(&b_messageBits_data[0], &messageBits_data[0], 563U * sizeof
(real_T));
c_st.site = &eu_emlrtRSI;
PHYReceive(SD, &c_st, b_ObjAGC, b_ObjSDRuReceiver, b_ObjDetect,
b_ObjPreambleDemod, b_ObjDataDemod, &SD->f15.estimate,
tx->shortPreambleOFDM, tx->longPreamble, tx->pilots,
tx->pilotLocationsWithoutGuardbands,
tx->dataSubcarrierIndexies.data,
tx->dataSubcarrierIndexies.size, b_messageBits_data,
messageBits_size, Response_data, Response_size);
/* Choose next state */
c_st.site = &fu_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg16 = 0;
if (state < 2) {
if (sza[state] != 1 + 6 * state) {
exitg16 = 1;
} else {
state++;
}
} else {
state = 0;
exitg16 = 2;
}
} while (exitg16 == 0);
if (exitg16 == 1) {
} else {
do {
exitg15 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv343[state]) {
exitg15 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg15 = 1;
}
} while (exitg15 == 0);
}
if (flag) {
state = 1;
} else {
c_st.site = &gu_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg14 = 0;
if (state < 2) {
if (sza[state] != 1 + (state << 3)) {
exitg14 = 1;
} else {
state++;
}
} else {
state = 0;
exitg14 = 2;
}
} while (exitg14 == 0);
if (exitg14 == 1) {
} else {
do {
exitg13 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv344[state]) {
exitg13 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg13 = 1;
}
} while (exitg13 == 0);
}
if (flag || (Response_size[1] == 0)) {
state = 2;
} else {
/* Successfully decoded */
state = 3;
}
}
/* Timeout occured */
guard1 = TRUE;
}
break;
case 1:
timeouts++;
if (timeouts > 10.0) {
/* if DebugFlag;fprintf('DL| Max timeouts reached\n');end */
c_st.site = &du_emlrtRSI;
l_fprintf(&c_st);
emlrtDimSizeGeqCheckFastR2012b(80, 7, &cb_emlrtECI, &b_st);
Response_size[0] = 1;
Response_size[1] = 7;
for (state = 0; state < 7; state++) {
Response_data[state] = b[state];
}
exitg10 = 1;
} else {
state = 0;
/* Get another message */
/* Message corrupted */
guard1 = TRUE;
}
break;
case 2:
timeouts += 0.01;
state = 0;
/* Get another message */
/* Default: Message successfully received */
guard1 = TRUE;
break;
case 3:
/* otherwise */
/* disp(['DL| MSG: ',Response]) */
/* disp(['DL| Timeouts: ',num2str(timeouts)]) */
/* Final Duplication check */
c_st.site = &bu_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)previousMessage_size[state];
}
for (state = 0; state < 2; state++) {
szb[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg12 = 0;
if (state < 2) {
if (sza[state] != szb[state]) {
exitg12 = 1;
} else {
state++;
}
} else {
state = 0;
exitg12 = 2;
}
} while (exitg12 == 0);
if (exitg12 == 1) {
} else {
do {
exitg11 = 0;
if (state <= previousMessage_size[1] - 1) {
if (previousMessage_data[state] != Response_data[state]) {
exitg11 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg11 = 1;
}
} while (exitg11 == 0);
}
if (flag) {
/* Dupe */
/* if DebugFlag;fprintf('DL| Duplicate Message\n');end */
c_st.site = &cu_emlrtRSI;
j_fprintf(&c_st);
previousMessage_size[0] = 1;
previousMessage_size[1] = Response_size[1];
loop_ub = Response_size[1];
for (state = 0; state < loop_ub; state++) {
previousMessage_data[previousMessage_size[0] * state] =
Response_data[Response_size[0] * state];
}
/* Update history for next iteration */
state = Response_size[1] - 2;
originNodeID = (uint8_T)
Response_data[emlrtDynamicBoundsCheckFastR2012b(state, 1,
Response_size[1], &wb_emlrtBCI, &b_st) - 1] - 48;
/* extract node ID and convert char to number */
state = Response_size[1] - 1;
destNodeID = (real_T)(uint8_T)
Response_data[emlrtDynamicBoundsCheckFastR2012b(state, 1,
Response_size[1], &xb_emlrtBCI, &b_st) - 1] - 48.0;
/* extract node ID and convert char to number */
emlrtDimSizeGeqCheckFastR2012b(80, 9, &ab_emlrtECI, &b_st);
Response_size[0] = 1;
Response_size[1] = 9;
for (state = 0; state < 9; state++) {
Response_data[state] = b_b[state];
}
/* Tell upper layers duplicate */
} else {
/* No Dupe */
previousMessage_size[0] = 1;
previousMessage_size[1] = Response_size[1];
loop_ub = Response_size[1];
for (state = 0; state < loop_ub; state++) {
previousMessage_data[previousMessage_size[0] * state] =
Response_data[Response_size[0] * state];
}
/* Update history for next iteration */
state = Response_size[1] - 2;
originNodeID = (uint8_T)
Response_data[emlrtDynamicBoundsCheckFastR2012b(state, 1,
Response_size[1], &ub_emlrtBCI, &b_st) - 1] - 48;
/* extract node ID and convert char to number */
state = Response_size[1] - 1;
destNodeID = (real_T)(uint8_T)
Response_data[emlrtDynamicBoundsCheckFastR2012b(state, 1,
Response_size[1], &vb_emlrtBCI, &b_st) - 1] - 48.0;
/* extract node ID and convert char to number */
if (1 > Response_size[1] - 3) {
loop_ub = 0;
} else {
emlrtDynamicBoundsCheckFastR2012b(1, 1, Response_size[1],
&tb_emlrtBCI, &b_st);
state = Response_size[1] - 3;
loop_ub = emlrtDynamicBoundsCheckFastR2012b(state, 1, Response_size
[1], &tb_emlrtBCI, &b_st);
}
emlrtDimSizeGeqCheckFastR2012b(80, loop_ub, &bb_emlrtECI, &b_st);
for (state = 0; state < loop_ub; state++) {
b_Response_data[state] = Response_data[state];
}
Response_size[0] = 1;
Response_size[1] = loop_ub;
for (state = 0; state < loop_ub; state++) {
Response_data[state] = b_Response_data[state];
}
/* Remove identifer key and nodeIDs */
}
exitg10 = 1;
break;
default:
guard1 = TRUE;
break;
}
if (guard1 == TRUE) {
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, &b_st);
}
} while (exitg10 == 0);
/* Final check */
c_st.site = &hu_emlrtRSI;
if (muDoubleScalarAbs(destNodeID) > 3.0) {
destNodeID = tx->nodeNum;
/* Something went wrong, probably corrupt message, reset to self */
}
/* % Possible response messages */
/* 1.) Timeout */
/* 2.) Some message */
b_st.site = &st_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg9 = 0;
if (state < 2) {
if (sza[state] != 1 + 6 * state) {
exitg9 = 1;
} else {
state++;
}
} else {
state = 0;
exitg9 = 2;
}
} while (exitg9 == 0);
if (exitg9 == 1) {
} else {
do {
exitg8 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv343[state]) {
exitg8 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg8 = 1;
}
} while (exitg8 == 0);
}
b_guard1 = FALSE;
if (!flag) {
b_st.site = &st_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg7 = 0;
if (state < 2) {
if (sza[state] != 1 + (state << 3)) {
exitg7 = 1;
} else {
state++;
}
} else {
state = 0;
exitg7 = 2;
}
} while (exitg7 == 0);
if (exitg7 == 1) {
} else {
do {
exitg6 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv345[state]) {
exitg6 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg6 = 1;
}
} while (exitg6 == 0);
}
if (!flag) {
/* fprintf('###########################################\n'); */
b_st.site = &tt_emlrtRSI;
n_fprintf(&b_st, Response_data, Response_size);
b_st.site = &ut_emlrtRSI;
p_fprintf(&b_st, (int16_T)originNodeID);
} else {
b_guard1 = TRUE;
}
} else {
b_guard1 = TRUE;
}
if (b_guard1 == TRUE) {
b_st.site = &vt_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg5 = 0;
if (state < 2) {
if (sza[state] != 1 + (state << 3)) {
exitg5 = 1;
} else {
state++;
}
} else {
state = 0;
exitg5 = 2;
}
} while (exitg5 == 0);
if (exitg5 == 1) {
} else {
do {
exitg4 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv345[state]) {
exitg4 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg4 = 1;
}
} while (exitg4 == 0);
}
if (flag) {
b_st.site = &wt_emlrtRSI;
r_fprintf(&b_st);
/* %% Send ACK */
b_st.site = &xt_emlrtRSI;
f_fprintf(&b_st, (int16_T)originNodeID, tx->
offsetTable[emlrtDynamicBoundsCheckFastR2012b(originNodeID, 1,
3, &yb_emlrtBCI, &st) - 1]);
b_st.site = &yt_emlrtRSI;
c_st.site = &gb_emlrtRSI;
obj->CenterFrequency = 2.24E+9 + tx->offsetTable[originNodeID - 1];
c_st.site = &gb_emlrtRSI;
if (obj->isInitialized && (!obj->isReleased)) {
flag = TRUE;
} else {
flag = FALSE;
}
if (flag) {
obj->TunablePropsChanged = TRUE;
obj->tunablePropertyChanged[1] = TRUE;
}
/* Adjust offset for node */
b_st.site = &au_emlrtRSI;
b_PHYTransmit(SD, &b_st, obj, b_ObjSDRuReceiver, originNodeID,
destNodeID);
}
}
st.site = &fm_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg3 = 0;
if (state < 2) {
if (sza[state] != 1 + (state << 1)) {
exitg3 = 1;
} else {
state++;
}
} else {
state = 0;
exitg3 = 2;
}
} while (exitg3 == 0);
if (exitg3 == 1) {
} else {
do {
exitg2 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv346[state]) {
exitg2 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg2 = 1;
}
} while (exitg2 == 0);
}
if (flag) {
st.site = &gm_emlrtRSI;
t_fprintf(&st);
msgStatus = TRUE;
exitg1 = TRUE;
} else {
st.site = &hm_emlrtRSI;
v_fprintf(&st);
if (tries + 1 >= 4) {
st.site = &im_emlrtRSI;
x_fprintf(&st);
st.site = &jm_emlrtRSI;
ab_fprintf(&st);
st.site = &km_emlrtRSI;
x_fprintf(&st);
exitg1 = TRUE;
} else {
tries++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
}
}
return msgStatus;
}
static void c5_chartstep_c5_testing_Control(SFc5_testing_ControlInstanceStruct
*chartInstance)
{
real_T c5_hoistedGlobal;
real_T c5_lambda;
uint32_T c5_debug_family_var_map[5];
boolean_T c5_positiveInput;
real_T c5_nargin = 1.0;
real_T c5_nargout = 1.0;
real_T c5_lambda1;
real_T c5_x;
real_T c5_xk;
real_T c5_b_x;
real_T c5_c_x;
real_T c5_d_x;
real_T c5_e_x;
real_T c5_f_x;
real_T c5_y;
real_T c5_g_x;
real_T c5_b_y;
real_T c5_b;
real_T c5_c_y;
real_T c5_h_x;
real_T c5_i_x;
real_T c5_dv0[1];
boolean_T c5_b0;
boolean_T c5_b_positiveInput;
boolean_T c5_j_x;
boolean_T c5_k_x;
int32_T c5_k;
int32_T c5_tmp_sizes[2];
int32_T c5_iv0[2];
int32_T c5_i0;
int32_T c5_i1;
int32_T c5_loop_ub;
int32_T c5_i2;
int32_T c5_tmp_data[1];
int32_T c5_i3;
int32_T c5_b_tmp_sizes[2];
int32_T c5_b_tmp_data[1];
int32_T c5_b_loop_ub;
int32_T c5_i4;
real_T *c5_b_lambda1;
real_T *c5_b_lambda;
c5_b_lambda1 = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c5_b_lambda = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 2U, chartInstance->c5_sfEvent);
c5_hoistedGlobal = *c5_b_lambda;
c5_lambda = c5_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 5U, 5U, c5_debug_family_names,
c5_debug_family_var_map);
sf_debug_symbol_scope_add_eml_importable(&c5_positiveInput, 0U,
c5_b_sf_marshallOut, c5_b_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c5_nargin, 1U, c5_sf_marshallOut,
c5_sf_marshallIn);
sf_debug_symbol_scope_add_eml_importable(&c5_nargout, 2U, c5_sf_marshallOut,
c5_sf_marshallIn);
sf_debug_symbol_scope_add_eml(&c5_lambda, 3U, c5_sf_marshallOut);
sf_debug_symbol_scope_add_eml_importable(&c5_lambda1, 4U, c5_sf_marshallOut,
c5_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c5_sfEvent, 15);
c5_positiveInput = (c5_lambda > 0.0);
_SFD_EML_CALL(0U, chartInstance->c5_sfEvent, 16);
c5_x = c5_lambda;
c5_xk = c5_x;
c5_b_x = c5_xk;
c5_c_x = c5_b_x;
c5_lambda = c5_c_x / 6.2831853071795862;
c5_d_x = c5_lambda;
c5_e_x = c5_d_x;
c5_e_x = muDoubleScalarRound(c5_e_x);
c5_f_x = c5_lambda - c5_e_x;
c5_y = muDoubleScalarAbs(c5_f_x);
c5_g_x = c5_lambda;
c5_b_y = muDoubleScalarAbs(c5_g_x);
c5_b = c5_b_y;
c5_c_y = 2.2204460492503131E-16 * c5_b;
if (c5_y <= c5_c_y) {
c5_lambda = 0.0;
} else {
c5_h_x = c5_lambda;
c5_i_x = c5_h_x;
c5_i_x = muDoubleScalarFloor(c5_i_x);
c5_lambda = (c5_lambda - c5_i_x) * 6.2831853071795862;
}
_SFD_EML_CALL(0U, chartInstance->c5_sfEvent, 17);
c5_dv0[0] = c5_lambda;
c5_b0 = (c5_lambda == 0.0);
c5_b_positiveInput = c5_positiveInput;
c5_j_x = (c5_b0 && c5_b_positiveInput);
c5_k_x = c5_j_x;
c5_k = 0;
if (c5_k_x) {
c5_k = 1;
}
c5_tmp_sizes[0] = 1;
c5_iv0[0] = 1;
c5_iv0[1] = c5_k;
c5_tmp_sizes[1] = c5_iv0[1];
c5_i0 = c5_tmp_sizes[0];
c5_i1 = c5_tmp_sizes[1];
c5_loop_ub = c5_k - 1;
for (c5_i2 = 0; c5_i2 <= c5_loop_ub; c5_i2++) {
c5_tmp_data[c5_i2] = 0;
}
for (c5_i3 = 0; c5_i3 < 2; c5_i3++) {
c5_b_tmp_sizes[c5_i3] = c5_tmp_sizes[c5_i3];
}
if (c5_j_x) {
_SFD_EML_ARRAY_BOUNDS_CHECK("", 1, 1, c5_b_tmp_sizes[1], 1, 0);
c5_b_tmp_data[0] = 1;
}
c5_b_loop_ub = c5_b_tmp_sizes[0] * c5_b_tmp_sizes[1] - 1;
for (c5_i4 = 0; c5_i4 <= c5_b_loop_ub; c5_i4++) {
c5_dv0[c5_b_tmp_data[c5_i4] - 1] = 6.2831853071795862;
}
c5_lambda = c5_dv0[0];
_SFD_EML_CALL(0U, chartInstance->c5_sfEvent, 18);
c5_lambda1 = c5_lambda;
_SFD_EML_CALL(0U, chartInstance->c5_sfEvent, -18);
sf_debug_symbol_scope_pop();
*c5_b_lambda1 = c5_lambda1;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 2U, chartInstance->c5_sfEvent);
}
