/**
* This function is called periodically (as specified by the control frequency).
* The useful functions that you can call used in doloop() are listed below.
*
* frequency() returns frequency of simulation.
* period() returns period of simulation.
* duration() returns duration of simulation.
* simTicks() returns elapsed simulation ticks.
* simTimeInNano() returns elapsed simulation time in nano seconds.
* simTimeInMiliSec() returns elapsed simulation time in miliseconds.
* simTimeInSec() returns elapsed simulation time in seconds.
* overruns() returns the count of overruns.
*
* @return If you return 0, the control will continue to execute. If you return
* nonzero, the control will abort and stop() function will be called.
*/
int ZenomMatlab::doloop()
{
tnext = rt_SimGetNextSampleHit();
rtsiSetSolverStopTime(rtmGetRTWSolverInfo(rtM),tnext);
OUTPUTS(rtM, 0);
//rtExtModeSingleTaskUpload(rtM);
UPDATED(rtM, 0);
rt_SimUpdateDiscreteTaskSampleHits(rtmGetNumSampleTimes(rtM),
rtmGetTimingData(rtM),
rtmGetSampleHitPtr(rtM),
rtmGetTPtr(rtM));
if (rtmGetSampleTime(rtM, 0) == CONTINUOUS_SAMPLE_TIME) {
rt_UpdateContinuousStates(rtM);
}
mmi = &(rtmGetDataMapInfo(rtM).mmi);
Xrt_SetParameterInfo(mmi);
return 0;
}
/* Function: rtOneStep ========================================================
*
* Abstract:
* Perform one step of the model.
*/
static void rt_OneStep(RT_MODEL *S)
{
real_T tnext;
/***********************************************
* Check and see if error status has been set *
***********************************************/
if (rtmGetErrorStatus(S) != NULL) {
GBLbuf.stopExecutionFlag = 1;
return;
}
/* enable interrupts here */
tnext = rt_SimGetNextSampleHit();
rtsiSetSolverStopTime(rtmGetRTWSolverInfo(S),tnext);
outputs(S, 0);
rtExtModeSingleTaskUpload(S);
update(S, 0);
rt_SimUpdateDiscreteTaskSampleHits(rtmGetNumSampleTimes(S),
rtmGetTimingData(S),
rtmGetSampleHitPtr(S),
rtmGetTPtr(S));
if (rtmGetSampleTime(S,0) == CONTINUOUS_SAMPLE_TIME) {
rt_UpdateContinuousStates(S);
}
rtExtModeCheckEndTrigger();
} /* end rtOneStep */
/* 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 */
/* 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.
*/
static void rt_OneStep(RT_MODEL *S)
{
real_T tnext;
/***********************************************
* 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));
tnext = rt_SimGetNextSampleHit();
rtsiSetSolverStopTime(rtmGetRTWSolverInfo(S),tnext);
MdlOutputs(0);
rtExtModeSingleTaskUpload(S);
/*GBLbuf.errmsg = rt_UpdateTXYLogVars(rtmGetRTWLogInfo(S),
rtmGetTPtr(S));
if (GBLbuf.errmsg != NULL) {
GBLbuf.stopExecutionFlag = 1;
return;
}*//*removed logging*/
/*rt_UpdateSigLogVars(rtmGetRTWLogInfo(S), rtmGetTPtr(S));*//*removed logging*/
MdlUpdate(0);
rt_SimUpdateDiscreteTaskSampleHits(rtmGetNumSampleTimes(S),
rtmGetTimingData(S),
rtmGetSampleHitPtr(S),
rtmGetTPtr(S));
if (rtmGetSampleTime(S,0) == CONTINUOUS_SAMPLE_TIME) {
rt_UpdateContinuousStates(S);
}
GBLbuf.isrOverrun--;
rtExtModeCheckEndTrigger();
} /* end rtOneStep */
