void baseRateTask(void *arg) { runModel = (rtmGetErrorStatus(Model_M) == (NULL)) && !rtmGetStopRequested (Model_M); while (runModel) { mw_osSemaphoreWaitEver(&baserateTaskSem); /* External mode */ { boolean_T rtmStopReq = false; rtExtModePauseIfNeeded(Model_M->extModeInfo, 1, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(Model_M, true); } if (rtmGetStopRequested(Model_M) == true) { rtmSetErrorStatus(Model_M, "Simulation finished"); break; } } Model_step(); /* Get model outputs here */ rtExtModeCheckEndTrigger(); runModel = (rtmGetErrorStatus(Model_M) == (NULL)) && !rtmGetStopRequested (Model_M); } runModel = 0; terminateTask(arg); taskDelete((void *)0); }
int main(void) { volatile boolean_T runModel = 1; float modelBaseRate = 2.0; float systemClock = 0; init(); MW_Arduino_Init(); rtmSetErrorStatus(test_motor_M, 0); /* initialize external mode */ rtParseArgsForExtMode(0, NULL); test_motor_initialize(); sei(); /* External mode */ rtSetTFinalForExtMode(&rtmGetTFinal(test_motor_M)); rtExtModeCheckInit(1); { boolean_T rtmStopReq = false; rtExtModeWaitForStartPkt(test_motor_M->extModeInfo, 1, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(test_motor_M, true); } } rtERTExtModeStartMsg(); cli(); configureArduinoAVRTimer(); runModel = (rtmGetErrorStatus(test_motor_M) == (NULL)) && !rtmGetStopRequested (test_motor_M); sei(); sei(); while (runModel) { /* External mode */ { boolean_T rtmStopReq = false; rtExtModeOneStep(test_motor_M->extModeInfo, 1, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(test_motor_M, true); } } runModel = (rtmGetErrorStatus(test_motor_M) == (NULL)) && !rtmGetStopRequested (test_motor_M); } rtExtModeShutdown(1); /* Disable rt_OneStep() here */ /* Terminate model */ test_motor_terminate(); cli(); return 0; }
void baseRateTask(void *arg) { baseRateInfo_t info = *((baseRateInfo_t *)arg); MW_setTaskPeriod(info.period, info.signo); while ((rtmGetErrorStatus(motorControlTask_M) == (NULL)) && !rtmGetStopRequested(motorControlTask_M) ) { /* Wait for the next timer interrupt */ if (MW_sigWaitWithOverrunDetection(&info.sigMask) == 1) { printf("Overrun - rate for base rate task too fast.\n"); fflush(stdout); } /* External mode */ { boolean_T rtmStopReq = false; rtExtModePauseIfNeeded(motorControlTask_M->extModeInfo, 2, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(motorControlTask_M, true); } if (rtmGetStopRequested(motorControlTask_M) == true) { rtmSetErrorStatus(motorControlTask_M, "Simulation finished"); break; } } /* External mode */ { boolean_T rtmStopReq = false; rtExtModeOneStep(motorControlTask_M->extModeInfo, 2, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(motorControlTask_M, true); } } motorControlTask_output(); /* Get model outputs here */ /* External mode */ rtExtModeUploadCheckTrigger(2); { /* Sample time: [0.0s, 0.0s] */ rtExtModeUpload(0, motorControlTask_M->Timing.t[0]); } { /* Sample time: [0.02s, 0.0s] */ rtExtModeUpload(1, ((motorControlTask_M->Timing.clockTick1) * 0.02)); } motorControlTask_update(); rtExtModeCheckEndTrigger(); } /* while */ sem_post(&stopSem); }
void baseRateTask(void *arg) { baseRateInfo_t info = *((baseRateInfo_t *)arg); MW_setTaskPeriod(info.period, info.signo); while ((rtmGetErrorStatus(Serial_M) == (NULL)) && !rtmGetStopRequested (Serial_M) ) { /* Wait for the next timer interrupt */ MW_sigWait(&info.sigMask); /* External mode */ { boolean_T rtmStopReq = false; rtExtModePauseIfNeeded(Serial_M->extModeInfo, 2, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(Serial_M, true); } if (rtmGetStopRequested(Serial_M) == true) { rtmSetErrorStatus(Serial_M, "Simulation finished"); break; } } /* External mode */ { boolean_T rtmStopReq = false; rtExtModeOneStep(Serial_M->extModeInfo, 2, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(Serial_M, true); } } Serial_output(); /* Get model outputs here */ /* External mode */ rtExtModeUploadCheckTrigger(2); { /* Sample time: [0.0s, 0.0s] */ rtExtModeUpload(0, Serial_M->Timing.t[0]); } { /* Sample time: [0.05s, 0.0s] */ rtExtModeUpload(1, ((Serial_M->Timing.clockTick1) * 0.05)); } Serial_update(); rtExtModeCheckEndTrigger(); } /* while */ sem_post(&stopSem); }
void baseRateTask(void *arg) { baseRateInfo_t info = *((baseRateInfo_t *)arg); MW_setTaskPeriod(info.period, info.signo); while ((rtmGetErrorStatus(raspberrypi_audioequalizer_M) == (NULL)) && !rtmGetStopRequested(raspberrypi_audioequalizer_M) ) { /* Wait for the next timer interrupt */ MW_sigWait(&info.sigMask); /* External mode */ { boolean_T rtmStopReq = FALSE; rtExtModePauseIfNeeded(raspberrypi_audioequalizer_M->extModeInfo, 1, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(raspberrypi_audioequalizer_M, TRUE); } if (rtmGetStopRequested(raspberrypi_audioequalizer_M) == TRUE) { rtmSetErrorStatus(raspberrypi_audioequalizer_M, "Simulation finished"); break; } } /* External mode */ { boolean_T rtmStopReq = FALSE; rtExtModeOneStep(raspberrypi_audioequalizer_M->extModeInfo, 1, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(raspberrypi_audioequalizer_M, TRUE); } } raspberrypi_audioequalizer_output(); /* Get model outputs here */ /* External mode */ rtExtModeUploadCheckTrigger(1); { /* Sample time: [0.1s, 0.0s] */ rtExtModeUpload(0, raspberrypi_audioequalizer_M->Timing.taskTime0); } raspberrypi_audioequalizer_update(); rtExtModeCheckEndTrigger(); } /* while */ sem_post(&stopSem); }
/* Model step function */ void Hammerstein_step(void) { /* DiscreteStateSpace: '<S1>/LinearModel' */ { Hammerstein_B.LinearModel = Hammerstein_P.LinearModel_C* Hammerstein_DWork.LinearModel_DSTATE; } /* Level2 S-Function Block: '<S1>/Pwlinear1' (sfunpwlinear) */ { SimStruct *rts = Hammerstein_M->childSfunctions[0]; ssSetOutputPortSignal(rts, 0, &Hammerstein_Y.Out1); sfcnOutputs(rts, 0); } /* Level2 S-Function Block: '<S1>/Pwlinear' (sfunpwlinear) */ { SimStruct *rts = Hammerstein_M->childSfunctions[1]; sfcnOutputs(rts, 0); } /* Update for DiscreteStateSpace: '<S1>/LinearModel' */ { Hammerstein_DWork.LinearModel_DSTATE = Hammerstein_B.Pwlinear + Hammerstein_P.LinearModel_A*Hammerstein_DWork.LinearModel_DSTATE; } /* Matfile logging */ rt_UpdateTXYLogVars(Hammerstein_M->rtwLogInfo, (Hammerstein_M->Timing.t)); /* signal main to stop simulation */ { /* Sample time: [0.06s, 0.0s] */ if ((rtmGetTFinal(Hammerstein_M)!=-1) && !((rtmGetTFinal(Hammerstein_M)-Hammerstein_M->Timing.t[0]) > Hammerstein_M->Timing.t[0] * (DBL_EPSILON))) { rtmSetErrorStatus(Hammerstein_M, "Simulation finished"); } if (rtmGetStopRequested(Hammerstein_M)) { rtmSetErrorStatus(Hammerstein_M, "Simulation finished"); } } /* Update absolute time for base rate */ /* The "clockTick0" counts the number of times the code of this task has * been executed. The absolute time is the multiplication of "clockTick0" * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not * overflow during the application lifespan selected. * Timer of this task consists of two 32 bit unsigned integers. * The two integers represent the low bits Timing.clockTick0 and the high bits * Timing.clockTickH0. When the low bit overflows to 0, the high bits increment. */ if (!(++Hammerstein_M->Timing.clockTick0)) { ++Hammerstein_M->Timing.clockTickH0; } Hammerstein_M->Timing.t[0] = Hammerstein_M->Timing.clockTick0 * Hammerstein_M->Timing.stepSize0 + Hammerstein_M->Timing.clockTickH0 * Hammerstein_M->Timing.stepSize0 * 4294967296.0; }
/* Model update function */ void udpRead_update(void) { /* Update for UnitDelay: '<S3>/FixPt Unit Delay2' incorporates: * Constant: '<S3>/FixPt Constant' */ udpRead_DW.FixPtUnitDelay2_DSTATE = udpRead_P.FixPtConstant_Value; /* Update for UnitDelay: '<S3>/FixPt Unit Delay1' */ udpRead_DW.FixPtUnitDelay1_DSTATE = udpRead_B.Xnew; /* signal main to stop simulation */ { /* Sample time: [0.001s, 0.0s] */ if ((rtmGetTFinal(udpRead_M)!=-1) && !((rtmGetTFinal(udpRead_M)-udpRead_M->Timing.taskTime0) > udpRead_M->Timing.taskTime0 * (DBL_EPSILON))) { rtmSetErrorStatus(udpRead_M, "Simulation finished"); } if (rtmGetStopRequested(udpRead_M)) { rtmSetErrorStatus(udpRead_M, "Simulation finished"); } } /* Update absolute time for base rate */ /* The "clockTick0" counts the number of times the code of this task has * been executed. The absolute time is the multiplication of "clockTick0" * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not * overflow during the application lifespan selected. */ udpRead_M->Timing.taskTime0 = (++udpRead_M->Timing.clockTick0) * udpRead_M->Timing.stepSize0; }
void baseRateTask(void *arg) { runModel = (rtmGetErrorStatus(VesselSimulator_M) == (NULL)) && !rtmGetStopRequested(VesselSimulator_M); while (runModel) { sem_wait(&baserateTaskSem); VesselSimulator_step(); // Get model outputs here runModel = (rtmGetErrorStatus(VesselSimulator_M) == (NULL)) && !rtmGetStopRequested(VesselSimulator_M); } sem_post(&termSem); pthread_exit((void *)0); }
void baseRateTask(void *arg) { runModel = (rtmGetErrorStatus(main_M) == (NULL)) && !rtmGetStopRequested (main_M); while (runModel) { sem_wait(&baserateTaskSem); main_step(); /* Get model outputs here */ runModel = (rtmGetErrorStatus(main_M) == (NULL)) && !rtmGetStopRequested (main_M); } sem_post(&termSem); pthread_exit((void *)0); }
void baseRateTask(void *arg) { baseRateInfo_t info = *((baseRateInfo_t *)arg); MW_setTaskPeriod(info.period, info.signo); while ((rtmGetErrorStatus(beagleboard_communication_M) == (NULL)) && !rtmGetStopRequested(beagleboard_communication_M) ) { /* Wait for the next timer interrupt */ MW_sigWait(&info.sigMask); beagleboard_communication_output(); /* Get model outputs here */ beagleboard_communication_update(); } /* while */ sem_post(&stopSem); }
void BonebrakerController::MatlabUpdate() {//Matlab Autogenerated code static boolean_T OverrunFlag = 0; if (OverrunFlag) { rtmSetErrorStatus(quadrotor_controller_M, "Overrun"); return; } OverrunFlag = TRUE; quadrotor_controller_step(); OverrunFlag = FALSE; if((rtmGetErrorStatus(quadrotor_controller_M) == (NULL)) && !rtmGetStopRequested(quadrotor_controller_M)) { rtExtModeCheckEndTrigger(); }else { rtExtModeShutdown(1); } }
/* Model update function */ void motor_update(void) { /* signal main to stop simulation */ { /* Sample time: [0.2s, 0.0s] */ if ((rtmGetTFinal(motor_M)!=-1) && !((rtmGetTFinal(motor_M)-motor_M->Timing.taskTime0) > motor_M->Timing.taskTime0 * (DBL_EPSILON))) { rtmSetErrorStatus(motor_M, "Simulation finished"); } if (rtmGetStopRequested(motor_M)) { rtmSetErrorStatus(motor_M, "Simulation finished"); } } /* Update absolute time for base rate */ /* The "clockTick0" counts the number of times the code of this task has * been executed. The absolute time is the multiplication of "clockTick0" * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not * overflow during the application lifespan selected. */ motor_M->Timing.taskTime0 = (++motor_M->Timing.clockTick0) * motor_M->Timing.stepSize0; }
int_T main(void) { init(); #ifdef _RTT_USE_SERIAL1_ Serial_begin(1, 9600); #endif #ifdef _RTT_USE_SERIAL2_ Serial_begin(2, 9600); #endif #ifdef _RTT_USE_SERIAL3_ Serial_begin(3, 9600); #endif /* initialize external mode */ rtParseArgsForExtMode(0, NULL); velo_id_gain_initialize(); /* External mode */ rtSetTFinalForExtMode(&rtmGetTFinal(velo_id_gain_M)); rtExtModeCheckInit(2); { boolean_T rtmStopReq = false; rtExtModeWaitForStartPkt(velo_id_gain_M->extModeInfo, 2, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(velo_id_gain_M, true); } } rtERTExtModeStartMsg(); arduino_Timer_Setup(); /* The main step loop */ while ((rtmGetErrorStatus(velo_id_gain_M) == (NULL)) && !rtmGetStopRequested (velo_id_gain_M)) { /* External mode */ { boolean_T rtmStopReq = false; rtExtModeOneStep(velo_id_gain_M->extModeInfo, 2, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(velo_id_gain_M, true); } } rtExtModeCheckEndTrigger(); } rtExtModeShutdown(2); delay(1000); velo_id_gain_terminate(); /* Disable Interrupts */ cli(); return 0; }
/* 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 step function */ void Motor_Test_All_step(void) { /* local block i/o variables */ real_T rtb_Output; uint8_T rtb_FixPtSum1; /* MultiPortSwitch: '<S1>/Output' incorporates: * Constant: '<S1>/Vector' * UnitDelay: '<S2>/Output' */ rtb_Output = Motor_Test_All_P.RepeatingSequenceStair_OutValue[Motor_Test_All_DW.Output_DSTATE]; /* ModelReference: '<Root>/Model' */ motor_hl(&Motor_Test_All_P.enable_Value, &rtb_Output, &Motor_Test_All_P.enable_Value); /* ModelReference: '<Root>/Model1' */ motor_vr(&Motor_Test_All_P.enable_Value, &rtb_Output, &Motor_Test_All_P.enable_Value); /* ModelReference: '<Root>/Model2' */ motor_vl(&Motor_Test_All_P.enable_Value, &rtb_Output, &Motor_Test_All_P.enable_Value); /* ModelReference: '<Root>/Model3' */ motor_hr(&Motor_Test_All_P.enable_Value, &rtb_Output, &Motor_Test_All_P.enable_Value); /* Sum: '<S3>/FixPt Sum1' incorporates: * Constant: '<S3>/FixPt Constant' * UnitDelay: '<S2>/Output' */ rtb_FixPtSum1 = (uint8_T)((uint16_T)Motor_Test_All_DW.Output_DSTATE + Motor_Test_All_P.FixPtConstant_Value); /* Switch: '<S4>/FixPt Switch' */ if (rtb_FixPtSum1 > Motor_Test_All_P.LimitedCounter_uplimit) { /* Update for UnitDelay: '<S2>/Output' incorporates: * Constant: '<S4>/Constant' */ Motor_Test_All_DW.Output_DSTATE = Motor_Test_All_P.Constant_Value; } else { /* Update for UnitDelay: '<S2>/Output' */ Motor_Test_All_DW.Output_DSTATE = rtb_FixPtSum1; } /* End of Switch: '<S4>/FixPt Switch' */ /* External mode */ rtExtModeUploadCheckTrigger(1); { /* Sample time: [10.0s, 0.0s] */ rtExtModeUpload(0, Motor_Test_All_M->Timing.taskTime0); } /* signal main to stop simulation */ { /* Sample time: [10.0s, 0.0s] */ if ((rtmGetTFinal(Motor_Test_All_M)!=-1) && !((rtmGetTFinal(Motor_Test_All_M)-Motor_Test_All_M->Timing.taskTime0) > Motor_Test_All_M->Timing.taskTime0 * (DBL_EPSILON))) { rtmSetErrorStatus(Motor_Test_All_M, "Simulation finished"); } if (rtmGetStopRequested(Motor_Test_All_M)) { rtmSetErrorStatus(Motor_Test_All_M, "Simulation finished"); } } /* Update absolute time for base rate */ /* The "clockTick0" counts the number of times the code of this task has * been executed. The absolute time is the multiplication of "clockTick0" * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not * overflow during the application lifespan selected. */ Motor_Test_All_M->Timing.taskTime0 = (++Motor_Test_All_M->Timing.clockTick0) * Motor_Test_All_M->Timing.stepSize0; }
int main(int argc, char * argv[]) { RT_MODEL * S; const char * status; int_T count; int exit_code = exit_success; boolean_T parseError = FALSE; real_T final_time = -2; /* Let model select final time */ int scheduling_priority; struct qsched_param scheduling; t_period timeout; t_timer_notify notify; t_error result; /* * Make controller threads higher priority than external mode threads: * ext_priority = priority of lowest priority external mode thread * min_priority = minimum allowable priority of lowest priority model task * max_priority = maximum allowable priority of lowest priority model task */ int ext_priority = qsched_get_priority_min(QSCHED_FIFO); int min_priority = ext_priority + 2; int max_priority = qsched_get_priority_max(QSCHED_FIFO) - 0; qsigset_t signal_set; qsigaction_t action; int_T stack_size = 0; /* default stack size */ (void) ssPrintf("Entered main(argc=%d, argv=%p)\n", argc, argv); for (count = 0; count < argc; count++) { (void) ssPrintf(" argv[%d] = %s\n", count, argv[count]); } scheduling_priority = 2; /* default priority */ if (scheduling_priority < min_priority) scheduling_priority = min_priority; else if (scheduling_priority > max_priority) scheduling_priority = max_priority; /* * Parse the standard RTW parameters. Let all unrecognized parameters * pass through to external mode for parsing. NULL out all args handled * so that the external mode parsing can ignore them. */ for (count = 1; count < argc; ) { const char *option = argv[count++]; char extraneous_characters[2]; if ((strcmp(option, "-tf") == 0) && (count != argc)) {/* final time */ const char * tf_argument = argv[count++]; double time_value; /* use a double for the sscanf since real_T may be a float or a double depending on the platform */ if (strcmp(tf_argument, "inf") == 0) { time_value = RUN_FOREVER; } else { int items = sscanf(tf_argument, "%lf%1s", &time_value, extraneous_characters); if ((items != 1) || (time_value < 0.0) ) { (void) fprintf(stderr, "final_time must be a positive, real value or inf.\n"); parseError = true; break; } } final_time = (real_T) time_value; argv[count-2] = NULL; argv[count-1] = NULL; } else if ((strcmp(option, "-pri") == 0) && (count != argc)) {/* base priority */ const char * tf_argument = argv[count++]; int priority; /* use an int for the sscanf since int_T may be the wrong size depending on the platform */ int items = sscanf(tf_argument, "%d%1s", &priority, extraneous_characters); if ((items != 1) || (priority < min_priority) ) { (void) fprintf(stderr, "priority must be a greater than or equal to %d.\n", min_priority); parseError = true; break; } if (priority > max_priority) { (void) fprintf(stderr, "priority must be less than or equal to %d.\n", max_priority); parseError = true; break; } scheduling_priority = priority; argv[count-2] = NULL; argv[count-1] = NULL; } else if ((strcmp(option, "-ss") == 0) && (count != argc)) {/* stack size */ const char * stack_argument = argv[count++]; int stack; /* use an int for the sscanf since int_T may be the wrong size depending on the platform */ int items = sscanf(stack_argument, "%d%1s", &stack, extraneous_characters); if ((items != 1) || (stack < QTHREAD_STACK_MIN) ) { (void) fprintf(stderr, "stack size must be a integral value greater than or equal to %d.\n", QTHREAD_STACK_MIN); parseError = true; break; } stack_size = (int_T)stack; argv[count-2] = NULL; argv[count-1] = NULL; } else if ((strcmp(option, "-d") == 0) && (count != argc)) {/* current directory */ const char * path_name = argv[count++]; _chdir(path_name); argv[count-2] = NULL; argv[count-1] = NULL; } } rtExtModeQuarcParseArgs(argc, (const char **) argv, "shmem://Crane:1"); /* * Check for unprocessed ("unhandled") args. */ for (count = 1; count < argc; count++) { if (argv[count] != NULL) { (void) fprintf(stderr, "Unexpected command line argument: \"%s\".\n", argv[count]); parseError = TRUE; } } if (parseError) { (void) fprintf(stderr, "\nUsage: Crane -option1 val1 -option2 val2 -option3 ...\n\n"); (void) fprintf(stderr, "\t-tf 20 - sets final time to 20 seconds\n"); (void) fprintf(stderr, "\t-d C:\\data - sets current directory to C:\\data\n"); (void) fprintf(stderr, "\t-pri 5 - sets the minimum thread priority\n"); (void) fprintf(stderr, "\t-ss 65536 - sets the stack size for model threads\n"); (void) fprintf(stderr, "\t-w - wait for host to connect before starting\n"); (void) fprintf(stderr, "\t-uri shmem://mymodel - set external mode URL to \"shmem://mymodel\"\n"); (void) fprintf(stderr, "\n"); return (exit_failure); } /**************************** * Initialize global memory * ****************************/ (void)memset(&GBLbuf, 0, sizeof(GBLbuf)); /************************ * Initialize the model * ************************/ rt_InitInfAndNaN(sizeof(real_T)); S = Crane(); if (rtmGetErrorStatus(S) != NULL) { (void) fprintf(stderr, "Error during model registration: %s\n", rtmGetErrorStatus(S)); return (exit_failure); } if (final_time >= 0.0 || final_time == RUN_FOREVER) { rtmSetTFinal(S, final_time); } else { rtmSetTFinal(S, rtInf); } action.sa_handler = control_c_handler; action.sa_flags = 0; qsigemptyset(&action.sa_mask); qsigaction(SIGINT, &action, NULL); qsigaction(SIGBREAK, &action, NULL); qsigemptyset(&signal_set); qsigaddset(&signal_set, SIGINT); qsigaddset(&signal_set, SIGBREAK); qthread_sigmask(QSIG_UNBLOCK, &signal_set, NULL); initialize_sizes(S); initialize_sample_times(S); status = rt_SimInitTimingEngine(rtmGetNumSampleTimes(S), rtmGetStepSize(S), rtmGetSampleTimePtr(S), rtmGetOffsetTimePtr(S), rtmGetSampleHitPtr(S), rtmGetSampleTimeTaskIDPtr(S), rtmGetTStart(S), &rtmGetSimTimeStep(S), &rtmGetTimingData(S)); if (status != NULL) { (void) fprintf(stderr, "Failed to initialize sample time engine: %s\n", status); return (exit_failure); } rt_CreateIntegrationData(S); fflush(stdout); if (rtExtModeQuarcStartup(rtmGetRTWExtModeInfo(S), rtmGetNumSampleTimes(S), &rtmGetStopRequested(S), ext_priority, /* external mode thread priority */ stack_size, SS_HAVESTDIO)) { (void) ssPrintf("\n** starting the model **\n"); start(S); if (rtmGetErrorStatus(S) == NULL) { /************************************************************************* * Execute the model. *************************************************************************/ if (rtmGetTFinal(S) == RUN_FOREVER) { (void) ssPrintf("\n**May run forever. Model stop time set to infinity.**\n"); } timeout.seconds = (t_long) (rtmGetStepSize(S)); timeout.nanoseconds = (t_int) ((rtmGetStepSize(S) - timeout.seconds) * 1000000000L); result = qtimer_event_create(¬ify.notify_value.event); if (result == 0) { t_timer timer; scheduling.sched_priority = scheduling_priority; qthread_setschedparam(qthread_self(), QSCHED_FIFO, &scheduling); notify.notify_type = TIMER_NOTIFY_EVENT; result = qtimer_create(¬ify, &timer); if (result == 0) { result = qtimer_begin_resolution(timer, &timeout); if (result == 0) { t_period actual_timeout; (void) ssPrintf("Creating main thread with priority %d and period %g...\n", scheduling_priority, rtmGetStepSize(S)); result = qtimer_get_actual_period(timer, &timeout, &actual_timeout); if (result == 0 && (timeout.nanoseconds != actual_timeout.nanoseconds || timeout.seconds != actual_timeout.seconds)) (void) ssPrintf("*** Actual period will be %g ***\n", actual_timeout.seconds + 1e-9 * actual_timeout.nanoseconds); fflush(stdout); result = qtimer_set_time(timer, &timeout, true); if (result == 0) { /* Enter the periodic loop */ while (result == 0) { if (GBLbuf.stopExecutionFlag || rtmGetStopRequested(S)) { break; } if (rtmGetTFinal(S) != RUN_FOREVER && rtmGetTFinal(S) - rtmGetT (S) <= rtmGetT(S)*DBL_EPSILON) { break; } if (qtimer_get_overrun(timer) > 0) { (void) fprintf(stderr, "Sampling rate is too fast for base rate\n"); fflush(stderr); } rt_OneStep(S); result = qtimer_event_wait(notify.notify_value.event); } /* disarm the timer */ qtimer_cancel(timer); if (rtmGetStopRequested(S) == false && rtmGetErrorStatus(S) == NULL) { /* Execute model last time step if final time expired */ rt_OneStep(S); } (void) ssPrintf("Main thread exited\n"); } else { msg_get_error_messageA(NULL, result, GBLbuf.submessage, sizeof (GBLbuf.submessage)); string_format(GBLbuf.message, sizeof(GBLbuf.message), "Unable to set base rate. %s", GBLbuf.submessage); rtmSetErrorStatus(S, GBLbuf.message); } qtimer_end_resolution(timer); } else { msg_get_error_messageA(NULL, result, GBLbuf.submessage, sizeof (GBLbuf.submessage)); string_format(GBLbuf.message, sizeof(GBLbuf.message), "Sampling period of %lg is too fast for the system clock. %s", rtmGetStepSize(S), GBLbuf.submessage); rtmSetErrorStatus(S, GBLbuf.message); } qtimer_delete(timer); } else { msg_get_error_messageA(NULL, result, GBLbuf.submessage, sizeof (GBLbuf.submessage)); string_format(GBLbuf.message, sizeof(GBLbuf.message), "Unable to create timer for base rate. %s", GBLbuf.submessage); rtmSetErrorStatus(S, GBLbuf.message); } } else { msg_get_error_messageA(NULL, result, GBLbuf.submessage, sizeof (GBLbuf.submessage)); string_format(GBLbuf.message, sizeof(GBLbuf.message), "Unable to create timer event for base rate. %s", GBLbuf.submessage); rtmSetErrorStatus(S, GBLbuf.message); } GBLbuf.stopExecutionFlag = 1; } } else { rtmSetErrorStatus(S, "Unable to initialize external mode."); } rtExtSetReturnStatus(rtmGetErrorStatus(S)); rtExtModeQuarcCleanup(rtmGetNumSampleTimes(S)); /******************** * Cleanup and exit * ********************/ if (rtmGetErrorStatus(S) != NULL) { (void) fprintf(stderr, "%s\n", rtmGetErrorStatus(S)); exit_code = exit_failure; } (void) ssPrintf("Invoking model termination function...\n"); terminate(S); (void) ssPrintf("Exiting real-time code\n"); return (exit_code); }
/* Model initialize function */ void Hammerstein_initialize(void) { /* Registration code */ /* initialize non-finites */ rt_InitInfAndNaN(sizeof(real_T)); /* initialize real-time model */ (void) memset((void *)Hammerstein_M, 0, sizeof(RT_MODEL_Hammerstein)); rtsiSetSolverName(&Hammerstein_M->solverInfo,"FixedStepDiscrete"); Hammerstein_M->solverInfoPtr = (&Hammerstein_M->solverInfo); /* Initialize timing info */ { int_T *mdlTsMap = Hammerstein_M->Timing.sampleTimeTaskIDArray; mdlTsMap[0] = 0; Hammerstein_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]); Hammerstein_M->Timing.sampleTimes = (&Hammerstein_M-> Timing.sampleTimesArray[0]); Hammerstein_M->Timing.offsetTimes = (&Hammerstein_M-> Timing.offsetTimesArray[0]); /* task periods */ Hammerstein_M->Timing.sampleTimes[0] = (0.06); /* task offsets */ Hammerstein_M->Timing.offsetTimes[0] = (0.0); } rtmSetTPtr(Hammerstein_M, &Hammerstein_M->Timing.tArray[0]); { int_T *mdlSampleHits = Hammerstein_M->Timing.sampleHitArray; mdlSampleHits[0] = 1; Hammerstein_M->Timing.sampleHits = (&mdlSampleHits[0]); } rtmSetTFinal(Hammerstein_M, 9.9599999999999991); Hammerstein_M->Timing.stepSize0 = 0.06; /* Setup for data logging */ { static RTWLogInfo rt_DataLoggingInfo; Hammerstein_M->rtwLogInfo = &rt_DataLoggingInfo; } /* Setup for data logging */ { rtliSetLogXSignalInfo(Hammerstein_M->rtwLogInfo, (NULL)); rtliSetLogXSignalPtrs(Hammerstein_M->rtwLogInfo, (NULL)); rtliSetLogT(Hammerstein_M->rtwLogInfo, "tout"); rtliSetLogX(Hammerstein_M->rtwLogInfo, ""); rtliSetLogXFinal(Hammerstein_M->rtwLogInfo, ""); rtliSetSigLog(Hammerstein_M->rtwLogInfo, ""); rtliSetLogVarNameModifier(Hammerstein_M->rtwLogInfo, "rt_"); rtliSetLogFormat(Hammerstein_M->rtwLogInfo, 0); rtliSetLogMaxRows(Hammerstein_M->rtwLogInfo, 1000); rtliSetLogDecimation(Hammerstein_M->rtwLogInfo, 1); /* * Set pointers to the data and signal info for each output */ { static void * rt_LoggedOutputSignalPtrs[] = { &Hammerstein_Y.Out1 }; rtliSetLogYSignalPtrs(Hammerstein_M->rtwLogInfo, ((LogSignalPtrsType) rt_LoggedOutputSignalPtrs)); } { static int_T rt_LoggedOutputWidths[] = { 1 }; static int_T rt_LoggedOutputNumDimensions[] = { 1 }; static int_T rt_LoggedOutputDimensions[] = { 1 }; static boolean_T rt_LoggedOutputIsVarDims[] = { 0 }; static void* rt_LoggedCurrentSignalDimensions[] = { (NULL) }; static int_T rt_LoggedCurrentSignalDimensionsSize[] = { 4 }; static BuiltInDTypeId rt_LoggedOutputDataTypeIds[] = { SS_DOUBLE }; static int_T rt_LoggedOutputComplexSignals[] = { 0 }; static const char_T *rt_LoggedOutputLabels[] = { "" }; static const char_T *rt_LoggedOutputBlockNames[] = { "Hammerstein/Out1" }; static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = { { 0, SS_DOUBLE, SS_DOUBLE, 0, 0, 0, 1.0, 0, 0.0 } }; static RTWLogSignalInfo rt_LoggedOutputSignalInfo[] = { { 1, rt_LoggedOutputWidths, rt_LoggedOutputNumDimensions, rt_LoggedOutputDimensions, rt_LoggedOutputIsVarDims, rt_LoggedCurrentSignalDimensions, rt_LoggedCurrentSignalDimensionsSize, rt_LoggedOutputDataTypeIds, rt_LoggedOutputComplexSignals, (NULL), { rt_LoggedOutputLabels }, (NULL), (NULL), (NULL), { rt_LoggedOutputBlockNames }, { (NULL) }, (NULL), rt_RTWLogDataTypeConvert } }; rtliSetLogYSignalInfo(Hammerstein_M->rtwLogInfo, rt_LoggedOutputSignalInfo); /* set currSigDims field */ rt_LoggedCurrentSignalDimensions[0] = &rt_LoggedOutputWidths[0]; } rtliSetLogY(Hammerstein_M->rtwLogInfo, "yout"); } Hammerstein_M->solverInfoPtr = (&Hammerstein_M->solverInfo); Hammerstein_M->Timing.stepSize = (0.06); rtsiSetFixedStepSize(&Hammerstein_M->solverInfo, 0.06); rtsiSetSolverMode(&Hammerstein_M->solverInfo, SOLVER_MODE_SINGLETASKING); /* block I/O */ (void) memset(((void *) &Hammerstein_B), 0, sizeof(BlockIO_Hammerstein)); /* states (dwork) */ (void) memset((void *)&Hammerstein_DWork, 0, sizeof(D_Work_Hammerstein)); /* external inputs */ Hammerstein_U.In1 = 0.0; /* external outputs */ Hammerstein_Y.Out1 = 0.0; /* child S-Function registration */ { RTWSfcnInfo *sfcnInfo = &Hammerstein_M->NonInlinedSFcns.sfcnInfo; Hammerstein_M->sfcnInfo = (sfcnInfo); rtssSetErrorStatusPtr(sfcnInfo, (&rtmGetErrorStatus(Hammerstein_M))); rtssSetNumRootSampTimesPtr(sfcnInfo, &Hammerstein_M->Sizes.numSampTimes); Hammerstein_M->NonInlinedSFcns.taskTimePtrs[0] = &(rtmGetTPtr(Hammerstein_M) [0]); rtssSetTPtrPtr(sfcnInfo,Hammerstein_M->NonInlinedSFcns.taskTimePtrs); rtssSetTStartPtr(sfcnInfo, &rtmGetTStart(Hammerstein_M)); rtssSetTFinalPtr(sfcnInfo, &rtmGetTFinal(Hammerstein_M)); rtssSetTimeOfLastOutputPtr(sfcnInfo, &rtmGetTimeOfLastOutput(Hammerstein_M)); rtssSetStepSizePtr(sfcnInfo, &Hammerstein_M->Timing.stepSize); rtssSetStopRequestedPtr(sfcnInfo, &rtmGetStopRequested(Hammerstein_M)); rtssSetDerivCacheNeedsResetPtr(sfcnInfo, &Hammerstein_M->ModelData.derivCacheNeedsReset); rtssSetZCCacheNeedsResetPtr(sfcnInfo, &Hammerstein_M->ModelData.zCCacheNeedsReset); rtssSetBlkStateChangePtr(sfcnInfo, &Hammerstein_M->ModelData.blkStateChange); rtssSetSampleHitsPtr(sfcnInfo, &Hammerstein_M->Timing.sampleHits); rtssSetPerTaskSampleHitsPtr(sfcnInfo, &Hammerstein_M->Timing.perTaskSampleHits); rtssSetSimModePtr(sfcnInfo, &Hammerstein_M->simMode); rtssSetSolverInfoPtr(sfcnInfo, &Hammerstein_M->solverInfoPtr); } Hammerstein_M->Sizes.numSFcns = (2); /* register each child */ { (void) memset((void *)&Hammerstein_M->NonInlinedSFcns.childSFunctions[0], 0, 2*sizeof(SimStruct)); Hammerstein_M->childSfunctions = (&Hammerstein_M->NonInlinedSFcns.childSFunctionPtrs[0]); Hammerstein_M->childSfunctions[0] = (&Hammerstein_M->NonInlinedSFcns.childSFunctions[0]); Hammerstein_M->childSfunctions[1] = (&Hammerstein_M->NonInlinedSFcns.childSFunctions[1]); /* Level2 S-Function Block: Hammerstein/<S1>/Pwlinear1 (sfunpwlinear) */ { SimStruct *rts = Hammerstein_M->childSfunctions[0]; /* timing info */ time_T *sfcnPeriod = Hammerstein_M->NonInlinedSFcns.Sfcn0.sfcnPeriod; time_T *sfcnOffset = Hammerstein_M->NonInlinedSFcns.Sfcn0.sfcnOffset; int_T *sfcnTsMap = Hammerstein_M->NonInlinedSFcns.Sfcn0.sfcnTsMap; (void) memset((void*)sfcnPeriod, 0, sizeof(time_T)*1); (void) memset((void*)sfcnOffset, 0, sizeof(time_T)*1); ssSetSampleTimePtr(rts, &sfcnPeriod[0]); ssSetOffsetTimePtr(rts, &sfcnOffset[0]); ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap); /* Set up the mdlInfo pointer */ { ssSetBlkInfo2Ptr(rts, &Hammerstein_M->NonInlinedSFcns.blkInfo2[0]); } ssSetRTWSfcnInfo(rts, Hammerstein_M->sfcnInfo); /* Allocate memory of model methods 2 */ { ssSetModelMethods2(rts, &Hammerstein_M->NonInlinedSFcns.methods2[0]); } /* Allocate memory of model methods 3 */ { ssSetModelMethods3(rts, &Hammerstein_M->NonInlinedSFcns.methods3[0]); } /* Allocate memory for states auxilliary information */ { ssSetStatesInfo2(rts, &Hammerstein_M->NonInlinedSFcns.statesInfo2[0]); } /* inputs */ { _ssSetNumInputPorts(rts, 1); ssSetPortInfoForInputs(rts, &Hammerstein_M->NonInlinedSFcns.Sfcn0.inputPortInfo[0]); /* port 0 */ { ssSetInputPortRequiredContiguous(rts, 0, 1); ssSetInputPortSignal(rts, 0, &Hammerstein_B.LinearModel); _ssSetInputPortNumDimensions(rts, 0, 1); ssSetInputPortWidth(rts, 0, 1); } } /* outputs */ { ssSetPortInfoForOutputs(rts, &Hammerstein_M->NonInlinedSFcns.Sfcn0.outputPortInfo[0]); _ssSetNumOutputPorts(rts, 1); /* port 0 */ { _ssSetOutputPortNumDimensions(rts, 0, 1); ssSetOutputPortWidth(rts, 0, 1); ssSetOutputPortSignal(rts, 0, ((real_T *) &Hammerstein_Y.Out1)); } } /* path info */ ssSetModelName(rts, "Pwlinear1"); ssSetPath(rts, "Hammerstein/Hammerstein-Wiener Model1/Pwlinear1"); ssSetRTModel(rts,Hammerstein_M); ssSetParentSS(rts, (NULL)); ssSetRootSS(rts, rts); ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2); /* parameters */ { mxArray **sfcnParams = (mxArray **) &Hammerstein_M->NonInlinedSFcns.Sfcn0.params; ssSetSFcnParamsCount(rts, 7); ssSetSFcnParamsPtr(rts, &sfcnParams[0]); ssSetSFcnParam(rts, 0, (mxArray*)Hammerstein_P.Pwlinear1_P1_Size); ssSetSFcnParam(rts, 1, (mxArray*)Hammerstein_P.Pwlinear1_P2_Size); ssSetSFcnParam(rts, 2, (mxArray*)Hammerstein_P.Pwlinear1_P3_Size); ssSetSFcnParam(rts, 3, (mxArray*)Hammerstein_P.Pwlinear1_P4_Size); ssSetSFcnParam(rts, 4, (mxArray*)Hammerstein_P.Pwlinear1_P5_Size); ssSetSFcnParam(rts, 5, (mxArray*)Hammerstein_P.Pwlinear1_P6_Size); ssSetSFcnParam(rts, 6, (mxArray*)Hammerstein_P.Pwlinear1_P7_Size); } /* registration */ sfunpwlinear(rts); sfcnInitializeSizes(rts); sfcnInitializeSampleTimes(rts); /* adjust sample time */ ssSetSampleTime(rts, 0, 0.06); ssSetOffsetTime(rts, 0, 0.0); sfcnTsMap[0] = 0; /* set compiled values of dynamic vector attributes */ ssSetNumNonsampledZCs(rts, 0); /* Update connectivity flags for each port */ _ssSetInputPortConnected(rts, 0, 1); _ssSetOutputPortConnected(rts, 0, 1); _ssSetOutputPortBeingMerged(rts, 0, 0); /* Update the BufferDstPort flags for each input port */ ssSetInputPortBufferDstPort(rts, 0, -1); } /* Level2 S-Function Block: Hammerstein/<S1>/Pwlinear (sfunpwlinear) */ { SimStruct *rts = Hammerstein_M->childSfunctions[1]; /* timing info */ time_T *sfcnPeriod = Hammerstein_M->NonInlinedSFcns.Sfcn1.sfcnPeriod; time_T *sfcnOffset = Hammerstein_M->NonInlinedSFcns.Sfcn1.sfcnOffset; int_T *sfcnTsMap = Hammerstein_M->NonInlinedSFcns.Sfcn1.sfcnTsMap; (void) memset((void*)sfcnPeriod, 0, sizeof(time_T)*1); (void) memset((void*)sfcnOffset, 0, sizeof(time_T)*1); ssSetSampleTimePtr(rts, &sfcnPeriod[0]); ssSetOffsetTimePtr(rts, &sfcnOffset[0]); ssSetSampleTimeTaskIDPtr(rts, sfcnTsMap); /* Set up the mdlInfo pointer */ { ssSetBlkInfo2Ptr(rts, &Hammerstein_M->NonInlinedSFcns.blkInfo2[1]); } ssSetRTWSfcnInfo(rts, Hammerstein_M->sfcnInfo); /* Allocate memory of model methods 2 */ { ssSetModelMethods2(rts, &Hammerstein_M->NonInlinedSFcns.methods2[1]); } /* Allocate memory of model methods 3 */ { ssSetModelMethods3(rts, &Hammerstein_M->NonInlinedSFcns.methods3[1]); } /* Allocate memory for states auxilliary information */ { ssSetStatesInfo2(rts, &Hammerstein_M->NonInlinedSFcns.statesInfo2[1]); } /* inputs */ { _ssSetNumInputPorts(rts, 1); ssSetPortInfoForInputs(rts, &Hammerstein_M->NonInlinedSFcns.Sfcn1.inputPortInfo[0]); /* port 0 */ { ssSetInputPortRequiredContiguous(rts, 0, 1); ssSetInputPortSignal(rts, 0, &Hammerstein_U.In1); _ssSetInputPortNumDimensions(rts, 0, 1); ssSetInputPortWidth(rts, 0, 1); } } /* outputs */ { ssSetPortInfoForOutputs(rts, &Hammerstein_M->NonInlinedSFcns.Sfcn1.outputPortInfo[0]); _ssSetNumOutputPorts(rts, 1); /* port 0 */ { _ssSetOutputPortNumDimensions(rts, 0, 1); ssSetOutputPortWidth(rts, 0, 1); ssSetOutputPortSignal(rts, 0, ((real_T *) &Hammerstein_B.Pwlinear)); } } /* path info */ ssSetModelName(rts, "Pwlinear"); ssSetPath(rts, "Hammerstein/Hammerstein-Wiener Model1/Pwlinear"); ssSetRTModel(rts,Hammerstein_M); ssSetParentSS(rts, (NULL)); ssSetRootSS(rts, rts); ssSetVersion(rts, SIMSTRUCT_VERSION_LEVEL2); /* parameters */ { mxArray **sfcnParams = (mxArray **) &Hammerstein_M->NonInlinedSFcns.Sfcn1.params; ssSetSFcnParamsCount(rts, 7); ssSetSFcnParamsPtr(rts, &sfcnParams[0]); ssSetSFcnParam(rts, 0, (mxArray*)Hammerstein_P.Pwlinear_P1_Size); ssSetSFcnParam(rts, 1, (mxArray*)Hammerstein_P.Pwlinear_P2_Size); ssSetSFcnParam(rts, 2, (mxArray*)Hammerstein_P.Pwlinear_P3_Size); ssSetSFcnParam(rts, 3, (mxArray*)Hammerstein_P.Pwlinear_P4_Size); ssSetSFcnParam(rts, 4, (mxArray*)Hammerstein_P.Pwlinear_P5_Size); ssSetSFcnParam(rts, 5, (mxArray*)Hammerstein_P.Pwlinear_P6_Size); ssSetSFcnParam(rts, 6, (mxArray*)Hammerstein_P.Pwlinear_P7_Size); } /* registration */ sfunpwlinear(rts); sfcnInitializeSizes(rts); sfcnInitializeSampleTimes(rts); /* adjust sample time */ ssSetSampleTime(rts, 0, 0.06); ssSetOffsetTime(rts, 0, 0.0); sfcnTsMap[0] = 0; /* set compiled values of dynamic vector attributes */ ssSetNumNonsampledZCs(rts, 0); /* Update connectivity flags for each port */ _ssSetInputPortConnected(rts, 0, 1); _ssSetOutputPortConnected(rts, 0, 1); _ssSetOutputPortBeingMerged(rts, 0, 0); /* Update the BufferDstPort flags for each input port */ ssSetInputPortBufferDstPort(rts, 0, -1); } } /* Matfile logging */ rt_StartDataLoggingWithStartTime(Hammerstein_M->rtwLogInfo, 0.0, rtmGetTFinal (Hammerstein_M), Hammerstein_M->Timing.stepSize0, (&rtmGetErrorStatus (Hammerstein_M))); /* Level2 S-Function Block: '<S1>/Pwlinear1' (sfunpwlinear) */ { SimStruct *rts = Hammerstein_M->childSfunctions[0]; sfcnStart(rts); if (ssGetErrorStatus(rts) != (NULL)) return; } /* Level2 S-Function Block: '<S1>/Pwlinear' (sfunpwlinear) */ { SimStruct *rts = Hammerstein_M->childSfunctions[1]; sfcnStart(rts); if (ssGetErrorStatus(rts) != (NULL)) return; } /* InitializeConditions for DiscreteStateSpace: '<S1>/LinearModel' */ Hammerstein_DWork.LinearModel_DSTATE = Hammerstein_P.LinearModel_X0; /* Level2 S-Function Block: '<S1>/Pwlinear1' (sfunpwlinear) */ { SimStruct *rts = Hammerstein_M->childSfunctions[0]; sfcnInitializeConditions(rts); if (ssGetErrorStatus(rts) != (NULL)) return; } /* Level2 S-Function Block: '<S1>/Pwlinear' (sfunpwlinear) */ { SimStruct *rts = Hammerstein_M->childSfunctions[1]; sfcnInitializeConditions(rts); if (ssGetErrorStatus(rts) != (NULL)) return; } }
/* Function: main ============================================================= * * Abstract: * Execute model on a generic target such as a workstation. */ int_T main(int_T argc, const char_T *argv[]) { RT_MODEL *S; const char *status; real_T finaltime = -2.0; int_T oldStyle_argc; const char_T *oldStyle_argv[5]; /****************************** * MathError Handling for BC++ * ******************************/ #ifdef BORLAND signal(SIGFPE, (fptr)divideByZero); #endif /******************* * Parse arguments * *******************/ if ((argc > 1) && (argv[1][0] != '-')) { /* old style */ if ( argc > 3 ) { displayUsage(); exit(EXIT_FAILURE); } oldStyle_argc = 1; oldStyle_argv[0] = argv[0]; if (argc >= 2) { oldStyle_argc = 3; oldStyle_argv[1] = "-tf"; oldStyle_argv[2] = argv[1]; } if (argc == 3) { oldStyle_argc = 5; oldStyle_argv[3] = "-port"; oldStyle_argv[4] = argv[2]; } argc = oldStyle_argc; argv = oldStyle_argv; } { /* new style: */ double tmpDouble; char_T tmpStr2[200]; int_T count = 1; int_T parseError = FALSE; /* * Parse the standard RTW parameters. Let all unrecognized parameters * pass through to external mode for parsing. NULL out all args handled * so that the external mode parsing can ignore them. */ while(count < argc) { const char_T *option = argv[count++]; /* final time */ if ((strcmp(option, "-tf") == 0) && (count != argc)) { const char_T *tfStr = argv[count++]; sscanf(tfStr, "%200s", tmpStr2); if (strcmp(tmpStr2, "inf") == 0) { tmpDouble = RUN_FOREVER; } else { char_T tmpstr[2]; if ( (sscanf(tmpStr2,"%lf%1s", &tmpDouble, tmpstr) != 1) || (tmpDouble < 0.0) ) { (void)printf("finaltime must be a positive, real value or inf\n"); parseError = TRUE; break; } } finaltime = (real_T) tmpDouble; argv[count-2] = NULL; argv[count-1] = NULL; } } if (parseError) { (void)printf("\nUsage: %s -option1 val1 -option2 val2 -option3 " "...\n\n", QUOTE(MODEL)); (void)printf("\t-tf 20 - sets final time to 20 seconds\n"); exit(EXIT_FAILURE); } rtExtModeParseArgs(argc, argv, NULL); /* * Check for unprocessed ("unhandled") args. */ { int i; for (i=1; i<argc; i++) { if (argv[i] != NULL) { printf("Unexpected command line argument: %s\n",argv[i]); exit(EXIT_FAILURE); } } } } /**************************** * Initialize global memory * ****************************/ (void)memset(&GBLbuf, 0, sizeof(GBLbuf)); /************************ * Initialize the model * ************************/ rt_InitInfAndNaN(sizeof(real_T)); S = MODEL(); if (rtmGetErrorStatus(S) != NULL) { (void)fprintf(stderr,"Error during model registration: %s\n", rtmGetErrorStatus(S)); exit(EXIT_FAILURE); } if (finaltime >= 0.0 || finaltime == RUN_FOREVER) rtmSetTFinal(S,finaltime); MdlInitializeSizes(); MdlInitializeSampleTimes(); status = rt_SimInitTimingEngine(rtmGetNumSampleTimes(S), rtmGetStepSize(S), rtmGetSampleTimePtr(S), rtmGetOffsetTimePtr(S), rtmGetSampleHitPtr(S), rtmGetSampleTimeTaskIDPtr(S), rtmGetTStart(S), &rtmGetSimTimeStep(S), &rtmGetTimingData(S)); if (status != NULL) { (void)fprintf(stderr, "Failed to initialize sample time engine: %s\n", status); exit(EXIT_FAILURE); } rt_CreateIntegrationData(S); /* #ifdef UseMMIDataLogging rt_FillStateSigInfoFromMMI(rtmGetRTWLogInfo(S),&rtmGetErrorStatus(S)); rt_FillSigLogInfoFromMMI(rtmGetRTWLogInfo(S),&rtmGetErrorStatus(S)); #endif*/ /* GBLbuf.errmsg = rt_StartDataLogging(rtmGetRTWLogInfo(S), rtmGetTFinal(S), rtmGetStepSize(S), &rtmGetErrorStatus(S)); if (GBLbuf.errmsg != NULL) { (void)fprintf(stderr,"Error starting data logging: %s\n",GBLbuf.errmsg); return(EXIT_FAILURE); }*//*removed datalogging*/ rtExtModeCheckInit(rtmGetNumSampleTimes(S)); rtExtModeWaitForStartPkt(rtmGetRTWExtModeInfo(S), rtmGetNumSampleTimes(S), (boolean_T *)&rtmGetStopRequested(S)); (void)printf("\n** starting the model **\n"); MdlStart(); if (rtmGetErrorStatus(S) != NULL) { GBLbuf.stopExecutionFlag = 1; } /************************************************************************* * Execute the model. You may attach rtOneStep to an ISR, if so replace * * the call to rtOneStep (below) with a call to a background task * * application. * *************************************************************************/ if (rtmGetTFinal(S) == RUN_FOREVER) { printf ("\n**May run forever. Model stop time set to infinity.**\n"); } stepTime=(FPS*CLOCKS_PER_SEC)/1000; nextStart = clock(); nextStart+=stepTime; while (!GBLbuf.stopExecutionFlag && (rtmGetTFinal(S) == RUN_FOREVER || rtmGetTFinal(S)-rtmGetT(S) > rtmGetT(S)*DBL_EPSILON)) { rtExtModePauseIfNeeded(rtmGetRTWExtModeInfo(S), rtmGetNumSampleTimes(S), (boolean_T *)&rtmGetStopRequested(S)); if( clock() >= nextStart) { if( stepTime > 0) { printf("***Execution slower than requested rate: Actual speed =%d ms***\n",(1000*(stepTime+clock()-nextStart))/CLOCKS_PER_SEC); nextStart=clock(); } } while (clock() < nextStart) {} nextStart+=stepTime; if (rtmGetStopRequested(S)) break; rt_OneStep(S); } if (!GBLbuf.stopExecutionFlag && !rtmGetStopRequested(S)) { /* Execute model last time step */ rt_OneStep(S); } /******************** * Cleanup and exit * ********************/ /* #ifdef UseMMIDataLogging rt_CleanUpForStateLogWithMMI(rtmGetRTWLogInfo(S)); rt_CleanUpForSigLogWithMMI(rtmGetRTWLogInfo(S)); #endif rt_StopDataLogging(MATFILE,rtmGetRTWLogInfo(S));*/ rtExtModeShutdown(rtmGetNumSampleTimes(S)); if (GBLbuf.errmsg) { (void)fprintf(stderr,"%s\n",GBLbuf.errmsg); exit(EXIT_FAILURE); } if (rtmGetErrorStatus(S) != NULL) { (void)fprintf(stderr,"ErrorStatus set: \"%s\"\n", rtmGetErrorStatus(S)); exit(EXIT_FAILURE); } if (GBLbuf.isrOverrun) { (void)fprintf(stderr, "%s: ISR overrun - base sampling rate is too fast\n", QUOTE(MODEL)); exit(EXIT_FAILURE); } #ifdef MULTITASKING else { int_T i; for (i=1; i<NUMST; i++) { if (GBLbuf.overrunFlags[i]) { (void)fprintf(stderr, "%s ISR overrun - sampling rate is too fast for " "sample time index %d\n", QUOTE(MODEL), i); exit(EXIT_FAILURE); } } } #endif MdlTerminate(); return(EXIT_SUCCESS); } /* end main */
/* 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); } } }
/* 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 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 */ } } }
/* Function: rtOneStep ======================================================== * * Abstract: * Perform one step of the model. This function is modeled such that * it could be called from an interrupt service routine (ISR) with minor * modifications. * * This routine is modeled for use in a multitasking environment and * therefore needs to be fully re-entrant when it is called from an * interrupt service routine. * * Note: * Error checking is provided which will only be used if this routine * is attached to an interrupt. * */ static void rt_OneStep(RT_MODEL *S) { int_T i; real_T tnext; int_T *sampleHit = rtmGetSampleHitPtr(S); /*********************************************** * Check and see if base step time is too fast * ***********************************************/ if (GBLbuf.isrOverrun++) { GBLbuf.stopExecutionFlag = 1; return; } /*********************************************** * Check and see if error status has been set * ***********************************************/ if (rtmGetErrorStatus(S) != NULL) { GBLbuf.stopExecutionFlag = 1; return; } /* enable interrupts here */ /* * In a multi-tasking environment, this would be removed from the base rate * and called as a "background" task. */ rtExtModeOneStep(rtmGetRTWExtModeInfo(S), rtmGetNumSampleTimes(S), (boolean_T *)&rtmGetStopRequested(S)); /*********************************************** * Update discrete events * ***********************************************/ tnext = rt_SimUpdateDiscreteEvents(rtmGetNumSampleTimes(S), rtmGetTimingData(S), rtmGetSampleHitPtr(S), rtmGetPerTaskSampleHitsPtr(S)); rtsiSetSolverStopTime(rtmGetRTWSolverInfo(S),tnext); for (i=FIRST_TID+1; i < NUMST; i++) { if (sampleHit[i] && GBLbuf.eventFlags[i]++) { GBLbuf.isrOverrun--; GBLbuf.overrunFlags[i]++; /* Are we sampling too fast for */ GBLbuf.stopExecutionFlag=1; /* sample time "i"? */ return; } } /******************************************* * Step the model for the base sample time * *******************************************/ MdlOutputs(FIRST_TID); rtExtModeUploadCheckTrigger(rtmGetNumSampleTimes(S)); rtExtModeUpload(FIRST_TID,rtmGetTaskTime(S, FIRST_TID)); /* GBLbuf.errmsg = rt_UpdateTXYLogVars(rtmGetRTWLogInfo(S), rtmGetTPtr(S)); if (GBLbuf.errmsg != NULL) { GBLbuf.stopExecutionFlag = 1; return; }*/ /* rt_UpdateSigLogVars(rtmGetRTWLogInfo(S), rtmGetTPtr(S));*/ MdlUpdate(FIRST_TID); if (rtmGetSampleTime(S,0) == CONTINUOUS_SAMPLE_TIME) { rt_UpdateContinuousStates(S); } else { rt_SimUpdateDiscreteTaskTime(rtmGetTPtr(S), rtmGetTimingData(S), 0); } #if FIRST_TID == 1 rt_SimUpdateDiscreteTaskTime(rtmGetTPtr(S), rtmGetTimingData(S),1); #endif /************************************************************************ * Model step complete for base sample time, now it is okay to * * re-interrupt this ISR. * ************************************************************************/ GBLbuf.isrOverrun--; /********************************************* * Step the model for any other sample times * *********************************************/ for (i=FIRST_TID+1; i<NUMST; i++) { /* If task "i" is running, don't run any lower priority task */ if (GBLbuf.overrunFlags[i]) return; if (GBLbuf.eventFlags[i]) { GBLbuf.overrunFlags[i]++; MdlOutputs(i); rtExtModeUpload(i, rtmGetTaskTime(S,i)); MdlUpdate(i); rt_SimUpdateDiscreteTaskTime(rtmGetTPtr(S), rtmGetTimingData(S),i); /* Indicate task complete for sample time "i" */ GBLbuf.overrunFlags[i]--; GBLbuf.eventFlags[i]--; } } rtExtModeCheckEndTrigger(); } /* end rtOneStep */
/* Model step function */ void motor_test_hierarchies_step(void) { /* local block i/o variables */ real_T rtb_FromWs; real_T tmp; uint8_T tmp_0; /* Constant: '<Root>/enable' */ motor_test_hierarchies_B.enable = motor_test_hierarchies_P.enable_Value; /* FromWorkspace: '<S3>/FromWs' */ { real_T *pDataValues = (real_T *) motor_test_hierarchies_DW.FromWs_PWORK.DataPtr; real_T *pTimeValues = (real_T *) motor_test_hierarchies_DW.FromWs_PWORK.TimePtr; int_T currTimeIndex = motor_test_hierarchies_DW.FromWs_IWORK.PrevIndex; real_T t = motor_test_hierarchies_M->Timing.t[0]; /* Get index */ if (t <= pTimeValues[0]) { currTimeIndex = 0; } else if (t >= pTimeValues[9]) { currTimeIndex = 8; } else { if (t < pTimeValues[currTimeIndex]) { while (t < pTimeValues[currTimeIndex]) { currTimeIndex--; } } else { while (t >= pTimeValues[currTimeIndex + 1]) { currTimeIndex++; } } } motor_test_hierarchies_DW.FromWs_IWORK.PrevIndex = currTimeIndex; /* Post output */ { real_T t1 = pTimeValues[currTimeIndex]; real_T t2 = pTimeValues[currTimeIndex + 1]; if (t1 == t2) { if (t < t1) { rtb_FromWs = pDataValues[currTimeIndex]; } else { rtb_FromWs = pDataValues[currTimeIndex + 1]; } } else { real_T f1 = (t2 - t) / (t2 - t1); real_T f2 = 1.0 - f1; real_T d1; real_T d2; int_T TimeIndex= currTimeIndex; d1 = pDataValues[TimeIndex]; d2 = pDataValues[TimeIndex + 1]; rtb_FromWs = (real_T) rtInterpolate(d1, d2, f1, f2); pDataValues += 10; } } } /* Outputs for Atomic SubSystem: '<S1>/hl' */ /* Constant: '<Root>/direction' */ motor_test_hierarchies_hl(motor_test_hierarchies_B.enable, rtb_FromWs, motor_test_hierarchies_P.direction_Value, &motor_test_hierarchies_B.hl, (P_hl_motor_test_hierarchies_T *)&motor_test_hierarchies_P.hl); /* End of Outputs for SubSystem: '<S1>/hl' */ /* Outputs for Atomic SubSystem: '<S1>/hr' */ /* Switch: '<S5>/Switch' incorporates: * Constant: '<Root>/direction' * Constant: '<S5>/Constant2' */ if (motor_test_hierarchies_B.enable > motor_test_hierarchies_P.Switch_Threshold) { tmp = motor_test_hierarchies_P.direction_Value; } else { tmp = motor_test_hierarchies_P.Constant2_Value; } /* End of Switch: '<S5>/Switch' */ /* DataTypeConversion: '<S10>/Data Type Conversion' */ if (tmp < 256.0) { if (tmp >= 0.0) { tmp_0 = (uint8_T)tmp; } else { tmp_0 = 0U; } } else { tmp_0 = MAX_uint8_T; } /* End of DataTypeConversion: '<S10>/Data Type Conversion' */ /* S-Function (arduinodigitaloutput_sfcn): '<S10>/Digital Output' */ MW_digitalWrite(motor_test_hierarchies_P.DigitalOutput_pinNumber, tmp_0); /* Switch: '<S5>/Switch1' incorporates: * Constant: '<S5>/Constant3' * DataTypeConversion: '<S11>/Data Type Conversion' */ if (motor_test_hierarchies_B.enable > motor_test_hierarchies_P.Switch1_Threshold) { /* DataTypeConversion: '<S11>/Data Type Conversion' */ if (rtb_FromWs < 256.0) { if (rtb_FromWs >= 0.0) { motor_test_hierarchies_B.DataTypeConversion_b = (uint8_T)rtb_FromWs; } else { motor_test_hierarchies_B.DataTypeConversion_b = 0U; } } else { motor_test_hierarchies_B.DataTypeConversion_b = MAX_uint8_T; } } else if (motor_test_hierarchies_P.Constant3_Value < 256.0) { /* DataTypeConversion: '<S11>/Data Type Conversion' incorporates: * Constant: '<S5>/Constant3' */ if (motor_test_hierarchies_P.Constant3_Value >= 0.0) { motor_test_hierarchies_B.DataTypeConversion_b = (uint8_T) motor_test_hierarchies_P.Constant3_Value; } else { motor_test_hierarchies_B.DataTypeConversion_b = 0U; } } else { /* DataTypeConversion: '<S11>/Data Type Conversion' */ motor_test_hierarchies_B.DataTypeConversion_b = MAX_uint8_T; } /* End of Switch: '<S5>/Switch1' */ /* S-Function (arduinoanalogoutput_sfcn): '<S11>/PWM' */ MW_analogWrite(motor_test_hierarchies_P.PWM_pinNumber, motor_test_hierarchies_B.DataTypeConversion_b); /* Outputs for Atomic SubSystem: '<S1>/vl' */ /* Constant: '<Root>/direction' */ motor_test_hierarchies_hl(motor_test_hierarchies_B.enable, rtb_FromWs, motor_test_hierarchies_P.direction_Value, &motor_test_hierarchies_B.vl, (P_hl_motor_test_hierarchies_T *)&motor_test_hierarchies_P.vl); /* End of Outputs for SubSystem: '<S1>/vl' */ /* Outputs for Atomic SubSystem: '<S1>/vr' */ /* Switch: '<S7>/Switch' incorporates: * Constant: '<Root>/direction' * Constant: '<S7>/Constant2' */ if (motor_test_hierarchies_B.enable > motor_test_hierarchies_P.Switch_Threshold_k) { tmp = motor_test_hierarchies_P.direction_Value; } else { tmp = motor_test_hierarchies_P.Constant2_Value_n; } /* End of Switch: '<S7>/Switch' */ /* DataTypeConversion: '<S14>/Data Type Conversion' */ if (tmp < 256.0) { if (tmp >= 0.0) { tmp_0 = (uint8_T)tmp; } else { tmp_0 = 0U; } } else { tmp_0 = MAX_uint8_T; } /* End of DataTypeConversion: '<S14>/Data Type Conversion' */ /* S-Function (arduinodigitaloutput_sfcn): '<S14>/Digital Output' */ MW_digitalWrite(motor_test_hierarchies_P.DigitalOutput_pinNumber_a, tmp_0); /* Switch: '<S7>/Switch1' incorporates: * Constant: '<S7>/Constant3' * DataTypeConversion: '<S15>/Data Type Conversion' */ if (motor_test_hierarchies_B.enable > motor_test_hierarchies_P.Switch1_Threshold_o) { /* DataTypeConversion: '<S15>/Data Type Conversion' */ if (rtb_FromWs < 256.0) { if (rtb_FromWs >= 0.0) { motor_test_hierarchies_B.DataTypeConversion = (uint8_T)rtb_FromWs; } else { motor_test_hierarchies_B.DataTypeConversion = 0U; } } else { motor_test_hierarchies_B.DataTypeConversion = MAX_uint8_T; } } else if (motor_test_hierarchies_P.Constant3_Value_f < 256.0) { /* DataTypeConversion: '<S15>/Data Type Conversion' incorporates: * Constant: '<S7>/Constant3' */ if (motor_test_hierarchies_P.Constant3_Value_f >= 0.0) { motor_test_hierarchies_B.DataTypeConversion = (uint8_T) motor_test_hierarchies_P.Constant3_Value_f; } else { motor_test_hierarchies_B.DataTypeConversion = 0U; } } else { /* DataTypeConversion: '<S15>/Data Type Conversion' */ motor_test_hierarchies_B.DataTypeConversion = MAX_uint8_T; } /* End of Switch: '<S7>/Switch1' */ /* S-Function (arduinoanalogoutput_sfcn): '<S15>/PWM' */ MW_analogWrite(motor_test_hierarchies_P.PWM_pinNumber_n, motor_test_hierarchies_B.DataTypeConversion); /* External mode */ rtExtModeUploadCheckTrigger(2); { /* Sample time: [0.0s, 0.0s] */ rtExtModeUpload(0, motor_test_hierarchies_M->Timing.t[0]); } { /* Sample time: [1.0s, 0.0s] */ rtExtModeUpload(1, ((motor_test_hierarchies_M->Timing.clockTick1) )); } /* signal main to stop simulation */ { /* Sample time: [0.0s, 0.0s] */ if ((rtmGetTFinal(motor_test_hierarchies_M)!=-1) && !((rtmGetTFinal(motor_test_hierarchies_M)- motor_test_hierarchies_M->Timing.t[0]) > motor_test_hierarchies_M->Timing.t[0] * (DBL_EPSILON))) { rtmSetErrorStatus(motor_test_hierarchies_M, "Simulation finished"); } if (rtmGetStopRequested(motor_test_hierarchies_M)) { rtmSetErrorStatus(motor_test_hierarchies_M, "Simulation finished"); } } /* Update absolute time for base rate */ /* The "clockTick0" counts the number of times the code of this task has * been executed. The absolute time is the multiplication of "clockTick0" * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not * overflow during the application lifespan selected. */ motor_test_hierarchies_M->Timing.t[0] = (++motor_test_hierarchies_M->Timing.clockTick0) * motor_test_hierarchies_M->Timing.stepSize0; { /* Update absolute timer for sample time: [1.0s, 0.0s] */ /* The "clockTick1" counts the number of times the code of this task has * been executed. The resolution of this integer timer is 1.0, which is the step size * of the task. Size of "clockTick1" ensures timer will not overflow during the * application lifespan selected. */ motor_test_hierarchies_M->Timing.clockTick1++; } }
int main(void) { volatile boolean_T runModel = 1; float modelBaseRate = 0.01; float systemClock = 168; #ifndef USE_RTX __disable_irq(); #endif ; stm32f4xx_init_board(); SystemCoreClockUpdate(); bootloaderInit(); rtmSetErrorStatus(BeschleunigungsAuswertung_M, 0); /* initialize external mode */ rtParseArgsForExtMode(0, NULL); BeschleunigungsAuswertung_initialize(); __enable_irq(); /* External mode */ rtSetTFinalForExtMode(&rtmGetTFinal(BeschleunigungsAuswertung_M)); rtExtModeCheckInit(1); { boolean_T rtmStopReq = false; rtExtModeWaitForStartPkt(BeschleunigungsAuswertung_M->extModeInfo, 1, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(BeschleunigungsAuswertung_M, true); } } rtERTExtModeStartMsg(); __disable_irq(); ARMCM_SysTick_Config(modelBaseRate); runModel = (rtmGetErrorStatus(BeschleunigungsAuswertung_M) == (NULL)) && !rtmGetStopRequested(BeschleunigungsAuswertung_M); __enable_irq(); __enable_irq(); while (runModel) { /* External mode */ { boolean_T rtmStopReq = false; rtExtModeOneStep(BeschleunigungsAuswertung_M->extModeInfo, 1, &rtmStopReq); if (rtmStopReq) { rtmSetStopRequested(BeschleunigungsAuswertung_M, true); } } runModel = (rtmGetErrorStatus(BeschleunigungsAuswertung_M) == (NULL)) && !rtmGetStopRequested(BeschleunigungsAuswertung_M); } rtExtModeShutdown(1); #ifndef USE_RTX (void)systemClock; #endif ; /* Disable rt_OneStep() here */ /* Terminate model */ BeschleunigungsAuswertung_terminate(); __disable_irq(); return 0; }
/* Model step function */ void motor_hr_step(void) { real_T tmp; uint8_T tmp_0; /* Switch: '<Root>/Switch' incorporates: * Constant: '<Root>/Constant2' * Inport: '<Root>/direction' * Inport: '<Root>/enable' */ if (motor_hr_U.enable > motor_hr_P.Switch_Threshold) { tmp = motor_hr_U.direction; } else { tmp = motor_hr_P.Constant2_Value; } /* End of Switch: '<Root>/Switch' */ /* DataTypeConversion: '<S1>/Data Type Conversion' */ if (tmp < 256.0) { if (tmp >= 0.0) { tmp_0 = (uint8_T)tmp; } else { tmp_0 = 0U; } } else { tmp_0 = MAX_uint8_T; } /* End of DataTypeConversion: '<S1>/Data Type Conversion' */ /* S-Function (arduinodigitaloutput_sfcn): '<S1>/Digital Output' */ MW_digitalWrite(motor_hr_P.DigitalOutput_pinNumber, tmp_0); /* Switch: '<Root>/Switch1' incorporates: * Constant: '<Root>/Constant3' * Inport: '<Root>/enable' * Inport: '<Root>/power' */ if (motor_hr_U.enable > motor_hr_P.Switch1_Threshold) { tmp = motor_hr_U.power; } else { tmp = motor_hr_P.Constant3_Value; } /* End of Switch: '<Root>/Switch1' */ /* DataTypeConversion: '<S2>/Data Type Conversion' */ if (tmp < 256.0) { if (tmp >= 0.0) { tmp_0 = (uint8_T)tmp; } else { tmp_0 = 0U; } } else { tmp_0 = MAX_uint8_T; } /* End of DataTypeConversion: '<S2>/Data Type Conversion' */ /* S-Function (arduinoanalogoutput_sfcn): '<S2>/PWM' */ MW_analogWrite(motor_hr_P.PWM_pinNumber, tmp_0); /* External mode */ rtExtModeUploadCheckTrigger(1); { /* Sample time: [20.0s, 0.0s] */ rtExtModeUpload(0, motor_hr_M->Timing.taskTime0); } /* signal main to stop simulation */ { /* Sample time: [20.0s, 0.0s] */ if ((rtmGetTFinal(motor_hr_M)!=-1) && !((rtmGetTFinal(motor_hr_M)-motor_hr_M->Timing.taskTime0) > motor_hr_M->Timing.taskTime0 * (DBL_EPSILON))) { rtmSetErrorStatus(motor_hr_M, "Simulation finished"); } if (rtmGetStopRequested(motor_hr_M)) { rtmSetErrorStatus(motor_hr_M, "Simulation finished"); } } /* Update absolute time for base rate */ /* The "clockTick0" counts the number of times the code of this task has * been executed. The absolute time is the multiplication of "clockTick0" * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not * overflow during the application lifespan selected. */ motor_hr_M->Timing.taskTime0 = (++motor_hr_M->Timing.clockTick0) * motor_hr_M->Timing.stepSize0; }
/* 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 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 step function */ void GyroskopAuswertung_step(void) { /* S-Function (MPU6050_CustomBlock): '<Root>/Sensor1' */ MPU6050_CustomBlock_Outputs_wrapper( &GyroskopAuswertung_B.Sensor1_o1, &GyroskopAuswertung_B.Sensor1_o2, &GyroskopAuswertung_B.Sensor1_o3, &GyroskopAuswertung_B.Sensor1_o4, &GyroskopAuswertung_B.Sensor1_o5, &GyroskopAuswertung_B.Sensor1_o6, &GyroskopAuswertung_DW.Sensor1_DSTATE, &GyroskopAuswertung_P.Sensor1_P1, 1, &GyroskopAuswertung_P.Sensor1_P2, 1); /* S-Function (MPU6050_CustomBlock): '<Root>/Sensor2' */ MPU6050_CustomBlock_Outputs_wrapper( &GyroskopAuswertung_B.Sensor2_o1, &GyroskopAuswertung_B.Sensor2_o2, &GyroskopAuswertung_B.Sensor2_o3, &GyroskopAuswertung_B.Sensor2_o4, &GyroskopAuswertung_B.Sensor2_o5, &GyroskopAuswertung_B.Sensor2_o6, &GyroskopAuswertung_DW.Sensor2_DSTATE, &GyroskopAuswertung_P.Sensor2_P1, 1, &GyroskopAuswertung_P.Sensor2_P2, 1); /* S-Function "MPU6050_CustomBlock_wrapper" Block: <Root>/Sensor1 */ MPU6050_CustomBlock_Update_wrapper( &GyroskopAuswertung_B.Sensor1_o1, &GyroskopAuswertung_B.Sensor1_o2, &GyroskopAuswertung_B.Sensor1_o3, &GyroskopAuswertung_B.Sensor1_o4, &GyroskopAuswertung_B.Sensor1_o5, &GyroskopAuswertung_B.Sensor1_o6, &GyroskopAuswertung_DW.Sensor1_DSTATE, &GyroskopAuswertung_P.Sensor1_P1, 1, &GyroskopAuswertung_P.Sensor1_P2, 1); /* S-Function "MPU6050_CustomBlock_wrapper" Block: <Root>/Sensor2 */ MPU6050_CustomBlock_Update_wrapper( &GyroskopAuswertung_B.Sensor2_o1, &GyroskopAuswertung_B.Sensor2_o2, &GyroskopAuswertung_B.Sensor2_o3, &GyroskopAuswertung_B.Sensor2_o4, &GyroskopAuswertung_B.Sensor2_o5, &GyroskopAuswertung_B.Sensor2_o6, &GyroskopAuswertung_DW.Sensor2_DSTATE, &GyroskopAuswertung_P.Sensor2_P1, 1, &GyroskopAuswertung_P.Sensor2_P2, 1); /* External mode */ rtExtModeUploadCheckTrigger(1); { /* Sample time: [0.01s, 0.0s] */ rtExtModeUpload(0, GyroskopAuswertung_M->Timing.taskTime0); } /* signal main to stop simulation */ { /* Sample time: [0.01s, 0.0s] */ if ((rtmGetTFinal(GyroskopAuswertung_M)!=-1) && !((rtmGetTFinal(GyroskopAuswertung_M)- GyroskopAuswertung_M->Timing.taskTime0) > GyroskopAuswertung_M->Timing.taskTime0 * (DBL_EPSILON))) { rtmSetErrorStatus(GyroskopAuswertung_M, "Simulation finished"); } if (rtmGetStopRequested(GyroskopAuswertung_M)) { rtmSetErrorStatus(GyroskopAuswertung_M, "Simulation finished"); } } /* Update absolute time for base rate */ /* The "clockTick0" counts the number of times the code of this task has * been executed. The absolute time is the multiplication of "clockTick0" * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not * overflow during the application lifespan selected. * Timer of this task consists of two 32 bit unsigned integers. * The two integers represent the low bits Timing.clockTick0 and the high bits * Timing.clockTickH0. When the low bit overflows to 0, the high bits increment. */ if (!(++GyroskopAuswertung_M->Timing.clockTick0)) { ++GyroskopAuswertung_M->Timing.clockTickH0; } GyroskopAuswertung_M->Timing.taskTime0 = GyroskopAuswertung_M->Timing.clockTick0 * GyroskopAuswertung_M->Timing.stepSize0 + GyroskopAuswertung_M->Timing.clockTickH0 * GyroskopAuswertung_M->Timing.stepSize0 * 4294967296.0; }
/* Model step function */ void motor_control_step(void) { real_T rtb_PulseGenerator; real32_T rtb_Sum1; real32_T rtb_FilterCoefficient; /* DiscretePulseGenerator: '<Root>/Pulse Generator' */ rtb_PulseGenerator = (motor_control_DW.clockTickCounter < motor_control_P.PulseGenerator_Duty) && (motor_control_DW.clockTickCounter >= 0L) ? motor_control_P.PulseGenerator_Amp : 0.0; if (motor_control_DW.clockTickCounter >= motor_control_P.PulseGenerator_Period - 1.0) { motor_control_DW.clockTickCounter = 0L; } else { motor_control_DW.clockTickCounter++; } /* End of DiscretePulseGenerator: '<Root>/Pulse Generator' */ /* Sum: '<Root>/Sum2' incorporates: * Constant: '<Root>/ref' */ motor_control_B.Sum2 = (real32_T)(motor_control_P.ref_Value - rtb_PulseGenerator); /* S-Function (Encoder_read): '<Root>/Encoder' */ Encoder_read_Outputs_wrapper( &motor_control_B.Encoder, &motor_control_DW.Encoder_DSTATE); /* Sum: '<Root>/Sum1' */ rtb_Sum1 = motor_control_B.Sum2 - motor_control_B.Encoder; /* Gain: '<S1>/Filter Coefficient' incorporates: * DiscreteIntegrator: '<S1>/Filter' * Gain: '<S1>/Derivative Gain' * Sum: '<S1>/SumD' */ rtb_FilterCoefficient = (motor_control_P.DiscretePIDController_D * rtb_Sum1 - motor_control_DW.Filter_DSTATE) * motor_control_P.DiscretePIDController_N; /* Sum: '<S1>/Sum' incorporates: * DiscreteIntegrator: '<S1>/Integrator' * Gain: '<S1>/Proportional Gain' */ motor_control_B.Sum = (motor_control_P.DiscretePIDController_P * rtb_Sum1 + motor_control_DW.Integrator_DSTATE) + rtb_FilterCoefficient; /* Sum: '<Root>/Sum' incorporates: * Constant: '<Root>/Constant' */ motor_control_B.Sum_e = motor_control_B.Sum + motor_control_P.Constant_Value; /* S-Function (PWM_init): '<Root>/PWM' */ PWM_init_Outputs_wrapper(&motor_control_B.Sum_e, &motor_control_DW.PWM_DSTATE); /* S-Function "Encoder_read_wrapper" Block: <Root>/Encoder */ Encoder_read_Update_wrapper( &motor_control_B.Encoder, &motor_control_DW.Encoder_DSTATE); /* Update for DiscreteIntegrator: '<S1>/Integrator' incorporates: * Gain: '<S1>/Integral Gain' */ motor_control_DW.Integrator_DSTATE += motor_control_P.DiscretePIDController_I * rtb_Sum1 * motor_control_P.Integrator_gainval; /* Update for DiscreteIntegrator: '<S1>/Filter' */ motor_control_DW.Filter_DSTATE += motor_control_P.Filter_gainval * rtb_FilterCoefficient; /* S-Function "PWM_init_wrapper" Block: <Root>/PWM */ PWM_init_Update_wrapper(&motor_control_B.Sum_e, &motor_control_DW.PWM_DSTATE); /* External mode */ rtExtModeUploadCheckTrigger(1); { /* Sample time: [0.05s, 0.0s] */ rtExtModeUpload(0, motor_control_M->Timing.taskTime0); } /* signal main to stop simulation */ { /* Sample time: [0.05s, 0.0s] */ if ((rtmGetTFinal(motor_control_M)!=-1) && !((rtmGetTFinal(motor_control_M)-motor_control_M->Timing.taskTime0) > motor_control_M->Timing.taskTime0 * (DBL_EPSILON))) { rtmSetErrorStatus(motor_control_M, "Simulation finished"); } if (rtmGetStopRequested(motor_control_M)) { rtmSetErrorStatus(motor_control_M, "Simulation finished"); } } /* Update absolute time for base rate */ /* The "clockTick0" counts the number of times the code of this task has * been executed. The absolute time is the multiplication of "clockTick0" * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not * overflow during the application lifespan selected. */ motor_control_M->Timing.taskTime0 = (++motor_control_M->Timing.clockTick0) * motor_control_M->Timing.stepSize0; }
/* Function: main ============================================================= * * Abstract: * Execute model on a generic target such as a workstation. */ int_T main(int_T argc, const char *argv[]) { /* External mode */ // rtParseArgsForExtMode(argc, argv); /******************************************* * warn if the model will run indefinitely * *******************************************/ #if MAT_FILE==0 && EXT_MODE==0 printf("warning: the simulation will run with no stop time; " "to change this behavior select the 'MAT-file logging' option\n"); fflush(NULL); #endif (void)printf("\n** starting the model **\n"); /************************ * Initialize the model * ************************/ rt_InitModel(); /* External mode */ rtSetTFinalForExtMode(&rtmGetTFinal(RT_MDL)); rtExtModeCheckInit(NUMST); Clock_Params clkParams; Timer_Params user_sys_tick_params; Timer_Handle user_sys_tick_timer; /* Create timer for user system tick */ Timer_Params_init(&user_sys_tick_params); user_sys_tick_params.period = STEP_SIZE; user_sys_tick_params.periodType = Timer_PeriodType_MICROSECS; user_sys_tick_params.arg = 1; user_sys_tick_timer = Timer_create(1, (ti_sysbios_hal_Timer_FuncPtr)Clock_tick, &user_sys_tick_params, NULL); if(user_sys_tick_timer == NULL) { System_abort("Unable to create user system tick timer!"); } /* Create a periodic Clock Instance with period = 1 system time units */ Clock_Params_init(&clkParams); clkParams.period = 1; clkParams.startFlag = TRUE; Clock_create(clk0Fxn, 10, &clkParams, NULL); // rtExtModeWaitForStartPkt(rtmGetRTWExtModeInfo(RT_MDL), // NUMST, // (boolean_T *)&rtmGetStopRequested(RT_MDL)); /*********************************************************************** * Execute (step) the model. You may also attach rtOneStep to an ISR, * * in which case you replace the call to rtOneStep with a call to a * * background task. Note that the generated code sets error status * * to "Simulation finished" when MatFileLogging is specified in TLC. * ***********************************************************************/ // while (rtmGetErrorStatus(RT_MDL) == NULL && // !rtmGetStopRequested(RT_MDL)) { // // // rtExtModePauseIfNeeded(rtmGetRTWExtModeInfo(RT_MDL), // // NUMST, // // (boolean_T *)&rtmGetStopRequested(RT_MDL)); // // if (rtmGetStopRequested(RT_MDL)) break; // // /* external mode */ // rtExtModeOneStep(rtmGetRTWExtModeInfo(RT_MDL), // NUMST, // (boolean_T *)&rtmGetStopRequested(RT_MDL)); // // rt_OneStep(); // } rtExtModeC6000Startup(rtmGetRTWExtModeInfo(RT_MDL), NUMST, (boolean_T *)&rtmGetStopRequested(RT_MDL)); BIOS_start(); }