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