/* Model initialize function */ void testSHM_initialize(boolean_T firstTime) { (void)firstTime; /* Registration code */ /* initialize non-finites */ rt_InitInfAndNaN(sizeof(real_T)); /* initialize real-time model */ (void) memset((void *)testSHM_M,0, sizeof(RT_MODEL_testSHM)); rtsiSetSolverName(&testSHM_M->solverInfo,"FixedStepDiscrete"); testSHM_M->solverInfoPtr = (&testSHM_M->solverInfo); /* Initialize timing info */ { int_T *mdlTsMap = testSHM_M->Timing.sampleTimeTaskIDArray; mdlTsMap[0] = 0; testSHM_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]); testSHM_M->Timing.sampleTimes = (&testSHM_M->Timing.sampleTimesArray[0]); testSHM_M->Timing.offsetTimes = (&testSHM_M->Timing.offsetTimesArray[0]); /* task periods */ testSHM_M->Timing.sampleTimes[0] = (0.001); /* task offsets */ testSHM_M->Timing.offsetTimes[0] = (0.0); } rtmSetTPtr(testSHM_M, &testSHM_M->Timing.tArray[0]); { int_T *mdlSampleHits = testSHM_M->Timing.sampleHitArray; mdlSampleHits[0] = 1; testSHM_M->Timing.sampleHits = (&mdlSampleHits[0]); } rtmSetTFinal(testSHM_M, 10.0); testSHM_M->Timing.stepSize0 = 0.001; /* Setup for data logging */ { static RTWLogInfo rt_DataLoggingInfo; testSHM_M->rtwLogInfo = &rt_DataLoggingInfo; rtliSetLogXSignalInfo(testSHM_M->rtwLogInfo, (NULL)); rtliSetLogXSignalPtrs(testSHM_M->rtwLogInfo, (NULL)); rtliSetLogT(testSHM_M->rtwLogInfo, "tout"); rtliSetLogX(testSHM_M->rtwLogInfo, ""); rtliSetLogXFinal(testSHM_M->rtwLogInfo, ""); rtliSetSigLog(testSHM_M->rtwLogInfo, ""); rtliSetLogVarNameModifier(testSHM_M->rtwLogInfo, "rt_"); rtliSetLogFormat(testSHM_M->rtwLogInfo, 0); rtliSetLogMaxRows(testSHM_M->rtwLogInfo, 1000); rtliSetLogDecimation(testSHM_M->rtwLogInfo, 1); rtliSetLogY(testSHM_M->rtwLogInfo, ""); rtliSetLogYSignalInfo(testSHM_M->rtwLogInfo, (NULL)); rtliSetLogYSignalPtrs(testSHM_M->rtwLogInfo, (NULL)); } testSHM_M->solverInfoPtr = (&testSHM_M->solverInfo); testSHM_M->Timing.stepSize = (0.001); rtsiSetFixedStepSize(&testSHM_M->solverInfo, 0.001); rtsiSetSolverMode(&testSHM_M->solverInfo, SOLVER_MODE_SINGLETASKING); /* block I/O */ testSHM_M->ModelData.blockIO = ((void *) &testSHM_B); (void) memset(((void *) &testSHM_B),0, sizeof(BlockIO_testSHM)); /* parameters */ testSHM_M->ModelData.defaultParam = ((real_T *) &testSHM_P); /* states (dwork) */ testSHM_M->Work.dwork = ((void *) &testSHM_DWork); (void) memset((void *)&testSHM_DWork, 0, sizeof(D_Work_testSHM)); /* C API for Parameter Tuning and/or Signal Monitoring */ { static ModelMappingInfo mapInfo; (void) memset((char_T *) &mapInfo,0, sizeof(mapInfo)); /* block signal monitoring map */ mapInfo.Signals.blockIOSignals = &rtBIOSignals[0]; mapInfo.Signals.numBlockIOSignals = 2; /* parameter tuning maps */ mapInfo.Parameters.blockTuning = &rtBlockTuning[0]; mapInfo.Parameters.variableTuning = &rtVariableTuning[0]; mapInfo.Parameters.parametersMap = rtParametersMap; mapInfo.Parameters.dimensionsMap = rtDimensionsMap; mapInfo.Parameters.numBlockTuning = 4; mapInfo.Parameters.numVariableTuning = 0; testSHM_M->SpecialInfo.mappingInfo = (&mapInfo); } /* child S-Function registration */ { RTWSfcnInfo *sfcnInfo = &testSHM_M->NonInlinedSFcns.sfcnInfo; testSHM_M->sfcnInfo = (sfcnInfo); rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(testSHM_M))); rtssSetNumRootSampTimesPtr(sfcnInfo, &testSHM_M->Sizes.numSampTimes); rtssSetTPtrPtr(sfcnInfo, &rtmGetTPtr(testSHM_M)); rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(testSHM_M)); rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(testSHM_M)); rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(testSHM_M)); rtssSetStepSizePtr(sfcnInfo, &testSHM_M->Timing.stepSize); rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(testSHM_M)); rtssSetDerivCacheNeedsResetPtr(sfcnInfo, &testSHM_M->ModelData.derivCacheNeedsReset); rtssSetZCCacheNeedsResetPtr(sfcnInfo, &testSHM_M->ModelData.zCCacheNeedsReset); rtssSetBlkStateChangePtr(sfcnInfo, &testSHM_M->ModelData.blkStateChange); rtssSetSampleHitsPtr(sfcnInfo, &testSHM_M->Timing.sampleHits); rtssSetPerTaskSampleHitsPtr(sfcnInfo, &testSHM_M->Timing.perTaskSampleHits); rtssSetSimModePtr(sfcnInfo, &testSHM_M->simMode); rtssSetSolverInfoPtr(sfcnInfo, &testSHM_M->solverInfoPtr); } testSHM_M->Sizes.numSFcns = (2); /* register each child */ { (void) memset((void *)&testSHM_M->NonInlinedSFcns.childSFunctions[0],0, 2*sizeof(SimStruct)); testSHM_M->childSfunctions = (&testSHM_M-> NonInlinedSFcns.childSFunctionPtrs[0]); testSHM_M->childSfunctions[0] = (&testSHM_M-> NonInlinedSFcns.childSFunctions[0]); testSHM_M->childSfunctions[1] = (&testSHM_M-> NonInlinedSFcns.childSFunctions[1]); /* Level2 S-Function Block: testSHM/<Root>/S-Function (sSHM) */ { SimStruct *rts = testSHM_M->childSfunctions[0]; /* timing info */ time_T *sfcnPeriod = testSHM_M->NonInlinedSFcns.Sfcn0.sfcnPeriod; time_T *sfcnOffset = testSHM_M->NonInlinedSFcns.Sfcn0.sfcnOffset; int_T *sfcnTsMap = testSHM_M->NonInlinedSFcns.Sfcn0.sfcnTsMap; (void) memset((void*)sfcnPeriod,0, sizeof(time_T)*1); (void) memset((void*)sfcnOffset,0, sizeof(time_T)*1); ssSetSampleTimePtr(rts, &sfcnPeriod[0]); ssSetOffsetTimePtr(rts, &sfcnOffset[0]); ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap); /* Set up the mdlInfo pointer */ { ssSetBlkInfo2Ptr(rts, &testSHM_M->NonInlinedSFcns.blkInfo2[0]); ssSetRTWSfcnInfo(rts, testSHM_M->sfcnInfo); } /* Allocate memory of model methods 2 */ { ssSetModelMethods2(rts, &testSHM_M->NonInlinedSFcns.methods2[0]); } /* Allocate memory of model methods 3 */ { ssSetModelMethods3(rts, &testSHM_M->NonInlinedSFcns.methods3[0]); } /* inputs */ { _ssSetNumInputPorts(rts, 1); ssSetPortInfoForInputs(rts, &testSHM_M->NonInlinedSFcns.Sfcn0.inputPortInfo[0]); /* port 0 */ { ssSetInputPortRequiredContiguous(rts, 0, 1); ssSetInputPortSignal(rts, 0, testSHM_B.TmpHiddenBufferAtSFunctionInpor); _ssSetInputPortNumDimensions(rts, 0, 1); ssSetInputPortWidth(rts, 0, 3); } } /* outputs */ { ssSetPortInfoForOutputs(rts, &testSHM_M->NonInlinedSFcns.Sfcn0.outputPortInfo[0]); _ssSetNumOutputPorts(rts, 1); /* port 0 */ { _ssSetOutputPortNumDimensions(rts, 0, 1); ssSetOutputPortWidth(rts, 0, 3); ssSetOutputPortSignal(rts, 0, ((real_T *) testSHM_B.SFunction)); } } /* path info */ ssSetModelName(rts, "S-Function"); ssSetPath(rts, "testSHM/S-Function"); ssSetRTModel(rts,testSHM_M); ssSetParentSS(rts, (NULL)); ssSetRootSS(rts, rts); ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2); /* work vectors */ { struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) &testSHM_M->NonInlinedSFcns.Sfcn0.dWork; struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *) &testSHM_M->NonInlinedSFcns.Sfcn0.dWorkAux; ssSetSFcnDWork(rts, dWorkRecord); ssSetSFcnDWorkAux(rts, dWorkAuxRecord); _ssSetNumDWork(rts, 2); /* DWORK1 */ ssSetDWorkWidth(rts, 0, 1); ssSetDWorkDataType(rts, 0,SS_POINTER); ssSetDWorkComplexSignal(rts, 0, 0); ssSetDWork(rts, 0, &testSHM_DWork.SFunction_DWORK1); /* DWORK2 */ ssSetDWorkWidth(rts, 1, 1); ssSetDWorkDataType(rts, 1,SS_POINTER); ssSetDWorkComplexSignal(rts, 1, 0); ssSetDWork(rts, 1, &testSHM_DWork.SFunction_DWORK2); } /* registration */ sSHM(rts); sfcnInitializeSizes(rts); sfcnInitializeSampleTimes(rts); /* adjust sample time */ ssSetSampleTime(rts, 0, 0.001); ssSetOffsetTime(rts, 0, 0.0); sfcnTsMap[0] = 0; /* set compiled values of dynamic vector attributes */ ssSetNumNonsampledZCs(rts, 0); /* Update connectivity flags for each port */ _ssSetInputPortConnected(rts, 0, 1); _ssSetOutputPortConnected(rts, 0, 1); _ssSetOutputPortBeingMerged(rts, 0, 0); /* Update the BufferDstPort flags for each input port */ ssSetInputPortBufferDstPort(rts, 0, -1); } /* Level2 S-Function Block: testSHM/<Root>/RTAI_SCOPE (sfun_rtai_scope) */ { SimStruct *rts = testSHM_M->childSfunctions[1]; /* timing info */ time_T *sfcnPeriod = testSHM_M->NonInlinedSFcns.Sfcn1.sfcnPeriod; time_T *sfcnOffset = testSHM_M->NonInlinedSFcns.Sfcn1.sfcnOffset; int_T *sfcnTsMap = testSHM_M->NonInlinedSFcns.Sfcn1.sfcnTsMap; (void) memset((void*)sfcnPeriod,0, sizeof(time_T)*1); (void) memset((void*)sfcnOffset,0, sizeof(time_T)*1); ssSetSampleTimePtr(rts, &sfcnPeriod[0]); ssSetOffsetTimePtr(rts, &sfcnOffset[0]); ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap); /* Set up the mdlInfo pointer */ { ssSetBlkInfo2Ptr(rts, &testSHM_M->NonInlinedSFcns.blkInfo2[1]); ssSetRTWSfcnInfo(rts, testSHM_M->sfcnInfo); } /* Allocate memory of model methods 2 */ { ssSetModelMethods2(rts, &testSHM_M->NonInlinedSFcns.methods2[1]); } /* Allocate memory of model methods 3 */ { ssSetModelMethods3(rts, &testSHM_M->NonInlinedSFcns.methods3[1]); } /* inputs */ { _ssSetNumInputPorts(rts, 3); ssSetPortInfoForInputs(rts, &testSHM_M->NonInlinedSFcns.Sfcn1.inputPortInfo[0]); /* port 0 */ { real_T const **sfcnUPtrs = (real_T const **) &testSHM_M->NonInlinedSFcns.Sfcn1.UPtrs0; sfcnUPtrs[0] = &testSHM_B.SFunction[0]; ssSetInputPortSignalPtrs(rts, 0, (InputPtrsType)&sfcnUPtrs[0]); _ssSetInputPortNumDimensions(rts, 0, 1); ssSetInputPortWidth(rts, 0, 1); } /* port 1 */ { real_T const **sfcnUPtrs = (real_T const **) &testSHM_M->NonInlinedSFcns.Sfcn1.UPtrs1; sfcnUPtrs[0] = &testSHM_B.SFunction[1]; ssSetInputPortSignalPtrs(rts, 1, (InputPtrsType)&sfcnUPtrs[0]); _ssSetInputPortNumDimensions(rts, 1, 1); ssSetInputPortWidth(rts, 1, 1); } /* port 2 */ { real_T const **sfcnUPtrs = (real_T const **) &testSHM_M->NonInlinedSFcns.Sfcn1.UPtrs2; sfcnUPtrs[0] = &testSHM_B.SFunction[2]; ssSetInputPortSignalPtrs(rts, 2, (InputPtrsType)&sfcnUPtrs[0]); _ssSetInputPortNumDimensions(rts, 2, 1); ssSetInputPortWidth(rts, 2, 1); } } /* path info */ ssSetModelName(rts, "RTAI_SCOPE"); ssSetPath(rts, "testSHM/RTAI_SCOPE"); ssSetRTModel(rts,testSHM_M); ssSetParentSS(rts, (NULL)); ssSetRootSS(rts, rts); ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2); /* parameters */ { mxArray **sfcnParams = (mxArray **) &testSHM_M->NonInlinedSFcns.Sfcn1.params; ssSetSFcnParamsCount(rts, 2); ssSetSFcnParamsPtr(rts, &sfcnParams[0]); ssSetSFcnParam(rts, 0, (mxArray*)&testSHM_P.RTAI_SCOPE_P1_Size[0]); ssSetSFcnParam(rts, 1, (mxArray*)&testSHM_P.RTAI_SCOPE_P2_Size[0]); } /* work vectors */ ssSetPWork(rts, (void **) &testSHM_DWork.RTAI_SCOPE_PWORK); { struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) &testSHM_M->NonInlinedSFcns.Sfcn1.dWork; struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *) &testSHM_M->NonInlinedSFcns.Sfcn1.dWorkAux; ssSetSFcnDWork(rts, dWorkRecord); ssSetSFcnDWorkAux(rts, dWorkAuxRecord); _ssSetNumDWork(rts, 1); /* PWORK */ ssSetDWorkWidth(rts, 0, 1); ssSetDWorkDataType(rts, 0,SS_POINTER); ssSetDWorkComplexSignal(rts, 0, 0); ssSetDWork(rts, 0, &testSHM_DWork.RTAI_SCOPE_PWORK); } /* registration */ sfun_rtai_scope(rts); sfcnInitializeSizes(rts); sfcnInitializeSampleTimes(rts); /* adjust sample time */ ssSetSampleTime(rts, 0, 0.001); ssSetOffsetTime(rts, 0, 0.0); sfcnTsMap[0] = 0; /* set compiled values of dynamic vector attributes */ ssSetNumNonsampledZCs(rts, 0); /* Update connectivity flags for each port */ _ssSetInputPortConnected(rts, 0, 1); _ssSetInputPortConnected(rts, 1, 1); _ssSetInputPortConnected(rts, 2, 1); /* Update the BufferDstPort flags for each input port */ ssSetInputPortBufferDstPort(rts, 0, -1); ssSetInputPortBufferDstPort(rts, 1, -1); ssSetInputPortBufferDstPort(rts, 2, -1); } } }
/* Model initialize function */ void 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 Mechanics_initialize(boolean_T firstTime) { (void)firstTime; /* Registration code */ /* initialize non-finites */ rt_InitInfAndNaN(sizeof(real_T)); /* initialize real-time model */ (void) memset((char_T *)Mechanics_M,0, sizeof(RT_MODEL_Mechanics)); { /* Setup solver object */ rtsiSetSimTimeStepPtr(&Mechanics_M->solverInfo, &Mechanics_M->Timing.simTimeStep); rtsiSetTPtr(&Mechanics_M->solverInfo, &rtmGetTPtr(Mechanics_M)); rtsiSetStepSizePtr(&Mechanics_M->solverInfo, &Mechanics_M->Timing.stepSize0); rtsiSetdXPtr(&Mechanics_M->solverInfo, &Mechanics_M->ModelData.derivs); rtsiSetContStatesPtr(&Mechanics_M->solverInfo, &Mechanics_M->ModelData.contStates); rtsiSetNumContStatesPtr(&Mechanics_M->solverInfo, &Mechanics_M->Sizes.numContStates); rtsiSetErrorStatusPtr(&Mechanics_M->solverInfo, (&rtmGetErrorStatus (Mechanics_M))); rtsiSetRTModelPtr(&Mechanics_M->solverInfo, Mechanics_M); } rtsiSetSimTimeStep(&Mechanics_M->solverInfo, MAJOR_TIME_STEP); Mechanics_M->ModelData.intgData.y = Mechanics_M->ModelData.odeY; Mechanics_M->ModelData.intgData.f[0] = Mechanics_M->ModelData.odeF[0]; Mechanics_M->ModelData.intgData.f[1] = Mechanics_M->ModelData.odeF[1]; Mechanics_M->ModelData.intgData.f[2] = Mechanics_M->ModelData.odeF[2]; Mechanics_M->ModelData.contStates = ((real_T *) &Mechanics_X); rtsiSetSolverData(&Mechanics_M->solverInfo, (void *) &Mechanics_M->ModelData.intgData); rtsiSetSolverName(&Mechanics_M->solverInfo,"ode3"); Mechanics_M->solverInfoPtr = (&Mechanics_M->solverInfo); /* Initialize timing info */ { int_T *mdlTsMap = Mechanics_M->Timing.sampleTimeTaskIDArray; mdlTsMap[0] = 0; mdlTsMap[1] = 1; Mechanics_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]); Mechanics_M->Timing.sampleTimes = (&Mechanics_M->Timing.sampleTimesArray[0]); Mechanics_M->Timing.offsetTimes = (&Mechanics_M->Timing.offsetTimesArray[0]); /* task periods */ Mechanics_M->Timing.sampleTimes[0] = (0.0); Mechanics_M->Timing.sampleTimes[1] = (35.0); /* task offsets */ Mechanics_M->Timing.offsetTimes[0] = (0.0); Mechanics_M->Timing.offsetTimes[1] = (0.0); } rtmSetTPtr(Mechanics_M, &Mechanics_M->Timing.tArray[0]); { int_T *mdlSampleHits = Mechanics_M->Timing.sampleHitArray; mdlSampleHits[0] = 1; mdlSampleHits[1] = 1; Mechanics_M->Timing.sampleHits = (&mdlSampleHits[0]); } rtmSetTFinal(Mechanics_M, -1); Mechanics_M->Timing.stepSize0 = 35.0; Mechanics_M->Timing.stepSize1 = 35.0; /* Setup for data logging */ { static RTWLogInfo rt_DataLoggingInfo; Mechanics_M->rtwLogInfo = &rt_DataLoggingInfo; rtliSetLogFormat(Mechanics_M->rtwLogInfo, 0); rtliSetLogMaxRows(Mechanics_M->rtwLogInfo, 1000); rtliSetLogDecimation(Mechanics_M->rtwLogInfo, 1); rtliSetLogVarNameModifier(Mechanics_M->rtwLogInfo, "rt_"); rtliSetLogT(Mechanics_M->rtwLogInfo, "tout"); rtliSetLogX(Mechanics_M->rtwLogInfo, ""); rtliSetLogXFinal(Mechanics_M->rtwLogInfo, ""); rtliSetSigLog(Mechanics_M->rtwLogInfo, ""); rtliSetLogXSignalInfo(Mechanics_M->rtwLogInfo, NULL); rtliSetLogXSignalPtrs(Mechanics_M->rtwLogInfo, NULL); rtliSetLogY(Mechanics_M->rtwLogInfo, ""); rtliSetLogYSignalInfo(Mechanics_M->rtwLogInfo, NULL); rtliSetLogYSignalPtrs(Mechanics_M->rtwLogInfo, NULL); } Mechanics_M->solverInfoPtr = (&Mechanics_M->solverInfo); Mechanics_M->Timing.stepSize = (35.0); rtsiSetFixedStepSize(&Mechanics_M->solverInfo, 35.0); rtsiSetSolverMode(&Mechanics_M->solverInfo, SOLVER_MODE_SINGLETASKING); /* block I/O */ Mechanics_M->ModelData.blockIO = ((void *) &Mechanics_B); { int_T i; void *pVoidBlockIORegion; pVoidBlockIORegion = (void *)(&Mechanics_B.Arduino); for (i = 0; i < 18; i++) { ((real_T*)pVoidBlockIORegion)[i] = 0.0; } } /* parameters */ Mechanics_M->ModelData.defaultParam = ((real_T *) &Mechanics_P); /* states (continuous) */ { real_T *x = (real_T *) &Mechanics_X; Mechanics_M->ModelData.contStates = (x); (void) memset((char_T *)x,0, sizeof(ContinuousStates_Mechanics)); } /* states (dwork) */ Mechanics_M->Work.dwork = ((void *) &Mechanics_DWork); (void) memset((char_T *) &Mechanics_DWork,0, sizeof(D_Work_Mechanics)); /* child S-Function registration */ { RTWSfcnInfo *sfcnInfo = &Mechanics_M->NonInlinedSFcns.sfcnInfo; Mechanics_M->sfcnInfo = (sfcnInfo); rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(Mechanics_M))); rtssSetNumRootSampTimesPtr(sfcnInfo, &Mechanics_M->Sizes.numSampTimes); rtssSetTPtrPtr(sfcnInfo, &rtmGetTPtr(Mechanics_M)); rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(Mechanics_M)); rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(Mechanics_M)); rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(Mechanics_M)); rtssSetStepSizePtr(sfcnInfo, &Mechanics_M->Timing.stepSize); rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(Mechanics_M)); rtssSetDerivCacheNeedsResetPtr(sfcnInfo, &Mechanics_M->ModelData.derivCacheNeedsReset); rtssSetZCCacheNeedsResetPtr(sfcnInfo, &Mechanics_M->ModelData.zCCacheNeedsReset); rtssSetBlkStateChangePtr(sfcnInfo, &Mechanics_M->ModelData.blkStateChange); rtssSetSampleHitsPtr(sfcnInfo, &Mechanics_M->Timing.sampleHits); rtssSetPerTaskSampleHitsPtr(sfcnInfo, &Mechanics_M->Timing.perTaskSampleHits); rtssSetSimModePtr(sfcnInfo, &Mechanics_M->simMode); rtssSetSolverInfoPtr(sfcnInfo, &Mechanics_M->solverInfoPtr); } Mechanics_M->Sizes.numSFcns = (1); /* register each child */ { (void) memset((void *)&Mechanics_M->NonInlinedSFcns.childSFunctions[0],0, 1*sizeof(SimStruct)); Mechanics_M->childSfunctions = (&Mechanics_M->NonInlinedSFcns.childSFunctionPtrs[0]); Mechanics_M->childSfunctions[0] = (&Mechanics_M->NonInlinedSFcns.childSFunctions[0]); /* Level2 S-Function Block: Mechanics/<Root>/Arduino (QueryInstrument) */ { SimStruct *rts = Mechanics_M->childSfunctions[0]; /* timing info */ time_T *sfcnPeriod = Mechanics_M->NonInlinedSFcns.Sfcn0.sfcnPeriod; time_T *sfcnOffset = Mechanics_M->NonInlinedSFcns.Sfcn0.sfcnOffset; int_T *sfcnTsMap = Mechanics_M->NonInlinedSFcns.Sfcn0.sfcnTsMap; (void) memset((void*)sfcnPeriod,0, sizeof(time_T)*1); (void) memset((void*)sfcnOffset,0, sizeof(time_T)*1); ssSetSampleTimePtr(rts, &sfcnPeriod[0]); ssSetOffsetTimePtr(rts, &sfcnOffset[0]); ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap); /* Set up the mdlInfo pointer */ { ssSetBlkInfo2Ptr(rts, &Mechanics_M->NonInlinedSFcns.blkInfo2[0]); ssSetRTWSfcnInfo(rts, Mechanics_M->sfcnInfo); } /* Allocate memory of model methods 2 */ { ssSetModelMethods2(rts, &Mechanics_M->NonInlinedSFcns.methods2[0]); } /* outputs */ { ssSetPortInfoForOutputs(rts, &Mechanics_M->NonInlinedSFcns.Sfcn0.outputPortInfo[0]); _ssSetNumOutputPorts(rts, 1); /* port 0 */ { _ssSetOutputPortNumDimensions(rts, 0, 1); ssSetOutputPortWidth(rts, 0, 1); ssSetOutputPortSignal(rts, 0, ((real_T *) &Mechanics_B.Arduino)); } } /* path info */ ssSetModelName(rts, "Arduino"); ssSetPath(rts, "Mechanics/Arduino"); ssSetRTModel(rts,Mechanics_M); ssSetParentSS(rts, NULL); ssSetRootSS(rts, rts); ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2); /* parameters */ { mxArray **sfcnParams = (mxArray **) &Mechanics_M->NonInlinedSFcns.Sfcn0.params; ssSetSFcnParamsCount(rts, 39); ssSetSFcnParamsPtr(rts, &sfcnParams[0]); ssSetSFcnParam(rts, 0, (mxArray*)&Mechanics_P.Arduino_P1_Size[0]); ssSetSFcnParam(rts, 1, (mxArray*)&Mechanics_P.Arduino_P2_Size[0]); ssSetSFcnParam(rts, 2, (mxArray*)&Mechanics_P.Arduino_P3_Size[0]); ssSetSFcnParam(rts, 3, (mxArray*)&Mechanics_P.Arduino_P4_Size[0]); ssSetSFcnParam(rts, 4, (mxArray*)&Mechanics_P.Arduino_P5_Size[0]); ssSetSFcnParam(rts, 5, (mxArray*)&Mechanics_P.Arduino_P6_Size[0]); ssSetSFcnParam(rts, 6, (mxArray*)&Mechanics_P.Arduino_P7_Size[0]); ssSetSFcnParam(rts, 7, (mxArray*)&Mechanics_P.Arduino_P8_Size[0]); ssSetSFcnParam(rts, 8, (mxArray*)&Mechanics_P.Arduino_P9_Size[0]); ssSetSFcnParam(rts, 9, (mxArray*)&Mechanics_P.Arduino_P10_Size[0]); ssSetSFcnParam(rts, 10, (mxArray*)&Mechanics_P.Arduino_P11_Size[0]); ssSetSFcnParam(rts, 11, (mxArray*)&Mechanics_P.Arduino_P12_Size[0]); ssSetSFcnParam(rts, 12, (mxArray*)&Mechanics_P.Arduino_P13_Size[0]); ssSetSFcnParam(rts, 13, (mxArray*)&Mechanics_P.Arduino_P14_Size[0]); ssSetSFcnParam(rts, 14, (mxArray*)&Mechanics_P.Arduino_P15_Size[0]); ssSetSFcnParam(rts, 15, (mxArray*)&Mechanics_P.Arduino_P16_Size[0]); ssSetSFcnParam(rts, 16, (mxArray*)&Mechanics_P.Arduino_P17_Size[0]); ssSetSFcnParam(rts, 17, (mxArray*)&Mechanics_P.Arduino_P18_Size[0]); ssSetSFcnParam(rts, 18, (mxArray*)&Mechanics_P.Arduino_P19_Size[0]); ssSetSFcnParam(rts, 19, (mxArray*)&Mechanics_P.Arduino_P20_Size[0]); ssSetSFcnParam(rts, 20, (mxArray*)&Mechanics_P.Arduino_P21_Size[0]); ssSetSFcnParam(rts, 21, (mxArray*)&Mechanics_P.Arduino_P22_Size[0]); ssSetSFcnParam(rts, 22, (mxArray*)&Mechanics_P.Arduino_P23_Size[0]); ssSetSFcnParam(rts, 23, (mxArray*)&Mechanics_P.Arduino_P24_Size[0]); ssSetSFcnParam(rts, 24, (mxArray*)&Mechanics_P.Arduino_P25_Size[0]); ssSetSFcnParam(rts, 25, (mxArray*)&Mechanics_P.Arduino_P26_Size[0]); ssSetSFcnParam(rts, 26, (mxArray*)&Mechanics_P.Arduino_P27_Size[0]); ssSetSFcnParam(rts, 27, (mxArray*)&Mechanics_P.Arduino_P28_Size[0]); ssSetSFcnParam(rts, 28, (mxArray*)&Mechanics_P.Arduino_P29_Size[0]); ssSetSFcnParam(rts, 29, (mxArray*)&Mechanics_P.Arduino_P30_Size[0]); ssSetSFcnParam(rts, 30, (mxArray*)&Mechanics_P.Arduino_P31_Size[0]); ssSetSFcnParam(rts, 31, (mxArray*)&Mechanics_P.Arduino_P32_Size[0]); ssSetSFcnParam(rts, 32, (mxArray*)&Mechanics_P.Arduino_P33_Size[0]); ssSetSFcnParam(rts, 33, (mxArray*)&Mechanics_P.Arduino_P34_Size[0]); ssSetSFcnParam(rts, 34, (mxArray*)&Mechanics_P.Arduino_P35_Size[0]); ssSetSFcnParam(rts, 35, (mxArray*)&Mechanics_P.Arduino_P36_Size[0]); ssSetSFcnParam(rts, 36, (mxArray*)&Mechanics_P.Arduino_P37_Size[0]); ssSetSFcnParam(rts, 37, (mxArray*)&Mechanics_P.Arduino_P38_Size[0]); ssSetSFcnParam(rts, 38, (mxArray*)&Mechanics_P.Arduino_P39_Size[0]); } /* work vectors */ ssSetPWork(rts, (void **) &Mechanics_DWork.Arduino_PWORK); { struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) &Mechanics_M->NonInlinedSFcns.Sfcn0.dWork; ssSetSFcnDWork(rts, dWorkRecord); _ssSetNumDWork(rts, 1); /* PWORK */ ssSetDWorkWidth(rts, 0, 1); ssSetDWorkDataType(rts, 0,SS_POINTER); ssSetDWorkComplexSignal(rts, 0, 0); ssSetDWork(rts, 0, &Mechanics_DWork.Arduino_PWORK); } /* registration */ QueryInstrument(rts); sfcnInitializeSizes(rts); sfcnInitializeSampleTimes(rts); /* adjust sample time */ ssSetSampleTime(rts, 0, 35.0); ssSetOffsetTime(rts, 0, 0.0); sfcnTsMap[0] = 1; /* set compiled values of dynamic vector attributes */ ssSetNumNonsampledZCs(rts, 0); /* Update connectivity flags for each port */ _ssSetOutputPortConnected(rts, 0, 1); _ssSetOutputPortBeingMerged(rts, 0, 0); /* Update the BufferDstPort flags for each input port */ } } }