/* Model initialize function */
void HConstfolding_initialize(void)
{
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)HConstfolding_M, 0,
sizeof(RT_MODEL_HConstfolding));
/* Initialize timing info */
{
int_T *mdlTsMap = HConstfolding_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
HConstfolding_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
HConstfolding_M->Timing.sampleTimes =
(&HConstfolding_M->Timing.sampleTimesArray[0]);
HConstfolding_M->Timing.offsetTimes =
(&HConstfolding_M->Timing.offsetTimesArray[0]);
/* task periods */
HConstfolding_M->Timing.sampleTimes[0] = (1.0);
/* task offsets */
HConstfolding_M->Timing.offsetTimes[0] = (0.0);
}
rtmSetTPtr(HConstfolding_M, &HConstfolding_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = HConstfolding_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
HConstfolding_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(HConstfolding_M, 1.0E+8);
HConstfolding_M->Timing.stepSize0 = 1.0;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
HConstfolding_M->rtwLogInfo = &rt_DataLoggingInfo;
}
/* Setup for data logging */
{
rtliSetLogXSignalInfo(HConstfolding_M->rtwLogInfo, (NULL));
rtliSetLogXSignalPtrs(HConstfolding_M->rtwLogInfo, (NULL));
rtliSetLogT(HConstfolding_M->rtwLogInfo, "tout");
rtliSetLogX(HConstfolding_M->rtwLogInfo, "");
rtliSetLogXFinal(HConstfolding_M->rtwLogInfo, "");
rtliSetSigLog(HConstfolding_M->rtwLogInfo, "");
rtliSetLogVarNameModifier(HConstfolding_M->rtwLogInfo, "rt_");
rtliSetLogFormat(HConstfolding_M->rtwLogInfo, 0);
rtliSetLogMaxRows(HConstfolding_M->rtwLogInfo, 1000);
rtliSetLogDecimation(HConstfolding_M->rtwLogInfo, 1);
/*
* Set pointers to the data and signal info for each output
*/
{
static void * rt_LoggedOutputSignalPtrs[] = {
&HConstfolding_Y.Out1
};
rtliSetLogYSignalPtrs(HConstfolding_M->rtwLogInfo, ((LogSignalPtrsType)
rt_LoggedOutputSignalPtrs));
}
{
static int_T rt_LoggedOutputWidths[] = {
1
};
static int_T rt_LoggedOutputNumDimensions[] = {
1
};
static int_T rt_LoggedOutputDimensions[] = {
1
};
static boolean_T rt_LoggedOutputIsVarDims[] = {
0
};
static void* rt_LoggedCurrentSignalDimensions[] = {
(NULL)
};
static int_T rt_LoggedCurrentSignalDimensionsSize[] = {
4
};
static BuiltInDTypeId rt_LoggedOutputDataTypeIds[] = {
SS_DOUBLE
};
static int_T rt_LoggedOutputComplexSignals[] = {
0
};
static const char_T *rt_LoggedOutputLabels[] = {
"" };
static const char_T *rt_LoggedOutputBlockNames[] = {
"HConstfolding/Out1" };
static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 }
};
static RTWLogSignalInfo rt_LoggedOutputSignalInfo[] = {
{
1,
rt_LoggedOutputWidths,
rt_LoggedOutputNumDimensions,
rt_LoggedOutputDimensions,
rt_LoggedOutputIsVarDims,
rt_LoggedCurrentSignalDimensions,
rt_LoggedCurrentSignalDimensionsSize,
rt_LoggedOutputDataTypeIds,
rt_LoggedOutputComplexSignals,
(NULL),
{ rt_LoggedOutputLabels },
(NULL),
(NULL),
(NULL),
{ rt_LoggedOutputBlockNames },
{ (NULL) },
(NULL),
rt_RTWLogDataTypeConvert
}
};
rtliSetLogYSignalInfo(HConstfolding_M->rtwLogInfo,
rt_LoggedOutputSignalInfo);
/* set currSigDims field */
rt_LoggedCurrentSignalDimensions[0] = &rt_LoggedOutputWidths[0];
}
rtliSetLogY(HConstfolding_M->rtwLogInfo, "yout");
}
HConstfolding_M->solverInfoPtr = (&HConstfolding_M->solverInfo);
HConstfolding_M->Timing.stepSize = (1.0);
rtsiSetFixedStepSize(&HConstfolding_M->solverInfo, 1.0);
rtsiSetSolverMode(&HConstfolding_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* states (dwork) */
(void) memset((void *)&HConstfolding_DWork, 0,
sizeof(D_Work_HConstfolding));
/* external outputs */
HConstfolding_Y.Out1 = 0.0;
/* Matfile logging */
rt_StartDataLoggingWithStartTime(HConstfolding_M->rtwLogInfo, 0.0,
rtmGetTFinal(HConstfolding_M), HConstfolding_M->Timing.stepSize0,
(&rtmGetErrorStatus(HConstfolding_M)));
/* Initialize Sizes */
HConstfolding_M->Sizes.numContStates = (0);/* Number of continuous states */
HConstfolding_M->Sizes.numY = (1); /* Number of model outputs */
HConstfolding_M->Sizes.numU = (0); /* Number of model inputs */
HConstfolding_M->Sizes.sysDirFeedThru = (0);/* The model is not direct feedthrough */
HConstfolding_M->Sizes.numSampTimes = (1);/* Number of sample times */
HConstfolding_M->Sizes.numBlocks = (14);/* Number of blocks */
HConstfolding_M->Sizes.numBlockIO = (0);/* Number of block outputs */
HConstfolding_M->Sizes.numBlockPrms = (10);/* Sum of parameter "widths" */
/* InitializeConditions for UnitDelay: '<Root>/Unit Delay' */
HConstfolding_DWork.UnitDelay_DSTATE = HConstfolding_P.UnitDelay_X0;
/* InitializeConditions for UnitDelay: '<Root>/Unit Delay1' */
HConstfolding_DWork.UnitDelay1_DSTATE = HConstfolding_P.UnitDelay1_X0;
}
/* Model initialize function */
void xpcosc_initialize(boolean_T firstTime)
{
(void)firstTime;
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)xpcosc_rtM, 0,
sizeof(rtModel_xpcosc));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&xpcosc_rtM->solverInfo,
&xpcosc_rtM->Timing.simTimeStep);
rtsiSetTPtr(&xpcosc_rtM->solverInfo, &rtmGetTPtr(xpcosc_rtM));
rtsiSetStepSizePtr(&xpcosc_rtM->solverInfo, &xpcosc_rtM->Timing.stepSize0);
rtsiSetdXPtr(&xpcosc_rtM->solverInfo, &xpcosc_rtM->ModelData.derivs);
rtsiSetContStatesPtr(&xpcosc_rtM->solverInfo,
&xpcosc_rtM->ModelData.contStates);
rtsiSetNumContStatesPtr(&xpcosc_rtM->solverInfo,
&xpcosc_rtM->Sizes.numContStates);
rtsiSetErrorStatusPtr(&xpcosc_rtM->solverInfo, (&rtmGetErrorStatus
(xpcosc_rtM)));
rtsiSetRTModelPtr(&xpcosc_rtM->solverInfo, xpcosc_rtM);
}
rtsiSetSimTimeStep(&xpcosc_rtM->solverInfo, MAJOR_TIME_STEP);
xpcosc_rtM->ModelData.intgData.y = xpcosc_rtM->ModelData.odeY;
xpcosc_rtM->ModelData.intgData.f[0] = xpcosc_rtM->ModelData.odeF[0];
xpcosc_rtM->ModelData.intgData.f[1] = xpcosc_rtM->ModelData.odeF[1];
xpcosc_rtM->ModelData.intgData.f[2] = xpcosc_rtM->ModelData.odeF[2];
xpcosc_rtM->ModelData.intgData.f[3] = xpcosc_rtM->ModelData.odeF[3];
xpcosc_rtM->ModelData.contStates = ((real_T *) &xpcosc_X);
rtsiSetSolverData(&xpcosc_rtM->solverInfo, (void *)
&xpcosc_rtM->ModelData.intgData);
rtsiSetSolverName(&xpcosc_rtM->solverInfo,"ode4");
xpcosc_rtM->solverInfoPtr = (&xpcosc_rtM->solverInfo);
/* Initialize timing info */
{
int_T *mdlTsMap = xpcosc_rtM->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
xpcosc_rtM->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
xpcosc_rtM->Timing.sampleTimes = (&xpcosc_rtM->Timing.sampleTimesArray[0]);
xpcosc_rtM->Timing.offsetTimes = (&xpcosc_rtM->Timing.offsetTimesArray[0]);
/* task periods */
xpcosc_rtM->Timing.sampleTimes[0] = (0.0);
xpcosc_rtM->Timing.sampleTimes[1] = (0.001);
/* task offsets */
xpcosc_rtM->Timing.offsetTimes[0] = (0.0);
xpcosc_rtM->Timing.offsetTimes[1] = (0.0);
}
rtmSetTPtr(xpcosc_rtM, &xpcosc_rtM->Timing.tArray[0]);
{
int_T *mdlSampleHits = xpcosc_rtM->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
xpcosc_rtM->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(xpcosc_rtM, 0.2);
xpcosc_rtM->Timing.stepSize0 = 0.001;
xpcosc_rtM->Timing.stepSize1 = 0.001;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
xpcosc_rtM->rtwLogInfo = &rt_DataLoggingInfo;
}
/* Setup for data logging */
{
/*
* Set pointers to the data and signal info each state
*/
{
static int_T rt_LoggedStateWidths[] = {
1,
1
};
static int_T rt_LoggedStateNumDimensions[] = {
1,
1
};
static int_T rt_LoggedStateDimensions[] = {
1,
1
};
static boolean_T rt_LoggedStateIsVarDims[] = {
0,
0
};
static BuiltInDTypeId rt_LoggedStateDataTypeIds[] = {
SS_DOUBLE,
SS_DOUBLE
};
static int_T rt_LoggedStateComplexSignals[] = {
0,
0
};
static const char_T *rt_LoggedStateLabels[] = {
"CSTATE",
"CSTATE"
};
static const char_T *rt_LoggedStateBlockNames[] = {
"xpcosc/Integrator1",
"xpcosc/Integrator"
};
static const char_T *rt_LoggedStateNames[] = {
"",
""
};
static boolean_T rt_LoggedStateCrossMdlRef[] = {
0,
0
};
static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 },
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 }
};
static RTWLogSignalInfo rt_LoggedStateSignalInfo = {
2,
rt_LoggedStateWidths,
rt_LoggedStateNumDimensions,
rt_LoggedStateDimensions,
rt_LoggedStateIsVarDims,
(NULL),
rt_LoggedStateDataTypeIds,
rt_LoggedStateComplexSignals,
(NULL),
{ rt_LoggedStateLabels },
(NULL),
(NULL),
(NULL),
{ rt_LoggedStateBlockNames },
{ rt_LoggedStateNames },
rt_LoggedStateCrossMdlRef,
rt_RTWLogDataTypeConvert
};
static void * rt_LoggedStateSignalPtrs[2];
rtliSetLogXSignalPtrs(xpcosc_rtM->rtwLogInfo, (LogSignalPtrsType)
rt_LoggedStateSignalPtrs);
rtliSetLogXSignalInfo(xpcosc_rtM->rtwLogInfo, &rt_LoggedStateSignalInfo);
rt_LoggedStateSignalPtrs[0] = (void*)&xpcosc_X.Integrator1_CSTATE;
rt_LoggedStateSignalPtrs[1] = (void*)&xpcosc_X.Integrator_CSTATE;
}
rtliSetLogT(xpcosc_rtM->rtwLogInfo, "tout");
rtliSetLogX(xpcosc_rtM->rtwLogInfo, "xout");
rtliSetLogXFinal(xpcosc_rtM->rtwLogInfo, "");
rtliSetSigLog(xpcosc_rtM->rtwLogInfo, "");
rtliSetLogVarNameModifier(xpcosc_rtM->rtwLogInfo, "rt_");
rtliSetLogFormat(xpcosc_rtM->rtwLogInfo, 0);
rtliSetLogMaxRows(xpcosc_rtM->rtwLogInfo, 0);
rtliSetLogDecimation(xpcosc_rtM->rtwLogInfo, 1);
/*
* Set pointers to the data and signal info for each output
*/
{
static void * rt_LoggedOutputSignalPtrs[] = {
&xpcosc_Y.Outport[0]
};
rtliSetLogYSignalPtrs(xpcosc_rtM->rtwLogInfo, ((LogSignalPtrsType)
rt_LoggedOutputSignalPtrs));
}
{
static int_T rt_LoggedOutputWidths[] = {
2
};
static int_T rt_LoggedOutputNumDimensions[] = {
1
};
static int_T rt_LoggedOutputDimensions[] = {
2
};
static boolean_T rt_LoggedOutputIsVarDims[] = {
0
};
static int_T* rt_LoggedCurrentSignalDimensions[] = {
(NULL)
};
static BuiltInDTypeId rt_LoggedOutputDataTypeIds[] = {
SS_DOUBLE
};
static int_T rt_LoggedOutputComplexSignals[] = {
0
};
static const char_T *rt_LoggedOutputLabels[] = {
"" };
static const char_T *rt_LoggedOutputBlockNames[] = {
"xpcosc/Outport" };
static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 }
};
static RTWLogSignalInfo rt_LoggedOutputSignalInfo[] = {
{
1,
rt_LoggedOutputWidths,
rt_LoggedOutputNumDimensions,
rt_LoggedOutputDimensions,
rt_LoggedOutputIsVarDims,
rt_LoggedCurrentSignalDimensions,
rt_LoggedOutputDataTypeIds,
rt_LoggedOutputComplexSignals,
(NULL),
{ rt_LoggedOutputLabels },
(NULL),
(NULL),
(NULL),
{ rt_LoggedOutputBlockNames },
{ (NULL) },
(NULL),
rt_RTWLogDataTypeConvert
}
};
rtliSetLogYSignalInfo(xpcosc_rtM->rtwLogInfo, rt_LoggedOutputSignalInfo);
/* set currSigDims field */
rt_LoggedCurrentSignalDimensions[0] = &rt_LoggedOutputWidths[0];
}
rtliSetLogY(xpcosc_rtM->rtwLogInfo, "yout");
}
/* external mode info */
xpcosc_rtM->Sizes.checksums[0] = (1235351435U);
xpcosc_rtM->Sizes.checksums[1] = (4143988505U);
xpcosc_rtM->Sizes.checksums[2] = (362576123U);
xpcosc_rtM->Sizes.checksums[3] = (1068881914U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[1];
xpcosc_rtM->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(xpcosc_rtM->extModeInfo,
&xpcosc_rtM->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(xpcosc_rtM->extModeInfo, xpcosc_rtM->Sizes.checksums);
rteiSetTPtr(xpcosc_rtM->extModeInfo, rtmGetTPtr(xpcosc_rtM));
}
xpcosc_rtM->solverInfoPtr = (&xpcosc_rtM->solverInfo);
xpcosc_rtM->Timing.stepSize = (0.001);
rtsiSetFixedStepSize(&xpcosc_rtM->solverInfo, 0.001);
rtsiSetSolverMode(&xpcosc_rtM->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
xpcosc_rtM->ModelData.blockIO = ((void *) &xpcosc_B);
{
xpcosc_B.Integrator1 = 0.0;
xpcosc_B.PCI6221AD = 0.0;
xpcosc_B.RateTransition1 = 0.0;
xpcosc_B.SignalGenerator = 0.0;
xpcosc_B.RateTransition = 0.0;
xpcosc_B.Gain = 0.0;
xpcosc_B.Integrator = 0.0;
xpcosc_B.Gain1 = 0.0;
xpcosc_B.Gain2 = 0.0;
xpcosc_B.Sum = 0.0;
}
/* parameters */
xpcosc_rtM->ModelData.defaultParam = ((real_T *)&xpcosc_P);
/* states (continuous) */
{
real_T *x = (real_T *) &xpcosc_X;
xpcosc_rtM->ModelData.contStates = (x);
(void) memset((void *)&xpcosc_X, 0,
sizeof(ContinuousStates_xpcosc));
}
/* states (dwork) */
xpcosc_rtM->Work.dwork = ((void *) &xpcosc_DWork);
(void) memset((void *)&xpcosc_DWork, 0,
sizeof(D_Work_xpcosc));
xpcosc_DWork.PCI6713DA_RWORK = 0.0;
/* external outputs */
xpcosc_rtM->ModelData.outputs = (&xpcosc_Y);
xpcosc_Y.Outport[0] = 0.0;
xpcosc_Y.Outport[1] = 0.0;
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
xpcosc_rtM->SpecialInfo.mappingInfo = (&dtInfo);
xpcosc_rtM->SpecialInfo.xpcData = ((void*) &dtInfo);
dtInfo.numDataTypes = 14;
dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
dtInfo.dataTypeNames = &rtDataTypeNames[0];
/* Block I/O transition table */
dtInfo.B = &rtBTransTable;
/* Parameters transition table */
dtInfo.P = &rtPTransTable;
}
/* Initialize DataMapInfo substructure containing ModelMap for C API */
xpcosc_InitializeDataMapInfo(xpcosc_rtM);
/* child S-Function registration */
{
RTWSfcnInfo *sfcnInfo = &xpcosc_rtM->NonInlinedSFcns.sfcnInfo;
xpcosc_rtM->sfcnInfo = (sfcnInfo);
rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(xpcosc_rtM)));
rtssSetNumRootSampTimesPtr(sfcnInfo, &xpcosc_rtM->Sizes.numSampTimes);
xpcosc_rtM->NonInlinedSFcns.taskTimePtrs[0] = &(rtmGetTPtr(xpcosc_rtM)[0]);
xpcosc_rtM->NonInlinedSFcns.taskTimePtrs[1] = &(rtmGetTPtr(xpcosc_rtM)[1]);
rtssSetTPtrPtr(sfcnInfo,xpcosc_rtM->NonInlinedSFcns.taskTimePtrs);
rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(xpcosc_rtM));
rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(xpcosc_rtM));
rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(xpcosc_rtM));
rtssSetStepSizePtr(sfcnInfo, &xpcosc_rtM->Timing.stepSize);
rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(xpcosc_rtM));
rtssSetDerivCacheNeedsResetPtr(sfcnInfo,
&xpcosc_rtM->ModelData.derivCacheNeedsReset);
rtssSetZCCacheNeedsResetPtr(sfcnInfo,
&xpcosc_rtM->ModelData.zCCacheNeedsReset);
rtssSetBlkStateChangePtr(sfcnInfo, &xpcosc_rtM->ModelData.blkStateChange);
rtssSetSampleHitsPtr(sfcnInfo, &xpcosc_rtM->Timing.sampleHits);
rtssSetPerTaskSampleHitsPtr(sfcnInfo, &xpcosc_rtM->Timing.perTaskSampleHits);
rtssSetSimModePtr(sfcnInfo, &xpcosc_rtM->simMode);
rtssSetSolverInfoPtr(sfcnInfo, &xpcosc_rtM->solverInfoPtr);
}
xpcosc_rtM->Sizes.numSFcns = (2);
/* register each child */
{
(void) memset((void *)&xpcosc_rtM->NonInlinedSFcns.childSFunctions[0], 0,
2*sizeof(SimStruct));
xpcosc_rtM->childSfunctions =
(&xpcosc_rtM->NonInlinedSFcns.childSFunctionPtrs[0]);
xpcosc_rtM->childSfunctions[0] =
(&xpcosc_rtM->NonInlinedSFcns.childSFunctions[0]);
xpcosc_rtM->childSfunctions[1] =
(&xpcosc_rtM->NonInlinedSFcns.childSFunctions[1]);
/* Level2 S-Function Block: xpcosc/<Root>/PCI-6221 AD (adnipcim) */
{
SimStruct *rts = xpcosc_rtM->childSfunctions[0];
/* timing info */
time_T *sfcnPeriod = xpcosc_rtM->NonInlinedSFcns.Sfcn0.sfcnPeriod;
time_T *sfcnOffset = xpcosc_rtM->NonInlinedSFcns.Sfcn0.sfcnOffset;
int_T *sfcnTsMap = xpcosc_rtM->NonInlinedSFcns.Sfcn0.sfcnTsMap;
(void) memset((void*)sfcnPeriod, 0,
sizeof(time_T)*1);
(void) memset((void*)sfcnOffset, 0,
sizeof(time_T)*1);
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
/* Set up the mdlInfo pointer */
{
ssSetBlkInfo2Ptr(rts, &xpcosc_rtM->NonInlinedSFcns.blkInfo2[0]);
}
ssSetRTWSfcnInfo(rts, xpcosc_rtM->sfcnInfo);
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &xpcosc_rtM->NonInlinedSFcns.methods2[0]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &xpcosc_rtM->NonInlinedSFcns.methods3[0]);
}
/* Allocate memory for states auxilliary information */
{
ssSetStatesInfo2(rts, &xpcosc_rtM->NonInlinedSFcns.statesInfo2[0]);
}
/* outputs */
{
ssSetPortInfoForOutputs(rts,
&xpcosc_rtM->NonInlinedSFcns.Sfcn0.outputPortInfo[0]);
_ssSetNumOutputPorts(rts, 1);
/* port 0 */
{
_ssSetOutputPortNumDimensions(rts, 0, 1);
ssSetOutputPortWidth(rts, 0, 1);
ssSetOutputPortSignal(rts, 0, ((real_T *) &xpcosc_B.PCI6221AD));
}
}
/* path info */
ssSetModelName(rts, "PCI-6221 AD");
ssSetPath(rts, "xpcosc/PCI-6221 AD");
ssSetRTModel(rts,xpcosc_rtM);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* parameters */
{
mxArray **sfcnParams = (mxArray **)
&xpcosc_rtM->NonInlinedSFcns.Sfcn0.params;
ssSetSFcnParamsCount(rts, 7);
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
ssSetSFcnParam(rts, 0, (mxArray*)xpcosc_P.PCI6221AD_P1_Size);
ssSetSFcnParam(rts, 1, (mxArray*)xpcosc_P.PCI6221AD_P2_Size);
ssSetSFcnParam(rts, 2, (mxArray*)xpcosc_P.PCI6221AD_P3_Size);
ssSetSFcnParam(rts, 3, (mxArray*)xpcosc_P.PCI6221AD_P4_Size);
ssSetSFcnParam(rts, 4, (mxArray*)xpcosc_P.PCI6221AD_P5_Size);
ssSetSFcnParam(rts, 5, (mxArray*)xpcosc_P.PCI6221AD_P6_Size);
ssSetSFcnParam(rts, 6, (mxArray*)xpcosc_P.PCI6221AD_P7_Size);
}
/* work vectors */
ssSetIWork(rts, (int_T *) &xpcosc_DWork.PCI6221AD_IWORK[0]);
ssSetPWork(rts, (void **) &xpcosc_DWork.PCI6221AD_PWORK);
{
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
&xpcosc_rtM->NonInlinedSFcns.Sfcn0.dWork;
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
&xpcosc_rtM->NonInlinedSFcns.Sfcn0.dWorkAux;
ssSetSFcnDWork(rts, dWorkRecord);
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
_ssSetNumDWork(rts, 2);
/* IWORK */
ssSetDWorkWidth(rts, 0, 41);
ssSetDWorkDataType(rts, 0,SS_INTEGER);
ssSetDWorkComplexSignal(rts, 0, 0);
ssSetDWork(rts, 0, &xpcosc_DWork.PCI6221AD_IWORK[0]);
/* PWORK */
ssSetDWorkWidth(rts, 1, 1);
ssSetDWorkDataType(rts, 1,SS_POINTER);
ssSetDWorkComplexSignal(rts, 1, 0);
ssSetDWork(rts, 1, &xpcosc_DWork.PCI6221AD_PWORK);
}
/* registration */
adnipcim(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.001);
ssSetOffsetTime(rts, 0, 0.0);
sfcnTsMap[0] = 1;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetOutputPortConnected(rts, 0, 1);
_ssSetOutputPortBeingMerged(rts, 0, 0);
/* Update the BufferDstPort flags for each input port */
}
/* Level2 S-Function Block: xpcosc/<Root>/PCI-6713 DA (danipci671x) */
{
SimStruct *rts = xpcosc_rtM->childSfunctions[1];
/* timing info */
time_T *sfcnPeriod = xpcosc_rtM->NonInlinedSFcns.Sfcn1.sfcnPeriod;
time_T *sfcnOffset = xpcosc_rtM->NonInlinedSFcns.Sfcn1.sfcnOffset;
int_T *sfcnTsMap = xpcosc_rtM->NonInlinedSFcns.Sfcn1.sfcnTsMap;
(void) memset((void*)sfcnPeriod, 0,
sizeof(time_T)*1);
(void) memset((void*)sfcnOffset, 0,
sizeof(time_T)*1);
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
/* Set up the mdlInfo pointer */
{
ssSetBlkInfo2Ptr(rts, &xpcosc_rtM->NonInlinedSFcns.blkInfo2[1]);
}
ssSetRTWSfcnInfo(rts, xpcosc_rtM->sfcnInfo);
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &xpcosc_rtM->NonInlinedSFcns.methods2[1]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &xpcosc_rtM->NonInlinedSFcns.methods3[1]);
}
/* Allocate memory for states auxilliary information */
{
ssSetStatesInfo2(rts, &xpcosc_rtM->NonInlinedSFcns.statesInfo2[1]);
}
/* inputs */
{
_ssSetNumInputPorts(rts, 1);
ssSetPortInfoForInputs(rts,
&xpcosc_rtM->NonInlinedSFcns.Sfcn1.inputPortInfo[0]);
/* port 0 */
{
real_T const **sfcnUPtrs = (real_T const **)
&xpcosc_rtM->NonInlinedSFcns.Sfcn1.UPtrs0;
sfcnUPtrs[0] = &xpcosc_B.RateTransition;
ssSetInputPortSignalPtrs(rts, 0, (InputPtrsType)&sfcnUPtrs[0]);
_ssSetInputPortNumDimensions(rts, 0, 1);
ssSetInputPortWidth(rts, 0, 1);
}
}
/* path info */
ssSetModelName(rts, "PCI-6713 DA");
ssSetPath(rts, "xpcosc/PCI-6713 DA");
ssSetRTModel(rts,xpcosc_rtM);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* parameters */
{
mxArray **sfcnParams = (mxArray **)
&xpcosc_rtM->NonInlinedSFcns.Sfcn1.params;
ssSetSFcnParamsCount(rts, 6);
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
ssSetSFcnParam(rts, 0, (mxArray*)xpcosc_P.PCI6713DA_P1_Size);
ssSetSFcnParam(rts, 1, (mxArray*)xpcosc_P.PCI6713DA_P2_Size);
ssSetSFcnParam(rts, 2, (mxArray*)xpcosc_P.PCI6713DA_P3_Size);
ssSetSFcnParam(rts, 3, (mxArray*)xpcosc_P.PCI6713DA_P4_Size);
ssSetSFcnParam(rts, 4, (mxArray*)xpcosc_P.PCI6713DA_P5_Size);
ssSetSFcnParam(rts, 5, (mxArray*)xpcosc_P.PCI6713DA_P6_Size);
}
/* work vectors */
ssSetRWork(rts, (real_T *) &xpcosc_DWork.PCI6713DA_RWORK);
ssSetIWork(rts, (int_T *) &xpcosc_DWork.PCI6713DA_IWORK[0]);
{
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
&xpcosc_rtM->NonInlinedSFcns.Sfcn1.dWork;
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
&xpcosc_rtM->NonInlinedSFcns.Sfcn1.dWorkAux;
ssSetSFcnDWork(rts, dWorkRecord);
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
_ssSetNumDWork(rts, 2);
/* RWORK */
ssSetDWorkWidth(rts, 0, 1);
ssSetDWorkDataType(rts, 0,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 0, 0);
ssSetDWork(rts, 0, &xpcosc_DWork.PCI6713DA_RWORK);
/* IWORK */
ssSetDWorkWidth(rts, 1, 2);
ssSetDWorkDataType(rts, 1,SS_INTEGER);
ssSetDWorkComplexSignal(rts, 1, 0);
ssSetDWork(rts, 1, &xpcosc_DWork.PCI6713DA_IWORK[0]);
}
/* registration */
danipci671x(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.001);
ssSetOffsetTime(rts, 0, 0.0);
sfcnTsMap[0] = 1;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetInputPortConnected(rts, 0, 1);
/* Update the BufferDstPort flags for each input port */
ssSetInputPortBufferDstPort(rts, 0, -1);
}
}
}
/* Model initialize function */
void CelpSimulink_initialize(boolean_T firstTime)
{
(void)firstTime;
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((char_T *)CelpSimulink_M,0,
sizeof(RT_MODEL_CelpSimulink));
/* Initialize timing info */
{
int_T *mdlTsMap = CelpSimulink_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
CelpSimulink_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
CelpSimulink_M->Timing.sampleTimes =
(&CelpSimulink_M->Timing.sampleTimesArray[0]);
CelpSimulink_M->Timing.offsetTimes =
(&CelpSimulink_M->Timing.offsetTimesArray[0]);
/* task periods */
CelpSimulink_M->Timing.sampleTimes[0] = (0.01);
/* task offsets */
CelpSimulink_M->Timing.offsetTimes[0] = (0.0);
}
rtmSetTPtr(CelpSimulink_M, &CelpSimulink_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = CelpSimulink_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
CelpSimulink_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(CelpSimulink_M, -1);
CelpSimulink_M->Timing.stepSize0 = 0.01;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
CelpSimulink_M->rtwLogInfo = &rt_DataLoggingInfo;
rtliSetLogXSignalInfo(CelpSimulink_M->rtwLogInfo, NULL);
rtliSetLogXSignalPtrs(CelpSimulink_M->rtwLogInfo, NULL);
rtliSetLogT(CelpSimulink_M->rtwLogInfo, "tout");
rtliSetLogX(CelpSimulink_M->rtwLogInfo, "");
rtliSetLogXFinal(CelpSimulink_M->rtwLogInfo, "");
rtliSetSigLog(CelpSimulink_M->rtwLogInfo, "");
rtliSetLogVarNameModifier(CelpSimulink_M->rtwLogInfo, "rt_");
rtliSetLogFormat(CelpSimulink_M->rtwLogInfo, 0);
rtliSetLogMaxRows(CelpSimulink_M->rtwLogInfo, 1000);
rtliSetLogDecimation(CelpSimulink_M->rtwLogInfo, 1);
rtliSetLogY(CelpSimulink_M->rtwLogInfo, "");
rtliSetLogYSignalInfo(CelpSimulink_M->rtwLogInfo, NULL);
rtliSetLogYSignalPtrs(CelpSimulink_M->rtwLogInfo, NULL);
}
CelpSimulink_M->solverInfoPtr = (&CelpSimulink_M->solverInfo);
CelpSimulink_M->Timing.stepSize = (0.01);
rtsiSetFixedStepSize(&CelpSimulink_M->solverInfo, 0.01);
rtsiSetSolverMode(&CelpSimulink_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
CelpSimulink_M->ModelData.blockIO = ((void *) &CelpSimulink_B);
(void) memset(((void *) &CelpSimulink_B),0,
sizeof(BlockIO_CelpSimulink));
{
int_T i;
void *pVoidBlockIORegion;
pVoidBlockIORegion = (void *)(&CelpSimulink_B.FromWaveFile[0]);
for (i = 0; i < 411; i++) {
((real32_T*)pVoidBlockIORegion)[i] = 0.0F;
}
}
/* parameters */
CelpSimulink_M->ModelData.defaultParam = ((real_T *) &CelpSimulink_P);
/* states (dwork) */
CelpSimulink_M->Work.dwork = ((void *) &CelpSimulink_DWork);
(void) memset((char_T *) &CelpSimulink_DWork,0,
sizeof(D_Work_CelpSimulink));
CelpSimulink_DWork.Maximum1_Valdata = 0.0;
{
int_T i;
real32_T *dwork_ptr = (real32_T *)
&CelpSimulink_DWork.PreEmphasis_FILT_STATES[0];
for (i = 0; i < 1122; i++) {
dwork_ptr[i] = 0.0F;
}
}
}
/* Model initialize function */
void BP_MC1_initialize(boolean_T firstTime)
{
(void)firstTime;
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)BP_MC1_M,0,
sizeof(RT_MODEL_BP_MC1));
/* Initialize timing info */
{
int_T *mdlTsMap = BP_MC1_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
BP_MC1_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
BP_MC1_M->Timing.sampleTimes = (&BP_MC1_M->Timing.sampleTimesArray[0]);
BP_MC1_M->Timing.offsetTimes = (&BP_MC1_M->Timing.offsetTimesArray[0]);
/* task periods */
BP_MC1_M->Timing.sampleTimes[0] = (0.05);
/* task offsets */
BP_MC1_M->Timing.offsetTimes[0] = (0.0);
}
rtmSetTPtr(BP_MC1_M, &BP_MC1_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = BP_MC1_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
BP_MC1_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(BP_MC1_M, -1);
BP_MC1_M->Timing.stepSize0 = 0.05;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
BP_MC1_M->rtwLogInfo = &rt_DataLoggingInfo;
}
/* Setup for data logging */
{
rtliSetLogXSignalInfo(BP_MC1_M->rtwLogInfo, (NULL));
rtliSetLogXSignalPtrs(BP_MC1_M->rtwLogInfo, (NULL));
rtliSetLogT(BP_MC1_M->rtwLogInfo, "");
rtliSetLogX(BP_MC1_M->rtwLogInfo, "");
rtliSetLogXFinal(BP_MC1_M->rtwLogInfo, "");
rtliSetSigLog(BP_MC1_M->rtwLogInfo, "");
rtliSetLogVarNameModifier(BP_MC1_M->rtwLogInfo, "rt_");
rtliSetLogFormat(BP_MC1_M->rtwLogInfo, 0);
rtliSetLogMaxRows(BP_MC1_M->rtwLogInfo, 1000);
rtliSetLogDecimation(BP_MC1_M->rtwLogInfo, 1);
rtliSetLogY(BP_MC1_M->rtwLogInfo, "");
rtliSetLogYSignalInfo(BP_MC1_M->rtwLogInfo, (NULL));
rtliSetLogYSignalPtrs(BP_MC1_M->rtwLogInfo, (NULL));
}
BP_MC1_M->solverInfoPtr = (&BP_MC1_M->solverInfo);
BP_MC1_M->Timing.stepSize = (0.05);
rtsiSetFixedStepSize(&BP_MC1_M->solverInfo, 0.05);
rtsiSetSolverMode(&BP_MC1_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
BP_MC1_M->ModelData.blockIO = ((void *) &BP_MC1_B);
(void) memset(((void *) &BP_MC1_B),0,
sizeof(BlockIO_BP_MC1));
{
BP_MC1_B.u1 = 0.0;
BP_MC1_B.Sign = 0.0;
BP_MC1_B.PortVPS_X = 0.0;
BP_MC1_B.PortVPS_X_g = 0.0;
BP_MC1_B.u1_p = 0.0;
BP_MC1_B.PortVSP_Y = 0.0;
BP_MC1_B.PortVSP_Y_i = 0.0;
BP_MC1_B.u1_g = 0.0;
BP_MC1_B.StarboardVSP_X = 0.0;
BP_MC1_B.u1_pj = 0.0;
BP_MC1_B.StarboardVSP_Y = 0.0;
BP_MC1_B.Servo1 = 0.0;
BP_MC1_B.Servo2 = 0.0;
BP_MC1_B.Servo3 = 0.0;
BP_MC1_B.Servo4 = 0.0;
BP_MC1_B.VPS_Speed_Gain = 0.0;
BP_MC1_B.Sum = 0.0;
BP_MC1_B.BowThrusterdirection = 0.0;
BP_MC1_B.BT_D_Gain1 = 0.0;
BP_MC1_B.BT_D_Gain2 = 0.0;
BP_MC1_B.Add = 0.0;
BP_MC1_B.BT_L_Gain1 = 0.0;
BP_MC1_B.BT_L_Gain2 = 0.0;
BP_MC1_B.Sum1 = 0.0;
BP_MC1_B.Sum2 = 0.0;
BP_MC1_B.Switch = 0.0;
BP_MC1_B.Switch2 = 0.0;
}
/* parameters */
BP_MC1_M->ModelData.defaultParam = ((real_T *) &BP_MC1_P);
/* states (dwork) */
BP_MC1_M->Work.dwork = ((void *) &BP_MC1_DWork);
(void) memset((void *)&BP_MC1_DWork, 0,
sizeof(D_Work_BP_MC1));
}
/* Model initialize function */
void fi_mdl_radix2fft_withscaling_initialize(boolean_T firstTime)
{
if (firstTime) {
/* registration code */
/* initialize real-time model */
(void)memset((char_T *)fi_mdl_radix2fft_withscaling_M, 0,
sizeof(rtModel_fi_mdl_radix2fft_withscaling));
/* Initialize timing info */
{
int_T *mdlTsMap =
fi_mdl_radix2fft_withscaling_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
fi_mdl_radix2fft_withscaling_M->Timing.sampleTimeTaskIDPtr =
(&mdlTsMap[0]);
fi_mdl_radix2fft_withscaling_M->Timing.sampleTimes =
(&fi_mdl_radix2fft_withscaling_M->Timing.sampleTimesArray[0]);
fi_mdl_radix2fft_withscaling_M->Timing.offsetTimes =
(&fi_mdl_radix2fft_withscaling_M->Timing.offsetTimesArray[0]);
/* task periods */
fi_mdl_radix2fft_withscaling_M->Timing.sampleTimes[0] = (0.25);
/* task offsets */
fi_mdl_radix2fft_withscaling_M->Timing.offsetTimes[0] = (0.0);
}
rtmSetTPtr(fi_mdl_radix2fft_withscaling_M,
&fi_mdl_radix2fft_withscaling_M->Timing.tArray[0]);
{
int_T *mdlSampleHits =
fi_mdl_radix2fft_withscaling_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
fi_mdl_radix2fft_withscaling_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(fi_mdl_radix2fft_withscaling_M, 0.0);
fi_mdl_radix2fft_withscaling_M->Timing.stepSize0 = 0.25;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
fi_mdl_radix2fft_withscaling_M->rtwLogInfo = &rt_DataLoggingInfo;
rtliSetLogFormat(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, 0);
rtliSetLogMaxRows(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, 1000);
rtliSetLogDecimation(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, 1);
rtliSetLogVarNameModifier(fi_mdl_radix2fft_withscaling_M->rtwLogInfo,
"rt_");
rtliSetLogT(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, "tout");
rtliSetLogX(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, "");
rtliSetLogXFinal(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, "");
rtliSetSigLog(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, "");
rtliSetLogXSignalInfo(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, NULL);
rtliSetLogXSignalPtrs(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, NULL);
rtliSetLogY(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, "");
rtliSetLogYSignalInfo(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, NULL);
rtliSetLogYSignalPtrs(fi_mdl_radix2fft_withscaling_M->rtwLogInfo, NULL);
}
fi_mdl_radix2fft_withscaling_M->solverInfoPtr =
(&fi_mdl_radix2fft_withscaling_M->solverInfo);
fi_mdl_radix2fft_withscaling_M->Timing.stepSize = (0.25);
rtsiSetFixedStepSize(&fi_mdl_radix2fft_withscaling_M->solverInfo, 0.25);
rtsiSetSolverMode(&fi_mdl_radix2fft_withscaling_M->solverInfo,
SOLVER_MODE_SINGLETASKING);
/* parameters */
fi_mdl_radix2fft_withscaling_M->ModelData.defaultParam = ((real_T *)
&fi_mdl_radix2fft_withscaling_P);
/* data type work */
fi_mdl_radix2fft_withscaling_M->Work.dwork = ((void *)
&fi_mdl_radix2fft_withscaling_DWork);
(void)memset((char_T *) &fi_mdl_radix2fft_withscaling_DWork, 0,
sizeof(D_Work_fi_mdl_radix2fft_withscaling));
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
}
}
/* Registration function */
RT_MODEL_sfcndemo_sfunmem_T *sfcndemo_sfunmem(void)
{
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)sfcndemo_sfunmem_M, 0,
sizeof(RT_MODEL_sfcndemo_sfunmem_T));
/* Initialize timing info */
{
int_T *mdlTsMap = sfcndemo_sfunmem_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
sfcndemo_sfunmem_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
sfcndemo_sfunmem_M->Timing.sampleTimes =
(&sfcndemo_sfunmem_M->Timing.sampleTimesArray[0]);
sfcndemo_sfunmem_M->Timing.offsetTimes =
(&sfcndemo_sfunmem_M->Timing.offsetTimesArray[0]);
/* task periods */
sfcndemo_sfunmem_M->Timing.sampleTimes[0] = (0.01);
/* task offsets */
sfcndemo_sfunmem_M->Timing.offsetTimes[0] = (0.0);
}
rtmSetTPtr(sfcndemo_sfunmem_M, &sfcndemo_sfunmem_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = sfcndemo_sfunmem_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
sfcndemo_sfunmem_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(sfcndemo_sfunmem_M, 0.5);
sfcndemo_sfunmem_M->Timing.stepSize0 = 0.01;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
sfcndemo_sfunmem_M->rtwLogInfo = &rt_DataLoggingInfo;
}
/* Setup for data logging */
{
rtliSetLogXSignalInfo(sfcndemo_sfunmem_M->rtwLogInfo, (NULL));
rtliSetLogXSignalPtrs(sfcndemo_sfunmem_M->rtwLogInfo, (NULL));
rtliSetLogT(sfcndemo_sfunmem_M->rtwLogInfo, "tout");
rtliSetLogX(sfcndemo_sfunmem_M->rtwLogInfo, "");
rtliSetLogXFinal(sfcndemo_sfunmem_M->rtwLogInfo, "");
rtliSetSigLog(sfcndemo_sfunmem_M->rtwLogInfo, "");
rtliSetLogVarNameModifier(sfcndemo_sfunmem_M->rtwLogInfo, "rt_");
rtliSetLogFormat(sfcndemo_sfunmem_M->rtwLogInfo, 0);
rtliSetLogMaxRows(sfcndemo_sfunmem_M->rtwLogInfo, 0);
rtliSetLogDecimation(sfcndemo_sfunmem_M->rtwLogInfo, 1);
/*
* Set pointers to the data and signal info for each output
*/
{
static void * rt_LoggedOutputSignalPtrs[] = {
&sfcndemo_sfunmem_Y.Out1,
&sfcndemo_sfunmem_Y.Out2[0]
};
rtliSetLogYSignalPtrs(sfcndemo_sfunmem_M->rtwLogInfo, ((LogSignalPtrsType)
rt_LoggedOutputSignalPtrs));
}
{
static int_T rt_LoggedOutputWidths[] = {
1,
2
};
static int_T rt_LoggedOutputNumDimensions[] = {
1,
1
};
static int_T rt_LoggedOutputDimensions[] = {
1,
2
};
static boolean_T rt_LoggedOutputIsVarDims[] = {
0,
0
};
static void* rt_LoggedCurrentSignalDimensions[] = {
(NULL),
(NULL)
};
static int_T rt_LoggedCurrentSignalDimensionsSize[] = {
4,
4
};
static BuiltInDTypeId rt_LoggedOutputDataTypeIds[] = {
SS_DOUBLE,
SS_DOUBLE
};
static int_T rt_LoggedOutputComplexSignals[] = {
0,
0
};
static const char_T *rt_LoggedOutputLabels[] = {
"",
"" };
static const char_T *rt_LoggedOutputBlockNames[] = {
"sfcndemo_sfunmem/Out1",
"sfcndemo_sfunmem/Out2" };
static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 },
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 }
};
static RTWLogSignalInfo rt_LoggedOutputSignalInfo[] = {
{
2,
rt_LoggedOutputWidths,
rt_LoggedOutputNumDimensions,
rt_LoggedOutputDimensions,
rt_LoggedOutputIsVarDims,
rt_LoggedCurrentSignalDimensions,
rt_LoggedCurrentSignalDimensionsSize,
rt_LoggedOutputDataTypeIds,
rt_LoggedOutputComplexSignals,
(NULL),
{ rt_LoggedOutputLabels },
(NULL),
(NULL),
(NULL),
{ rt_LoggedOutputBlockNames },
{ (NULL) },
(NULL),
rt_RTWLogDataTypeConvert
}
};
rtliSetLogYSignalInfo(sfcndemo_sfunmem_M->rtwLogInfo,
rt_LoggedOutputSignalInfo);
/* set currSigDims field */
rt_LoggedCurrentSignalDimensions[0] = &rt_LoggedOutputWidths[0];
rt_LoggedCurrentSignalDimensions[1] = &rt_LoggedOutputWidths[1];
}
rtliSetLogY(sfcndemo_sfunmem_M->rtwLogInfo, "yout");
}
sfcndemo_sfunmem_M->solverInfoPtr = (&sfcndemo_sfunmem_M->solverInfo);
sfcndemo_sfunmem_M->Timing.stepSize = (0.01);
rtsiSetFixedStepSize(&sfcndemo_sfunmem_M->solverInfo, 0.01);
rtsiSetSolverMode(&sfcndemo_sfunmem_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
sfcndemo_sfunmem_M->ModelData.blockIO = ((void *) &sfcndemo_sfunmem_B);
{
sfcndemo_sfunmem_B.DiscretePulseGenerator = 0.0;
sfcndemo_sfunmem_B.Sum = 0.0;
}
/* parameters */
sfcndemo_sfunmem_M->ModelData.defaultParam = ((real_T *)&sfcndemo_sfunmem_P);
/* states (dwork) */
sfcndemo_sfunmem_M->ModelData.dwork = ((void *) &sfcndemo_sfunmem_DW);
(void) memset((void *)&sfcndemo_sfunmem_DW, 0,
sizeof(DW_sfcndemo_sfunmem_T));
sfcndemo_sfunmem_DW.SFunction1_RWORK.InputAtLastUpdate = 0.0;
sfcndemo_sfunmem_DW.SFunction2_RWORK.InputAtLastUpdate[0] = 0.0;
sfcndemo_sfunmem_DW.SFunction2_RWORK.InputAtLastUpdate[1] = 0.0;
/* external outputs */
sfcndemo_sfunmem_M->ModelData.outputs = (&sfcndemo_sfunmem_Y);
sfcndemo_sfunmem_Y.Out1 = 0.0;
sfcndemo_sfunmem_Y.Out2[0] = 0.0;
sfcndemo_sfunmem_Y.Out2[1] = 0.0;
/* Initialize Sizes */
sfcndemo_sfunmem_M->Sizes.numContStates = (0);/* Number of continuous states */
sfcndemo_sfunmem_M->Sizes.numY = (3);/* Number of model outputs */
sfcndemo_sfunmem_M->Sizes.numU = (0);/* Number of model inputs */
sfcndemo_sfunmem_M->Sizes.sysDirFeedThru = (0);/* The model is not direct feedthrough */
sfcndemo_sfunmem_M->Sizes.numSampTimes = (1);/* Number of sample times */
sfcndemo_sfunmem_M->Sizes.numBlocks = (7);/* Number of blocks */
sfcndemo_sfunmem_M->Sizes.numBlockIO = (4);/* Number of block outputs */
sfcndemo_sfunmem_M->Sizes.numBlockPrms = (4);/* Sum of parameter "widths" */
return sfcndemo_sfunmem_M;
}
/* Model initialize function */
void testSHM_initialize(boolean_T firstTime)
{
(void)firstTime;
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)testSHM_M,0,
sizeof(RT_MODEL_testSHM));
rtsiSetSolverName(&testSHM_M->solverInfo,"FixedStepDiscrete");
testSHM_M->solverInfoPtr = (&testSHM_M->solverInfo);
/* Initialize timing info */
{
int_T *mdlTsMap = testSHM_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
testSHM_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
testSHM_M->Timing.sampleTimes = (&testSHM_M->Timing.sampleTimesArray[0]);
testSHM_M->Timing.offsetTimes = (&testSHM_M->Timing.offsetTimesArray[0]);
/* task periods */
testSHM_M->Timing.sampleTimes[0] = (0.001);
/* task offsets */
testSHM_M->Timing.offsetTimes[0] = (0.0);
}
rtmSetTPtr(testSHM_M, &testSHM_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = testSHM_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
testSHM_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(testSHM_M, 10.0);
testSHM_M->Timing.stepSize0 = 0.001;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
testSHM_M->rtwLogInfo = &rt_DataLoggingInfo;
rtliSetLogXSignalInfo(testSHM_M->rtwLogInfo, (NULL));
rtliSetLogXSignalPtrs(testSHM_M->rtwLogInfo, (NULL));
rtliSetLogT(testSHM_M->rtwLogInfo, "tout");
rtliSetLogX(testSHM_M->rtwLogInfo, "");
rtliSetLogXFinal(testSHM_M->rtwLogInfo, "");
rtliSetSigLog(testSHM_M->rtwLogInfo, "");
rtliSetLogVarNameModifier(testSHM_M->rtwLogInfo, "rt_");
rtliSetLogFormat(testSHM_M->rtwLogInfo, 0);
rtliSetLogMaxRows(testSHM_M->rtwLogInfo, 1000);
rtliSetLogDecimation(testSHM_M->rtwLogInfo, 1);
rtliSetLogY(testSHM_M->rtwLogInfo, "");
rtliSetLogYSignalInfo(testSHM_M->rtwLogInfo, (NULL));
rtliSetLogYSignalPtrs(testSHM_M->rtwLogInfo, (NULL));
}
testSHM_M->solverInfoPtr = (&testSHM_M->solverInfo);
testSHM_M->Timing.stepSize = (0.001);
rtsiSetFixedStepSize(&testSHM_M->solverInfo, 0.001);
rtsiSetSolverMode(&testSHM_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
testSHM_M->ModelData.blockIO = ((void *) &testSHM_B);
(void) memset(((void *) &testSHM_B),0,
sizeof(BlockIO_testSHM));
/* parameters */
testSHM_M->ModelData.defaultParam = ((real_T *) &testSHM_P);
/* states (dwork) */
testSHM_M->Work.dwork = ((void *) &testSHM_DWork);
(void) memset((void *)&testSHM_DWork, 0,
sizeof(D_Work_testSHM));
/* C API for Parameter Tuning and/or Signal Monitoring */
{
static ModelMappingInfo mapInfo;
(void) memset((char_T *) &mapInfo,0,
sizeof(mapInfo));
/* block signal monitoring map */
mapInfo.Signals.blockIOSignals = &rtBIOSignals[0];
mapInfo.Signals.numBlockIOSignals = 2;
/* parameter tuning maps */
mapInfo.Parameters.blockTuning = &rtBlockTuning[0];
mapInfo.Parameters.variableTuning = &rtVariableTuning[0];
mapInfo.Parameters.parametersMap = rtParametersMap;
mapInfo.Parameters.dimensionsMap = rtDimensionsMap;
mapInfo.Parameters.numBlockTuning = 4;
mapInfo.Parameters.numVariableTuning = 0;
testSHM_M->SpecialInfo.mappingInfo = (&mapInfo);
}
/* child S-Function registration */
{
RTWSfcnInfo *sfcnInfo = &testSHM_M->NonInlinedSFcns.sfcnInfo;
testSHM_M->sfcnInfo = (sfcnInfo);
rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(testSHM_M)));
rtssSetNumRootSampTimesPtr(sfcnInfo, &testSHM_M->Sizes.numSampTimes);
rtssSetTPtrPtr(sfcnInfo, &rtmGetTPtr(testSHM_M));
rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(testSHM_M));
rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(testSHM_M));
rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(testSHM_M));
rtssSetStepSizePtr(sfcnInfo, &testSHM_M->Timing.stepSize);
rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(testSHM_M));
rtssSetDerivCacheNeedsResetPtr(sfcnInfo,
&testSHM_M->ModelData.derivCacheNeedsReset);
rtssSetZCCacheNeedsResetPtr(sfcnInfo,
&testSHM_M->ModelData.zCCacheNeedsReset);
rtssSetBlkStateChangePtr(sfcnInfo, &testSHM_M->ModelData.blkStateChange);
rtssSetSampleHitsPtr(sfcnInfo, &testSHM_M->Timing.sampleHits);
rtssSetPerTaskSampleHitsPtr(sfcnInfo, &testSHM_M->Timing.perTaskSampleHits);
rtssSetSimModePtr(sfcnInfo, &testSHM_M->simMode);
rtssSetSolverInfoPtr(sfcnInfo, &testSHM_M->solverInfoPtr);
}
testSHM_M->Sizes.numSFcns = (2);
/* register each child */
{
(void) memset((void *)&testSHM_M->NonInlinedSFcns.childSFunctions[0],0,
2*sizeof(SimStruct));
testSHM_M->childSfunctions = (&testSHM_M->
NonInlinedSFcns.childSFunctionPtrs[0]);
testSHM_M->childSfunctions[0] = (&testSHM_M->
NonInlinedSFcns.childSFunctions[0]);
testSHM_M->childSfunctions[1] = (&testSHM_M->
NonInlinedSFcns.childSFunctions[1]);
/* Level2 S-Function Block: testSHM/<Root>/S-Function (sSHM) */
{
SimStruct *rts = testSHM_M->childSfunctions[0];
/* timing info */
time_T *sfcnPeriod = testSHM_M->NonInlinedSFcns.Sfcn0.sfcnPeriod;
time_T *sfcnOffset = testSHM_M->NonInlinedSFcns.Sfcn0.sfcnOffset;
int_T *sfcnTsMap = testSHM_M->NonInlinedSFcns.Sfcn0.sfcnTsMap;
(void) memset((void*)sfcnPeriod,0,
sizeof(time_T)*1);
(void) memset((void*)sfcnOffset,0,
sizeof(time_T)*1);
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
/* Set up the mdlInfo pointer */
{
ssSetBlkInfo2Ptr(rts, &testSHM_M->NonInlinedSFcns.blkInfo2[0]);
ssSetRTWSfcnInfo(rts, testSHM_M->sfcnInfo);
}
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &testSHM_M->NonInlinedSFcns.methods2[0]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &testSHM_M->NonInlinedSFcns.methods3[0]);
}
/* inputs */
{
_ssSetNumInputPorts(rts, 1);
ssSetPortInfoForInputs(rts,
&testSHM_M->NonInlinedSFcns.Sfcn0.inputPortInfo[0]);
/* port 0 */
{
ssSetInputPortRequiredContiguous(rts, 0, 1);
ssSetInputPortSignal(rts, 0, testSHM_B.TmpHiddenBufferAtSFunctionInpor);
_ssSetInputPortNumDimensions(rts, 0, 1);
ssSetInputPortWidth(rts, 0, 3);
}
}
/* outputs */
{
ssSetPortInfoForOutputs(rts,
&testSHM_M->NonInlinedSFcns.Sfcn0.outputPortInfo[0]);
_ssSetNumOutputPorts(rts, 1);
/* port 0 */
{
_ssSetOutputPortNumDimensions(rts, 0, 1);
ssSetOutputPortWidth(rts, 0, 3);
ssSetOutputPortSignal(rts, 0, ((real_T *) testSHM_B.SFunction));
}
}
/* path info */
ssSetModelName(rts, "S-Function");
ssSetPath(rts, "testSHM/S-Function");
ssSetRTModel(rts,testSHM_M);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* work vectors */
{
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
&testSHM_M->NonInlinedSFcns.Sfcn0.dWork;
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
&testSHM_M->NonInlinedSFcns.Sfcn0.dWorkAux;
ssSetSFcnDWork(rts, dWorkRecord);
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
_ssSetNumDWork(rts, 2);
/* DWORK1 */
ssSetDWorkWidth(rts, 0, 1);
ssSetDWorkDataType(rts, 0,SS_POINTER);
ssSetDWorkComplexSignal(rts, 0, 0);
ssSetDWork(rts, 0, &testSHM_DWork.SFunction_DWORK1);
/* DWORK2 */
ssSetDWorkWidth(rts, 1, 1);
ssSetDWorkDataType(rts, 1,SS_POINTER);
ssSetDWorkComplexSignal(rts, 1, 0);
ssSetDWork(rts, 1, &testSHM_DWork.SFunction_DWORK2);
}
/* registration */
sSHM(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.001);
ssSetOffsetTime(rts, 0, 0.0);
sfcnTsMap[0] = 0;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetInputPortConnected(rts, 0, 1);
_ssSetOutputPortConnected(rts, 0, 1);
_ssSetOutputPortBeingMerged(rts, 0, 0);
/* Update the BufferDstPort flags for each input port */
ssSetInputPortBufferDstPort(rts, 0, -1);
}
/* Level2 S-Function Block: testSHM/<Root>/RTAI_SCOPE (sfun_rtai_scope) */
{
SimStruct *rts = testSHM_M->childSfunctions[1];
/* timing info */
time_T *sfcnPeriod = testSHM_M->NonInlinedSFcns.Sfcn1.sfcnPeriod;
time_T *sfcnOffset = testSHM_M->NonInlinedSFcns.Sfcn1.sfcnOffset;
int_T *sfcnTsMap = testSHM_M->NonInlinedSFcns.Sfcn1.sfcnTsMap;
(void) memset((void*)sfcnPeriod,0,
sizeof(time_T)*1);
(void) memset((void*)sfcnOffset,0,
sizeof(time_T)*1);
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
/* Set up the mdlInfo pointer */
{
ssSetBlkInfo2Ptr(rts, &testSHM_M->NonInlinedSFcns.blkInfo2[1]);
ssSetRTWSfcnInfo(rts, testSHM_M->sfcnInfo);
}
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &testSHM_M->NonInlinedSFcns.methods2[1]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &testSHM_M->NonInlinedSFcns.methods3[1]);
}
/* inputs */
{
_ssSetNumInputPorts(rts, 3);
ssSetPortInfoForInputs(rts,
&testSHM_M->NonInlinedSFcns.Sfcn1.inputPortInfo[0]);
/* port 0 */
{
real_T const **sfcnUPtrs = (real_T const **)
&testSHM_M->NonInlinedSFcns.Sfcn1.UPtrs0;
sfcnUPtrs[0] = &testSHM_B.SFunction[0];
ssSetInputPortSignalPtrs(rts, 0, (InputPtrsType)&sfcnUPtrs[0]);
_ssSetInputPortNumDimensions(rts, 0, 1);
ssSetInputPortWidth(rts, 0, 1);
}
/* port 1 */
{
real_T const **sfcnUPtrs = (real_T const **)
&testSHM_M->NonInlinedSFcns.Sfcn1.UPtrs1;
sfcnUPtrs[0] = &testSHM_B.SFunction[1];
ssSetInputPortSignalPtrs(rts, 1, (InputPtrsType)&sfcnUPtrs[0]);
_ssSetInputPortNumDimensions(rts, 1, 1);
ssSetInputPortWidth(rts, 1, 1);
}
/* port 2 */
{
real_T const **sfcnUPtrs = (real_T const **)
&testSHM_M->NonInlinedSFcns.Sfcn1.UPtrs2;
sfcnUPtrs[0] = &testSHM_B.SFunction[2];
ssSetInputPortSignalPtrs(rts, 2, (InputPtrsType)&sfcnUPtrs[0]);
_ssSetInputPortNumDimensions(rts, 2, 1);
ssSetInputPortWidth(rts, 2, 1);
}
}
/* path info */
ssSetModelName(rts, "RTAI_SCOPE");
ssSetPath(rts, "testSHM/RTAI_SCOPE");
ssSetRTModel(rts,testSHM_M);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* parameters */
{
mxArray **sfcnParams = (mxArray **)
&testSHM_M->NonInlinedSFcns.Sfcn1.params;
ssSetSFcnParamsCount(rts, 2);
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
ssSetSFcnParam(rts, 0, (mxArray*)&testSHM_P.RTAI_SCOPE_P1_Size[0]);
ssSetSFcnParam(rts, 1, (mxArray*)&testSHM_P.RTAI_SCOPE_P2_Size[0]);
}
/* work vectors */
ssSetPWork(rts, (void **) &testSHM_DWork.RTAI_SCOPE_PWORK);
{
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
&testSHM_M->NonInlinedSFcns.Sfcn1.dWork;
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
&testSHM_M->NonInlinedSFcns.Sfcn1.dWorkAux;
ssSetSFcnDWork(rts, dWorkRecord);
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
_ssSetNumDWork(rts, 1);
/* PWORK */
ssSetDWorkWidth(rts, 0, 1);
ssSetDWorkDataType(rts, 0,SS_POINTER);
ssSetDWorkComplexSignal(rts, 0, 0);
ssSetDWork(rts, 0, &testSHM_DWork.RTAI_SCOPE_PWORK);
}
/* registration */
sfun_rtai_scope(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.001);
ssSetOffsetTime(rts, 0, 0.0);
sfcnTsMap[0] = 0;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetInputPortConnected(rts, 0, 1);
_ssSetInputPortConnected(rts, 1, 1);
_ssSetInputPortConnected(rts, 2, 1);
/* Update the BufferDstPort flags for each input port */
ssSetInputPortBufferDstPort(rts, 0, -1);
ssSetInputPortBufferDstPort(rts, 1, -1);
ssSetInputPortBufferDstPort(rts, 2, -1);
}
}
}
/* Model initialize function */
void Mechanics_initialize(boolean_T firstTime)
{
(void)firstTime;
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T)); /* initialize real-time model */
(void) memset((char_T *)Mechanics_M,0,
sizeof(RT_MODEL_Mechanics));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&Mechanics_M->solverInfo,
&Mechanics_M->Timing.simTimeStep);
rtsiSetTPtr(&Mechanics_M->solverInfo, &rtmGetTPtr(Mechanics_M));
rtsiSetStepSizePtr(&Mechanics_M->solverInfo, &Mechanics_M->Timing.stepSize0);
rtsiSetdXPtr(&Mechanics_M->solverInfo, &Mechanics_M->ModelData.derivs);
rtsiSetContStatesPtr(&Mechanics_M->solverInfo,
&Mechanics_M->ModelData.contStates);
rtsiSetNumContStatesPtr(&Mechanics_M->solverInfo,
&Mechanics_M->Sizes.numContStates);
rtsiSetErrorStatusPtr(&Mechanics_M->solverInfo, (&rtmGetErrorStatus
(Mechanics_M)));
rtsiSetRTModelPtr(&Mechanics_M->solverInfo, Mechanics_M);
}
rtsiSetSimTimeStep(&Mechanics_M->solverInfo, MAJOR_TIME_STEP);
Mechanics_M->ModelData.intgData.y = Mechanics_M->ModelData.odeY;
Mechanics_M->ModelData.intgData.f[0] = Mechanics_M->ModelData.odeF[0];
Mechanics_M->ModelData.intgData.f[1] = Mechanics_M->ModelData.odeF[1];
Mechanics_M->ModelData.intgData.f[2] = Mechanics_M->ModelData.odeF[2];
Mechanics_M->ModelData.contStates = ((real_T *) &Mechanics_X);
rtsiSetSolverData(&Mechanics_M->solverInfo, (void *)
&Mechanics_M->ModelData.intgData);
rtsiSetSolverName(&Mechanics_M->solverInfo,"ode3");
Mechanics_M->solverInfoPtr = (&Mechanics_M->solverInfo);
/* Initialize timing info */
{
int_T *mdlTsMap = Mechanics_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
Mechanics_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
Mechanics_M->Timing.sampleTimes = (&Mechanics_M->Timing.sampleTimesArray[0]);
Mechanics_M->Timing.offsetTimes = (&Mechanics_M->Timing.offsetTimesArray[0]);
/* task periods */
Mechanics_M->Timing.sampleTimes[0] = (0.0);
Mechanics_M->Timing.sampleTimes[1] = (35.0);
/* task offsets */
Mechanics_M->Timing.offsetTimes[0] = (0.0);
Mechanics_M->Timing.offsetTimes[1] = (0.0);
}
rtmSetTPtr(Mechanics_M, &Mechanics_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = Mechanics_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
Mechanics_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(Mechanics_M, -1);
Mechanics_M->Timing.stepSize0 = 35.0;
Mechanics_M->Timing.stepSize1 = 35.0;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
Mechanics_M->rtwLogInfo = &rt_DataLoggingInfo;
rtliSetLogFormat(Mechanics_M->rtwLogInfo, 0);
rtliSetLogMaxRows(Mechanics_M->rtwLogInfo, 1000);
rtliSetLogDecimation(Mechanics_M->rtwLogInfo, 1);
rtliSetLogVarNameModifier(Mechanics_M->rtwLogInfo, "rt_");
rtliSetLogT(Mechanics_M->rtwLogInfo, "tout");
rtliSetLogX(Mechanics_M->rtwLogInfo, "");
rtliSetLogXFinal(Mechanics_M->rtwLogInfo, "");
rtliSetSigLog(Mechanics_M->rtwLogInfo, "");
rtliSetLogXSignalInfo(Mechanics_M->rtwLogInfo, NULL);
rtliSetLogXSignalPtrs(Mechanics_M->rtwLogInfo, NULL);
rtliSetLogY(Mechanics_M->rtwLogInfo, "");
rtliSetLogYSignalInfo(Mechanics_M->rtwLogInfo, NULL);
rtliSetLogYSignalPtrs(Mechanics_M->rtwLogInfo, NULL);
}
Mechanics_M->solverInfoPtr = (&Mechanics_M->solverInfo);
Mechanics_M->Timing.stepSize = (35.0);
rtsiSetFixedStepSize(&Mechanics_M->solverInfo, 35.0);
rtsiSetSolverMode(&Mechanics_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
Mechanics_M->ModelData.blockIO = ((void *) &Mechanics_B);
{
int_T i;
void *pVoidBlockIORegion;
pVoidBlockIORegion = (void *)(&Mechanics_B.Arduino);
for (i = 0; i < 18; i++) {
((real_T*)pVoidBlockIORegion)[i] = 0.0;
}
}
/* parameters */
Mechanics_M->ModelData.defaultParam = ((real_T *) &Mechanics_P);
/* states (continuous) */
{
real_T *x = (real_T *) &Mechanics_X;
Mechanics_M->ModelData.contStates = (x);
(void) memset((char_T *)x,0,
sizeof(ContinuousStates_Mechanics));
}
/* states (dwork) */
Mechanics_M->Work.dwork = ((void *) &Mechanics_DWork);
(void) memset((char_T *) &Mechanics_DWork,0,
sizeof(D_Work_Mechanics));
/* child S-Function registration */
{
RTWSfcnInfo *sfcnInfo = &Mechanics_M->NonInlinedSFcns.sfcnInfo;
Mechanics_M->sfcnInfo = (sfcnInfo);
rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(Mechanics_M)));
rtssSetNumRootSampTimesPtr(sfcnInfo, &Mechanics_M->Sizes.numSampTimes);
rtssSetTPtrPtr(sfcnInfo, &rtmGetTPtr(Mechanics_M));
rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(Mechanics_M));
rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(Mechanics_M));
rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(Mechanics_M));
rtssSetStepSizePtr(sfcnInfo, &Mechanics_M->Timing.stepSize);
rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(Mechanics_M));
rtssSetDerivCacheNeedsResetPtr(sfcnInfo,
&Mechanics_M->ModelData.derivCacheNeedsReset);
rtssSetZCCacheNeedsResetPtr(sfcnInfo,
&Mechanics_M->ModelData.zCCacheNeedsReset);
rtssSetBlkStateChangePtr(sfcnInfo, &Mechanics_M->ModelData.blkStateChange);
rtssSetSampleHitsPtr(sfcnInfo, &Mechanics_M->Timing.sampleHits);
rtssSetPerTaskSampleHitsPtr(sfcnInfo, &Mechanics_M->Timing.perTaskSampleHits);
rtssSetSimModePtr(sfcnInfo, &Mechanics_M->simMode);
rtssSetSolverInfoPtr(sfcnInfo, &Mechanics_M->solverInfoPtr);
}
Mechanics_M->Sizes.numSFcns = (1);
/* register each child */
{
(void) memset((void *)&Mechanics_M->NonInlinedSFcns.childSFunctions[0],0,
1*sizeof(SimStruct));
Mechanics_M->childSfunctions =
(&Mechanics_M->NonInlinedSFcns.childSFunctionPtrs[0]);
Mechanics_M->childSfunctions[0] =
(&Mechanics_M->NonInlinedSFcns.childSFunctions[0]);
/* Level2 S-Function Block: Mechanics/<Root>/Arduino (QueryInstrument) */
{
SimStruct *rts = Mechanics_M->childSfunctions[0];
/* timing info */
time_T *sfcnPeriod = Mechanics_M->NonInlinedSFcns.Sfcn0.sfcnPeriod;
time_T *sfcnOffset = Mechanics_M->NonInlinedSFcns.Sfcn0.sfcnOffset;
int_T *sfcnTsMap = Mechanics_M->NonInlinedSFcns.Sfcn0.sfcnTsMap;
(void) memset((void*)sfcnPeriod,0,
sizeof(time_T)*1);
(void) memset((void*)sfcnOffset,0,
sizeof(time_T)*1);
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
/* Set up the mdlInfo pointer */
{
ssSetBlkInfo2Ptr(rts, &Mechanics_M->NonInlinedSFcns.blkInfo2[0]);
ssSetRTWSfcnInfo(rts, Mechanics_M->sfcnInfo);
}
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &Mechanics_M->NonInlinedSFcns.methods2[0]);
}
/* outputs */
{
ssSetPortInfoForOutputs(rts,
&Mechanics_M->NonInlinedSFcns.Sfcn0.outputPortInfo[0]);
_ssSetNumOutputPorts(rts, 1);
/* port 0 */
{
_ssSetOutputPortNumDimensions(rts, 0, 1);
ssSetOutputPortWidth(rts, 0, 1);
ssSetOutputPortSignal(rts, 0, ((real_T *) &Mechanics_B.Arduino));
}
}
/* path info */
ssSetModelName(rts, "Arduino");
ssSetPath(rts, "Mechanics/Arduino");
ssSetRTModel(rts,Mechanics_M);
ssSetParentSS(rts, NULL);
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* parameters */
{
mxArray **sfcnParams = (mxArray **)
&Mechanics_M->NonInlinedSFcns.Sfcn0.params;
ssSetSFcnParamsCount(rts, 39);
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
ssSetSFcnParam(rts, 0, (mxArray*)&Mechanics_P.Arduino_P1_Size[0]);
ssSetSFcnParam(rts, 1, (mxArray*)&Mechanics_P.Arduino_P2_Size[0]);
ssSetSFcnParam(rts, 2, (mxArray*)&Mechanics_P.Arduino_P3_Size[0]);
ssSetSFcnParam(rts, 3, (mxArray*)&Mechanics_P.Arduino_P4_Size[0]);
ssSetSFcnParam(rts, 4, (mxArray*)&Mechanics_P.Arduino_P5_Size[0]);
ssSetSFcnParam(rts, 5, (mxArray*)&Mechanics_P.Arduino_P6_Size[0]);
ssSetSFcnParam(rts, 6, (mxArray*)&Mechanics_P.Arduino_P7_Size[0]);
ssSetSFcnParam(rts, 7, (mxArray*)&Mechanics_P.Arduino_P8_Size[0]);
ssSetSFcnParam(rts, 8, (mxArray*)&Mechanics_P.Arduino_P9_Size[0]);
ssSetSFcnParam(rts, 9, (mxArray*)&Mechanics_P.Arduino_P10_Size[0]);
ssSetSFcnParam(rts, 10, (mxArray*)&Mechanics_P.Arduino_P11_Size[0]);
ssSetSFcnParam(rts, 11, (mxArray*)&Mechanics_P.Arduino_P12_Size[0]);
ssSetSFcnParam(rts, 12, (mxArray*)&Mechanics_P.Arduino_P13_Size[0]);
ssSetSFcnParam(rts, 13, (mxArray*)&Mechanics_P.Arduino_P14_Size[0]);
ssSetSFcnParam(rts, 14, (mxArray*)&Mechanics_P.Arduino_P15_Size[0]);
ssSetSFcnParam(rts, 15, (mxArray*)&Mechanics_P.Arduino_P16_Size[0]);
ssSetSFcnParam(rts, 16, (mxArray*)&Mechanics_P.Arduino_P17_Size[0]);
ssSetSFcnParam(rts, 17, (mxArray*)&Mechanics_P.Arduino_P18_Size[0]);
ssSetSFcnParam(rts, 18, (mxArray*)&Mechanics_P.Arduino_P19_Size[0]);
ssSetSFcnParam(rts, 19, (mxArray*)&Mechanics_P.Arduino_P20_Size[0]);
ssSetSFcnParam(rts, 20, (mxArray*)&Mechanics_P.Arduino_P21_Size[0]);
ssSetSFcnParam(rts, 21, (mxArray*)&Mechanics_P.Arduino_P22_Size[0]);
ssSetSFcnParam(rts, 22, (mxArray*)&Mechanics_P.Arduino_P23_Size[0]);
ssSetSFcnParam(rts, 23, (mxArray*)&Mechanics_P.Arduino_P24_Size[0]);
ssSetSFcnParam(rts, 24, (mxArray*)&Mechanics_P.Arduino_P25_Size[0]);
ssSetSFcnParam(rts, 25, (mxArray*)&Mechanics_P.Arduino_P26_Size[0]);
ssSetSFcnParam(rts, 26, (mxArray*)&Mechanics_P.Arduino_P27_Size[0]);
ssSetSFcnParam(rts, 27, (mxArray*)&Mechanics_P.Arduino_P28_Size[0]);
ssSetSFcnParam(rts, 28, (mxArray*)&Mechanics_P.Arduino_P29_Size[0]);
ssSetSFcnParam(rts, 29, (mxArray*)&Mechanics_P.Arduino_P30_Size[0]);
ssSetSFcnParam(rts, 30, (mxArray*)&Mechanics_P.Arduino_P31_Size[0]);
ssSetSFcnParam(rts, 31, (mxArray*)&Mechanics_P.Arduino_P32_Size[0]);
ssSetSFcnParam(rts, 32, (mxArray*)&Mechanics_P.Arduino_P33_Size[0]);
ssSetSFcnParam(rts, 33, (mxArray*)&Mechanics_P.Arduino_P34_Size[0]);
ssSetSFcnParam(rts, 34, (mxArray*)&Mechanics_P.Arduino_P35_Size[0]);
ssSetSFcnParam(rts, 35, (mxArray*)&Mechanics_P.Arduino_P36_Size[0]);
ssSetSFcnParam(rts, 36, (mxArray*)&Mechanics_P.Arduino_P37_Size[0]);
ssSetSFcnParam(rts, 37, (mxArray*)&Mechanics_P.Arduino_P38_Size[0]);
ssSetSFcnParam(rts, 38, (mxArray*)&Mechanics_P.Arduino_P39_Size[0]);
}
/* work vectors */
ssSetPWork(rts, (void **) &Mechanics_DWork.Arduino_PWORK);
{
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
&Mechanics_M->NonInlinedSFcns.Sfcn0.dWork;
ssSetSFcnDWork(rts, dWorkRecord);
_ssSetNumDWork(rts, 1);
/* PWORK */
ssSetDWorkWidth(rts, 0, 1);
ssSetDWorkDataType(rts, 0,SS_POINTER);
ssSetDWorkComplexSignal(rts, 0, 0);
ssSetDWork(rts, 0, &Mechanics_DWork.Arduino_PWORK);
}
/* registration */
QueryInstrument(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 35.0);
ssSetOffsetTime(rts, 0, 0.0);
sfcnTsMap[0] = 1;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetOutputPortConnected(rts, 0, 1);
_ssSetOutputPortBeingMerged(rts, 0, 0);
/* Update the BufferDstPort flags for each input port */
}
}
}
/* Model initialize function */
void m1006_initialize(boolean_T firstTime)
{
if (firstTime) {
/* registration code */
/* initialize real-time model */
(void)memset((char_T *)m1006_M, 0, sizeof(rtModel_m1006));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&m1006_M->solverInfo, &m1006_M->Timing.simTimeStep);
rtsiSetTPtr(&m1006_M->solverInfo, &rtmGetTPtr(m1006_M));
rtsiSetStepSizePtr(&m1006_M->solverInfo, &m1006_M->Timing.stepSize0);
rtsiSetdXPtr(&m1006_M->solverInfo, &m1006_M->ModelData.derivs);
rtsiSetContStatesPtr(&m1006_M->solverInfo, &m1006_M->ModelData.contStates);
rtsiSetNumContStatesPtr(&m1006_M->solverInfo,
&m1006_M->Sizes.numContStates);
rtsiSetErrorStatusPtr(&m1006_M->solverInfo, &rtmGetErrorStatus(m1006_M));
rtsiSetRTModelPtr(&m1006_M->solverInfo, m1006_M);
}
rtsiSetSimTimeStep(&m1006_M->solverInfo, MAJOR_TIME_STEP);
m1006_M->ModelData.intgData.y = m1006_M->ModelData.odeY;
m1006_M->ModelData.intgData.f[0] = m1006_M->ModelData.odeF[0];
m1006_M->ModelData.intgData.f[1] = m1006_M->ModelData.odeF[1];
m1006_M->ModelData.intgData.f[2] = m1006_M->ModelData.odeF[2];
m1006_M->ModelData.intgData.f[3] = m1006_M->ModelData.odeF[3];
m1006_M->ModelData.contStates = ((real_T *) &m1006_X);
rtsiSetSolverData(&m1006_M->solverInfo, (void
*)&m1006_M->ModelData.intgData);
rtsiSetSolverName(&m1006_M->solverInfo,"ode4");
/* Initialize timing info */
{
int_T *mdlTsMap = m1006_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
m1006_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
m1006_M->Timing.sampleTimes = (&m1006_M->Timing.sampleTimesArray[0]);
m1006_M->Timing.offsetTimes = (&m1006_M->Timing.offsetTimesArray[0]);
/* task periods */
m1006_M->Timing.sampleTimes[0] = (0.0);
m1006_M->Timing.sampleTimes[1] = (0.1);
/* task offsets */
m1006_M->Timing.offsetTimes[0] = (0.0);
m1006_M->Timing.offsetTimes[1] = (0.0);
}
rtmSetTPtr(m1006_M, &m1006_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = m1006_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
m1006_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(m1006_M, 10.0);
m1006_M->Timing.stepSize0 = 0.1;
m1006_M->Timing.stepSize1 = 0.1;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
m1006_M->rtwLogInfo = &rt_DataLoggingInfo;
rtliSetLogFormat(m1006_M->rtwLogInfo, 0);
rtliSetLogMaxRows(m1006_M->rtwLogInfo, 1000);
rtliSetLogDecimation(m1006_M->rtwLogInfo, 1);
rtliSetLogVarNameModifier(m1006_M->rtwLogInfo, "rt_");
rtliSetLogT(m1006_M->rtwLogInfo, "tout");
rtliSetLogX(m1006_M->rtwLogInfo, "");
rtliSetLogXFinal(m1006_M->rtwLogInfo, "");
rtliSetSigLog(m1006_M->rtwLogInfo, "");
rtliSetLogXSignalInfo(m1006_M->rtwLogInfo, NULL);
rtliSetLogXSignalPtrs(m1006_M->rtwLogInfo, NULL);
rtliSetLogY(m1006_M->rtwLogInfo, "yout");
/*
* Set pointers to the data and signal info for each output
*/
{
static void * rt_LoggedOutputSignalPtrs[] = {
&m1006_Y.Out1
};
rtliSetLogYSignalPtrs(m1006_M->rtwLogInfo,
((LogSignalPtrsType)rt_LoggedOutputSignalPtrs));
}
{
static int_T rt_LoggedOutputWidths[] = {
1
};
static int_T rt_LoggedOutputNumDimensions[] = {
1
};
static int_T rt_LoggedOutputDimensions[] = {
1
};
static BuiltInDTypeId rt_LoggedOutputDataTypeIds[] = {
SS_DOUBLE
};
static int_T rt_LoggedOutputComplexSignals[] = {
0
};
static const char_T *rt_LoggedOutputLabels[] = {
""};
static const char_T *rt_LoggedOutputBlockNames[] = {
"m1006/Out1"};
static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
{ 0, SS_DOUBLE, SS_DOUBLE, 1.0, 0, 0.0}
};
static RTWLogSignalInfo rt_LoggedOutputSignalInfo[] = {
{
1,
rt_LoggedOutputWidths,
rt_LoggedOutputNumDimensions,
rt_LoggedOutputDimensions,
rt_LoggedOutputDataTypeIds,
rt_LoggedOutputComplexSignals,
NULL,
rt_LoggedOutputLabels,
NULL,
NULL,
NULL,
rt_LoggedOutputBlockNames,
NULL,
rt_RTWLogDataTypeConvert
}
};
rtliSetLogYSignalInfo(m1006_M->rtwLogInfo, rt_LoggedOutputSignalInfo);
}
}
m1006_M->solverInfoPtr = (&m1006_M->solverInfo);
m1006_M->Timing.stepSize = (0.1);
rtsiSetFixedStepSize(&m1006_M->solverInfo, 0.1);
rtsiSetSolverMode(&m1006_M->solverInfo, SOLVER_MODE_SINGLETASKING);
{
/* block I/O */
void *b = (void *) &m1006_B;
m1006_M->ModelData.blockIO = (b);
{
int_T i;
b =&m1006_B.SineWave;
for (i = 0; i < 2; i++) {
((real_T*)b)[i] = 0.0;
}
}
}
/* parameters */
m1006_M->ModelData.defaultParam = ((real_T *) &m1006_P);
/* states */
{
real_T *x = (real_T *) &m1006_X;
m1006_M->ModelData.contStates = (x);
(void)memset((char_T *)x, 0, sizeof(ContinuousStates_m1006));
}
/* external outputs */
m1006_M->ModelData.outputs = (&m1006_Y);
m1006_Y.Out1 = 0.0;
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
}
}
void trajectory_test_initialize(boolean_T firstTime)
{
if (firstTime) {
/* Registration code */
/* initialize real-time model */
(void) memset((char_T *)trajectory_test_M,0,
sizeof(RT_MODEL_trajectory_test));
/* Initialize timing info */
{
int_T *mdlTsMap = trajectory_test_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
trajectory_test_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
trajectory_test_M->Timing.sampleTimes =
(&trajectory_test_M->Timing.sampleTimesArray[0]);
trajectory_test_M->Timing.offsetTimes =
(&trajectory_test_M->Timing.offsetTimesArray[0]);
/* task periods */
trajectory_test_M->Timing.sampleTimes[0] = (0.01);
/* task offsets */
trajectory_test_M->Timing.offsetTimes[0] = (0.0);
}
rtmSetTPtr(trajectory_test_M, &trajectory_test_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = trajectory_test_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
trajectory_test_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(trajectory_test_M, 20.0);
trajectory_test_M->Timing.stepSize0 = 0.01;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
trajectory_test_M->rtwLogInfo = &rt_DataLoggingInfo;
rtliSetLogFormat(trajectory_test_M->rtwLogInfo, 0);
rtliSetLogMaxRows(trajectory_test_M->rtwLogInfo, 1000);
rtliSetLogDecimation(trajectory_test_M->rtwLogInfo, 1);
rtliSetLogVarNameModifier(trajectory_test_M->rtwLogInfo, "rt_");
rtliSetLogT(trajectory_test_M->rtwLogInfo, "tout");
rtliSetLogX(trajectory_test_M->rtwLogInfo, "");
rtliSetLogXFinal(trajectory_test_M->rtwLogInfo, "");
rtliSetSigLog(trajectory_test_M->rtwLogInfo, "");
rtliSetLogXSignalInfo(trajectory_test_M->rtwLogInfo, NULL);
rtliSetLogXSignalPtrs(trajectory_test_M->rtwLogInfo, NULL);
rtliSetLogY(trajectory_test_M->rtwLogInfo, "");
rtliSetLogYSignalInfo(trajectory_test_M->rtwLogInfo, NULL);
rtliSetLogYSignalPtrs(trajectory_test_M->rtwLogInfo, NULL);
}
trajectory_test_M->solverInfoPtr = (&trajectory_test_M->solverInfo);
trajectory_test_M->Timing.stepSize = (0.01);
rtsiSetFixedStepSize(&trajectory_test_M->solverInfo, 0.01);
rtsiSetSolverMode(&trajectory_test_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
trajectory_test_M->ModelData.blockIO = ((void *) &trajectory_test_B);
{
int_T i;
void *pVoidBlockIORegion;
pVoidBlockIORegion = (void *)(&trajectory_test_B.sf_Trajectorydesign2.a0);
for (i = 0; i < 6; i++) {
((real_T*)pVoidBlockIORegion)[i] = 0.0;
}
pVoidBlockIORegion = (void *)(&trajectory_test_B.sf_Trajectorydesign1.a0);
for (i = 0; i < 6; i++) {
((real_T*)pVoidBlockIORegion)[i] = 0.0;
}
((real_T*)&trajectory_test_B.sf_Jointreferencesi_m.qa)[0] = 0.0;
((real_T*)&trajectory_test_B.sf_Jointreferencesing.qa)[0] = 0.0;
}
/* parameters */
trajectory_test_M->ModelData.defaultParam = ((real_T *) &trajectory_test_P);
/* states (dwork) */
trajectory_test_M->Work.dwork = ((void *) &trajectory_test_DWork);
(void) memset((char_T *) &trajectory_test_DWork,0,
sizeof(D_Work_trajectory_test));
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
}
}
/* Model initialize function */
void Hammerstein_initialize(void)
{
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)Hammerstein_M, 0,
sizeof(RT_MODEL_Hammerstein));
rtsiSetSolverName(&Hammerstein_M->solverInfo,"FixedStepDiscrete");
Hammerstein_M->solverInfoPtr = (&Hammerstein_M->solverInfo);
/* Initialize timing info */
{
int_T *mdlTsMap = Hammerstein_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
Hammerstein_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
Hammerstein_M->Timing.sampleTimes = (&Hammerstein_M->
Timing.sampleTimesArray[0]);
Hammerstein_M->Timing.offsetTimes = (&Hammerstein_M->
Timing.offsetTimesArray[0]);
/* task periods */
Hammerstein_M->Timing.sampleTimes[0] = (0.06);
/* task offsets */
Hammerstein_M->Timing.offsetTimes[0] = (0.0);
}
rtmSetTPtr(Hammerstein_M, &Hammerstein_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = Hammerstein_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
Hammerstein_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(Hammerstein_M, 9.9599999999999991);
Hammerstein_M->Timing.stepSize0 = 0.06;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
Hammerstein_M->rtwLogInfo = &rt_DataLoggingInfo;
}
/* Setup for data logging */
{
rtliSetLogXSignalInfo(Hammerstein_M->rtwLogInfo, (NULL));
rtliSetLogXSignalPtrs(Hammerstein_M->rtwLogInfo, (NULL));
rtliSetLogT(Hammerstein_M->rtwLogInfo, "tout");
rtliSetLogX(Hammerstein_M->rtwLogInfo, "");
rtliSetLogXFinal(Hammerstein_M->rtwLogInfo, "");
rtliSetSigLog(Hammerstein_M->rtwLogInfo, "");
rtliSetLogVarNameModifier(Hammerstein_M->rtwLogInfo, "rt_");
rtliSetLogFormat(Hammerstein_M->rtwLogInfo, 0);
rtliSetLogMaxRows(Hammerstein_M->rtwLogInfo, 1000);
rtliSetLogDecimation(Hammerstein_M->rtwLogInfo, 1);
/*
* Set pointers to the data and signal info for each output
*/
{
static void * rt_LoggedOutputSignalPtrs[] = {
&Hammerstein_Y.Out1
};
rtliSetLogYSignalPtrs(Hammerstein_M->rtwLogInfo, ((LogSignalPtrsType)
rt_LoggedOutputSignalPtrs));
}
{
static int_T rt_LoggedOutputWidths[] = {
1
};
static int_T rt_LoggedOutputNumDimensions[] = {
1
};
static int_T rt_LoggedOutputDimensions[] = {
1
};
static boolean_T rt_LoggedOutputIsVarDims[] = {
0
};
static void* rt_LoggedCurrentSignalDimensions[] = {
(NULL)
};
static int_T rt_LoggedCurrentSignalDimensionsSize[] = {
4
};
static BuiltInDTypeId rt_LoggedOutputDataTypeIds[] = {
SS_DOUBLE
};
static int_T rt_LoggedOutputComplexSignals[] = {
0
};
static const char_T *rt_LoggedOutputLabels[] = {
"" };
static const char_T *rt_LoggedOutputBlockNames[] = {
"Hammerstein/Out1" };
static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
{ 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 }
};
static RTWLogSignalInfo rt_LoggedOutputSignalInfo[] = {
{
1,
rt_LoggedOutputWidths,
rt_LoggedOutputNumDimensions,
rt_LoggedOutputDimensions,
rt_LoggedOutputIsVarDims,
rt_LoggedCurrentSignalDimensions,
rt_LoggedCurrentSignalDimensionsSize,
rt_LoggedOutputDataTypeIds,
rt_LoggedOutputComplexSignals,
(NULL),
{ rt_LoggedOutputLabels },
(NULL),
(NULL),
(NULL),
{ rt_LoggedOutputBlockNames },
{ (NULL) },
(NULL),
rt_RTWLogDataTypeConvert
}
};
rtliSetLogYSignalInfo(Hammerstein_M->rtwLogInfo, rt_LoggedOutputSignalInfo);
/* set currSigDims field */
rt_LoggedCurrentSignalDimensions[0] = &rt_LoggedOutputWidths[0];
}
rtliSetLogY(Hammerstein_M->rtwLogInfo, "yout");
}
Hammerstein_M->solverInfoPtr = (&Hammerstein_M->solverInfo);
Hammerstein_M->Timing.stepSize = (0.06);
rtsiSetFixedStepSize(&Hammerstein_M->solverInfo, 0.06);
rtsiSetSolverMode(&Hammerstein_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
(void) memset(((void *) &Hammerstein_B), 0,
sizeof(BlockIO_Hammerstein));
/* states (dwork) */
(void) memset((void *)&Hammerstein_DWork, 0,
sizeof(D_Work_Hammerstein));
/* external inputs */
Hammerstein_U.In1 = 0.0;
/* external outputs */
Hammerstein_Y.Out1 = 0.0;
/* child S-Function registration */
{
RTWSfcnInfo *sfcnInfo = &Hammerstein_M->NonInlinedSFcns.sfcnInfo;
Hammerstein_M->sfcnInfo = (sfcnInfo);
rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(Hammerstein_M)));
rtssSetNumRootSampTimesPtr(sfcnInfo, &Hammerstein_M->Sizes.numSampTimes);
Hammerstein_M->NonInlinedSFcns.taskTimePtrs[0] = &(rtmGetTPtr(Hammerstein_M)
[0]);
rtssSetTPtrPtr(sfcnInfo,Hammerstein_M->NonInlinedSFcns.taskTimePtrs);
rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(Hammerstein_M));
rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(Hammerstein_M));
rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(Hammerstein_M));
rtssSetStepSizePtr(sfcnInfo, &Hammerstein_M->Timing.stepSize);
rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(Hammerstein_M));
rtssSetDerivCacheNeedsResetPtr(sfcnInfo,
&Hammerstein_M->ModelData.derivCacheNeedsReset);
rtssSetZCCacheNeedsResetPtr(sfcnInfo,
&Hammerstein_M->ModelData.zCCacheNeedsReset);
rtssSetBlkStateChangePtr(sfcnInfo, &Hammerstein_M->ModelData.blkStateChange);
rtssSetSampleHitsPtr(sfcnInfo, &Hammerstein_M->Timing.sampleHits);
rtssSetPerTaskSampleHitsPtr(sfcnInfo,
&Hammerstein_M->Timing.perTaskSampleHits);
rtssSetSimModePtr(sfcnInfo, &Hammerstein_M->simMode);
rtssSetSolverInfoPtr(sfcnInfo, &Hammerstein_M->solverInfoPtr);
}
Hammerstein_M->Sizes.numSFcns = (2);
/* register each child */
{
(void) memset((void *)&Hammerstein_M->NonInlinedSFcns.childSFunctions[0], 0,
2*sizeof(SimStruct));
Hammerstein_M->childSfunctions =
(&Hammerstein_M->NonInlinedSFcns.childSFunctionPtrs[0]);
Hammerstein_M->childSfunctions[0] =
(&Hammerstein_M->NonInlinedSFcns.childSFunctions[0]);
Hammerstein_M->childSfunctions[1] =
(&Hammerstein_M->NonInlinedSFcns.childSFunctions[1]);
/* Level2 S-Function Block: Hammerstein/<S1>/Pwlinear1 (sfunpwlinear) */
{
SimStruct *rts = Hammerstein_M->childSfunctions[0];
/* timing info */
time_T *sfcnPeriod = Hammerstein_M->NonInlinedSFcns.Sfcn0.sfcnPeriod;
time_T *sfcnOffset = Hammerstein_M->NonInlinedSFcns.Sfcn0.sfcnOffset;
int_T *sfcnTsMap = Hammerstein_M->NonInlinedSFcns.Sfcn0.sfcnTsMap;
(void) memset((void*)sfcnPeriod, 0,
sizeof(time_T)*1);
(void) memset((void*)sfcnOffset, 0,
sizeof(time_T)*1);
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
/* Set up the mdlInfo pointer */
{
ssSetBlkInfo2Ptr(rts, &Hammerstein_M->NonInlinedSFcns.blkInfo2[0]);
}
ssSetRTWSfcnInfo(rts, Hammerstein_M->sfcnInfo);
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &Hammerstein_M->NonInlinedSFcns.methods2[0]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &Hammerstein_M->NonInlinedSFcns.methods3[0]);
}
/* Allocate memory for states auxilliary information */
{
ssSetStatesInfo2(rts, &Hammerstein_M->NonInlinedSFcns.statesInfo2[0]);
}
/* inputs */
{
_ssSetNumInputPorts(rts, 1);
ssSetPortInfoForInputs(rts,
&Hammerstein_M->NonInlinedSFcns.Sfcn0.inputPortInfo[0]);
/* port 0 */
{
ssSetInputPortRequiredContiguous(rts, 0, 1);
ssSetInputPortSignal(rts, 0, &Hammerstein_B.LinearModel);
_ssSetInputPortNumDimensions(rts, 0, 1);
ssSetInputPortWidth(rts, 0, 1);
}
}
/* outputs */
{
ssSetPortInfoForOutputs(rts,
&Hammerstein_M->NonInlinedSFcns.Sfcn0.outputPortInfo[0]);
_ssSetNumOutputPorts(rts, 1);
/* port 0 */
{
_ssSetOutputPortNumDimensions(rts, 0, 1);
ssSetOutputPortWidth(rts, 0, 1);
ssSetOutputPortSignal(rts, 0, ((real_T *) &Hammerstein_Y.Out1));
}
}
/* path info */
ssSetModelName(rts, "Pwlinear1");
ssSetPath(rts, "Hammerstein/Hammerstein-Wiener Model1/Pwlinear1");
ssSetRTModel(rts,Hammerstein_M);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* parameters */
{
mxArray **sfcnParams = (mxArray **)
&Hammerstein_M->NonInlinedSFcns.Sfcn0.params;
ssSetSFcnParamsCount(rts, 7);
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
ssSetSFcnParam(rts, 0, (mxArray*)Hammerstein_P.Pwlinear1_P1_Size);
ssSetSFcnParam(rts, 1, (mxArray*)Hammerstein_P.Pwlinear1_P2_Size);
ssSetSFcnParam(rts, 2, (mxArray*)Hammerstein_P.Pwlinear1_P3_Size);
ssSetSFcnParam(rts, 3, (mxArray*)Hammerstein_P.Pwlinear1_P4_Size);
ssSetSFcnParam(rts, 4, (mxArray*)Hammerstein_P.Pwlinear1_P5_Size);
ssSetSFcnParam(rts, 5, (mxArray*)Hammerstein_P.Pwlinear1_P6_Size);
ssSetSFcnParam(rts, 6, (mxArray*)Hammerstein_P.Pwlinear1_P7_Size);
}
/* registration */
sfunpwlinear(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.06);
ssSetOffsetTime(rts, 0, 0.0);
sfcnTsMap[0] = 0;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetInputPortConnected(rts, 0, 1);
_ssSetOutputPortConnected(rts, 0, 1);
_ssSetOutputPortBeingMerged(rts, 0, 0);
/* Update the BufferDstPort flags for each input port */
ssSetInputPortBufferDstPort(rts, 0, -1);
}
/* Level2 S-Function Block: Hammerstein/<S1>/Pwlinear (sfunpwlinear) */
{
SimStruct *rts = Hammerstein_M->childSfunctions[1];
/* timing info */
time_T *sfcnPeriod = Hammerstein_M->NonInlinedSFcns.Sfcn1.sfcnPeriod;
time_T *sfcnOffset = Hammerstein_M->NonInlinedSFcns.Sfcn1.sfcnOffset;
int_T *sfcnTsMap = Hammerstein_M->NonInlinedSFcns.Sfcn1.sfcnTsMap;
(void) memset((void*)sfcnPeriod, 0,
sizeof(time_T)*1);
(void) memset((void*)sfcnOffset, 0,
sizeof(time_T)*1);
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
/* Set up the mdlInfo pointer */
{
ssSetBlkInfo2Ptr(rts, &Hammerstein_M->NonInlinedSFcns.blkInfo2[1]);
}
ssSetRTWSfcnInfo(rts, Hammerstein_M->sfcnInfo);
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &Hammerstein_M->NonInlinedSFcns.methods2[1]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &Hammerstein_M->NonInlinedSFcns.methods3[1]);
}
/* Allocate memory for states auxilliary information */
{
ssSetStatesInfo2(rts, &Hammerstein_M->NonInlinedSFcns.statesInfo2[1]);
}
/* inputs */
{
_ssSetNumInputPorts(rts, 1);
ssSetPortInfoForInputs(rts,
&Hammerstein_M->NonInlinedSFcns.Sfcn1.inputPortInfo[0]);
/* port 0 */
{
ssSetInputPortRequiredContiguous(rts, 0, 1);
ssSetInputPortSignal(rts, 0, &Hammerstein_U.In1);
_ssSetInputPortNumDimensions(rts, 0, 1);
ssSetInputPortWidth(rts, 0, 1);
}
}
/* outputs */
{
ssSetPortInfoForOutputs(rts,
&Hammerstein_M->NonInlinedSFcns.Sfcn1.outputPortInfo[0]);
_ssSetNumOutputPorts(rts, 1);
/* port 0 */
{
_ssSetOutputPortNumDimensions(rts, 0, 1);
ssSetOutputPortWidth(rts, 0, 1);
ssSetOutputPortSignal(rts, 0, ((real_T *) &Hammerstein_B.Pwlinear));
}
}
/* path info */
ssSetModelName(rts, "Pwlinear");
ssSetPath(rts, "Hammerstein/Hammerstein-Wiener Model1/Pwlinear");
ssSetRTModel(rts,Hammerstein_M);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* parameters */
{
mxArray **sfcnParams = (mxArray **)
&Hammerstein_M->NonInlinedSFcns.Sfcn1.params;
ssSetSFcnParamsCount(rts, 7);
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
ssSetSFcnParam(rts, 0, (mxArray*)Hammerstein_P.Pwlinear_P1_Size);
ssSetSFcnParam(rts, 1, (mxArray*)Hammerstein_P.Pwlinear_P2_Size);
ssSetSFcnParam(rts, 2, (mxArray*)Hammerstein_P.Pwlinear_P3_Size);
ssSetSFcnParam(rts, 3, (mxArray*)Hammerstein_P.Pwlinear_P4_Size);
ssSetSFcnParam(rts, 4, (mxArray*)Hammerstein_P.Pwlinear_P5_Size);
ssSetSFcnParam(rts, 5, (mxArray*)Hammerstein_P.Pwlinear_P6_Size);
ssSetSFcnParam(rts, 6, (mxArray*)Hammerstein_P.Pwlinear_P7_Size);
}
/* registration */
sfunpwlinear(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.06);
ssSetOffsetTime(rts, 0, 0.0);
sfcnTsMap[0] = 0;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetInputPortConnected(rts, 0, 1);
_ssSetOutputPortConnected(rts, 0, 1);
_ssSetOutputPortBeingMerged(rts, 0, 0);
/* Update the BufferDstPort flags for each input port */
ssSetInputPortBufferDstPort(rts, 0, -1);
}
}
/* Matfile logging */
rt_StartDataLoggingWithStartTime(Hammerstein_M->rtwLogInfo, 0.0, rtmGetTFinal
(Hammerstein_M), Hammerstein_M->Timing.stepSize0, (&rtmGetErrorStatus
(Hammerstein_M)));
/* Level2 S-Function Block: '<S1>/Pwlinear1' (sfunpwlinear) */
{
SimStruct *rts = Hammerstein_M->childSfunctions[0];
sfcnStart(rts);
if (ssGetErrorStatus(rts) != (NULL))
return;
}
/* Level2 S-Function Block: '<S1>/Pwlinear' (sfunpwlinear) */
{
SimStruct *rts = Hammerstein_M->childSfunctions[1];
sfcnStart(rts);
if (ssGetErrorStatus(rts) != (NULL))
return;
}
/* InitializeConditions for DiscreteStateSpace: '<S1>/LinearModel' */
Hammerstein_DWork.LinearModel_DSTATE = Hammerstein_P.LinearModel_X0;
/* Level2 S-Function Block: '<S1>/Pwlinear1' (sfunpwlinear) */
{
SimStruct *rts = Hammerstein_M->childSfunctions[0];
sfcnInitializeConditions(rts);
if (ssGetErrorStatus(rts) != (NULL))
return;
}
/* Level2 S-Function Block: '<S1>/Pwlinear' (sfunpwlinear) */
{
SimStruct *rts = Hammerstein_M->childSfunctions[1];
sfcnInitializeConditions(rts);
if (ssGetErrorStatus(rts) != (NULL))
return;
}
}