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;
}
