/* 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 motor_initialize(void)
{
/* Registration code */
/* initialize real-time model */
(void) memset((void *)motor_M, 0,
sizeof(RT_MODEL_motor_T));
rtmSetTFinal(motor_M, -1);
motor_M->Timing.stepSize0 = 0.2;
/* External mode info */
motor_M->Sizes.checksums[0] = (1008116136U);
motor_M->Sizes.checksums[1] = (3564589615U);
motor_M->Sizes.checksums[2] = (1322083197U);
motor_M->Sizes.checksums[3] = (1603772587U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[1];
motor_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(motor_M->extModeInfo,
&motor_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(motor_M->extModeInfo, motor_M->Sizes.checksums);
rteiSetTPtr(motor_M->extModeInfo, rtmGetTPtr(motor_M));
}
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
motor_M->SpecialInfo.mappingInfo = (&dtInfo);
dtInfo.numDataTypes = 14;
dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
dtInfo.dataTypeNames = &rtDataTypeNames[0];
/* Parameters transition table */
dtInfo.P = &rtPTransTable;
}
{
uint8_T tmp;
uint8_T tmp_0;
uint8_T tmp_1;
uint8_T tmp_2;
uint8_T tmp_3;
uint8_T tmp_4;
/* Start for S-Function (linuxGpioWrite_sfcn): '<S1>/Left_high' */
tmp_4 = motor_P.Left_high_p4;
MW_gpioInit(motor_P.Left_high_p1, motor_P.Left_high_p2, motor_P.Left_high_p3,
&tmp_4);
/* Start for S-Function (linuxGpioWrite_sfcn): '<S1>/Left_low' */
tmp_3 = motor_P.Left_low_p4;
MW_gpioInit(motor_P.Left_low_p1, motor_P.Left_low_p2, motor_P.Left_low_p3,
&tmp_3);
/* Start for S-Function (linuxGpioWrite_sfcn): '<S1>/Right_high' */
tmp_2 = motor_P.Right_high_p4;
MW_gpioInit(motor_P.Right_high_p1, motor_P.Right_high_p2,
motor_P.Right_high_p3, &tmp_2);
/* Start for S-Function (linuxGpioWrite_sfcn): '<S1>/Right_low' */
tmp_1 = motor_P.Right_low_p4;
MW_gpioInit(motor_P.Right_low_p1, motor_P.Right_low_p2, motor_P.Right_low_p3,
&tmp_1);
/* Start for S-Function (linuxGpioWrite_sfcn): '<S1>/EN_Left' */
tmp_0 = motor_P.EN_Left_p4;
MW_gpioInit(motor_P.EN_Left_p1, motor_P.EN_Left_p2, motor_P.EN_Left_p3,
&tmp_0);
/* Start for S-Function (linuxGpioWrite_sfcn): '<S1>/EN_Right' */
tmp = motor_P.EN_Right_p4;
MW_gpioInit(motor_P.EN_Right_p1, motor_P.EN_Right_p2, motor_P.EN_Right_p3,
&tmp);
}
}
/* Model initialize function */
void motor_hr_initialize(void)
{
/* Registration code */
/* initialize real-time model */
(void) memset((void *)motor_hr_M, 0,
sizeof(RT_MODEL_motor_hr_T));
rtmSetTFinal(motor_hr_M, 1000.0);
motor_hr_M->Timing.stepSize0 = 20.0;
/* External mode info */
motor_hr_M->Sizes.checksums[0] = (822641153U);
motor_hr_M->Sizes.checksums[1] = (2911569967U);
motor_hr_M->Sizes.checksums[2] = (108929926U);
motor_hr_M->Sizes.checksums[3] = (297514658U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[3];
motor_hr_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
systemRan[1] = &rtAlwaysEnabled;
systemRan[2] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(motor_hr_M->extModeInfo,
&motor_hr_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(motor_hr_M->extModeInfo, motor_hr_M->Sizes.checksums);
rteiSetTPtr(motor_hr_M->extModeInfo, rtmGetTPtr(motor_hr_M));
}
/* states (dwork) */
(void) memset((void *)&motor_hr_DW, 0,
sizeof(DW_motor_hr_T));
/* external inputs */
(void) memset((void *)&motor_hr_U, 0,
sizeof(ExtU_motor_hr_T));
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
motor_hr_M->SpecialInfo.mappingInfo = (&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;
}
/* Start for S-Function (arduinodigitaloutput_sfcn): '<S1>/Digital Output' */
MW_pinModeOutput(motor_hr_P.DigitalOutput_pinNumber);
/* Start for S-Function (arduinoanalogoutput_sfcn): '<S2>/PWM' */
MW_pinModeOutput(motor_hr_P.PWM_pinNumber);
}
/* Registration function */
RT_MODEL_DI_model_T *DI_model(void)
{
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)DI_model_M, 0,
sizeof(RT_MODEL_DI_model_T));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&DI_model_M->solverInfo,
&DI_model_M->Timing.simTimeStep);
rtsiSetTPtr(&DI_model_M->solverInfo, &rtmGetTPtr(DI_model_M));
rtsiSetStepSizePtr(&DI_model_M->solverInfo, &DI_model_M->Timing.stepSize0);
rtsiSetErrorStatusPtr(&DI_model_M->solverInfo, (&rtmGetErrorStatus
(DI_model_M)));
rtsiSetRTModelPtr(&DI_model_M->solverInfo, DI_model_M);
}
rtsiSetSimTimeStep(&DI_model_M->solverInfo, MAJOR_TIME_STEP);
rtsiSetSolverName(&DI_model_M->solverInfo,"FixedStepDiscrete");
DI_model_M->solverInfoPtr = (&DI_model_M->solverInfo);
/* Initialize timing info */
{
int_T *mdlTsMap = DI_model_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
DI_model_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
DI_model_M->Timing.sampleTimes = (&DI_model_M->Timing.sampleTimesArray[0]);
DI_model_M->Timing.offsetTimes = (&DI_model_M->Timing.offsetTimesArray[0]);
/* task periods */
DI_model_M->Timing.sampleTimes[0] = (0.0);
DI_model_M->Timing.sampleTimes[1] = (0.01);
/* task offsets */
DI_model_M->Timing.offsetTimes[0] = (0.0);
DI_model_M->Timing.offsetTimes[1] = (0.0);
}
rtmSetTPtr(DI_model_M, &DI_model_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = DI_model_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
DI_model_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(DI_model_M, 30.0);
DI_model_M->Timing.stepSize0 = 0.01;
DI_model_M->Timing.stepSize1 = 0.01;
/* External mode info */
DI_model_M->Sizes.checksums[0] = (943881189U);
DI_model_M->Sizes.checksums[1] = (2376373844U);
DI_model_M->Sizes.checksums[2] = (1356612486U);
DI_model_M->Sizes.checksums[3] = (687118842U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[1];
DI_model_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(DI_model_M->extModeInfo,
&DI_model_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(DI_model_M->extModeInfo, DI_model_M->Sizes.checksums);
rteiSetTPtr(DI_model_M->extModeInfo, rtmGetTPtr(DI_model_M));
}
DI_model_M->solverInfoPtr = (&DI_model_M->solverInfo);
DI_model_M->Timing.stepSize = (0.01);
rtsiSetFixedStepSize(&DI_model_M->solverInfo, 0.01);
rtsiSetSolverMode(&DI_model_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
DI_model_M->SpecialInfo.mappingInfo = (&dtInfo);
dtInfo.numDataTypes = 14;
dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
dtInfo.dataTypeNames = &rtDataTypeNames[0];
}
/* child S-Function registration */
{
RTWSfcnInfo *sfcnInfo = &DI_model_M->NonInlinedSFcns.sfcnInfo;
DI_model_M->sfcnInfo = (sfcnInfo);
rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(DI_model_M)));
rtssSetNumRootSampTimesPtr(sfcnInfo, &DI_model_M->Sizes.numSampTimes);
DI_model_M->NonInlinedSFcns.taskTimePtrs[0] = &(rtmGetTPtr(DI_model_M)[0]);
DI_model_M->NonInlinedSFcns.taskTimePtrs[1] = &(rtmGetTPtr(DI_model_M)[1]);
rtssSetTPtrPtr(sfcnInfo,DI_model_M->NonInlinedSFcns.taskTimePtrs);
rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(DI_model_M));
rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(DI_model_M));
rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(DI_model_M));
rtssSetStepSizePtr(sfcnInfo, &DI_model_M->Timing.stepSize);
rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(DI_model_M));
rtssSetDerivCacheNeedsResetPtr(sfcnInfo,
&DI_model_M->ModelData.derivCacheNeedsReset);
rtssSetZCCacheNeedsResetPtr(sfcnInfo,
&DI_model_M->ModelData.zCCacheNeedsReset);
rtssSetBlkStateChangePtr(sfcnInfo, &DI_model_M->ModelData.blkStateChange);
rtssSetSampleHitsPtr(sfcnInfo, &DI_model_M->Timing.sampleHits);
rtssSetPerTaskSampleHitsPtr(sfcnInfo, &DI_model_M->Timing.perTaskSampleHits);
rtssSetSimModePtr(sfcnInfo, &DI_model_M->simMode);
rtssSetSolverInfoPtr(sfcnInfo, &DI_model_M->solverInfoPtr);
}
DI_model_M->Sizes.numSFcns = (1);
/* register each child */
{
(void) memset((void *)&DI_model_M->NonInlinedSFcns.childSFunctions[0], 0,
1*sizeof(SimStruct));
DI_model_M->childSfunctions =
(&DI_model_M->NonInlinedSFcns.childSFunctionPtrs[0]);
DI_model_M->childSfunctions[0] =
(&DI_model_M->NonInlinedSFcns.childSFunctions[0]);
/* Level2 S-Function Block: DI_model/<Root>/S-Function (DI_v1) */
{
SimStruct *rts = DI_model_M->childSfunctions[0];
/* timing info */
time_T *sfcnPeriod = DI_model_M->NonInlinedSFcns.Sfcn0.sfcnPeriod;
time_T *sfcnOffset = DI_model_M->NonInlinedSFcns.Sfcn0.sfcnOffset;
int_T *sfcnTsMap = DI_model_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, &DI_model_M->NonInlinedSFcns.blkInfo2[0]);
}
ssSetRTWSfcnInfo(rts, DI_model_M->sfcnInfo);
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &DI_model_M->NonInlinedSFcns.methods2[0]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &DI_model_M->NonInlinedSFcns.methods3[0]);
}
/* Allocate memory for states auxilliary information */
{
ssSetStatesInfo2(rts, &DI_model_M->NonInlinedSFcns.statesInfo2[0]);
}
/* inputs */
{
_ssSetNumInputPorts(rts, 1);
ssSetPortInfoForInputs(rts,
&DI_model_M->NonInlinedSFcns.Sfcn0.inputPortInfo[0]);
/* port 0 */
{
ssSetInputPortRequiredContiguous(rts, 0, 1);
ssSetInputPortSignal(rts, 0, (real_T*)&DI_model_RGND);
_ssSetInputPortNumDimensions(rts, 0, 1);
ssSetInputPortWidth(rts, 0, 1);
}
}
/* path info */
ssSetModelName(rts, "S-Function");
ssSetPath(rts, "DI_model/S-Function");
ssSetRTModel(rts,DI_model_M);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* registration */
DI_v1(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.0);
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, 0);
/* Update the BufferDstPort flags for each input port */
ssSetInputPortBufferDstPort(rts, 0, -1);
}
}
/* Initialize Sizes */
DI_model_M->Sizes.numContStates = (0);/* Number of continuous states */
DI_model_M->Sizes.numY = (0); /* Number of model outputs */
DI_model_M->Sizes.numU = (0); /* Number of model inputs */
DI_model_M->Sizes.sysDirFeedThru = (0);/* The model is not direct feedthrough */
DI_model_M->Sizes.numSampTimes = (2);/* Number of sample times */
DI_model_M->Sizes.numBlocks = (1); /* Number of blocks */
return DI_model_M;
}
/* Model initialize function */
void Crane_initialize(boolean_T firstTime)
{
(void)firstTime;
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T)); /* initialize real-time model */
(void) memset((char_T *)Crane_M,0,
sizeof(RT_MODEL_Crane));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&Crane_M->solverInfo, &Crane_M->Timing.simTimeStep);
rtsiSetTPtr(&Crane_M->solverInfo, &rtmGetTPtr(Crane_M));
rtsiSetStepSizePtr(&Crane_M->solverInfo, &Crane_M->Timing.stepSize0);
rtsiSetdXPtr(&Crane_M->solverInfo, &Crane_M->ModelData.derivs);
rtsiSetContStatesPtr(&Crane_M->solverInfo, &Crane_M->ModelData.contStates);
rtsiSetNumContStatesPtr(&Crane_M->solverInfo, &Crane_M->Sizes.numContStates);
rtsiSetErrorStatusPtr(&Crane_M->solverInfo, (&rtmGetErrorStatus(Crane_M)));
rtsiSetRTModelPtr(&Crane_M->solverInfo, Crane_M);
}
rtsiSetSimTimeStep(&Crane_M->solverInfo, MAJOR_TIME_STEP);
Crane_M->ModelData.intgData.f[0] = Crane_M->ModelData.odeF[0];
Crane_M->ModelData.contStates = ((real_T *) &Crane_X);
rtsiSetSolverData(&Crane_M->solverInfo, (void *)&Crane_M->ModelData.intgData);
rtsiSetSolverName(&Crane_M->solverInfo,"ode1");
/* Initialize timing info */
{
int_T *mdlTsMap = Crane_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
Crane_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
Crane_M->Timing.sampleTimes = (&Crane_M->Timing.sampleTimesArray[0]);
Crane_M->Timing.offsetTimes = (&Crane_M->Timing.offsetTimesArray[0]);
/* task periods */
Crane_M->Timing.sampleTimes[0] = (0.0);
Crane_M->Timing.sampleTimes[1] = (0.001);
/* task offsets */
Crane_M->Timing.offsetTimes[0] = (0.0);
Crane_M->Timing.offsetTimes[1] = (0.0);
}
rtmSetTPtr(Crane_M, &Crane_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = Crane_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
Crane_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(Crane_M, -1);
Crane_M->Timing.stepSize0 = 0.001;
Crane_M->Timing.stepSize1 = 0.001;
/* external mode info */
Crane_M->Sizes.checksums[0] = (2478158774U);
Crane_M->Sizes.checksums[1] = (3803381746U);
Crane_M->Sizes.checksums[2] = (277883647U);
Crane_M->Sizes.checksums[3] = (670793414U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[1];
Crane_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(&rt_ExtModeInfo,
&Crane_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(&rt_ExtModeInfo, Crane_M->Sizes.checksums);
rteiSetTPtr(&rt_ExtModeInfo, rtmGetTPtr(Crane_M));
}
Crane_M->solverInfoPtr = (&Crane_M->solverInfo);
Crane_M->Timing.stepSize = (0.001);
rtsiSetFixedStepSize(&Crane_M->solverInfo, 0.001);
rtsiSetSolverMode(&Crane_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
Crane_M->ModelData.blockIO = ((void *) &Crane_B);
{
int_T i;
void *pVoidBlockIORegion;
pVoidBlockIORegion = (void *)(&Crane_B.Block1_o1[0]);
for (i = 0; i < 49; i++) {
((real_T*)pVoidBlockIORegion)[i] = 0.0;
}
}
/* parameters */
Crane_M->ModelData.defaultParam = ((real_T *) &Crane_P);
/* states (continuous) */
{
real_T *x = (real_T *) &Crane_X;
Crane_M->ModelData.contStates = (x);
(void) memset((char_T *)x,0,
sizeof(ContinuousStates_Crane));
}
/* states (dwork) */
Crane_M->Work.dwork = ((void *) &Crane_DWork);
(void) memset((char_T *) &Crane_DWork,0,
sizeof(D_Work_Crane));
{
int_T i;
real_T *dwork_ptr = (real_T *) &Crane_DWork.Memory_PreviousInput[0];
for (i = 0; i < 11; i++) {
dwork_ptr[i] = 0.0;
}
}
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo,0,
sizeof(dtInfo));
Crane_M->SpecialInfo.mappingInfo = (&dtInfo);
dtInfo.numDataTypes = 15;
dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
dtInfo.dataTypeNames = &rtDataTypeNames[0];
/* Block I/O transition table */
dtInfo.B = &rtBTransTable;
/* Parameters transition table */
dtInfo.P = &rtPTransTable;
}
}
/* Model initialize function */
void Motor_Test_All_initialize(void)
{
/* Registration code */
/* initialize real-time model */
(void) memset((void *)Motor_Test_All_M, 0,
sizeof(RT_MODEL_Motor_Test_All_T));
rtmSetTFinal(Motor_Test_All_M, 100.0);
Motor_Test_All_M->Timing.stepSize0 = 10.0;
/* External mode info */
Motor_Test_All_M->Sizes.checksums[0] = (391574619U);
Motor_Test_All_M->Sizes.checksums[1] = (1808842219U);
Motor_Test_All_M->Sizes.checksums[2] = (99353943U);
Motor_Test_All_M->Sizes.checksums[3] = (1218331709U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[2];
Motor_Test_All_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
systemRan[1] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(Motor_Test_All_M->extModeInfo,
&Motor_Test_All_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(Motor_Test_All_M->extModeInfo,
Motor_Test_All_M->Sizes.checksums);
rteiSetTPtr(Motor_Test_All_M->extModeInfo, rtmGetTPtr(Motor_Test_All_M));
}
/* states (dwork) */
(void) memset((void *)&Motor_Test_All_DW, 0,
sizeof(DW_Motor_Test_All_T));
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
Motor_Test_All_M->SpecialInfo.mappingInfo = (&dtInfo);
dtInfo.numDataTypes = 18;
dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
dtInfo.dataTypeNames = &rtDataTypeNames[0];
/* Block I/O transition table */
dtInfo.B = &rtBTransTable;
/* Parameters transition table */
dtInfo.P = &rtPTransTable;
}
/* Model Initialize fcn for ModelReference Block: '<Root>/Model' */
motor_hl_initialize(rtmGetErrorStatusPointer(Motor_Test_All_M),
&(Motor_Test_All_DW.Model_DWORK1.rtm));
/* Model Initialize fcn for ModelReference Block: '<Root>/Model1' */
motor_vr_initialize(rtmGetErrorStatusPointer(Motor_Test_All_M),
&(Motor_Test_All_DW.Model1_DWORK1.rtm));
/* Model Initialize fcn for ModelReference Block: '<Root>/Model2' */
motor_vl_initialize(rtmGetErrorStatusPointer(Motor_Test_All_M),
&(Motor_Test_All_DW.Model2_DWORK1.rtm));
/* Model Initialize fcn for ModelReference Block: '<Root>/Model3' */
motor_hr_initialize(rtmGetErrorStatusPointer(Motor_Test_All_M),
&(Motor_Test_All_DW.Model3_DWORK1.rtm));
/* Start for ModelReference: '<Root>/Model' */
motor_hl_Start();
/* Start for ModelReference: '<Root>/Model1' */
motor_vr_Start();
/* Start for ModelReference: '<Root>/Model2' */
motor_vl_Start();
/* Start for ModelReference: '<Root>/Model3' */
motor_hr_Start();
/* InitializeConditions for UnitDelay: '<S2>/Output' */
Motor_Test_All_DW.Output_DSTATE = Motor_Test_All_P.Output_InitialCondition;
}
/* Model initialize function */
void arbeitspunkt_initialize(boolean_T firstTime)
{
(void)firstTime;
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T)); /* initialize real-time model */
(void) memset((char_T *)arbeitspunkt_M,0,
sizeof(RT_MODEL_arbeitspunkt));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&arbeitspunkt_M->solverInfo,
&arbeitspunkt_M->Timing.simTimeStep);
rtsiSetTPtr(&arbeitspunkt_M->solverInfo, &rtmGetTPtr(arbeitspunkt_M));
rtsiSetStepSizePtr(&arbeitspunkt_M->solverInfo,
&arbeitspunkt_M->Timing.stepSize0);
rtsiSetErrorStatusPtr(&arbeitspunkt_M->solverInfo, (&rtmGetErrorStatus
(arbeitspunkt_M)));
rtsiSetRTModelPtr(&arbeitspunkt_M->solverInfo, arbeitspunkt_M);
}
rtsiSetSimTimeStep(&arbeitspunkt_M->solverInfo, MAJOR_TIME_STEP);
rtsiSetSolverName(&arbeitspunkt_M->solverInfo,"FixedStepDiscrete");
/* Initialize timing info */
{
int_T *mdlTsMap = arbeitspunkt_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
arbeitspunkt_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
arbeitspunkt_M->Timing.sampleTimes =
(&arbeitspunkt_M->Timing.sampleTimesArray[0]);
arbeitspunkt_M->Timing.offsetTimes =
(&arbeitspunkt_M->Timing.offsetTimesArray[0]);
/* task periods */
arbeitspunkt_M->Timing.sampleTimes[0] = (0.0);
arbeitspunkt_M->Timing.sampleTimes[1] = (0.001);
/* task offsets */
arbeitspunkt_M->Timing.offsetTimes[0] = (0.0);
arbeitspunkt_M->Timing.offsetTimes[1] = (0.0);
}
rtmSetTPtr(arbeitspunkt_M, &arbeitspunkt_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = arbeitspunkt_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
arbeitspunkt_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(arbeitspunkt_M, 10.0);
arbeitspunkt_M->Timing.stepSize0 = 0.001;
arbeitspunkt_M->Timing.stepSize1 = 0.001;
/* external mode info */
arbeitspunkt_M->Sizes.checksums[0] = (51356583U);
arbeitspunkt_M->Sizes.checksums[1] = (1228941243U);
arbeitspunkt_M->Sizes.checksums[2] = (1622391598U);
arbeitspunkt_M->Sizes.checksums[3] = (3849823737U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[1];
arbeitspunkt_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(&rt_ExtModeInfo,
&arbeitspunkt_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(&rt_ExtModeInfo, arbeitspunkt_M->Sizes.checksums);
rteiSetTPtr(&rt_ExtModeInfo, rtmGetTPtr(arbeitspunkt_M));
}
arbeitspunkt_M->solverInfoPtr = (&arbeitspunkt_M->solverInfo);
arbeitspunkt_M->Timing.stepSize = (0.001);
rtsiSetFixedStepSize(&arbeitspunkt_M->solverInfo, 0.001);
rtsiSetSolverMode(&arbeitspunkt_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
arbeitspunkt_M->ModelData.blockIO = ((void *) &arbeitspunkt_B);
{
int_T i;
void *pVoidBlockIORegion;
pVoidBlockIORegion = (void *)(&arbeitspunkt_B.V_Step);
for (i = 0; i < 3; i++) {
((real_T*)pVoidBlockIORegion)[i] = 0.0;
}
}
/* parameters */
arbeitspunkt_M->ModelData.defaultParam = ((real_T *) &arbeitspunkt_P);
/* states (dwork) */
arbeitspunkt_M->Work.dwork = ((void *) &arbeitspunkt_DWork);
(void) memset((char_T *) &arbeitspunkt_DWork,0,
sizeof(D_Work_arbeitspunkt));
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo,0,
sizeof(dtInfo));
arbeitspunkt_M->SpecialInfo.mappingInfo = (&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;
}
}
/* Registration function */
RT_MODEL_RA4_student_T *RA4_student(void)
{
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)RA4_student_M, 0,
sizeof(RT_MODEL_RA4_student_T));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&RA4_student_M->solverInfo,
&RA4_student_M->Timing.simTimeStep);
rtsiSetTPtr(&RA4_student_M->solverInfo, &rtmGetTPtr(RA4_student_M));
rtsiSetStepSizePtr(&RA4_student_M->solverInfo,
&RA4_student_M->Timing.stepSize0);
rtsiSetErrorStatusPtr(&RA4_student_M->solverInfo, (&rtmGetErrorStatus
(RA4_student_M)));
rtsiSetRTModelPtr(&RA4_student_M->solverInfo, RA4_student_M);
}
rtsiSetSimTimeStep(&RA4_student_M->solverInfo, MAJOR_TIME_STEP);
rtsiSetSolverName(&RA4_student_M->solverInfo,"FixedStepDiscrete");
RA4_student_M->solverInfoPtr = (&RA4_student_M->solverInfo);
/* Initialize timing info */
{
int_T *mdlTsMap = RA4_student_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
RA4_student_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
RA4_student_M->Timing.sampleTimes = (&RA4_student_M->
Timing.sampleTimesArray[0]);
RA4_student_M->Timing.offsetTimes = (&RA4_student_M->
Timing.offsetTimesArray[0]);
/* task periods */
RA4_student_M->Timing.sampleTimes[0] = (0.0);
RA4_student_M->Timing.sampleTimes[1] = (0.000244140625);
/* task offsets */
RA4_student_M->Timing.offsetTimes[0] = (0.0);
RA4_student_M->Timing.offsetTimes[1] = (0.0);
}
rtmSetTPtr(RA4_student_M, &RA4_student_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = RA4_student_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
RA4_student_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(RA4_student_M, 1000.0);
RA4_student_M->Timing.stepSize0 = 0.000244140625;
RA4_student_M->Timing.stepSize1 = 0.000244140625;
/* Setup for data logging */
{
static RTWLogInfo rt_DataLoggingInfo;
rt_DataLoggingInfo.loggingInterval = NULL;
RA4_student_M->rtwLogInfo = &rt_DataLoggingInfo;
}
/* Setup for data logging */
{
rtliSetLogXSignalInfo(RA4_student_M->rtwLogInfo, (NULL));
rtliSetLogXSignalPtrs(RA4_student_M->rtwLogInfo, (NULL));
rtliSetLogT(RA4_student_M->rtwLogInfo, "tout");
rtliSetLogX(RA4_student_M->rtwLogInfo, "");
rtliSetLogXFinal(RA4_student_M->rtwLogInfo, "");
rtliSetLogVarNameModifier(RA4_student_M->rtwLogInfo, "rt_");
rtliSetLogFormat(RA4_student_M->rtwLogInfo, 0);
rtliSetLogMaxRows(RA4_student_M->rtwLogInfo, 0);
rtliSetLogDecimation(RA4_student_M->rtwLogInfo, 1);
rtliSetLogY(RA4_student_M->rtwLogInfo, "");
rtliSetLogYSignalInfo(RA4_student_M->rtwLogInfo, (NULL));
rtliSetLogYSignalPtrs(RA4_student_M->rtwLogInfo, (NULL));
}
/* External mode info */
RA4_student_M->Sizes.checksums[0] = (2785597085U);
RA4_student_M->Sizes.checksums[1] = (79388889U);
RA4_student_M->Sizes.checksums[2] = (3150282079U);
RA4_student_M->Sizes.checksums[3] = (1201550713U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[2];
RA4_student_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
systemRan[1] = (sysRanDType *)&RA4_student_DW.Controller_SubsysRanBC;
rteiSetModelMappingInfoPtr(RA4_student_M->extModeInfo,
&RA4_student_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(RA4_student_M->extModeInfo,
RA4_student_M->Sizes.checksums);
rteiSetTPtr(RA4_student_M->extModeInfo, rtmGetTPtr(RA4_student_M));
}
RA4_student_M->solverInfoPtr = (&RA4_student_M->solverInfo);
RA4_student_M->Timing.stepSize = (0.000244140625);
rtsiSetFixedStepSize(&RA4_student_M->solverInfo, 0.000244140625);
rtsiSetSolverMode(&RA4_student_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
RA4_student_M->ModelData.blockIO = ((void *) &RA4_student_B);
(void) memset(((void *) &RA4_student_B), 0,
sizeof(B_RA4_student_T));
{
RA4_student_B.UnitDelay2[0] = 0.0;
RA4_student_B.UnitDelay2[1] = 0.0;
RA4_student_B.UnitDelay2[2] = 0.0;
RA4_student_B.UnitDelay1 = 0.0;
RA4_student_B.RobotArm_sfcn_o1 = 0.0;
RA4_student_B.RobotArm_sfcn_o2[0] = 0.0;
RA4_student_B.RobotArm_sfcn_o2[1] = 0.0;
RA4_student_B.RobotArm_sfcn_o2[2] = 0.0;
RA4_student_B.RobotArm_sfcn_o4 = 0.0;
RA4_student_B.Sum4 = 0.0;
RA4_student_B.Sum5 = 0.0;
RA4_student_B.Sum6 = 0.0;
RA4_student_B.ReferenceSolenoid = 0.0;
RA4_student_B.SFunction[0] = 0.0;
RA4_student_B.SFunction[1] = 0.0;
RA4_student_B.SFunction[2] = 0.0;
RA4_student_B.SFunction[3] = 0.0;
}
/* parameters */
RA4_student_M->ModelData.defaultParam = ((real_T *)&RA4_student_P);
/* states (dwork) */
RA4_student_M->ModelData.dwork = ((void *) &RA4_student_DW);
(void) memset((void *)&RA4_student_DW, 0,
sizeof(DW_RA4_student_T));
RA4_student_DW.UnitDelay2_DSTATE[0] = 0.0;
RA4_student_DW.UnitDelay2_DSTATE[1] = 0.0;
RA4_student_DW.UnitDelay2_DSTATE[2] = 0.0;
RA4_student_DW.UnitDelay1_DSTATE = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK0 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK1 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK2 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK3 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK4 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK5 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK6 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK7 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK8 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK9 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK10 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK11 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK12 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK13 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK14 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK15 = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK16[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK16[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK17[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK17[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK18[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK18[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK18[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK18[3] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK19[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK19[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK19[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK19[3] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK20[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK20[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK21[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK21[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK21[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK21[3] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK22[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK22[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK22[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK22[3] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK23[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK23[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK24[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK24[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK25[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK25[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK25[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK25[3] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK26[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK26[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK26[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK26[3] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK27[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK27[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK28[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK28[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK28[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK28[3] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK29[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK29[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK29[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK29[3] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK30[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK30[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK31[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK31[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK32[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK32[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK32[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK32[3] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK33[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK33[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK33[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK33[3] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK34[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK34[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK35[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK35[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK35[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK35[3] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK36[0] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK36[1] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK36[2] = 0.0;
RA4_student_DW.RobotArm_sfcn_DWORK36[3] = 0.0;
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
RA4_student_M->SpecialInfo.mappingInfo = (&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;
}
/* child S-Function registration */
{
RTWSfcnInfo *sfcnInfo = &RA4_student_M->NonInlinedSFcns.sfcnInfo;
RA4_student_M->sfcnInfo = (sfcnInfo);
rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(RA4_student_M)));
rtssSetNumRootSampTimesPtr(sfcnInfo, &RA4_student_M->Sizes.numSampTimes);
RA4_student_M->NonInlinedSFcns.taskTimePtrs[0] = &(rtmGetTPtr(RA4_student_M)
[0]);
RA4_student_M->NonInlinedSFcns.taskTimePtrs[1] = &(rtmGetTPtr(RA4_student_M)
[1]);
rtssSetTPtrPtr(sfcnInfo,RA4_student_M->NonInlinedSFcns.taskTimePtrs);
rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(RA4_student_M));
rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(RA4_student_M));
rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(RA4_student_M));
rtssSetStepSizePtr(sfcnInfo, &RA4_student_M->Timing.stepSize);
rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(RA4_student_M));
rtssSetDerivCacheNeedsResetPtr(sfcnInfo,
&RA4_student_M->ModelData.derivCacheNeedsReset);
rtssSetZCCacheNeedsResetPtr(sfcnInfo,
&RA4_student_M->ModelData.zCCacheNeedsReset);
rtssSetBlkStateChangePtr(sfcnInfo, &RA4_student_M->ModelData.blkStateChange);
rtssSetSampleHitsPtr(sfcnInfo, &RA4_student_M->Timing.sampleHits);
rtssSetPerTaskSampleHitsPtr(sfcnInfo,
&RA4_student_M->Timing.perTaskSampleHits);
rtssSetSimModePtr(sfcnInfo, &RA4_student_M->simMode);
rtssSetSolverInfoPtr(sfcnInfo, &RA4_student_M->solverInfoPtr);
}
RA4_student_M->Sizes.numSFcns = (2);
/* register each child */
{
(void) memset((void *)&RA4_student_M->NonInlinedSFcns.childSFunctions[0], 0,
2*sizeof(SimStruct));
RA4_student_M->childSfunctions =
(&RA4_student_M->NonInlinedSFcns.childSFunctionPtrs[0]);
RA4_student_M->childSfunctions[0] =
(&RA4_student_M->NonInlinedSFcns.childSFunctions[0]);
RA4_student_M->childSfunctions[1] =
(&RA4_student_M->NonInlinedSFcns.childSFunctions[1]);
/* Level2 S-Function Block: RA4_student/<S6>/S-Function (sf_rt_scope) */
{
SimStruct *rts = RA4_student_M->childSfunctions[0];
/* timing info */
time_T *sfcnPeriod = RA4_student_M->NonInlinedSFcns.Sfcn0.sfcnPeriod;
time_T *sfcnOffset = RA4_student_M->NonInlinedSFcns.Sfcn0.sfcnOffset;
int_T *sfcnTsMap = RA4_student_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, &RA4_student_M->NonInlinedSFcns.blkInfo2[0]);
}
ssSetRTWSfcnInfo(rts, RA4_student_M->sfcnInfo);
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &RA4_student_M->NonInlinedSFcns.methods2[0]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &RA4_student_M->NonInlinedSFcns.methods3[0]);
}
/* Allocate memory for states auxilliary information */
{
ssSetStatesInfo2(rts, &RA4_student_M->NonInlinedSFcns.statesInfo2[0]);
ssSetPeriodicStatesInfo(rts,
&RA4_student_M->NonInlinedSFcns.periodicStatesInfo[0]);
}
/* inputs */
{
_ssSetNumInputPorts(rts, 1);
ssSetPortInfoForInputs(rts,
&RA4_student_M->NonInlinedSFcns.Sfcn0.inputPortInfo[0]);
/* port 0 */
{
real_T const **sfcnUPtrs = (real_T const **)
&RA4_student_M->NonInlinedSFcns.Sfcn0.UPtrs0;
sfcnUPtrs[0] = (real_T*)&RA4_student_RGND;
sfcnUPtrs[1] = (real_T*)&RA4_student_RGND;
sfcnUPtrs[2] = (real_T*)&RA4_student_RGND;
sfcnUPtrs[3] = (real_T*)&RA4_student_RGND;
sfcnUPtrs[4] = (real_T*)&RA4_student_RGND;
sfcnUPtrs[5] = (real_T*)&RA4_student_RGND;
sfcnUPtrs[6] = (real_T*)&RA4_student_RGND;
sfcnUPtrs[7] = (real_T*)&RA4_student_RGND;
ssSetInputPortSignalPtrs(rts, 0, (InputPtrsType)&sfcnUPtrs[0]);
_ssSetInputPortNumDimensions(rts, 0, 1);
ssSetInputPortWidth(rts, 0, 8);
}
}
/* outputs */
{
ssSetPortInfoForOutputs(rts,
&RA4_student_M->NonInlinedSFcns.Sfcn0.outputPortInfo[0]);
_ssSetNumOutputPorts(rts, 1);
/* port 0 */
{
_ssSetOutputPortNumDimensions(rts, 0, 1);
ssSetOutputPortWidth(rts, 0, 4);
ssSetOutputPortSignal(rts, 0, ((real_T *) RA4_student_B.SFunction));
}
}
/* path info */
ssSetModelName(rts, "S-Function");
ssSetPath(rts, "RA4_student/Controller/RTScope/S-Function");
ssSetRTModel(rts,RA4_student_M);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* parameters */
{
mxArray **sfcnParams = (mxArray **)
&RA4_student_M->NonInlinedSFcns.Sfcn0.params;
ssSetSFcnParamsCount(rts, 1);
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
ssSetSFcnParam(rts, 0, (mxArray*)RA4_student_P.SFunction_P1_Size);
}
/* registration */
sf_rt_scope(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.0);
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);
}
/* RTW Generated Level2 S-Function Block: RA4_student/<S2>/Robot Arm_sfcn (Robot_sf) */
{
SimStruct *rts = RA4_student_M->childSfunctions[1];
/* timing info */
time_T *sfcnPeriod = RA4_student_M->NonInlinedSFcns.Sfcn1.sfcnPeriod;
time_T *sfcnOffset = RA4_student_M->NonInlinedSFcns.Sfcn1.sfcnOffset;
int_T *sfcnTsMap = RA4_student_M->NonInlinedSFcns.Sfcn1.sfcnTsMap;
(void) memset((void*)sfcnPeriod, 0,
sizeof(time_T)*2);
(void) memset((void*)sfcnOffset, 0,
sizeof(time_T)*2);
ssSetSampleTimePtr(rts, &sfcnPeriod[0]);
ssSetOffsetTimePtr(rts, &sfcnOffset[0]);
ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap);
/* Set up the mdlInfo pointer */
{
ssSetBlkInfo2Ptr(rts, &RA4_student_M->NonInlinedSFcns.blkInfo2[1]);
}
ssSetRTWSfcnInfo(rts, RA4_student_M->sfcnInfo);
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &RA4_student_M->NonInlinedSFcns.methods2[1]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &RA4_student_M->NonInlinedSFcns.methods3[1]);
}
/* Allocate memory for states auxilliary information */
{
ssSetStatesInfo2(rts, &RA4_student_M->NonInlinedSFcns.statesInfo2[1]);
ssSetPeriodicStatesInfo(rts,
&RA4_student_M->NonInlinedSFcns.periodicStatesInfo[1]);
}
/* inputs */
{
_ssSetNumInputPorts(rts, 2);
ssSetPortInfoForInputs(rts,
&RA4_student_M->NonInlinedSFcns.Sfcn1.inputPortInfo[0]);
/* port 0 */
{
real_T const **sfcnUPtrs = (real_T const **)
&RA4_student_M->NonInlinedSFcns.Sfcn1.UPtrs0;
sfcnUPtrs[0] = RA4_student_B.UnitDelay2;
sfcnUPtrs[1] = &RA4_student_B.UnitDelay2[1];
sfcnUPtrs[2] = &RA4_student_B.UnitDelay2[2];
ssSetInputPortSignalPtrs(rts, 0, (InputPtrsType)&sfcnUPtrs[0]);
_ssSetInputPortNumDimensions(rts, 0, 1);
ssSetInputPortWidth(rts, 0, 3);
}
/* port 1 */
{
real_T const **sfcnUPtrs = (real_T const **)
&RA4_student_M->NonInlinedSFcns.Sfcn1.UPtrs1;
sfcnUPtrs[0] = &RA4_student_B.UnitDelay1;
ssSetInputPortSignalPtrs(rts, 1, (InputPtrsType)&sfcnUPtrs[0]);
_ssSetInputPortNumDimensions(rts, 1, 1);
ssSetInputPortWidth(rts, 1, 1);
}
}
/* outputs */
{
ssSetPortInfoForOutputs(rts,
&RA4_student_M->NonInlinedSFcns.Sfcn1.outputPortInfo[0]);
_ssSetNumOutputPorts(rts, 4);
/* port 0 */
{
_ssSetOutputPortNumDimensions(rts, 0, 1);
ssSetOutputPortWidth(rts, 0, 1);
ssSetOutputPortSignal(rts, 0, ((real_T *)
&RA4_student_B.RobotArm_sfcn_o1));
}
/* port 1 */
{
_ssSetOutputPortNumDimensions(rts, 1, 1);
ssSetOutputPortWidth(rts, 1, 3);
ssSetOutputPortSignal(rts, 1, ((real_T *)
RA4_student_B.RobotArm_sfcn_o2));
}
/* port 2 */
{
_ssSetOutputPortNumDimensions(rts, 2, 1);
ssSetOutputPortWidth(rts, 2, 3);
ssSetOutputPortSignal(rts, 2, ((boolean_T *)
RA4_student_B.RobotArm_sfcn_o3));
}
/* port 3 */
{
_ssSetOutputPortNumDimensions(rts, 3, 1);
ssSetOutputPortWidth(rts, 3, 1);
ssSetOutputPortSignal(rts, 3, ((real_T *)
&RA4_student_B.RobotArm_sfcn_o4));
}
}
/* path info */
ssSetModelName(rts, "Robot Arm_sfcn");
ssSetPath(rts, "RA4_student/Robot Arm1/Robot Arm_sfcn");
ssSetRTModel(rts,RA4_student_M);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* work vectors */
{
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
&RA4_student_M->NonInlinedSFcns.Sfcn1.dWork;
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
&RA4_student_M->NonInlinedSFcns.Sfcn1.dWorkAux;
ssSetSFcnDWork(rts, dWorkRecord);
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
_ssSetNumDWork(rts, 47);
/* DWORK0 */
ssSetDWorkWidth(rts, 0, 1);
ssSetDWorkDataType(rts, 0,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 0, 0);
ssSetDWorkUsedAsDState(rts, 0, 1);
ssSetDWork(rts, 0, &RA4_student_DW.RobotArm_sfcn_DWORK0);
/* DWORK1 */
ssSetDWorkWidth(rts, 1, 1);
ssSetDWorkDataType(rts, 1,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 1, 0);
ssSetDWorkUsedAsDState(rts, 1, 1);
ssSetDWork(rts, 1, &RA4_student_DW.RobotArm_sfcn_DWORK1);
/* DWORK2 */
ssSetDWorkWidth(rts, 2, 1);
ssSetDWorkDataType(rts, 2,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 2, 0);
ssSetDWorkUsedAsDState(rts, 2, 1);
ssSetDWork(rts, 2, &RA4_student_DW.RobotArm_sfcn_DWORK2);
/* DWORK3 */
ssSetDWorkWidth(rts, 3, 1);
ssSetDWorkDataType(rts, 3,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 3, 0);
ssSetDWorkUsedAsDState(rts, 3, 1);
ssSetDWork(rts, 3, &RA4_student_DW.RobotArm_sfcn_DWORK3);
/* DWORK4 */
ssSetDWorkWidth(rts, 4, 1);
ssSetDWorkDataType(rts, 4,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 4, 0);
ssSetDWorkUsedAsDState(rts, 4, 1);
ssSetDWork(rts, 4, &RA4_student_DW.RobotArm_sfcn_DWORK4);
/* DWORK5 */
ssSetDWorkWidth(rts, 5, 1);
ssSetDWorkDataType(rts, 5,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 5, 0);
ssSetDWorkUsedAsDState(rts, 5, 1);
ssSetDWork(rts, 5, &RA4_student_DW.RobotArm_sfcn_DWORK5);
/* DWORK6 */
ssSetDWorkWidth(rts, 6, 1);
ssSetDWorkDataType(rts, 6,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 6, 0);
ssSetDWorkUsedAsDState(rts, 6, 1);
ssSetDWork(rts, 6, &RA4_student_DW.RobotArm_sfcn_DWORK6);
/* DWORK7 */
ssSetDWorkWidth(rts, 7, 1);
ssSetDWorkDataType(rts, 7,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 7, 0);
ssSetDWorkUsedAsDState(rts, 7, 1);
ssSetDWork(rts, 7, &RA4_student_DW.RobotArm_sfcn_DWORK7);
/* DWORK8 */
ssSetDWorkWidth(rts, 8, 1);
ssSetDWorkDataType(rts, 8,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 8, 0);
ssSetDWorkUsedAsDState(rts, 8, 1);
ssSetDWork(rts, 8, &RA4_student_DW.RobotArm_sfcn_DWORK8);
/* DWORK9 */
ssSetDWorkWidth(rts, 9, 1);
ssSetDWorkDataType(rts, 9,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 9, 0);
ssSetDWorkUsedAsDState(rts, 9, 1);
ssSetDWork(rts, 9, &RA4_student_DW.RobotArm_sfcn_DWORK9);
/* DWORK10 */
ssSetDWorkWidth(rts, 10, 1);
ssSetDWorkDataType(rts, 10,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 10, 0);
ssSetDWork(rts, 10, &RA4_student_DW.RobotArm_sfcn_DWORK10);
/* DWORK11 */
ssSetDWorkWidth(rts, 11, 1);
ssSetDWorkDataType(rts, 11,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 11, 0);
ssSetDWork(rts, 11, &RA4_student_DW.RobotArm_sfcn_DWORK11);
/* DWORK12 */
ssSetDWorkWidth(rts, 12, 1);
ssSetDWorkDataType(rts, 12,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 12, 0);
ssSetDWork(rts, 12, &RA4_student_DW.RobotArm_sfcn_DWORK12);
/* DWORK13 */
ssSetDWorkWidth(rts, 13, 1);
ssSetDWorkDataType(rts, 13,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 13, 0);
ssSetDWork(rts, 13, &RA4_student_DW.RobotArm_sfcn_DWORK13);
/* DWORK14 */
ssSetDWorkWidth(rts, 14, 1);
ssSetDWorkDataType(rts, 14,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 14, 0);
ssSetDWork(rts, 14, &RA4_student_DW.RobotArm_sfcn_DWORK14);
/* DWORK15 */
ssSetDWorkWidth(rts, 15, 1);
ssSetDWorkDataType(rts, 15,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 15, 0);
ssSetDWork(rts, 15, &RA4_student_DW.RobotArm_sfcn_DWORK15);
/* DWORK16 */
ssSetDWorkWidth(rts, 16, 2);
ssSetDWorkDataType(rts, 16,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 16, 0);
ssSetDWork(rts, 16, &RA4_student_DW.RobotArm_sfcn_DWORK16[0]);
/* DWORK17 */
ssSetDWorkWidth(rts, 17, 2);
ssSetDWorkDataType(rts, 17,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 17, 0);
ssSetDWork(rts, 17, &RA4_student_DW.RobotArm_sfcn_DWORK17[0]);
/* DWORK18 */
ssSetDWorkWidth(rts, 18, 4);
ssSetDWorkDataType(rts, 18,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 18, 0);
ssSetDWork(rts, 18, &RA4_student_DW.RobotArm_sfcn_DWORK18[0]);
/* DWORK19 */
ssSetDWorkWidth(rts, 19, 4);
ssSetDWorkDataType(rts, 19,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 19, 0);
ssSetDWork(rts, 19, &RA4_student_DW.RobotArm_sfcn_DWORK19[0]);
/* DWORK20 */
ssSetDWorkWidth(rts, 20, 2);
ssSetDWorkDataType(rts, 20,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 20, 0);
ssSetDWork(rts, 20, &RA4_student_DW.RobotArm_sfcn_DWORK20[0]);
/* DWORK21 */
ssSetDWorkWidth(rts, 21, 4);
ssSetDWorkDataType(rts, 21,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 21, 0);
ssSetDWork(rts, 21, &RA4_student_DW.RobotArm_sfcn_DWORK21[0]);
/* DWORK22 */
ssSetDWorkWidth(rts, 22, 4);
ssSetDWorkDataType(rts, 22,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 22, 0);
ssSetDWork(rts, 22, &RA4_student_DW.RobotArm_sfcn_DWORK22[0]);
/* DWORK23 */
ssSetDWorkWidth(rts, 23, 2);
ssSetDWorkDataType(rts, 23,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 23, 0);
ssSetDWork(rts, 23, &RA4_student_DW.RobotArm_sfcn_DWORK23[0]);
/* DWORK24 */
ssSetDWorkWidth(rts, 24, 2);
ssSetDWorkDataType(rts, 24,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 24, 0);
ssSetDWork(rts, 24, &RA4_student_DW.RobotArm_sfcn_DWORK24[0]);
/* DWORK25 */
ssSetDWorkWidth(rts, 25, 4);
ssSetDWorkDataType(rts, 25,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 25, 0);
ssSetDWork(rts, 25, &RA4_student_DW.RobotArm_sfcn_DWORK25[0]);
/* DWORK26 */
ssSetDWorkWidth(rts, 26, 4);
ssSetDWorkDataType(rts, 26,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 26, 0);
ssSetDWork(rts, 26, &RA4_student_DW.RobotArm_sfcn_DWORK26[0]);
/* DWORK27 */
ssSetDWorkWidth(rts, 27, 2);
ssSetDWorkDataType(rts, 27,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 27, 0);
ssSetDWork(rts, 27, &RA4_student_DW.RobotArm_sfcn_DWORK27[0]);
/* DWORK28 */
ssSetDWorkWidth(rts, 28, 4);
ssSetDWorkDataType(rts, 28,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 28, 0);
ssSetDWork(rts, 28, &RA4_student_DW.RobotArm_sfcn_DWORK28[0]);
/* DWORK29 */
ssSetDWorkWidth(rts, 29, 4);
ssSetDWorkDataType(rts, 29,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 29, 0);
ssSetDWork(rts, 29, &RA4_student_DW.RobotArm_sfcn_DWORK29[0]);
/* DWORK30 */
ssSetDWorkWidth(rts, 30, 2);
ssSetDWorkDataType(rts, 30,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 30, 0);
ssSetDWork(rts, 30, &RA4_student_DW.RobotArm_sfcn_DWORK30[0]);
/* DWORK31 */
ssSetDWorkWidth(rts, 31, 2);
ssSetDWorkDataType(rts, 31,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 31, 0);
ssSetDWork(rts, 31, &RA4_student_DW.RobotArm_sfcn_DWORK31[0]);
/* DWORK32 */
ssSetDWorkWidth(rts, 32, 4);
ssSetDWorkDataType(rts, 32,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 32, 0);
ssSetDWork(rts, 32, &RA4_student_DW.RobotArm_sfcn_DWORK32[0]);
/* DWORK33 */
ssSetDWorkWidth(rts, 33, 4);
ssSetDWorkDataType(rts, 33,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 33, 0);
ssSetDWork(rts, 33, &RA4_student_DW.RobotArm_sfcn_DWORK33[0]);
/* DWORK34 */
ssSetDWorkWidth(rts, 34, 2);
ssSetDWorkDataType(rts, 34,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 34, 0);
ssSetDWork(rts, 34, &RA4_student_DW.RobotArm_sfcn_DWORK34[0]);
/* DWORK35 */
ssSetDWorkWidth(rts, 35, 4);
ssSetDWorkDataType(rts, 35,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 35, 0);
ssSetDWork(rts, 35, &RA4_student_DW.RobotArm_sfcn_DWORK35[0]);
/* DWORK36 */
ssSetDWorkWidth(rts, 36, 4);
ssSetDWorkDataType(rts, 36,SS_DOUBLE);
ssSetDWorkComplexSignal(rts, 36, 0);
ssSetDWork(rts, 36, &RA4_student_DW.RobotArm_sfcn_DWORK36[0]);
/* DWORK37 */
ssSetDWorkWidth(rts, 37, 1);
ssSetDWorkDataType(rts, 37,SS_INT32);
ssSetDWorkComplexSignal(rts, 37, 0);
ssSetDWork(rts, 37, &RA4_student_DW.RobotArm_sfcn_DWORK37);
/* DWORK38 */
ssSetDWorkWidth(rts, 38, 1);
ssSetDWorkDataType(rts, 38,SS_UINT16);
ssSetDWorkComplexSignal(rts, 38, 0);
ssSetDWork(rts, 38, &RA4_student_DW.RobotArm_sfcn_DWORK38);
/* DWORK39 */
ssSetDWorkWidth(rts, 39, 1);
ssSetDWorkDataType(rts, 39,SS_UINT16);
ssSetDWorkComplexSignal(rts, 39, 0);
ssSetDWork(rts, 39, &RA4_student_DW.RobotArm_sfcn_DWORK39);
/* DWORK40 */
ssSetDWorkWidth(rts, 40, 1);
ssSetDWorkDataType(rts, 40,SS_UINT16);
ssSetDWorkComplexSignal(rts, 40, 0);
ssSetDWork(rts, 40, &RA4_student_DW.RobotArm_sfcn_DWORK40);
/* DWORK41 */
ssSetDWorkWidth(rts, 41, 1);
ssSetDWorkDataType(rts, 41,SS_UINT8);
ssSetDWorkComplexSignal(rts, 41, 0);
ssSetDWork(rts, 41, &RA4_student_DW.RobotArm_sfcn_DWORK41);
/* DWORK42 */
ssSetDWorkWidth(rts, 42, 1);
ssSetDWorkDataType(rts, 42,SS_UINT8);
ssSetDWorkComplexSignal(rts, 42, 0);
ssSetDWork(rts, 42, &RA4_student_DW.RobotArm_sfcn_DWORK42);
/* DWORK43 */
ssSetDWorkWidth(rts, 43, 1);
ssSetDWorkDataType(rts, 43,SS_UINT8);
ssSetDWorkComplexSignal(rts, 43, 0);
ssSetDWork(rts, 43, &RA4_student_DW.RobotArm_sfcn_DWORK43);
/* DWORK44 */
ssSetDWorkWidth(rts, 44, 1);
ssSetDWorkDataType(rts, 44,SS_UINT8);
ssSetDWorkComplexSignal(rts, 44, 0);
ssSetDWork(rts, 44, &RA4_student_DW.RobotArm_sfcn_DWORK44);
/* DWORK45 */
ssSetDWorkWidth(rts, 45, 1);
ssSetDWorkDataType(rts, 45,SS_UINT8);
ssSetDWorkComplexSignal(rts, 45, 0);
ssSetDWork(rts, 45, &RA4_student_DW.RobotArm_sfcn_DWORK45);
/* DWORK46 */
ssSetDWorkWidth(rts, 46, 1);
ssSetDWorkDataType(rts, 46,SS_UINT8);
ssSetDWorkComplexSignal(rts, 46, 0);
ssSetDWork(rts, 46, &RA4_student_DW.RobotArm_sfcn_DWORK46);
}
/* registration */
Robot_sf(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.0);
ssSetOffsetTime(rts, 0, 0.0);
ssSetSampleTime(rts, 1, 0.000244140625);
ssSetOffsetTime(rts, 1, 0.0);
sfcnTsMap[0] = 0;
sfcnTsMap[1] = 1;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetInputPortConnected(rts, 0, 1);
_ssSetInputPortConnected(rts, 1, 1);
_ssSetOutputPortConnected(rts, 0, 1);
_ssSetOutputPortConnected(rts, 1, 1);
_ssSetOutputPortConnected(rts, 2, 1);
_ssSetOutputPortConnected(rts, 3, 1);
_ssSetOutputPortBeingMerged(rts, 0, 0);
_ssSetOutputPortBeingMerged(rts, 1, 0);
_ssSetOutputPortBeingMerged(rts, 2, 0);
_ssSetOutputPortBeingMerged(rts, 3, 0);
/* Update the BufferDstPort flags for each input port */
ssSetInputPortBufferDstPort(rts, 0, -1);
ssSetInputPortBufferDstPort(rts, 1, -1);
/* Instance data for generated S-Function: Robot */
#include "Robot_sfcn_rtw/Robot_sid.h"
}
}
/* Initialize Sizes */
RA4_student_M->Sizes.numContStates = (0);/* Number of continuous states */
RA4_student_M->Sizes.numY = (0); /* Number of model outputs */
RA4_student_M->Sizes.numU = (0); /* Number of model inputs */
RA4_student_M->Sizes.sysDirFeedThru = (0);/* The model is not direct feedthrough */
RA4_student_M->Sizes.numSampTimes = (2);/* Number of sample times */
RA4_student_M->Sizes.numBlocks = (24);/* Number of blocks */
RA4_student_M->Sizes.numBlockIO = (11);/* Number of block outputs */
RA4_student_M->Sizes.numBlockPrms = (16);/* Sum of parameter "widths" */
return RA4_student_M;
}
/* Model initialize function */
void GyroskopAuswertung_initialize(void)
{
/* Registration code */
/* initialize real-time model */
(void) memset((void *)GyroskopAuswertung_M, 0,
sizeof(RT_MODEL_GyroskopAuswertung_T));
rtmSetTFinal(GyroskopAuswertung_M, 10.0);
GyroskopAuswertung_M->Timing.stepSize0 = 0.01;
/* External mode info */
GyroskopAuswertung_M->Sizes.checksums[0] = (1941814335U);
GyroskopAuswertung_M->Sizes.checksums[1] = (4017032776U);
GyroskopAuswertung_M->Sizes.checksums[2] = (2489100557U);
GyroskopAuswertung_M->Sizes.checksums[3] = (945044384U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[1];
GyroskopAuswertung_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(GyroskopAuswertung_M->extModeInfo,
&GyroskopAuswertung_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(GyroskopAuswertung_M->extModeInfo,
GyroskopAuswertung_M->Sizes.checksums);
rteiSetTPtr(GyroskopAuswertung_M->extModeInfo, rtmGetTPtr
(GyroskopAuswertung_M));
}
/* block I/O */
(void) memset(((void *) &GyroskopAuswertung_B), 0,
sizeof(B_GyroskopAuswertung_T));
/* states (dwork) */
(void) memset((void *)&GyroskopAuswertung_DW, 0,
sizeof(DW_GyroskopAuswertung_T));
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
GyroskopAuswertung_M->SpecialInfo.mappingInfo = (&dtInfo);
dtInfo.numDataTypes = 14;
dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
dtInfo.dataTypeNames = &rtDataTypeNames[0];
/* Block I/O transition table */
dtInfo.BTransTable = &rtBTransTable;
/* Parameters transition table */
dtInfo.PTransTable = &rtPTransTable;
}
/* S-Function Block: <Root>/Sensor1 */
{
real_T initVector[1] = { 0 };
{
int_T i1;
for (i1=0; i1 < 1; i1++) {
GyroskopAuswertung_DW.Sensor1_DSTATE = initVector[0];
}
}
}
/* S-Function Block: <Root>/Sensor2 */
{
real_T initVector[1] = { 0 };
{
int_T i1;
for (i1=0; i1 < 1; i1++) {
GyroskopAuswertung_DW.Sensor2_DSTATE = initVector[0];
}
}
}
}
/* Model initialize function */
void motor_control_initialize(void)
{
/* Registration code */
/* initialize real-time model */
(void) memset((void *)motor_control_M, 0,
sizeof(RT_MODEL_motor_control_T));
rtmSetTFinal(motor_control_M, -1);
motor_control_M->Timing.stepSize0 = 0.05;
/* External mode info */
motor_control_M->Sizes.checksums[0] = (2107225776U);
motor_control_M->Sizes.checksums[1] = (1965539276U);
motor_control_M->Sizes.checksums[2] = (1036431389U);
motor_control_M->Sizes.checksums[3] = (618126809U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[1];
motor_control_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(motor_control_M->extModeInfo,
&motor_control_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(motor_control_M->extModeInfo,
motor_control_M->Sizes.checksums);
rteiSetTPtr(motor_control_M->extModeInfo, rtmGetTPtr(motor_control_M));
}
/* block I/O */
(void) memset(((void *) &motor_control_B), 0,
sizeof(B_motor_control_T));
/* states (dwork) */
(void) memset((void *)&motor_control_DW, 0,
sizeof(DW_motor_control_T));
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
motor_control_M->SpecialInfo.mappingInfo = (&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;
}
/* Start for DiscretePulseGenerator: '<Root>/Pulse Generator' */
motor_control_DW.clockTickCounter = 0L;
/* S-Function Block: <Root>/Encoder */
{
real_T initVector[1] = { 0 };
{
int_T i1;
for (i1=0; i1 < 1; i1++) {
motor_control_DW.Encoder_DSTATE = initVector[0];
}
}
}
/* InitializeConditions for DiscreteIntegrator: '<S1>/Integrator' */
motor_control_DW.Integrator_DSTATE = motor_control_P.Integrator_IC;
/* InitializeConditions for DiscreteIntegrator: '<S1>/Filter' */
motor_control_DW.Filter_DSTATE = motor_control_P.Filter_IC;
/* S-Function Block: <Root>/PWM */
{
real_T initVector[1] = { 0 };
{
int_T i1;
for (i1=0; i1 < 1; i1++) {
motor_control_DW.PWM_DSTATE = initVector[0];
}
}
}
}
/* Model initialize function */
void omni_interface_initialize(boolean_T firstTime)
{
(void)firstTime;
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T)); /* initialize real-time model */
(void) memset((char_T *)omni_interface_M,0,
sizeof(RT_MODEL_omni_interface));
/* Initialize timing info */
{
int_T *mdlTsMap = omni_interface_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
omni_interface_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
omni_interface_M->Timing.sampleTimes =
(&omni_interface_M->Timing.sampleTimesArray[0]);
omni_interface_M->Timing.offsetTimes =
(&omni_interface_M->Timing.offsetTimesArray[0]);
/* task periods */
omni_interface_M->Timing.sampleTimes[0] = (0.001);
/* task offsets */
omni_interface_M->Timing.offsetTimes[0] = (0.0);
}
rtmSetTPtr(omni_interface_M, &omni_interface_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = omni_interface_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
omni_interface_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(omni_interface_M, -1);
omni_interface_M->Timing.stepSize0 = 0.001;
/* external mode info */
omni_interface_M->Sizes.checksums[0] = (3515672156U);
omni_interface_M->Sizes.checksums[1] = (4130000490U);
omni_interface_M->Sizes.checksums[2] = (2703472843U);
omni_interface_M->Sizes.checksums[3] = (3284165155U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[13];
omni_interface_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
systemRan[1] = &rtAlwaysEnabled;
systemRan[2] = &rtAlwaysEnabled;
systemRan[3] = &rtAlwaysEnabled;
systemRan[4] = &rtAlwaysEnabled;
systemRan[5] = &rtAlwaysEnabled;
systemRan[6] = &rtAlwaysEnabled;
systemRan[7] = &rtAlwaysEnabled;
systemRan[8] = &rtAlwaysEnabled;
systemRan[9] = &rtAlwaysEnabled;
systemRan[10] = &rtAlwaysEnabled;
systemRan[11] = &rtAlwaysEnabled;
systemRan[12] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(&rt_ExtModeInfo,
&omni_interface_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(&rt_ExtModeInfo, omni_interface_M->Sizes.checksums);
rteiSetTPtr(&rt_ExtModeInfo, rtmGetTPtr(omni_interface_M));
}
omni_interface_M->solverInfoPtr = (&omni_interface_M->solverInfo);
omni_interface_M->Timing.stepSize = (0.001);
rtsiSetFixedStepSize(&omni_interface_M->solverInfo, 0.001);
rtsiSetSolverMode(&omni_interface_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
omni_interface_M->ModelData.blockIO = ((void *) &omni_interface_B);
(void) memset(((void *) &omni_interface_B),0,
sizeof(BlockIO_omni_interface));
{
int_T i;
void *pVoidBlockIORegion;
pVoidBlockIORegion = (void *)(&omni_interface_B.Gain2[0]);
for (i = 0; i < 12; i++) {
((real_T*)pVoidBlockIORegion)[i] = 0.0;
}
}
/* parameters */
omni_interface_M->ModelData.defaultParam = ((real_T *) &omni_interface_P);
/* states (dwork) */
omni_interface_M->Work.dwork = ((void *) &omni_interface_DWork);
(void) memset((char_T *) &omni_interface_DWork,0,
sizeof(D_Work_omni_interface));
{
int_T i;
real_T *dwork_ptr = (real_T *) &omni_interface_DWork.FixPtUnitDelay1_DSTATE;
for (i = 0; i < 19; i++) {
dwork_ptr[i] = 0.0;
}
}
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo,0,
sizeof(dtInfo));
omni_interface_M->SpecialInfo.mappingInfo = (&dtInfo);
dtInfo.numDataTypes = 18;
dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
dtInfo.dataTypeNames = &rtDataTypeNames[0];
/* Block I/O transition table */
dtInfo.B = &rtBTransTable;
/* Parameters transition table */
dtInfo.P = &rtPTransTable;
}
}
/* Model initialize function */
void motor_test_hierarchies_initialize(void)
{
/* Registration code */
/* initialize real-time model */
(void) memset((void *)motor_test_hierarchies_M, 0,
sizeof(RT_MODEL_motor_test_hierarchi_T));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&motor_test_hierarchies_M->solverInfo,
&motor_test_hierarchies_M->Timing.simTimeStep);
rtsiSetTPtr(&motor_test_hierarchies_M->solverInfo, &rtmGetTPtr
(motor_test_hierarchies_M));
rtsiSetStepSizePtr(&motor_test_hierarchies_M->solverInfo,
&motor_test_hierarchies_M->Timing.stepSize0);
rtsiSetErrorStatusPtr(&motor_test_hierarchies_M->solverInfo,
(&rtmGetErrorStatus(motor_test_hierarchies_M)));
rtsiSetRTModelPtr(&motor_test_hierarchies_M->solverInfo,
motor_test_hierarchies_M);
}
rtsiSetSimTimeStep(&motor_test_hierarchies_M->solverInfo, MAJOR_TIME_STEP);
rtsiSetSolverName(&motor_test_hierarchies_M->solverInfo,"FixedStepDiscrete");
rtmSetTPtr(motor_test_hierarchies_M, &motor_test_hierarchies_M->Timing.tArray
[0]);
rtmSetTFinal(motor_test_hierarchies_M, 200.0);
motor_test_hierarchies_M->Timing.stepSize0 = 1.0;
/* External mode info */
motor_test_hierarchies_M->Sizes.checksums[0] = (1277721381U);
motor_test_hierarchies_M->Sizes.checksums[1] = (3056422068U);
motor_test_hierarchies_M->Sizes.checksums[2] = (826496824U);
motor_test_hierarchies_M->Sizes.checksums[3] = (767811506U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[9];
motor_test_hierarchies_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
systemRan[1] = &rtAlwaysEnabled;
systemRan[2] = &rtAlwaysEnabled;
systemRan[3] = &rtAlwaysEnabled;
systemRan[4] = &rtAlwaysEnabled;
systemRan[5] = &rtAlwaysEnabled;
systemRan[6] = &rtAlwaysEnabled;
systemRan[7] = &rtAlwaysEnabled;
systemRan[8] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(motor_test_hierarchies_M->extModeInfo,
&motor_test_hierarchies_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(motor_test_hierarchies_M->extModeInfo,
motor_test_hierarchies_M->Sizes.checksums);
rteiSetTPtr(motor_test_hierarchies_M->extModeInfo, rtmGetTPtr
(motor_test_hierarchies_M));
}
/* block I/O */
(void) memset(((void *) &motor_test_hierarchies_B), 0,
sizeof(B_motor_test_hierarchies_T));
/* states (dwork) */
(void) memset((void *)&motor_test_hierarchies_DW, 0,
sizeof(DW_motor_test_hierarchies_T));
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
motor_test_hierarchies_M->SpecialInfo.mappingInfo = (&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;
}
/* Start for FromWorkspace: '<S3>/FromWs' */
{
static real_T pTimeValues0[] = { 0.0, 1.0, 1.0, 2.0, 2.0, 4.0, 4.0, 6.0, 6.0,
7.0 } ;
static real_T pDataValues0[] = { 0.0, 128.0, 128.0, 128.0, 128.0, 255.0,
255.0, 255.0, 255.0, 0.0 } ;
motor_test_hierarchies_DW.FromWs_PWORK.TimePtr = (void *) pTimeValues0;
motor_test_hierarchies_DW.FromWs_PWORK.DataPtr = (void *) pDataValues0;
motor_test_hierarchies_DW.FromWs_IWORK.PrevIndex = 0;
}
/* Start for Atomic SubSystem: '<S1>/hl' */
motor_test_hierarchies_hl_Start((P_hl_motor_test_hierarchies_T *)
&motor_test_hierarchies_P.hl);
/* End of Start for SubSystem: '<S1>/hl' */
/* Start for Atomic SubSystem: '<S1>/hr' */
/* Start for S-Function (arduinodigitaloutput_sfcn): '<S10>/Digital Output' */
MW_pinModeOutput(motor_test_hierarchies_P.DigitalOutput_pinNumber);
/* Start for S-Function (arduinoanalogoutput_sfcn): '<S11>/PWM' */
MW_pinModeOutput(motor_test_hierarchies_P.PWM_pinNumber);
/* Start for Atomic SubSystem: '<S1>/vl' */
motor_test_hierarchies_hl_Start((P_hl_motor_test_hierarchies_T *)
&motor_test_hierarchies_P.vl);
/* End of Start for SubSystem: '<S1>/vl' */
/* Start for Atomic SubSystem: '<S1>/vr' */
/* Start for S-Function (arduinodigitaloutput_sfcn): '<S14>/Digital Output' */
MW_pinModeOutput(motor_test_hierarchies_P.DigitalOutput_pinNumber_a);
/* Start for S-Function (arduinoanalogoutput_sfcn): '<S15>/PWM' */
MW_pinModeOutput(motor_test_hierarchies_P.PWM_pinNumber_n);
}
/* Model initialize function */
void udpRead_initialize(void)
{
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)udpRead_M, 0,
sizeof(RT_MODEL_udpRead_T));
rtmSetTFinal(udpRead_M, -1);
udpRead_M->Timing.stepSize0 = 0.001;
/* External mode info */
udpRead_M->Sizes.checksums[0] = (597430241U);
udpRead_M->Sizes.checksums[1] = (1019470990U);
udpRead_M->Sizes.checksums[2] = (4143940322U);
udpRead_M->Sizes.checksums[3] = (93090447U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[5];
udpRead_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
systemRan[1] = (sysRanDType *)&udpRead_DW.ForIteratorSubsystem_SubsysRanB;
systemRan[2] = (sysRanDType *)&udpRead_DW.ForIteratorSubsystem1_SubsysRan;
systemRan[3] = (sysRanDType *)&udpRead_DW.EnabledSubsystem_SubsysRanBC;
systemRan[4] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(udpRead_M->extModeInfo,
&udpRead_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(udpRead_M->extModeInfo, udpRead_M->Sizes.checksums);
rteiSetTPtr(udpRead_M->extModeInfo, rtmGetTPtr(udpRead_M));
}
/* block I/O */
(void) memset(((void *) &udpRead_B), 0,
sizeof(B_udpRead_T));
/* states (dwork) */
(void) memset((void *)&udpRead_DW, 0,
sizeof(DW_udpRead_T));
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
udpRead_M->SpecialInfo.mappingInfo = (&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;
}
{
char_T *sErr;
/* Start for S-Function (sdspFromNetwork): '<Root>/UDP Receive' */
sErr = GetErrorBuffer(&udpRead_DW.UDPReceive_NetworkLib[0U]);
CreateUDPInterface(&udpRead_DW.UDPReceive_NetworkLib[0U]);
if (*sErr == 0) {
LibCreate_Network(&udpRead_DW.UDPReceive_NetworkLib[0U], 0, "0.0.0.0",
25000, "0.0.0.0", -1, 8192, 4, 0);
}
if (*sErr == 0) {
LibStart(&udpRead_DW.UDPReceive_NetworkLib[0U]);
}
if (*sErr != 0) {
DestroyUDPInterface(&udpRead_DW.UDPReceive_NetworkLib[0U]);
if (*sErr != 0) {
rtmSetErrorStatus(udpRead_M, sErr);
rtmSetStopRequested(udpRead_M, 1);
}
}
/* End of Start for S-Function (sdspFromNetwork): '<Root>/UDP Receive' */
/* InitializeConditions for UnitDelay: '<S3>/FixPt Unit Delay2' */
udpRead_DW.FixPtUnitDelay2_DSTATE =
udpRead_P.FixPtUnitDelay2_InitialConditio;
/* InitializeConditions for UnitDelay: '<S3>/FixPt Unit Delay1' */
udpRead_DW.FixPtUnitDelay1_DSTATE = udpRead_P.UnitDelayResettable_vinit;
}
}
/* Model initialize function */
void Maglev_PD_initialize(boolean_T firstTime)
{
(void)firstTime;
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((char_T *)Maglev_PD_M,0,
sizeof(RT_MODEL_Maglev_PD));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&Maglev_PD_M->solverInfo,
&Maglev_PD_M->Timing.simTimeStep);
rtsiSetTPtr(&Maglev_PD_M->solverInfo, &rtmGetTPtr(Maglev_PD_M));
rtsiSetStepSizePtr(&Maglev_PD_M->solverInfo, &Maglev_PD_M->Timing.stepSize0);
rtsiSetErrorStatusPtr(&Maglev_PD_M->solverInfo, (&rtmGetErrorStatus
(Maglev_PD_M)));
rtsiSetRTModelPtr(&Maglev_PD_M->solverInfo, Maglev_PD_M);
}
rtsiSetSimTimeStep(&Maglev_PD_M->solverInfo, MAJOR_TIME_STEP);
rtsiSetSolverName(&Maglev_PD_M->solverInfo,"FixedStepDiscrete");
/* Initialize timing info */
{
int_T *mdlTsMap = Maglev_PD_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
mdlTsMap[2] = 2;
Maglev_PD_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
Maglev_PD_M->Timing.sampleTimes = (&Maglev_PD_M->Timing.sampleTimesArray[0]);
Maglev_PD_M->Timing.offsetTimes = (&Maglev_PD_M->Timing.offsetTimesArray[0]);
/* task periods */
Maglev_PD_M->Timing.sampleTimes[0] = (0.0);
Maglev_PD_M->Timing.sampleTimes[1] = (0.001);
Maglev_PD_M->Timing.sampleTimes[2] = (0.01);
/* task offsets */
Maglev_PD_M->Timing.offsetTimes[0] = (0.0);
Maglev_PD_M->Timing.offsetTimes[1] = (0.0);
Maglev_PD_M->Timing.offsetTimes[2] = (0.0);
}
rtmSetTPtr(Maglev_PD_M, &Maglev_PD_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = Maglev_PD_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
mdlSampleHits[2] = 1;
Maglev_PD_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(Maglev_PD_M, 200.0);
Maglev_PD_M->Timing.stepSize0 = 0.001;
Maglev_PD_M->Timing.stepSize1 = 0.001;
Maglev_PD_M->Timing.stepSize2 = 0.01;
/* external mode info */
Maglev_PD_M->Sizes.checksums[0] = (2405431628U);
Maglev_PD_M->Sizes.checksums[1] = (4276893873U);
Maglev_PD_M->Sizes.checksums[2] = (2115234442U);
Maglev_PD_M->Sizes.checksums[3] = (4197356474U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[2];
Maglev_PD_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
systemRan[1] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(&rt_ExtModeInfo,
&Maglev_PD_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(&rt_ExtModeInfo, Maglev_PD_M->Sizes.checksums);
rteiSetTPtr(&rt_ExtModeInfo, rtmGetTPtr(Maglev_PD_M));
}
Maglev_PD_M->solverInfoPtr = (&Maglev_PD_M->solverInfo);
Maglev_PD_M->Timing.stepSize = (0.001);
rtsiSetFixedStepSize(&Maglev_PD_M->solverInfo, 0.001);
rtsiSetSolverMode(&Maglev_PD_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
Maglev_PD_M->ModelData.blockIO = ((void *) &Maglev_PD_B);
{
int_T i;
void *pVoidBlockIORegion;
pVoidBlockIORegion = (void *)(&Maglev_PD_B.AnalogInput);
for (i = 0; i < 9; i++) {
((real_T*)pVoidBlockIORegion)[i] = 0.0;
}
}
/* parameters */
Maglev_PD_M->ModelData.defaultParam = ((real_T *) &Maglev_PD_P);
/* states (dwork) */
Maglev_PD_M->Work.dwork = ((void *) &Maglev_PD_DWork);
(void) memset((char_T *) &Maglev_PD_DWork,0,
sizeof(D_Work_Maglev_PD));
{
real_T *dwork_ptr = (real_T *) &Maglev_PD_DWork.DiscreteTransferFcn1_DSTATE;
dwork_ptr[0] = 0.0;
dwork_ptr[1] = 0.0;
}
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo,0,
sizeof(dtInfo));
Maglev_PD_M->SpecialInfo.mappingInfo = (&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;
}
}
/* Registration function */
RT_MODEL_DO_model_T *DO_model(void)
{
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T));
/* initialize real-time model */
(void) memset((void *)DO_model_M, 0,
sizeof(RT_MODEL_DO_model_T));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&DO_model_M->solverInfo,
&DO_model_M->Timing.simTimeStep);
rtsiSetTPtr(&DO_model_M->solverInfo, &rtmGetTPtr(DO_model_M));
rtsiSetStepSizePtr(&DO_model_M->solverInfo, &DO_model_M->Timing.stepSize0);
rtsiSetErrorStatusPtr(&DO_model_M->solverInfo, (&rtmGetErrorStatus
(DO_model_M)));
rtsiSetRTModelPtr(&DO_model_M->solverInfo, DO_model_M);
}
rtsiSetSimTimeStep(&DO_model_M->solverInfo, MAJOR_TIME_STEP);
rtsiSetSolverName(&DO_model_M->solverInfo,"FixedStepDiscrete");
DO_model_M->solverInfoPtr = (&DO_model_M->solverInfo);
/* Initialize timing info */
{
int_T *mdlTsMap = DO_model_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
DO_model_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
DO_model_M->Timing.sampleTimes = (&DO_model_M->Timing.sampleTimesArray[0]);
DO_model_M->Timing.offsetTimes = (&DO_model_M->Timing.offsetTimesArray[0]);
/* task periods */
DO_model_M->Timing.sampleTimes[0] = (0.0);
DO_model_M->Timing.sampleTimes[1] = (0.02);
/* task offsets */
DO_model_M->Timing.offsetTimes[0] = (0.0);
DO_model_M->Timing.offsetTimes[1] = (0.0);
}
rtmSetTPtr(DO_model_M, &DO_model_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = DO_model_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
DO_model_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(DO_model_M, 10.0);
DO_model_M->Timing.stepSize0 = 0.02;
DO_model_M->Timing.stepSize1 = 0.02;
/* External mode info */
DO_model_M->Sizes.checksums[0] = (1233238421U);
DO_model_M->Sizes.checksums[1] = (25660452U);
DO_model_M->Sizes.checksums[2] = (2649484807U);
DO_model_M->Sizes.checksums[3] = (3179384684U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[1];
DO_model_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(DO_model_M->extModeInfo,
&DO_model_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(DO_model_M->extModeInfo, DO_model_M->Sizes.checksums);
rteiSetTPtr(DO_model_M->extModeInfo, rtmGetTPtr(DO_model_M));
}
DO_model_M->solverInfoPtr = (&DO_model_M->solverInfo);
DO_model_M->Timing.stepSize = (0.02);
rtsiSetFixedStepSize(&DO_model_M->solverInfo, 0.02);
rtsiSetSolverMode(&DO_model_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
DO_model_M->ModelData.blockIO = ((void *) &DO_model_B);
(void) memset(((void *) &DO_model_B), 0,
sizeof(B_DO_model_T));
/* parameters */
DO_model_M->ModelData.defaultParam = ((real_T *)&DO_model_P);
/* states (dwork) */
DO_model_M->ModelData.dwork = ((void *) &DO_model_DW);
(void) memset((void *)&DO_model_DW, 0,
sizeof(DW_DO_model_T));
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo, 0,
sizeof(dtInfo));
DO_model_M->SpecialInfo.mappingInfo = (&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;
}
/* child S-Function registration */
{
RTWSfcnInfo *sfcnInfo = &DO_model_M->NonInlinedSFcns.sfcnInfo;
DO_model_M->sfcnInfo = (sfcnInfo);
rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(DO_model_M)));
rtssSetNumRootSampTimesPtr(sfcnInfo, &DO_model_M->Sizes.numSampTimes);
DO_model_M->NonInlinedSFcns.taskTimePtrs[0] = &(rtmGetTPtr(DO_model_M)[0]);
DO_model_M->NonInlinedSFcns.taskTimePtrs[1] = &(rtmGetTPtr(DO_model_M)[1]);
rtssSetTPtrPtr(sfcnInfo,DO_model_M->NonInlinedSFcns.taskTimePtrs);
rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(DO_model_M));
rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(DO_model_M));
rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(DO_model_M));
rtssSetStepSizePtr(sfcnInfo, &DO_model_M->Timing.stepSize);
rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(DO_model_M));
rtssSetDerivCacheNeedsResetPtr(sfcnInfo,
&DO_model_M->ModelData.derivCacheNeedsReset);
rtssSetZCCacheNeedsResetPtr(sfcnInfo,
&DO_model_M->ModelData.zCCacheNeedsReset);
rtssSetBlkStateChangePtr(sfcnInfo, &DO_model_M->ModelData.blkStateChange);
rtssSetSampleHitsPtr(sfcnInfo, &DO_model_M->Timing.sampleHits);
rtssSetPerTaskSampleHitsPtr(sfcnInfo, &DO_model_M->Timing.perTaskSampleHits);
rtssSetSimModePtr(sfcnInfo, &DO_model_M->simMode);
rtssSetSolverInfoPtr(sfcnInfo, &DO_model_M->solverInfoPtr);
}
DO_model_M->Sizes.numSFcns = (1);
/* register each child */
{
(void) memset((void *)&DO_model_M->NonInlinedSFcns.childSFunctions[0], 0,
1*sizeof(SimStruct));
DO_model_M->childSfunctions =
(&DO_model_M->NonInlinedSFcns.childSFunctionPtrs[0]);
DO_model_M->childSfunctions[0] =
(&DO_model_M->NonInlinedSFcns.childSFunctions[0]);
/* Level2 S-Function Block: DO_model/<Root>/S-Function (DO_v1) */
{
SimStruct *rts = DO_model_M->childSfunctions[0];
/* timing info */
time_T *sfcnPeriod = DO_model_M->NonInlinedSFcns.Sfcn0.sfcnPeriod;
time_T *sfcnOffset = DO_model_M->NonInlinedSFcns.Sfcn0.sfcnOffset;
int_T *sfcnTsMap = DO_model_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, &DO_model_M->NonInlinedSFcns.blkInfo2[0]);
}
ssSetRTWSfcnInfo(rts, DO_model_M->sfcnInfo);
/* Allocate memory of model methods 2 */
{
ssSetModelMethods2(rts, &DO_model_M->NonInlinedSFcns.methods2[0]);
}
/* Allocate memory of model methods 3 */
{
ssSetModelMethods3(rts, &DO_model_M->NonInlinedSFcns.methods3[0]);
}
/* Allocate memory for states auxilliary information */
{
ssSetStatesInfo2(rts, &DO_model_M->NonInlinedSFcns.statesInfo2[0]);
}
/* outputs */
{
ssSetPortInfoForOutputs(rts,
&DO_model_M->NonInlinedSFcns.Sfcn0.outputPortInfo[0]);
_ssSetNumOutputPorts(rts, 1);
/* port 0 */
{
_ssSetOutputPortNumDimensions(rts, 0, 1);
ssSetOutputPortWidth(rts, 0, 1);
ssSetOutputPortSignal(rts, 0, ((real_T *) &DO_model_B.SFunction));
}
}
/* path info */
ssSetModelName(rts, "S-Function");
ssSetPath(rts, "DO_model/S-Function");
ssSetRTModel(rts,DO_model_M);
ssSetParentSS(rts, (NULL));
ssSetRootSS(rts, rts);
ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2);
/* parameters */
{
mxArray **sfcnParams = (mxArray **)
&DO_model_M->NonInlinedSFcns.Sfcn0.params;
ssSetSFcnParamsCount(rts, 1);
ssSetSFcnParamsPtr(rts, &sfcnParams[0]);
ssSetSFcnParam(rts, 0, (mxArray*)DO_model_P.SFunction_P1_Size);
}
/* work vectors */
ssSetIWork(rts, (int_T *) &DO_model_DW.SFunction_IWORK);
{
struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *)
&DO_model_M->NonInlinedSFcns.Sfcn0.dWork;
struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
&DO_model_M->NonInlinedSFcns.Sfcn0.dWorkAux;
ssSetSFcnDWork(rts, dWorkRecord);
ssSetSFcnDWorkAux(rts, dWorkAuxRecord);
_ssSetNumDWork(rts, 1);
/* IWORK */
ssSetDWorkWidth(rts, 0, 1);
ssSetDWorkDataType(rts, 0,SS_INTEGER);
ssSetDWorkComplexSignal(rts, 0, 0);
ssSetDWork(rts, 0, &DO_model_DW.SFunction_IWORK);
}
/* registration */
DO_v1(rts);
sfcnInitializeSizes(rts);
sfcnInitializeSampleTimes(rts);
/* adjust sample time */
ssSetSampleTime(rts, 0, 0.0);
ssSetOffsetTime(rts, 0, 0.0);
sfcnTsMap[0] = 0;
/* set compiled values of dynamic vector attributes */
ssSetNumNonsampledZCs(rts, 0);
/* Update connectivity flags for each port */
_ssSetOutputPortConnected(rts, 0, 0);
_ssSetOutputPortBeingMerged(rts, 0, 0);
/* Update the BufferDstPort flags for each input port */
}
}
/* Initialize Sizes */
DO_model_M->Sizes.numContStates = (0);/* Number of continuous states */
DO_model_M->Sizes.numY = (0); /* Number of model outputs */
DO_model_M->Sizes.numU = (0); /* Number of model inputs */
DO_model_M->Sizes.sysDirFeedThru = (0);/* The model is not direct feedthrough */
DO_model_M->Sizes.numSampTimes = (2);/* Number of sample times */
DO_model_M->Sizes.numBlocks = (1); /* Number of blocks */
DO_model_M->Sizes.numBlockIO = (1); /* Number of block outputs */
DO_model_M->Sizes.numBlockPrms = (3);/* Sum of parameter "widths" */
return DO_model_M;
}
/* Model initialize function */
void Server_initialize(boolean_T firstTime)
{
(void)firstTime;
/* Registration code */
/* initialize non-finites */
rt_InitInfAndNaN(sizeof(real_T)); /* initialize real-time model */
(void) memset((char_T *)Server_M,0,
sizeof(RT_MODEL_Server));
{
/* Setup solver object */
rtsiSetSimTimeStepPtr(&Server_M->solverInfo, &Server_M->Timing.simTimeStep);
rtsiSetTPtr(&Server_M->solverInfo, &rtmGetTPtr(Server_M));
rtsiSetStepSizePtr(&Server_M->solverInfo, &Server_M->Timing.stepSize0);
rtsiSetErrorStatusPtr(&Server_M->solverInfo, (&rtmGetErrorStatus(Server_M)));
rtsiSetRTModelPtr(&Server_M->solverInfo, Server_M);
}
rtsiSetSimTimeStep(&Server_M->solverInfo, MAJOR_TIME_STEP);
rtsiSetSolverName(&Server_M->solverInfo,"FixedStepDiscrete");
/* Initialize timing info */
{
int_T *mdlTsMap = Server_M->Timing.sampleTimeTaskIDArray;
mdlTsMap[0] = 0;
mdlTsMap[1] = 1;
Server_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
Server_M->Timing.sampleTimes = (&Server_M->Timing.sampleTimesArray[0]);
Server_M->Timing.offsetTimes = (&Server_M->Timing.offsetTimesArray[0]);
/* task periods */
Server_M->Timing.sampleTimes[0] = (0.0);
Server_M->Timing.sampleTimes[1] = (0.001);
/* task offsets */
Server_M->Timing.offsetTimes[0] = (0.0);
Server_M->Timing.offsetTimes[1] = (0.0);
}
rtmSetTPtr(Server_M, &Server_M->Timing.tArray[0]);
{
int_T *mdlSampleHits = Server_M->Timing.sampleHitArray;
mdlSampleHits[0] = 1;
mdlSampleHits[1] = 1;
Server_M->Timing.sampleHits = (&mdlSampleHits[0]);
}
rtmSetTFinal(Server_M, -1);
Server_M->Timing.stepSize0 = 0.001;
Server_M->Timing.stepSize1 = 0.001;
/* external mode info */
Server_M->Sizes.checksums[0] = (3791027284U);
Server_M->Sizes.checksums[1] = (1928235140U);
Server_M->Sizes.checksums[2] = (386570905U);
Server_M->Sizes.checksums[3] = (3697957716U);
{
static const sysRanDType rtAlwaysEnabled = SUBSYS_RAN_BC_ENABLE;
static RTWExtModeInfo rt_ExtModeInfo;
static const sysRanDType *systemRan[1];
Server_M->extModeInfo = (&rt_ExtModeInfo);
rteiSetSubSystemActiveVectorAddresses(&rt_ExtModeInfo, systemRan);
systemRan[0] = &rtAlwaysEnabled;
rteiSetModelMappingInfoPtr(&rt_ExtModeInfo,
&Server_M->SpecialInfo.mappingInfo);
rteiSetChecksumsPtr(&rt_ExtModeInfo, Server_M->Sizes.checksums);
rteiSetTPtr(&rt_ExtModeInfo, rtmGetTPtr(Server_M));
}
Server_M->solverInfoPtr = (&Server_M->solverInfo);
Server_M->Timing.stepSize = (0.001);
rtsiSetFixedStepSize(&Server_M->solverInfo, 0.001);
rtsiSetSolverMode(&Server_M->solverInfo, SOLVER_MODE_SINGLETASKING);
/* block I/O */
Server_M->ModelData.blockIO = ((void *) &Server_B);
(void) memset(((void *) &Server_B),0,
sizeof(BlockIO_Server));
{
((real_T*)&Server_B.SineWave)[0] = 0.0;
}
/* parameters */
Server_M->ModelData.defaultParam = ((real_T *) &Server_P);
/* states (dwork) */
Server_M->Work.dwork = ((void *) &Server_DWork);
(void) memset((char_T *) &Server_DWork,0,
sizeof(D_Work_Server));
/* data type transition information */
{
static DataTypeTransInfo dtInfo;
(void) memset((char_T *) &dtInfo,0,
sizeof(dtInfo));
Server_M->SpecialInfo.mappingInfo = (&dtInfo);
dtInfo.numDataTypes = 16;
dtInfo.dataTypeSizes = &rtDataTypeSizes[0];
dtInfo.dataTypeNames = &rtDataTypeNames[0];
/* Block I/O transition table */
dtInfo.B = &rtBTransTable;
/* Parameters transition table */
dtInfo.P = &rtPTransTable;
}
}