void d_SystemCore_release(const emlrtStack *sp, c_commcodegen_PhaseFrequencyOff * obj) { static const char_T cv6[7] = { 'r', 'e', 'l', 'e', 'a', 's', 'e' }; c_commcodegen_PhaseFrequencyOff *b_obj; emlrtStack st; emlrtStack b_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; if (obj->isInitialized != 2) { } else { emlrtErrorWithMessageIdR2012b(sp, &e_emlrtRTEI, "MATLAB:system:methodCalledWhenReleasedCodegen", 3, 4, 7, cv6); } if (obj->isInitialized == 1) { obj->isInitialized = 2; st.site = &u_emlrtRSI; b_obj = obj; b_st.site = &eb_emlrtRSI; if (b_obj->cSFunObject.S0_isInitialized == 2) { emlrtErrorWithMessageIdR2012b(&b_st, &f_emlrtRTEI, "MATLAB:system:runtimeMethodCalledWhenReleasedCodegen", 0); } /* System object Destructor function: comm.PhaseFrequencyOffset */ if ((b_obj->cSFunObject.S0_isInitialized == 1) && (b_obj->cSFunObject.S0_isInitialized != 2)) { b_obj->cSFunObject.S0_isInitialized = 2; } } }
void e_SystemCore_release(const emlrtStack *sp, c_comm_RaisedCosineReceiveFilte * obj) { static const char_T cv7[7] = { 'r', 'e', 'l', 'e', 'a', 's', 'e' }; c_comm_RaisedCosineReceiveFilte *b_obj; dspcodegen_FIRDecimator_1 *c_obj; emlrtStack st; emlrtStack b_st; emlrtStack c_st; emlrtStack d_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; d_st.prev = &c_st; d_st.tls = c_st.tls; if (obj->isInitialized != 2) { } else { emlrtErrorWithMessageIdR2012b(sp, &e_emlrtRTEI, "MATLAB:system:methodCalledWhenReleasedCodegen", 3, 4, 7, cv7); } if (obj->isInitialized == 1) { obj->isInitialized = 2; st.site = &u_emlrtRSI; b_obj = obj; b_st.site = &hc_emlrtRSI; c_obj = &b_obj->pFilter; if (b_obj->pFilter.isInitialized != 2) { } else { emlrtErrorWithMessageIdR2012b(&b_st, &e_emlrtRTEI, "MATLAB:system:methodCalledWhenReleasedCodegen", 3, 4, 7, cv7); } if (b_obj->pFilter.isInitialized == 1) { b_obj->pFilter.isInitialized = 2; c_st.site = &u_emlrtRSI; d_st.site = &ab_emlrtRSI; if (c_obj->cSFunObject.S0_isInitialized == 2) { emlrtErrorWithMessageIdR2012b(&d_st, &f_emlrtRTEI, "MATLAB:system:runtimeMethodCalledWhenReleasedCodegen", 0); } /* System object Destructor function: dsp.FIRDecimator */ if ((c_obj->cSFunObject.S0_isInitialized == 1) && (c_obj->cSFunObject.S0_isInitialized != 2)) { c_obj->cSFunObject.S0_isInitialized = 2; } } } }
void c_eml_error(const emlrtStack *sp) { static const char_T varargin_1[4] = { 's', 'q', 'r', 't' }; emlrtErrorWithMessageIdR2012b(sp, &ec_emlrtRTEI, "Coder:toolbox:ElFunDomainError", 3, 4, 4, varargin_1); }
/* Function Definitions */ void eml_error(const emlrtStack *sp) { static char_T cv0[4][1] = { { 's' }, { 'q' }, { 'r' }, { 't' } }; emlrtErrorWithMessageIdR2012b(sp, &emlrtRTEI, "Coder:toolbox:ElFunDomainError", 3, 4, 4, cv0); }
void d_eml_error(const emlrtStack *sp) { static const char_T varargin_1[3] = { 'l', 'o', 'g' }; emlrtErrorWithMessageIdR2012b(sp, &ec_emlrtRTEI, "Coder:toolbox:ElFunDomainError", 3, 4, 3, varargin_1); }
/* Function Definitions */ void check_forloop_overflow_error(const emlrtStack *sp) { static const char_T cv0[5] = { 'i', 'n', 't', '3', '2' }; emlrtErrorWithMessageIdR2012b(sp, &n_emlrtRTEI, "Coder:toolbox:int_forloop_overflow", 3, 4, 5, cv0); }
void b_eml_error(const emlrtStack *sp) { static char_T cv1[4][1] = { { 'a' }, { 'c' }, { 'o' }, { 's' } }; emlrtErrorWithMessageIdR2012b(sp, &emlrtRTEI, "Coder:toolbox:ElFunDomainError", 3, 4, 4, cv1); }
void SystemCore_release(const emlrtStack *sp, comm_SDRuReceiver *obj) { static const char_T cv9[7] = { 'r', 'e', 'l', 'e', 'a', 's', 'e' }; comm_SDRuReceiver *b_obj; boolean_T disconnected; int32_T driverApiH; int32_T errMsg_size[2]; char_T errMsg_data[1024]; UsrpErrorCapiEnumT errStatus; int32_T tmp_size[2]; char_T tmp_data[128]; emlrtStack st; emlrtStack b_st; emlrtStack c_st; emlrtStack d_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; d_st.prev = &c_st; d_st.tls = c_st.tls; if (obj->isInitialized != 2) { } else { emlrtErrorWithMessageIdR2012b(sp, &c_emlrtRTEI, "MATLAB:system:methodCalledWhenReleasedCodegen", 3, 4, 7, cv9); } if (obj->isInitialized == 1) { obj->isInitialized = 2; st.site = &k_emlrtRSI; b_obj = obj; b_st.site = &h_emlrtRSI; disconnected = true; if (b_obj->pConnected) { c_st.site = &h_emlrtRSI; driverApiH = b_obj->pDriverHandle; /* Copyright 2011-2012 The MathWorks, Inc. */ d_st.site = &w_emlrtRSI; b_mapiPrivate(&d_st, driverApiH, &errStatus, errMsg_data, errMsg_size); if (errStatus == UsrpDriverSuccess) { b_obj->pDriverHandle = 0; } else { c_st.site = &h_emlrtRSI; reportDrivers(&c_st, tmp_data, tmp_size); if (!(tmp_size[1] == 0)) { disconnected = false; c_st.site = &h_emlrtRSI; c_warning(&c_st, errMsg_data, errMsg_size); } } b_obj->pConnected = !disconnected; } } }
/* Function Definitions */ static void eml_error(void) { static char_T cv0[4][1] = { { 's' }, { 'q' }, { 'r' }, { 't' } }; emlrtPushRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal); emlrtErrorWithMessageIdR2012b(emlrtRootTLSGlobal, &emlrtRTEI, "Coder:toolbox:ElFunDomainError", 3, 4, 4, cv0); emlrtPopRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal); }
void diag(const emlrtStack *sp, const emxArray_real_T *v, emxArray_real_T *d) { int32_T m; int32_T n; int32_T stride; boolean_T b1; emlrtStack st; emlrtStack b_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; if ((v->size[0] == 1) && (v->size[1] == 1)) { m = d->size[0]; d->size[0] = 1; emxEnsureCapacity(sp, (emxArray__common *)d, m, (int32_T)sizeof(real_T), &g_emlrtRTEI); d->data[0] = v->data[0]; } else { if (!((v->size[0] == 1) || (v->size[1] == 1))) { } else { emlrtErrorWithMessageIdR2012b(sp, &j_emlrtRTEI, "Coder:toolbox:diag_varsizedMatrixVector", 0); } m = v->size[0]; n = v->size[1]; if (0 < v->size[1]) { n = muIntScalarMin_sint32(m, n); stride = v->size[0] + 1; } else { n = 0; stride = 0; } m = d->size[0]; d->size[0] = n; emxEnsureCapacity(sp, (emxArray__common *)d, m, (int32_T)sizeof(real_T), &g_emlrtRTEI); st.site = &j_emlrtRSI; if (1 > n) { b1 = false; } else { b1 = (n > 2147483646); } if (b1) { b_st.site = &k_emlrtRSI; check_forloop_overflow_error(&b_st); } for (m = 0; m + 1 <= n; m++) { d->data[m] = v->data[m * stride]; } } }
/* Function Definitions */ static void SystemCore_setupAndReset(const emlrtStack *sp, comm_SDRuReceiver *obj) { comm_SDRuReceiver *b_obj; static const char_T cv19[5] = { 's', 'e', 't', 'u', 'p' }; int32_T errMsg_size[2]; char_T errMsg_data[1024]; UsrpErrorCapiEnumT deviceStatus; int32_T driverApiH; int32_T errStr_size[2]; char_T errStr_data[1024]; UsrpErrorCapiEnumT errStat; emlrtStack st; emlrtStack b_st; emlrtStack c_st; emlrtStack d_st; st.prev = sp; st.tls = sp->tls; st.site = &k_emlrtRSI; b_st.prev = &st; b_st.tls = st.tls; c_st.prev = &b_st; c_st.tls = b_st.tls; d_st.prev = &c_st; d_st.tls = c_st.tls; b_obj = obj; if (b_obj->isInitialized == 0) { } else { emlrtErrorWithMessageIdR2012b(&st, &c_emlrtRTEI, "MATLAB:system:methodCalledWhenLockedReleasedCodegen", 3, 4, 5, cv19); } b_obj->isInitialized = 1; b_st.site = &k_emlrtRSI; c_st.site = &h_emlrtRSI; SDRuReceiver_setupImplLocal(&c_st, b_obj, &deviceStatus, errMsg_data, errMsg_size); if (deviceStatus == UsrpDriverSuccess) { b_obj->pConnected = true; } else { c_st.site = &h_emlrtRSI; driverApiH = b_obj->pDriverHandle; /* Copyright 2011-2012 The MathWorks, Inc. */ d_st.site = &w_emlrtRSI; b_mapiPrivate(&d_st, driverApiH, &errStat, errStr_data, errStr_size); b_obj->pConnected = false; } c_st.site = &h_emlrtRSI; reportSDRuStatus(&c_st, deviceStatus, errMsg_data, errMsg_size); }
/* Function Definitions */ void b_rdivide(const emlrtStack *sp, const emxArray_real_T *x, const emxArray_real_T *y, emxArray_real_T *z) { uint32_T varargin_1[2]; int32_T k; uint32_T varargin_2[2]; boolean_T p; boolean_T b_p; boolean_T exitg1; int32_T loop_ub; for (k = 0; k < 2; k++) { varargin_1[k] = (uint32_T)x->size[k]; } for (k = 0; k < 2; k++) { varargin_2[k] = (uint32_T)y->size[k]; } p = false; b_p = true; k = 0; exitg1 = false; while ((!exitg1) && (k < 2)) { if (!((int32_T)varargin_1[k] == (int32_T)varargin_2[k])) { b_p = false; exitg1 = true; } else { k++; } } if (!b_p) { } else { p = true; } if (p) { } else { emlrtErrorWithMessageIdR2012b(sp, &hc_emlrtRTEI, "MATLAB:dimagree", 0); } k = z->size[0] * z->size[1]; z->size[0] = x->size[0]; z->size[1] = x->size[1]; emxEnsureCapacity(sp, (emxArray__common *)z, k, (int32_T)sizeof(real_T), &n_emlrtRTEI); loop_ub = x->size[0] * x->size[1]; for (k = 0; k < loop_ub; k++) { z->data[k] = x->data[k] / y->data[k]; } }
/* Function Definitions */ void SystemCore_release(const emlrtStack *sp, comm_AGC *obj) { static const char_T cv3[7] = { 'r', 'e', 'l', 'e', 'a', 's', 'e' }; if (obj->isInitialized != 2) { } else { emlrtErrorWithMessageIdR2012b(sp, &e_emlrtRTEI, "MATLAB:system:methodCalledWhenReleasedCodegen", 3, 4, 7, cv3); } if (obj->isInitialized == 1) { obj->isInitialized = 2; } }
/* Function Definitions */ real_T mean(const emlrtStack *sp, const emxArray_real_T *x) { boolean_T b10; real_T b_x; emlrtStack st; st.prev = sp; st.tls = sp->tls; if ((x->size[1] == 1) || (x->size[1] != 1)) { b10 = true; } else { b10 = false; } if (b10) { } else { emlrtErrorWithMessageIdR2012b(sp, &kc_emlrtRTEI, "Coder:toolbox:autoDimIncompatibility", 0); } b10 = !b_isequal(x); if (b10) { } else { emlrtErrorWithMessageIdR2012b(sp, &jc_emlrtRTEI, "Coder:toolbox:UnsupportedSpecialEmpty", 0); } b10 = !b_isequal(x); if (b10) { } else { emlrtErrorWithMessageIdR2012b(sp, &ic_emlrtRTEI, "Coder:toolbox:UnsupportedSpecialEmpty", 0); } st.site = &ae_emlrtRSI; b_x = combine_vector_elements(&st, x); return b_x / (real_T)x->size[1]; }
void c_SystemCore_release(const emlrtStack *sp, c_comm_PSKCoarseFrequencyEstima * obj) { static const char_T cv5[7] = { 'r', 'e', 'l', 'e', 'a', 's', 'e' }; if (obj->isInitialized != 2) { } else { emlrtErrorWithMessageIdR2012b(sp, &e_emlrtRTEI, "MATLAB:system:methodCalledWhenReleasedCodegen", 3, 4, 7, cv5); } if (obj->isInitialized == 1) { obj->isInitialized = 2; /* System object Destructor function: dsp.FFT */ } }
/* Function Definitions */ void b_rdivide(const emlrtStack *sp, const real_T x_data[], const int32_T x_size[2], const real_T y_data[], const int32_T y_size[2], real_T z_data[], int32_T z_size[2]) { int8_T varargin_1[2]; int8_T varargin_2[2]; int32_T k; boolean_T p; boolean_T b_p; boolean_T exitg1; int32_T loop_ub; for (k = 0; k < 2; k++) { varargin_1[k] = (int8_T)x_size[k]; varargin_2[k] = (int8_T)y_size[k]; } p = false; b_p = true; k = 0; exitg1 = false; while ((!exitg1) && (k < 2)) { if (!(varargin_1[k] == varargin_2[k])) { b_p = false; exitg1 = true; } else { k++; } } if (!b_p) { } else { p = true; } if (p) { } else { emlrtErrorWithMessageIdR2012b(sp, &b_emlrtRTEI, "MATLAB:dimagree", 0); } z_size[0] = x_size[0]; z_size[1] = x_size[1]; loop_ub = x_size[0] * x_size[1]; for (k = 0; k < loop_ub; k++) { z_data[k] = x_data[k] / y_data[k]; } }
void indexShapeCheck(const emlrtStack *sp, int32_T matrixSize, const int32_T indexSize[2]) { boolean_T guard1 = false; boolean_T nonSingletonDimFound; emlrtStack st; st.prev = sp; st.tls = sp->tls; guard1 = false; if (!(matrixSize != 1)) { nonSingletonDimFound = false; if (indexSize[0] != 1) { nonSingletonDimFound = true; } if (indexSize[1] != 1) { if (nonSingletonDimFound) { nonSingletonDimFound = false; } else { nonSingletonDimFound = true; } } if (nonSingletonDimFound) { nonSingletonDimFound = true; } else { guard1 = true; } } else { guard1 = true; } if (guard1) { nonSingletonDimFound = false; } st.site = &n_emlrtRSI; if (!nonSingletonDimFound) { } else { emlrtErrorWithMessageIdR2012b(&st, &n_emlrtRTEI, "Coder:FE:PotentialVectorVector", 0); } }
void b_SystemCore_step(transceive202StackData *SD, const emlrtStack *sp, comm_SDRuReceiver *obj, creal_T varargout_1[1408], uint32_T *varargout_2) { static const char_T cv18[4] = { 's', 't', 'e', 'p' }; emlrtStack st; st.prev = sp; st.tls = sp->tls; if (obj->isInitialized != 2) { } else { emlrtErrorWithMessageIdR2012b(sp, &c_emlrtRTEI, "MATLAB:system:methodCalledWhenReleasedCodegen", 3, 4, 4, cv18); } if (obj->isInitialized != 1) { st.site = &k_emlrtRSI; SystemCore_setupAndReset(&st, obj); } st.site = &k_emlrtRSI; SDRuReceiver_stepImpl(SD, &st, obj, varargout_1, varargout_2); }
void power(const emlrtStack *sp, const emxArray_real_T *a, emxArray_real_T *y) { uint32_T uv0[3]; int32_T i2; int32_T k; emlrtStack st; emlrtStack b_st; emlrtStack c_st; st.prev = sp; st.tls = sp->tls; st.site = &ed_emlrtRSI; b_st.prev = &st; b_st.tls = st.tls; c_st.prev = &b_st; c_st.tls = b_st.tls; b_st.site = &fd_emlrtRSI; c_st.site = &gd_emlrtRSI; for (i2 = 0; i2 < 3; i2++) { uv0[i2] = (uint32_T)a->size[i2]; } i2 = y->size[0] * y->size[1] * y->size[2]; y->size[0] = (int32_T)uv0[0]; y->size[1] = (int32_T)uv0[1]; y->size[2] = (int32_T)uv0[2]; emxEnsureCapacity(&c_st, (emxArray__common *)y, i2, (int32_T)sizeof(real_T), &l_emlrtRTEI); if (dimagree(y, a)) { } else { emlrtErrorWithMessageIdR2012b(&c_st, &l_emlrtRTEI, "MATLAB:dimagree", 0); } i2 = (int32_T)uv0[0] * (int32_T)uv0[1] * (int32_T)uv0[2]; for (k = 0; k < i2; k++) { y->data[k] = a->data[k] * a->data[k]; } }
/* Function Definitions */ void b_eml_error(const emlrtStack *sp) { emlrtErrorWithMessageIdR2012b(sp, &ec_emlrtRTEI, "Coder:toolbox:reshape_emptyReshapeLimit", 0); }
void error(const emlrtStack *sp) { emlrtErrorWithMessageIdR2012b(sp, &o_emlrtRTEI, "Coder:toolbox:ElFunDomainError", 3, 4, 4, "sqrt"); }
/* Function Definitions */ void b_error(const emlrtStack *sp) { emlrtErrorWithMessageIdR2012b(sp, &o_emlrtRTEI, "Coder:toolbox:power_domainError", 0); }
/* Function Definitions */ void check_forloop_overflow_error(const emlrtStack *sp) { emlrtErrorWithMessageIdR2012b(sp, &m_emlrtRTEI, "Coder:toolbox:int_forloop_overflow", 3, 4, 5, "int32"); }
/* Function Definitions */ void generateOFDMSignal(const emlrtStack *sp, OFDMDemodulator_1 *iobj_0, OFDMDemodulator_1 *iobj_1, OFDMDemodulator_1 **hPreambleDemod, OFDMDemodulator_1 **hDataDemod, creal_T r[25600], d_struct_T *tx) { OFDMModulator_1 hDataMod; OFDMModulator hPreambleMod; creal_T shortPreambleOFDM[64]; int32_T i; creal_T completeShortPreambleOFDM[160]; creal_T longPreambleOFDM[64]; creal_T completeLongPreambleOFDM[160]; real_T originalData[560]; real_T x[560]; int32_T ib; real_T b_originalData[560]; commcodegen_CRCGenerator_6 hGen; real_T dataWithCRC[563]; commcodegen_BPSKModulator_1 hMod; creal_T modData[563]; real_T varargin_1[13]; int32_T k; commcodegen_BPSKModulator_1 *obj; const mxArray *y; static const int32_T iv54[2] = { 1, 45 }; const mxArray *m10; char_T cv58[45]; static const char_T cv59[45] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y', 's', 't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l', 'e', 'd', 'W', 'h', 'e', 'n', 'R', 'e', 'l', 'e', 'a', 's', 'e', 'd', 'C', 'o', 'd', 'e', 'g', 'e', 'n' }; const mxArray *b_y; static const int32_T iv55[2] = { 1, 4 }; char_T cv60[4]; static const char_T cv61[4] = { 's', 't', 'e', 'p' }; const mxArray *c_y; static const int32_T iv56[2] = { 1, 51 }; char_T cv62[51]; static const char_T cv63[51] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y', 's', 't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l', 'e', 'd', 'W', 'h', 'e', 'n', 'L', 'o', 'c', 'k', 'e', 'd', 'R', 'e', 'l', 'e', 'a', 's', 'e', 'd', 'C', 'o', 'd', 'e', 'g', 'e', 'n' }; const mxArray *d_y; static const int32_T iv57[2] = { 1, 5 }; char_T cv64[5]; static const char_T cv65[5] = { 's', 'e', 't', 'u', 'p' }; static const int8_T value[8] = { 13, 1, 1, 1, 1, 1, 1, 1 }; boolean_T anyInputSizeChanged; boolean_T exitg2; static const int8_T iv58[8] = { 13, 1, 1, 1, 1, 1, 1, 1 }; creal_T varargout_1[13]; creal_T b_modData[576]; creal_T ofdmData[576]; comm_PNSequence_5 hPN; comm_PNSequence_5 *b_obj; static const int8_T iv59[8] = { 1, 0, 0, 0, 1, 0, 0, 1 }; static const int8_T iv60[7] = { 0, 0, 0, 0, 0, 0, 1 }; int8_T pilot[12]; uint8_T tmp; uint8_T tmp2; int8_T pilots[48]; int32_T ia; real_T b_pilots[48]; creal_T b_r[960]; creal_T preambles[320]; creal_T c_r[1280]; OFDMDemodulator_1 *object; int8_T b_data[4]; int32_T exitg1; int32_T exponent; boolean_T b2; int32_T i12; const mxArray *e_y; static const int32_T iv61[2] = { 1, 13 }; char_T cv66[13]; static const char_T cv67[13] = { 'c', 'o', 'm', 'm', ':', 'O', 'F', 'D', 'M', ':', 'x', 'x', 'x' }; static const creal_T dcv3[53] = { { 0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { -1.0, -1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { -1.0, -1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { -1.0, -1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { -1.0, -1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { - 1.0, -1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 } }; static const int8_T iv62[53] = { 1, 1, -1, -1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 0, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, -1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1 }; static const int8_T iv63[48] = { 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 49, 50, 51, 52, 53 }; emlrtStack st; emlrtStack b_st; emlrtStack c_st; emlrtStack d_st; emlrtStack e_st; emlrtStack f_st; emlrtStack g_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; d_st.prev = &c_st; d_st.tls = c_st.tls; e_st.prev = &d_st; e_st.tls = d_st.tls; f_st.prev = &e_st; f_st.tls = e_st.tls; g_st.prev = &f_st; g_st.tls = f_st.tls; emlrtHeapReferenceStackEnterFcnR2012b(sp); emxInitStruct_OFDMModulator_1(sp, &hDataMod, &s_emlrtRTEI, TRUE); emxInitStruct_OFDMModulator(sp, &hPreambleMod, &t_emlrtRTEI, TRUE); /* generateOFDMSignal: Generate OFDM signal based on the 802.11a standard. */ /* This function returns the time domain signal and a structure containing */ /* details about the signal itself. This information is required by the */ /* receiver to operate correctly. */ /* % System Parameters */ /* OFDM modulator FFT size */ /* Enable moving averages for estimates */ /* 1e3 */ /* Message to transmit */ /* String holder */ /* coder.varsize('payloadMessage', [1, 80], [0 1]); */ /* payloadMessage = ''; */ /* % Create Short Preamble */ /* % [-27:-17] */ /* % [-16:-1] */ /* % [0:15] */ /* [16:27] */ /* % Create modulator */ /* hPreambleMod = OFDMModulator(... */ /* 'NumGuardBandCarriers', [6; 5],... */ /* 'CyclicPrefixLength', 0,... */ /* 'FFTLength' , FFTLength,... */ /* 'NumSymbols', 1); */ /* Create modulator */ st.site = &lk_emlrtRSI; OFDMModulator_OFDMModulator(&hPreambleMod); /* Modulate and scale */ st.site = &mk_emlrtRSI; SystemCore_step(&st, &hPreambleMod, shortPreambleOFDM); st.site = &mk_emlrtRSI; for (i = 0; i < 64; i++) { shortPreambleOFDM[i].re *= 1.4719601443879744; shortPreambleOFDM[i].im *= 1.4719601443879744; } /* Form 10 Short Preambles */ memcpy(&completeShortPreambleOFDM[0], &shortPreambleOFDM[0], sizeof(creal_T) << 6); memcpy(&completeShortPreambleOFDM[64], &shortPreambleOFDM[0], sizeof(creal_T) << 6); memcpy(&completeShortPreambleOFDM[128], &shortPreambleOFDM[0], sizeof(creal_T) << 5); /* % Create Long Preamble */ /* Modulate */ st.site = &nk_emlrtRSI; b_SystemCore_step(&st, &hPreambleMod, longPreambleOFDM); /* Form 2 Long Preambles */ memcpy(&completeLongPreambleOFDM[0], &longPreambleOFDM[32], sizeof(creal_T) << 5); memcpy(&completeLongPreambleOFDM[32], &longPreambleOFDM[0], sizeof(creal_T) << 6); memcpy(&completeLongPreambleOFDM[96], &longPreambleOFDM[0], sizeof(creal_T) << 6); /* % Generate Data */ /* Use string as message */ st.site = &ok_emlrtRSI; b_OFDMletters2bits(&st, originalData); st.site = &pk_emlrtRSI; for (i = 0; i < 80; i++) { for (ib = 0; ib < 7; ib++) { x[ib + 7 * i] = originalData[i + 80 * ib]; } } memcpy(&b_originalData[0], &x[0], 560U * sizeof(real_T)); /* Generate CRC */ st.site = &qk_emlrtRSI; b_CRCGenerator_CRCGenerator(&hGen); st.site = &rk_emlrtRSI; e_SystemCore_step(&st, &hGen, b_originalData, dataWithCRC); /* Add CRC */ /* Construct modulator for each subcarrier */ st.site = &sk_emlrtRSI; BPSKModulator_BPSKModulator(&hMod); /* BPSK */ /* Apply modulator for each subcarrier */ st.site = &tk_emlrtRSI; f_SystemCore_step(&st, &hMod, dataWithCRC, modData); /* Pad IFFT */ st.site = &uk_emlrtRSI; b_st.site = &u_emlrtRSI; emlrtRandu(varargin_1, 13); for (k = 0; k < 13; k++) { b_st.site = &v_emlrtRSI; b_st.site = &v_emlrtRSI; c_st.site = &p_emlrtRSI; varargin_1[k] = muDoubleScalarFloor(varargin_1[k] * 2.0); } st.site = &uk_emlrtRSI; obj = &hMod; if (!obj->isReleased) { } else { y = NULL; m10 = mxCreateCharArray(2, iv54); for (i = 0; i < 45; i++) { cv58[i] = cv59[i]; } emlrtInitCharArrayR2013a(&st, 45, m10, cv58); emlrtAssign(&y, m10); b_y = NULL; m10 = mxCreateCharArray(2, iv55); for (i = 0; i < 4; i++) { cv60[i] = cv61[i]; } emlrtInitCharArrayR2013a(&st, 4, m10, cv60); emlrtAssign(&b_y, m10); b_st.site = &cb_emlrtRSI; c_error(&b_st, message(&b_st, y, b_y, &emlrtMCI), &emlrtMCI); } if (!obj->isInitialized) { b_st.site = &cb_emlrtRSI; if (!obj->isInitialized) { } else { c_y = NULL; m10 = mxCreateCharArray(2, iv56); for (i = 0; i < 51; i++) { cv62[i] = cv63[i]; } emlrtInitCharArrayR2013a(&b_st, 51, m10, cv62); emlrtAssign(&c_y, m10); d_y = NULL; m10 = mxCreateCharArray(2, iv57); for (i = 0; i < 5; i++) { cv64[i] = cv65[i]; } emlrtInitCharArrayR2013a(&b_st, 5, m10, cv64); emlrtAssign(&d_y, m10); c_st.site = &cb_emlrtRSI; c_error(&c_st, message(&c_st, c_y, d_y, &emlrtMCI), &emlrtMCI); } c_st.site = &cb_emlrtRSI; obj->isInitialized = TRUE; d_st.site = &db_emlrtRSI; c_st.site = &cb_emlrtRSI; d_st.site = &cb_emlrtRSI; e_st.site = &db_emlrtRSI; d_st.site = &cb_emlrtRSI; e_st.site = &db_emlrtRSI; c_st.site = &cb_emlrtRSI; d_st.site = &cb_emlrtRSI; d_st.site = &cb_emlrtRSI; d_st.site = &cb_emlrtRSI; e_st.site = &db_emlrtRSI; c_st.site = &cb_emlrtRSI; d_st.site = &cb_emlrtRSI; for (i = 0; i < 8; i++) { obj->inputVarSize1[i] = (uint32_T)value[i]; } e_st.site = &db_emlrtRSI; c_st.site = &cb_emlrtRSI; d_st.site = &cb_emlrtRSI; c_st.site = &cb_emlrtRSI; d_st.site = &cb_emlrtRSI; e_st.site = &cb_emlrtRSI; e_st.site = &cb_emlrtRSI; f_st.site = &gg_emlrtRSI; c_st.site = &cb_emlrtRSI; d_st.site = &cb_emlrtRSI; d_st.site = &cb_emlrtRSI; e_st.site = &gg_emlrtRSI; c_st.site = &cb_emlrtRSI; c_st.site = &cb_emlrtRSI; c_st.site = &cb_emlrtRSI; c_st.site = &cb_emlrtRSI; d_st.site = &gg_emlrtRSI; d_st.site = &gg_emlrtRSI; e_st.site = &db_emlrtRSI; c_st.site = &cb_emlrtRSI; d_st.site = &gg_emlrtRSI; e_st.site = NULL; } b_st.site = &cb_emlrtRSI; b_st.site = &cb_emlrtRSI; b_st.site = &cb_emlrtRSI; c_st.site = &cb_emlrtRSI; c_st.site = &cb_emlrtRSI; d_st.site = &gg_emlrtRSI; b_st.site = &cb_emlrtRSI; b_st.site = &cb_emlrtRSI; anyInputSizeChanged = FALSE; k = 0; exitg2 = FALSE; while ((exitg2 == FALSE) && (k < 8)) { if (obj->inputVarSize1[k] != (uint32_T)iv58[k]) { anyInputSizeChanged = TRUE; c_st.site = &cb_emlrtRSI; for (i = 0; i < 8; i++) { obj->inputVarSize1[i] = (uint32_T)value[i]; } d_st.site = &db_emlrtRSI; exitg2 = TRUE; } else { k++; } } if (anyInputSizeChanged) { b_st.site = &cb_emlrtRSI; b_st.site = &cb_emlrtRSI; } b_st.site = &cb_emlrtRSI; c_st.site = &cb_emlrtRSI; c_st.site = &cb_emlrtRSI; d_st.site = &gg_emlrtRSI; b_st.site = &cb_emlrtRSI; b_st.site = &cb_emlrtRSI; b_st.site = &cb_emlrtRSI; d_Nondirect_stepImpl(obj, varargin_1, varargout_1); memcpy(&b_modData[0], &modData[0], 563U * sizeof(creal_T)); memcpy(&b_modData[563], &varargout_1[0], 13U * sizeof(creal_T)); /* Calculate required data sizes for correct receiver operation */ /* Save desired message size */ /* Save number of transmitted frames */ /* Convert data into subcarrier streams */ st.site = &vk_emlrtRSI; memcpy(&ofdmData[0], &b_modData[0], 576U * sizeof(creal_T)); /* Create Pilots */ st.site = &wk_emlrtRSI; b_obj = &hPN; /* System object Constructor function: comm.PNSequence */ b_obj->S0_isInitialized = FALSE; b_obj->S1_isReleased = FALSE; for (i = 0; i < 8; i++) { b_obj->P0_Polynomial[i] = (uint8_T)iv59[i]; } for (i = 0; i < 7; i++) { b_obj->P1_IniState[i] = 1; b_obj->P2_Mask[i] = (uint8_T)iv60[i]; } st.site = &xk_emlrtRSI; b_obj = &hPN; if (!b_obj->S0_isInitialized) { b_obj->S0_isInitialized = TRUE; if (b_obj->S1_isReleased) { emlrtErrorWithMessageIdR2012b(&st, &bc_emlrtRTEI, "MATLAB:system:runtimeMethodCalledWhenReleasedCodegen", 0); } b_st.site = NULL; b_st.site = NULL; /* System object Initialization function: comm.PNSequence */ for (ib = 0; ib < 7; ib++) { b_obj->W0_shiftReg[ib] = b_obj->P1_IniState[ib]; emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, &b_st); } } b_st.site = NULL; /* System object Outputs function: comm.PNSequence */ for (ib = 0; ib < 12; ib++) { tmp = 0; for (i = 0; i < 7; i++) { tmp = (uint8_T)((uint32_T)tmp + (uint8_T)((uint32_T)b_obj->P0_Polynomial[i + 1] * b_obj->W0_shiftReg[i])); } tmp &= 1; tmp2 = 0; for (i = 0; i < 7; i++) { tmp2 = (uint8_T)((uint32_T)tmp2 + (uint8_T)((uint32_T)b_obj->W0_shiftReg[i] * b_obj->P2_Mask[i])); } pilot[ib] = (int8_T)(tmp2 & 1); for (i = 5; i > -1; i += -1) { b_obj->W0_shiftReg[i + 1] = b_obj->W0_shiftReg[i]; } b_obj->W0_shiftReg[0U] = tmp; } /* Create pilot */ st.site = &yk_emlrtRSI; ib = 0; for (i = 0; i < 4; i++) { ia = 0; for (k = 0; k < 12; k++) { pilots[ib] = pilot[ia]; b_st.site = &ng_emlrtRSI; ia++; b_st.site = &og_emlrtRSI; ib++; } } /* Expand to all pilot tones */ st.site = &al_emlrtRSI; for (i = 0; i < 12; i++) { for (ib = 0; ib < 4; ib++) { b_pilots[ib + (i << 2)] = 2.0 * (real_T)(pilots[i + 12 * ib] < 1) - 1.0; } } /* Bipolar to unipolar */ st.site = &bl_emlrtRSI; for (i = 0; i < 12; i++) { b_pilots[3 + (i << 2)] = -b_pilots[3 + (i << 2)]; } /* Invert last pilot */ /* Construct Modulator */ st.site = &cl_emlrtRSI; b_OFDMModulator_OFDMModulator(&st, &hDataMod); /* Modulate */ st.site = &dl_emlrtRSI; d_SystemCore_step(&st, &hDataMod, ofdmData, b_pilots, b_r); /* Add preambles to data */ memcpy(&preambles[0], &completeShortPreambleOFDM[0], 160U * sizeof(creal_T)); memcpy(&preambles[160], &completeLongPreambleOFDM[0], 160U * sizeof(creal_T)); memcpy(&c_r[0], &preambles[0], 320U * sizeof(creal_T)); memcpy(&c_r[320], &b_r[0], 960U * sizeof(creal_T)); /* Repeat frame */ st.site = &el_emlrtRSI; ib = 0; for (i = 0; i < 20; i++) { ia = 0; for (k = 0; k < 1280; k++) { r[ib] = c_r[ia]; b_st.site = &ng_emlrtRSI; ia++; b_st.site = &og_emlrtRSI; ib++; } } /* Save Demodulator object data for receiver */ /* hDataDemod = get(OFDMDemodulator(hDataMod)); */ /* hPreambleDemod = get(OFDMDemodulator(hPreambleMod)); */ st.site = &fl_emlrtRSI; object = iobj_0; *hDataDemod = object; b_st.site = &jj_emlrtRSI; object = *hDataDemod; c_st.site = &y_emlrtRSI; d_st.site = &bb_emlrtRSI; d_st.site = &bb_emlrtRSI; object->isInitialized = FALSE; object->isReleased = FALSE; e_st.site = &cb_emlrtRSI; f_st.site = &db_emlrtRSI; e_st.site = &cb_emlrtRSI; f_st.site = &db_emlrtRSI; c_st.site = &y_emlrtRSI; c_st.site = &ab_emlrtRSI; b_st.site = &kj_emlrtRSI; c_st.site = &db_emlrtRSI; c_st.site = &db_emlrtRSI; b_st.site = &lj_emlrtRSI; c_st.site = &db_emlrtRSI; c_st.site = &db_emlrtRSI; b_st.site = &mj_emlrtRSI; c_st.site = &db_emlrtRSI; c_st.site = &db_emlrtRSI; b_st.site = &nj_emlrtRSI; c_st.site = &db_emlrtRSI; b_st.site = &oj_emlrtRSI; c_st.site = &db_emlrtRSI; c_st.site = &db_emlrtRSI; b_st.site = &pj_emlrtRSI; c_st.site = &db_emlrtRSI; b_st.site = &qj_emlrtRSI; c_st.site = &db_emlrtRSI; /* OFDMBase Base object for OFDMModulator and OFDMDemodulator System objects */ /* Copyright 2013 The MathWorks, Inc. */ /* FFTLength FFT length */ /* Specify the IFFT length. This property can be set to an integer */ /* scalar. The value must be a power of two. The default value of */ /* this property is 64. */ /* CyclicPrefixLength Cyclic prefix length */ /* Specify the cyclic prefix length. This property can be set to a */ /* non-negative interher scalar. The default value of this property is 16. */ /* NumGuardBandCarriers Number of guard bands */ /* Specify the lower and upper guard bands in frequency domain.This */ /* property can be set to a non-nagative two-element vector. */ /* The default setting of this property is [6 5]. */ /* NumSymbols Number of OFDM symbols */ /* Specify the number of OFDM symbols at the output. The default value */ /* of this property is 1. */ /* PilotCarrierIndices Pilot subcarrier indices */ /* Specify the locations where pilots are to be inserted. You can */ /* set this property to a numeric scalar, column vector, matrix, or */ /* 3-D array. The defalut value of the property is [-21; -7; 7; 21]. */ /* Nontunable ideally */ /* Constructor */ /* validateattributes(fftLen, {'numeric'}, ... */ /* {'real','scalar','integer','finite','>=',8}, ... */ /* [class(obj) '.' propName], propName); */ /* validateattributes(CPLen, {'numeric'}, ... */ /* {'real','row','integer','nonnegative','finite'}, ... */ /* [class(obj) '.' propName], propName); */ /* validateattributes(guardBands, {'numeric'}, ... */ /* {'real','integer','nonnegative','finite','size', [2, 1]}, ... */ /* [class(obj) '.' propName], propName); */ /* validateattributes(numSym, {'numeric'}, ... */ /* {'real','scalar','integer','positive','finite'}, ... */ /* [class(obj) '.' propName], propName); */ /* validateattributes(pilotIdx, {'numeric'}, ... */ /* {'real','integer','positive','finite','3d'}, ... */ /* [class(obj) '.' propName], propName); */ /* Check the 3rd dimension for numTx */ d_st.site = &uh_emlrtRSI; e_st.site = &vh_emlrtRSI; for (k = 0; k < 4; k++) { b_data[k] = (int8_T)(12 + 14 * k); } f_st.site = &mi_emlrtRSI; i = 0; f_st.site = &ki_emlrtRSI; f_st.site = &ji_emlrtRSI; k = 1; while (k <= 4) { ib = b_data[k - 1]; do { exitg1 = 0; f_st.site = &ii_emlrtRSI; k++; if (k > 4) { exitg1 = 1; } else { f_st.site = &hi_emlrtRSI; frexp((real_T)ib / 2.0, &exponent); if (muDoubleScalarAbs(ib - b_data[k - 1]) < ldexp(1.0, exponent - 53)) { anyInputSizeChanged = TRUE; } else { anyInputSizeChanged = FALSE; } if (!anyInputSizeChanged) { exitg1 = 1; } } } while (exitg1 == 0); f_st.site = &gi_emlrtRSI; i++; b_data[i - 1] = (int8_T)ib; f_st.site = &fi_emlrtRSI; f_st.site = &fi_emlrtRSI; } f_st.site = &bi_emlrtRSI; f_st.site = &ai_emlrtRSI; f_st.site = &wh_emlrtRSI; if (1 > i) { b2 = FALSE; } else { b2 = (i > 2147483646); } if (b2) { g_st.site = &bg_emlrtRSI; check_forloop_overflow_error(&g_st); } d_st.site = &uh_emlrtRSI; d_st.site = &uh_emlrtRSI; if (1 > i) { i12 = 0; } else { i12 = i; } if (!(4 != i12)) { } else { e_y = NULL; m10 = mxCreateCharArray(2, iv61); for (i = 0; i < 13; i++) { cv66[i] = cv67[i]; } emlrtInitCharArrayR2013a(&d_st, 13, m10, cv66); emlrtAssign(&e_y, m10); e_st.site = &mv_emlrtRSI; c_error(&e_st, b_message(&e_st, e_y, &g_emlrtMCI), &g_emlrtMCI); } /* Error message: */ /* If pilot index is 2-D, the indices per symbol must be unique; */ /* If pilot index is 3-D, the indices across transmit antennas per symbol must be unique. */ c_st.site = &db_emlrtRSI; st.site = &gl_emlrtRSI; object = iobj_1; *hPreambleDemod = object; b_st.site = &jj_emlrtRSI; object = *hPreambleDemod; c_st.site = &y_emlrtRSI; d_st.site = &bb_emlrtRSI; d_st.site = &bb_emlrtRSI; object->isInitialized = FALSE; object->isReleased = FALSE; e_st.site = &cb_emlrtRSI; f_st.site = &db_emlrtRSI; e_st.site = &cb_emlrtRSI; f_st.site = &db_emlrtRSI; c_st.site = &y_emlrtRSI; c_st.site = &ab_emlrtRSI; b_st.site = &kj_emlrtRSI; c_st.site = &db_emlrtRSI; c_st.site = &db_emlrtRSI; b_st.site = &lj_emlrtRSI; c_st.site = &db_emlrtRSI; c_st.site = &db_emlrtRSI; b_st.site = &mj_emlrtRSI; c_st.site = &db_emlrtRSI; c_st.site = &db_emlrtRSI; b_st.site = &nj_emlrtRSI; c_st.site = &db_emlrtRSI; b_st.site = &oj_emlrtRSI; c_st.site = &db_emlrtRSI; c_st.site = &db_emlrtRSI; b_st.site = &pj_emlrtRSI; c_st.site = &db_emlrtRSI; /* Calcuate OFDM frequency bin size */ /* Calculate locations of pilots without guardbands */ /* Calculate locations of subcarrier datastreams without guardbands */ /* Remove guardband offsets */ /* Remove index offsets for pilots and guardbands */ /* dataSubcarrierIndexies([pilotLocationsWithoutGuardbands;DCNullLocation]) = [];%Remove pilot and DCNull locations */ /* Create return structure */ for (i = 0; i < 560; i++) { tx->originalData[i] = b_originalData[i]; } for (i = 0; i < 64; i++) { tx->shortPreambleOFDM[i] = shortPreambleOFDM[i]; } for (i = 0; i < 160; i++) { tx->completeShortPreambleOFDM[i] = completeShortPreambleOFDM[i]; } for (i = 0; i < 53; i++) { tx->shortPreamble[i] = dcv3[i]; } for (i = 0; i < 53; i++) { tx->longPreamble[i] = iv62[i]; } for (i = 0; i < 64; i++) { tx->longPreambleOFDM[i] = longPreambleOFDM[i]; } for (i = 0; i < 160; i++) { tx->completeLongPreambleOFDM[i] = completeLongPreambleOFDM[i]; } for (i = 0; i < 48; i++) { tx->pilots[i] = b_pilots[i]; } for (i = 0; i < 320; i++) { tx->preambles[i] = preambles[i]; } for (i = 0; i < 4; i++) { tx->pilotLocationsWithoutGuardbands[i] = 6.0 + 14.0 * (real_T)i; } tx->dataSubcarrierIndexies.size[0] = 1; tx->dataSubcarrierIndexies.size[1] = 48; for (i = 0; i < 48; i++) { tx->dataSubcarrierIndexies.data[i] = iv63[i]; } tx->samplingFreq = 5.0E+6; tx->FFTLength = 64.0; tx->enableMA = TRUE; tx->numCarriers = 48.0; tx->padBits = 13.0; tx->numSamples = 576.0; tx->messageCharacters = 80.0; tx->numFrames = 20.0; tx->frameLength = 1280.0; tx->freqBin = 78125.0; tx->DecimationFactor = 0.0; tx->receiveBufferLength = 0.0; /* padBits: 13 */ /* numSamples: 576 */ /* messageCharacters: 80 */ /* numFrames: 1000 */ /* frameLength: 1280 */ /* freqBin: 312500 */ /* hDataDemod: [1x1 struct] */ /* hPreambleDemod: [1x1 struct] */ st.site = NULL; b_Destructor(&hPN); emxFreeStruct_OFDMModulator(&hPreambleMod); emxFreeStruct_OFDMModulator_1(&hDataMod); emlrtHeapReferenceStackLeaveFcnR2012b(sp); }
/* Function Definitions */ void compmat(const emlrtStack *sp, const emxArray_uint8_T *x, real_T dims, emxArray_real_T *y) { int32_T i1; real_T d3; int32_T ii; int32_T i; emxArray_boolean_T *b_x; emxArray_int32_T *b_ii; int32_T nx; int32_T idx; boolean_T overflow; boolean_T exitg1; boolean_T guard1 = false; emlrtStack st; emlrtStack b_st; emlrtStack c_st; emlrtStack d_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; d_st.prev = &c_st; d_st.tls = c_st.tls; emlrtHeapReferenceStackEnterFcnR2012b(sp); /* UNTITLED Summary of this function goes here */ /* Detailed explanation goes here */ i1 = y->size[0] * y->size[1]; y->size[0] = 1; if (!(dims >= 0.0)) { emlrtNonNegativeCheckR2012b(dims, (emlrtDCInfo *)&j_emlrtDCI, sp); } d3 = dims; if (d3 != (int32_T)muDoubleScalarFloor(d3)) { emlrtIntegerCheckR2012b(d3, (emlrtDCInfo *)&i_emlrtDCI, sp); } y->size[1] = (int32_T)d3; emxEnsureCapacity(sp, (emxArray__common *)y, i1, (int32_T)sizeof(real_T), &f_emlrtRTEI); if (!(dims >= 0.0)) { emlrtNonNegativeCheckR2012b(dims, (emlrtDCInfo *)&j_emlrtDCI, sp); } if (d3 != (int32_T)muDoubleScalarFloor(d3)) { emlrtIntegerCheckR2012b(d3, (emlrtDCInfo *)&i_emlrtDCI, sp); } ii = (int32_T)d3; for (i1 = 0; i1 < ii; i1++) { y->data[i1] = 0.0; } emlrtForLoopVectorCheckR2012b(1.0, 1.0, dims, mxDOUBLE_CLASS, (int32_T)dims, (emlrtRTEInfo *)&n_emlrtRTEI, sp); i = 0; emxInit_boolean_T(sp, &b_x, 2, &f_emlrtRTEI, true); emxInit_int32_T(sp, &b_ii, 2, &g_emlrtRTEI, true); while (i <= (int32_T)dims - 1) { st.site = &k_emlrtRSI; i1 = b_x->size[0] * b_x->size[1]; b_x->size[0] = 1; b_x->size[1] = x->size[1]; emxEnsureCapacity(&st, (emxArray__common *)b_x, i1, (int32_T)sizeof (boolean_T), &f_emlrtRTEI); ii = x->size[0] * x->size[1]; for (i1 = 0; i1 < ii; i1++) { b_x->data[i1] = (x->data[i1] == 1.0 + (real_T)i); } b_st.site = &h_emlrtRSI; nx = b_x->size[1]; idx = 0; i1 = b_ii->size[0] * b_ii->size[1]; b_ii->size[0] = 1; b_ii->size[1] = b_x->size[1]; emxEnsureCapacity(&b_st, (emxArray__common *)b_ii, i1, (int32_T)sizeof (int32_T), &f_emlrtRTEI); c_st.site = &i_emlrtRSI; overflow = ((!(1 > b_x->size[1])) && (b_x->size[1] > 2147483646)); if (overflow) { d_st.site = &j_emlrtRSI; check_forloop_overflow_error(&d_st); } ii = 1; exitg1 = false; while ((!exitg1) && (ii <= nx)) { guard1 = false; if (b_x->data[ii - 1]) { idx++; b_ii->data[idx - 1] = ii; if (idx >= nx) { exitg1 = true; } else { guard1 = true; } } else { guard1 = true; } if (guard1) { ii++; } } if (idx <= b_x->size[1]) { } else { emlrtErrorWithMessageIdR2012b(&b_st, &k_emlrtRTEI, "Coder:builtins:AssertionFailed", 0); } if (b_x->size[1] == 1) { if (idx == 0) { i1 = b_ii->size[0] * b_ii->size[1]; b_ii->size[0] = 1; b_ii->size[1] = 0; emxEnsureCapacity(&b_st, (emxArray__common *)b_ii, i1, (int32_T)sizeof (int32_T), &f_emlrtRTEI); } } else { i1 = b_ii->size[0] * b_ii->size[1]; if (1 > idx) { b_ii->size[1] = 0; } else { b_ii->size[1] = idx; } emxEnsureCapacity(&b_st, (emxArray__common *)b_ii, i1, (int32_T)sizeof (int32_T), &b_emlrtRTEI); } i1 = y->size[1]; if (!((i + 1 >= 1) && (i + 1 <= i1))) { emlrtDynamicBoundsCheckR2012b(i + 1, 1, i1, (emlrtBCInfo *)&w_emlrtBCI, sp); } y->data[i] = b_ii->size[1]; i++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } emxFree_int32_T(&b_ii); emxFree_boolean_T(&b_x); emlrtHeapReferenceStackLeaveFcnR2012b(sp); }
void SystemCore_step(const emlrtStack *sp, comm_SDRuTransmitter *obj, const creal_T varargin_1[1408]) { static const char_T cv11[4] = { 's', 't', 'e', 'p' }; comm_SDRuTransmitter *b_obj; static const char_T cv12[5] = { 's', 'e', 't', 'u', 'p' }; int32_T k; static const int16_T inputSize[8] = { 1408, 1, 1, 1, 1, 1, 1, 1 }; int32_T errMsg_size[2]; char_T errMsg_data[1024]; UsrpErrorCapiEnumT deviceStatus; int32_T errStr_size[2]; char_T errStr_data[1024]; UsrpErrorCapiEnumT errStat; boolean_T exitg1; static const int16_T iv8[8] = { 1408, 1, 1, 1, 1, 1, 1, 1 }; emlrtStack st; emlrtStack b_st; emlrtStack c_st; emlrtStack d_st; emlrtStack e_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; d_st.prev = &c_st; d_st.tls = c_st.tls; e_st.prev = &d_st; e_st.tls = d_st.tls; if (obj->isInitialized != 2) { } else { emlrtErrorWithMessageIdR2012b(sp, &c_emlrtRTEI, "MATLAB:system:methodCalledWhenReleasedCodegen", 3, 4, 4, cv11); } if (obj->isInitialized != 1) { st.site = &k_emlrtRSI; b_obj = obj; b_st.site = &k_emlrtRSI; if (b_obj->isInitialized == 0) { } else { emlrtErrorWithMessageIdR2012b(&b_st, &c_emlrtRTEI, "MATLAB:system:methodCalledWhenLockedReleasedCodegen", 3, 4, 5, cv12); } b_obj->isInitialized = 1; c_st.site = &k_emlrtRSI; for (k = 0; k < 8; k++) { b_obj->inputVarSize1[k] = (uint32_T)inputSize[k]; } c_st.site = &k_emlrtRSI; d_st.site = &h_emlrtRSI; SDRuTransmitter_setupImplLocal(&d_st, b_obj, &deviceStatus, errMsg_data, errMsg_size); if (deviceStatus == UsrpDriverSuccess) { b_obj->pConnected = true; } else { d_st.site = &h_emlrtRSI; k = b_obj->pDriverHandle; /* Copyright 2011-2012 The MathWorks, Inc. */ e_st.site = &w_emlrtRSI; b_mapiPrivate(&e_st, k, &errStat, errStr_data, errStr_size); b_obj->pConnected = false; } d_st.site = &h_emlrtRSI; reportSDRuStatus(&d_st, deviceStatus, errMsg_data, errMsg_size); } st.site = &k_emlrtRSI; b_obj = obj; k = 0; exitg1 = false; while ((!exitg1) && (k < 8)) { if (b_obj->inputVarSize1[k] != (uint32_T)iv8[k]) { for (k = 0; k < 8; k++) { b_obj->inputVarSize1[k] = (uint32_T)inputSize[k]; } exitg1 = true; } else { k++; } } st.site = &k_emlrtRSI; SDRuTransmitter_stepImpl(&st, obj, varargin_1); }
/* Function Definitions */ void sendComplexDoubleData(const emlrtStack *sp, int32_T driverApiH, const creal_T data[1408], const real_T freq[2], const real_T loOffset[2], const real_T gain[2], real_T interp, uint32_T *underflow, UsrpErrorCapiEnumT *errStat, char_T errStr_data[], int32_T errStr_size[2]) { int32_T i15; static const char_T cv17[6] = { 's', 'i', 'l', 'e', 'n', 't' }; char_T u[6]; const mxArray *y; static const int32_T iv11[2] = { 1, 6 }; const mxArray *m4; UsrpErrorCapiEnumT errStat_i; creal_T b_data[1408]; real_T b_freq[2]; real_T b_loOffset[2]; real_T b_gain[2]; int32_T errStrSize; emlrtStack st; emlrtStack b_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; /* bug: must pass as top-level arg */ /* dportDtype = DataPortDataTypeCapiEnumT.DPortDTypeCDouble; */ /* Copyright 2011-2012 The MathWorks, Inc. */ st.site = &ab_emlrtRSI; /* */ /* This function unifies handling of interp vs. codegen call as well as */ /* errStat / errStr assignment. */ /* */ /* Copyright 2011-2015 The MathWorks, Inc. */ if (!isSetupsdruCalled) { for (i15 = 0; i15 < 6; i15++) { u[i15] = cv17[i15]; } y = NULL; m4 = emlrtCreateCharArray(2, iv11); emlrtInitCharArrayR2013a(&st, 6, m4, &u[0]); emlrtAssign(&y, m4); b_st.site = &eb_emlrtRSI; setupsdru(&b_st, sdruroot(&b_st, &c_emlrtMCI), y, &d_emlrtMCI); isSetupsdruCalled = true; } /* These sizes must match those in C code. */ /* Arbitrary max imposed on ML/SL side */ /* function is being called in interpreted mode */ /* not being found: */ /* eml_allow_enum_inputs; */ /* errStat_i = int32(0); */ errStr_size[0] = 1; memset(&errStr_data[0], 0, sizeof(char_T) << 10); memcpy(&b_data[0], &data[0], 1408U * sizeof(creal_T)); for (i15 = 0; i15 < 2; i15++) { b_freq[i15] = freq[i15]; b_loOffset[i15] = loOffset[i15]; b_gain[i15] = gain[i15]; } sendData_c(driverApiH, b_data, b_freq, b_loOffset, b_gain, interp, underflow, &errStat_i, &errStr_data[0]); /* errStat = UsrpErrorCapiEnumT(errStat_i); */ errStrSize = strlen(&errStr_data[0]); if (errStrSize <= 1024) { } else { emlrtErrorWithMessageIdR2012b(&st, &d_emlrtRTEI, "Coder:builtins:AssertionFailed", 0); } if (1 > errStrSize) { errStr_size[1] = 0; } else { errStr_size[1] = errStrSize; } *errStat = errStat_i; }
void eml_error(const emlrtStack *sp) { emlrtErrorWithMessageIdR2012b(sp, &ec_emlrtRTEI, "Coder:toolbox:cat_UnsupportedVariableSizeEmpty", 0); }
/* Function Definitions */ void MechanicalPointForce(const emlrtStack *sp, const emxArray_real_T *particlePosition, const emxArray_real_T *pointSourcePosition, real_T forceDirection, real_T forceMagnitude, real_T cutoff, emxArray_real_T *force) { uint32_T sz[2]; int32_T ix; emxArray_real_T *forceTemp; int32_T loop_ub; emxArray_real_T *forceMag; int32_T vlen; int32_T sIdx; emxArray_real_T *forceDir; emxArray_real_T *distToSource; emxArray_int32_T *r0; emxArray_boolean_T *r1; emxArray_int32_T *r2; emxArray_real_T *x; emxArray_real_T *b_x; emxArray_real_T *r3; emxArray_real_T *r4; emxArray_real_T *b_pointSourcePosition; emxArray_real_T *b_forceDir; emxArray_real_T *c_forceDir; int32_T k; int32_T vstride; int32_T iy; int32_T ixstart; boolean_T overflow; real_T s; boolean_T b0; uint32_T varargin_2[2]; boolean_T p; boolean_T exitg1; int32_T iv0[1]; int32_T iv1[2]; int32_T b_force[2]; int32_T iv2[1]; int32_T b_iy; int32_T c_iy; int32_T b_forceTemp[2]; emlrtStack st; emlrtStack b_st; emlrtStack c_st; emlrtStack d_st; emlrtStack e_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; d_st.prev = &c_st; d_st.tls = c_st.tls; e_st.prev = &d_st; e_st.tls = d_st.tls; emlrtHeapReferenceStackEnterFcnR2012b(sp); /* apply mechanical (push or pull) force on particles */ /* mechanicalForce is a logical flag */ /* particlPosition is a N by 3 vector of particle position */ /* pointSourcePosition is the position of force sources */ /* forceDirection is either -1 for 'in' or 1 for 'out' */ /* forceMagnitude is a positive number between 0 and 1 */ /* cutoff is the maximal direction the force operates on particle relative */ /* to the pointSourcePosition */ /* the output is a vector of N by 3 of delta position to th */ for (ix = 0; ix < 2; ix++) { sz[ix] = (uint32_T)particlePosition->size[ix]; } emxInit_real_T(sp, &forceTemp, 2, &c_emlrtRTEI, true); ix = forceTemp->size[0] * forceTemp->size[1]; forceTemp->size[0] = (int32_T)sz[0]; emxEnsureCapacity(sp, (emxArray__common *)forceTemp, ix, (int32_T)sizeof (real_T), &emlrtRTEI); ix = forceTemp->size[0] * forceTemp->size[1]; forceTemp->size[1] = (int32_T)sz[1]; emxEnsureCapacity(sp, (emxArray__common *)forceTemp, ix, (int32_T)sizeof (real_T), &emlrtRTEI); loop_ub = (int32_T)sz[0] * (int32_T)sz[1]; for (ix = 0; ix < loop_ub; ix++) { forceTemp->data[ix] = 0.0; } for (ix = 0; ix < 2; ix++) { sz[ix] = (uint32_T)particlePosition->size[ix]; } ix = force->size[0] * force->size[1]; force->size[0] = (int32_T)sz[0]; emxEnsureCapacity(sp, (emxArray__common *)force, ix, (int32_T)sizeof(real_T), &emlrtRTEI); ix = force->size[0] * force->size[1]; force->size[1] = (int32_T)sz[1]; emxEnsureCapacity(sp, (emxArray__common *)force, ix, (int32_T)sizeof(real_T), &emlrtRTEI); loop_ub = (int32_T)sz[0] * (int32_T)sz[1]; for (ix = 0; ix < loop_ub; ix++) { force->data[ix] = 0.0; } emxInit_real_T(sp, &forceMag, 2, &d_emlrtRTEI, true); vlen = particlePosition->size[0]; ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof(real_T), &emlrtRTEI); vlen = particlePosition->size[0]; ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[1] = vlen; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof(real_T), &emlrtRTEI); loop_ub = particlePosition->size[0] * particlePosition->size[0]; for (ix = 0; ix < loop_ub; ix++) { forceMag->data[ix] = 0.0; } sIdx = 0; emxInit_real_T(sp, &forceDir, 2, &e_emlrtRTEI, true); b_emxInit_real_T(sp, &distToSource, 1, &f_emlrtRTEI, true); emxInit_int32_T(sp, &r0, 1, &emlrtRTEI, true); emxInit_boolean_T(sp, &r1, 2, &emlrtRTEI, true); emxInit_int32_T(sp, &r2, 1, &emlrtRTEI, true); emxInit_real_T(sp, &x, 2, &emlrtRTEI, true); b_emxInit_real_T(sp, &b_x, 1, &emlrtRTEI, true); b_emxInit_real_T(sp, &r3, 1, &emlrtRTEI, true); b_emxInit_real_T(sp, &r4, 1, &emlrtRTEI, true); emxInit_real_T(sp, &b_pointSourcePosition, 2, &emlrtRTEI, true); b_emxInit_real_T(sp, &b_forceDir, 1, &emlrtRTEI, true); emxInit_real_T(sp, &c_forceDir, 2, &emlrtRTEI, true); while (sIdx <= pointSourcePosition->size[0] - 1) { loop_ub = pointSourcePosition->size[1]; ix = pointSourcePosition->size[0]; if ((sIdx + 1 >= 1) && (sIdx + 1 < ix)) { vlen = sIdx + 1; } else { vlen = emlrtDynamicBoundsCheckR2012b(sIdx + 1, 1, ix, (emlrtBCInfo *) &e_emlrtBCI, sp); } ix = b_pointSourcePosition->size[0] * b_pointSourcePosition->size[1]; b_pointSourcePosition->size[0] = 1; b_pointSourcePosition->size[1] = loop_ub; emxEnsureCapacity(sp, (emxArray__common *)b_pointSourcePosition, ix, (int32_T)sizeof(real_T), &emlrtRTEI); for (ix = 0; ix < loop_ub; ix++) { b_pointSourcePosition->data[b_pointSourcePosition->size[0] * ix] = pointSourcePosition->data[(vlen + pointSourcePosition->size[0] * ix) - 1]; } st.site = &emlrtRSI; bsxfun(&st, particlePosition, b_pointSourcePosition, forceDir); /* Find the distance between the particles and the source */ st.site = &b_emlrtRSI; b_st.site = &h_emlrtRSI; c_st.site = &i_emlrtRSI; d_st.site = &j_emlrtRSI; for (ix = 0; ix < 2; ix++) { sz[ix] = (uint32_T)forceDir->size[ix]; } ix = x->size[0] * x->size[1]; x->size[0] = (int32_T)sz[0]; x->size[1] = (int32_T)sz[1]; emxEnsureCapacity(&d_st, (emxArray__common *)x, ix, (int32_T)sizeof(real_T), &b_emlrtRTEI); if (dimagree(x, forceDir)) { } else { emlrtErrorWithMessageIdR2012b(&d_st, &b_emlrtRTEI, "MATLAB:dimagree", 0); } ix = (int32_T)sz[0] * (int32_T)sz[1]; for (k = 0; k < ix; k++) { x->data[k] = forceDir->data[k] * forceDir->data[k]; } st.site = &b_emlrtRSI; b_st.site = &k_emlrtRSI; c_st.site = &l_emlrtRSI; for (ix = 0; ix < 2; ix++) { sz[ix] = (uint32_T)x->size[ix]; } ix = b_x->size[0]; b_x->size[0] = (int32_T)sz[0]; emxEnsureCapacity(&c_st, (emxArray__common *)b_x, ix, (int32_T)sizeof(real_T), &emlrtRTEI); if ((x->size[0] == 0) || (x->size[1] == 0)) { ix = b_x->size[0]; b_x->size[0] = (int32_T)sz[0]; emxEnsureCapacity(&c_st, (emxArray__common *)b_x, ix, (int32_T)sizeof (real_T), &emlrtRTEI); loop_ub = (int32_T)sz[0]; for (ix = 0; ix < loop_ub; ix++) { b_x->data[ix] = 0.0; } } else { vlen = x->size[1]; vstride = x->size[0]; iy = -1; ixstart = -1; d_st.site = &m_emlrtRSI; overflow = (x->size[0] > 2147483646); if (overflow) { e_st.site = &g_emlrtRSI; check_forloop_overflow_error(&e_st); } for (loop_ub = 1; loop_ub <= vstride; loop_ub++) { ixstart++; ix = ixstart; s = x->data[ixstart]; d_st.site = &n_emlrtRSI; if (2 > vlen) { b0 = false; } else { b0 = (vlen > 2147483646); } if (b0) { e_st.site = &g_emlrtRSI; check_forloop_overflow_error(&e_st); } for (k = 2; k <= vlen; k++) { ix += vstride; s += x->data[ix]; } iy++; b_x->data[iy] = s; } } st.site = &b_emlrtRSI; ix = distToSource->size[0]; distToSource->size[0] = b_x->size[0]; emxEnsureCapacity(&st, (emxArray__common *)distToSource, ix, (int32_T)sizeof (real_T), &emlrtRTEI); loop_ub = b_x->size[0]; for (ix = 0; ix < loop_ub; ix++) { distToSource->data[ix] = b_x->data[ix]; } for (k = 0; k < b_x->size[0]; k++) { if (b_x->data[k] < 0.0) { b_st.site = &o_emlrtRSI; eml_error(&b_st); } } for (k = 0; k < b_x->size[0]; k++) { distToSource->data[k] = muDoubleScalarSqrt(distToSource->data[k]); } /* Normalize the forceDirection */ iy = 0; while (iy < 3) { loop_ub = forceDir->size[0]; ix = r2->size[0]; r2->size[0] = loop_ub; emxEnsureCapacity(sp, (emxArray__common *)r2, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); for (ix = 0; ix < loop_ub; ix++) { r2->data[ix] = ix; } ix = forceDir->size[1]; ixstart = 1 + iy; emlrtDynamicBoundsCheckR2012b(ixstart, 1, ix, (emlrtBCInfo *)&c_emlrtBCI, sp); st.site = &c_emlrtRSI; ix = forceDir->size[1]; ixstart = 1 + iy; emlrtDynamicBoundsCheckR2012b(ixstart, 1, ix, (emlrtBCInfo *)&d_emlrtBCI, &st); ix = forceDir->size[0]; sz[0] = (uint32_T)ix; sz[1] = 1U; varargin_2[0] = (uint32_T)distToSource->size[0]; varargin_2[1] = 1U; overflow = false; p = true; k = 0; exitg1 = false; while ((!exitg1) && (k < 2)) { if (!((int32_T)sz[k] == (int32_T)varargin_2[k])) { p = false; exitg1 = true; } else { k++; } } if (!p) { } else { overflow = true; } if (overflow) { } else { emlrtErrorWithMessageIdR2012b(&st, &l_emlrtRTEI, "MATLAB:dimagree", 0); } loop_ub = forceDir->size[0]; ix = b_x->size[0]; b_x->size[0] = loop_ub; emxEnsureCapacity(&st, (emxArray__common *)b_x, ix, (int32_T)sizeof(real_T), &emlrtRTEI); for (ix = 0; ix < loop_ub; ix++) { b_x->data[ix] = forceDir->data[ix + forceDir->size[0] * iy] / distToSource->data[ix]; } iv0[0] = r2->size[0]; emlrtSubAssignSizeCheckR2012b(iv0, 1, *(int32_T (*)[1])b_x->size, 1, (emlrtECInfo *)&d_emlrtECI, sp); loop_ub = b_x->size[0]; for (ix = 0; ix < loop_ub; ix++) { forceDir->data[r2->data[ix] + forceDir->size[0] * iy] = b_x->data[ix]; } /* bsxfun(@rdivide,forceDir,distToSource); */ iy++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } /* Multiply the */ if (forceDirection == -1.0) { ix = r4->size[0]; r4->size[0] = distToSource->size[0]; emxEnsureCapacity(sp, (emxArray__common *)r4, ix, (int32_T)sizeof(real_T), &emlrtRTEI); loop_ub = distToSource->size[0]; for (ix = 0; ix < loop_ub; ix++) { r4->data[ix] = 1.0 + distToSource->data[ix]; } rdivide(sp, forceMagnitude, r4, b_x); vlen = b_x->size[0]; ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof (real_T), &emlrtRTEI); ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[1] = 1; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof (real_T), &emlrtRTEI); loop_ub = b_x->size[0]; for (ix = 0; ix < loop_ub; ix++) { forceMag->data[ix] = 1.0 - b_x->data[ix]; } } else { if (forceDirection == 1.0) { ix = r3->size[0]; r3->size[0] = distToSource->size[0]; emxEnsureCapacity(sp, (emxArray__common *)r3, ix, (int32_T)sizeof(real_T), &emlrtRTEI); loop_ub = distToSource->size[0]; for (ix = 0; ix < loop_ub; ix++) { r3->data[ix] = 1.0 + distToSource->data[ix]; } rdivide(sp, forceMagnitude, r3, b_x); vlen = b_x->size[0]; ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof (real_T), &emlrtRTEI); ix = forceMag->size[0] * forceMag->size[1]; forceMag->size[1] = 1; emxEnsureCapacity(sp, (emxArray__common *)forceMag, ix, (int32_T)sizeof (real_T), &emlrtRTEI); loop_ub = b_x->size[0]; for (ix = 0; ix < loop_ub; ix++) { forceMag->data[ix] = b_x->data[ix]; } } } iy = 0; while (iy < 3) { ix = forceDir->size[1]; ixstart = 1 + iy; emlrtDynamicBoundsCheckR2012b(ixstart, 1, ix, (emlrtBCInfo *)&b_emlrtBCI, sp); ix = forceDir->size[0]; iv1[0] = ix; iv1[1] = 1; for (ix = 0; ix < 2; ix++) { b_force[ix] = forceMag->size[ix]; } if ((iv1[0] != b_force[0]) || (1 != b_force[1])) { emlrtSizeEqCheckNDR2012b(iv1, b_force, (emlrtECInfo *)&c_emlrtECI, sp); } loop_ub = forceTemp->size[0]; ix = r2->size[0]; r2->size[0] = loop_ub; emxEnsureCapacity(sp, (emxArray__common *)r2, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); for (ix = 0; ix < loop_ub; ix++) { r2->data[ix] = ix; } ix = forceTemp->size[1]; ixstart = 1 + iy; emlrtDynamicBoundsCheckR2012b(ixstart, 1, ix, (emlrtBCInfo *)&emlrtBCI, sp); loop_ub = forceDir->size[0]; vlen = forceDir->size[0]; vstride = forceDir->size[0]; ix = b_forceDir->size[0]; b_forceDir->size[0] = vstride; emxEnsureCapacity(sp, (emxArray__common *)b_forceDir, ix, (int32_T)sizeof (real_T), &emlrtRTEI); for (ix = 0; ix < vstride; ix++) { b_forceDir->data[ix] = forceDir->data[ix + forceDir->size[0] * iy]; } ix = c_forceDir->size[0] * c_forceDir->size[1]; c_forceDir->size[0] = loop_ub; c_forceDir->size[1] = 1; emxEnsureCapacity(sp, (emxArray__common *)c_forceDir, ix, (int32_T)sizeof (real_T), &emlrtRTEI); for (ix = 0; ix < loop_ub; ix++) { c_forceDir->data[ix] = b_forceDir->data[ix]; } ix = b_x->size[0]; b_x->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)b_x, ix, (int32_T)sizeof(real_T), &emlrtRTEI); for (ix = 0; ix < vlen; ix++) { b_x->data[ix] = c_forceDir->data[ix] * forceMag->data[ix]; } iv2[0] = r2->size[0]; emlrtSubAssignSizeCheckR2012b(iv2, 1, *(int32_T (*)[1])b_x->size, 1, (emlrtECInfo *)&b_emlrtECI, sp); loop_ub = b_x->size[0]; for (ix = 0; ix < loop_ub; ix++) { forceTemp->data[r2->data[ix] + forceTemp->size[0] * iy] = b_x->data[ix]; } /* bsxfun(@times,forceDir,forceTemp); */ iy++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } iy = distToSource->size[0] - 1; vlen = 0; for (vstride = 0; vstride <= iy; vstride++) { if (distToSource->data[vstride] > cutoff) { vlen++; } } ix = r2->size[0]; r2->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)r2, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); vlen = 0; for (vstride = 0; vstride <= iy; vstride++) { if (distToSource->data[vstride] > cutoff) { r2->data[vlen] = vstride + 1; vlen++; } } loop_ub = forceTemp->size[1]; vstride = forceTemp->size[0]; vlen = r2->size[0]; for (ix = 0; ix < loop_ub; ix++) { for (ixstart = 0; ixstart < vlen; ixstart++) { iy = r2->data[ixstart]; if ((iy >= 1) && (iy < vstride)) { b_iy = iy; } else { b_iy = emlrtDynamicBoundsCheckR2012b(iy, 1, vstride, (emlrtBCInfo *) &f_emlrtBCI, sp); } forceTemp->data[(b_iy + forceTemp->size[0] * ix) - 1] = 0.0; } } ix = r1->size[0] * r1->size[1]; r1->size[0] = forceTemp->size[0]; r1->size[1] = forceTemp->size[1]; emxEnsureCapacity(sp, (emxArray__common *)r1, ix, (int32_T)sizeof(boolean_T), &emlrtRTEI); loop_ub = forceTemp->size[0] * forceTemp->size[1]; for (ix = 0; ix < loop_ub; ix++) { r1->data[ix] = muDoubleScalarIsNaN(forceTemp->data[ix]); } iy = r1->size[0] * r1->size[1] - 1; vlen = 0; for (vstride = 0; vstride <= iy; vstride++) { if (r1->data[vstride]) { vlen++; } } ix = r0->size[0]; r0->size[0] = vlen; emxEnsureCapacity(sp, (emxArray__common *)r0, ix, (int32_T)sizeof(int32_T), &emlrtRTEI); vlen = 0; for (vstride = 0; vstride <= iy; vstride++) { if (r1->data[vstride]) { r0->data[vlen] = vstride + 1; vlen++; } } vstride = forceTemp->size[0]; vlen = forceTemp->size[1]; loop_ub = r0->size[0]; for (ix = 0; ix < loop_ub; ix++) { ixstart = vstride * vlen; iy = r0->data[ix]; if ((iy >= 1) && (iy < ixstart)) { c_iy = iy; } else { c_iy = emlrtDynamicBoundsCheckR2012b(iy, 1, ixstart, (emlrtBCInfo *) &g_emlrtBCI, sp); } forceTemp->data[c_iy - 1] = 0.0; } for (ix = 0; ix < 2; ix++) { b_force[ix] = force->size[ix]; } for (ix = 0; ix < 2; ix++) { b_forceTemp[ix] = forceTemp->size[ix]; } if ((b_force[0] != b_forceTemp[0]) || (b_force[1] != b_forceTemp[1])) { emlrtSizeEqCheckNDR2012b(b_force, b_forceTemp, (emlrtECInfo *)&emlrtECI, sp); } ix = force->size[0] * force->size[1]; emxEnsureCapacity(sp, (emxArray__common *)force, ix, (int32_T)sizeof(real_T), &emlrtRTEI); vlen = force->size[0]; vstride = force->size[1]; loop_ub = vlen * vstride; for (ix = 0; ix < loop_ub; ix++) { force->data[ix] += forceTemp->data[ix]; } sIdx++; if (*emlrtBreakCheckR2012bFlagVar != 0) { emlrtBreakCheckR2012b(sp); } } emxFree_real_T(&c_forceDir); emxFree_real_T(&b_forceDir); emxFree_real_T(&b_pointSourcePosition); emxFree_real_T(&r4); emxFree_real_T(&r3); emxFree_real_T(&b_x); emxFree_real_T(&x); emxFree_int32_T(&r2); emxFree_boolean_T(&r1); emxFree_int32_T(&r0); emxFree_real_T(&distToSource); emxFree_real_T(&forceDir); emxFree_real_T(&forceMag); emxFree_real_T(&forceTemp); emlrtHeapReferenceStackLeaveFcnR2012b(sp); }
void receiveData(const emlrtStack *sp, int32_T driverApiH, const real_T freq[2], const real_T loOffset[2], const real_T gain[2], real_T decim, cint16_T data[375000], uint32_T *dataLength, uint32_T *overflow, UsrpErrorCapiEnumT *errStat, char_T errStr_data[], int32_T errStr_size[2]) { static const char_T cv20[6] = { 's', 'i', 'l', 'e', 'n', 't' }; UsrpErrorCapiEnumT errStat_i; real_T b_freq[2]; real_T b_loOffset[2]; real_T b_gain[2]; int32_T i18; int32_T errStrSize; emlrtStack st; emlrtStack b_st; st.prev = sp; st.tls = sp->tls; b_st.prev = &st; b_st.tls = st.tls; /* Copyright 2011-2015 The MathWorks, Inc. */ st.site = &bb_emlrtRSI; /* */ /* This function unifies handling of interp vs. codegen call as well as */ /* errStat / errStr assignment. */ /* */ /* Copyright 2011-2015 The MathWorks, Inc. */ if (!isSetupsdruCalled) { b_st.site = &eb_emlrtRSI; setupsdru(&b_st, sdruroot(&b_st, &c_emlrtMCI), emlrt_marshallOut(&b_st, cv20), &d_emlrtMCI); isSetupsdruCalled = true; } /* These sizes must match those in C code. */ /* Arbitrary max imposed on ML/SL side */ /* function is being called in interpreted mode */ /* not being found: */ /* eml_allow_enum_inputs; */ /* errStat_i = int32(0); */ errStr_size[0] = 1; memset(&errStr_data[0], 0, sizeof(char_T) << 10); /* 46336 represents 0.00185344 seconds at 25Msps. 1 ms seems to be a decent */ /* time interval to interact with the IP stack on a default glnxa64 machine. */ /* 32768 seems to be the max for UHD(TM) so we may want to change to that. */ for (i18 = 0; i18 < 2; i18++) { b_freq[i18] = freq[i18]; b_loOffset[i18] = loOffset[i18]; b_gain[i18] = gain[i18]; } receiveData_c(driverApiH, b_freq, b_loOffset, b_gain, decim, data, dataLength, overflow, &errStat_i, &errStr_data[0]); /* errStat = UsrpErrorCapiEnumT(errStat_i); */ errStrSize = strlen(&errStr_data[0]); if (errStrSize <= 1024) { } else { emlrtErrorWithMessageIdR2012b(&st, &d_emlrtRTEI, "Coder:builtins:AssertionFailed", 0); } if (1 > errStrSize) { errStr_size[1] = 0; } else { errStr_size[1] = errStrSize; } *errStat = errStat_i; }