static void outputs(RT_MODEL * S, int_T tid)
{
MdlOutputs(tid);
}
/* Function: rsimOneStepMT =====================================================
*
* Perform one step of the model.
* Errors are set in the SimStruct's ErrorStatus, NULL means no errors.
*/
static void rsimOneStepMT(SimStruct *S)
{
int_T i;
const int_T FIRST_TID = gbl_raccel_tid01eq ? 1 : 0;
int_T* sampleHit = ssGetSampleHitPtr(S);
ssSetSimTimeStep(S, MAJOR_TIME_STEP);
/* Clear the flag that blocks set in their major time step methods (output,
update, etc.) to flag that they have changed their state. If this flag is
true then we need to run model outputs again at the first minor step
(i.e., at the same time as the last major step).*/
ssClearBlkStateChange(S);
#ifdef DEBUG_TIMING
rsimDisplayTimingData(S,
sizeof(struct SimStruct_tag),
sizeof(struct _ssMdlInfo));
#endif
if (gblExtModeEnabled) {
rtExtModeOneStep(ssGetRTWExtModeInfo(S),
ssGetNumSampleTimes(S),
(boolean_T*)&ssGetStopRequested(S));
if (ssGetStopRequested(S)) return;
}
/* Setup the task times and sample hit flags for the discrete rates */
rsimUpdateDiscreteTaskTimesAndSampleHits(S);
if (ssGetErrorStatus(S) != NULL) return;
ssSetLogOutput(S,TRUE);
/* Do output, log, update for the base rate */
MdlOutputs(FIRST_TID);
if (gblExtModeEnabled) {
rtExtModeUploadCheckTrigger(ssGetNumSampleTimes(S));
rtExtModeUpload(FIRST_TID, ssGetTaskTime(S, FIRST_TID));
}
if (ssGetLogOutput(S)) {
(void)rt_UpdateTXYLogVars(ssGetRTWLogInfo(S), ssGetTPtr(S));
if (ssGetErrorStatus(S) != NULL) return;
}
MdlUpdate(FIRST_TID);
if (ssGetErrorStatus(S) != NULL) return;
/* Do not log outputs during minor time steps */
ssSetLogOutput(S, FALSE);
ssSetTimeOfLastOutput(S,ssGetT(S));
/* Call the solver push time forward based on the continuous dynamics */
if (ssGetSampleTime(S,0) == CONTINUOUS_SAMPLE_TIME &&
!ssGetStopRequested(S) ) {
rsimUpdateSolverStopTimeForFixedStepMultiTaskingSim(S);
if (!ssGetStopRequested(S)) rsimAdvanceSolver(S);
}
/* Do output and update for the remaining rates */
ssSetLogOutput(S, TRUE);
for (i = FIRST_TID+1; i < gbl_raccel_NumST; i++) {
if ( !sampleHit[i] ) continue;
MdlOutputs(i);
rtExtModeUpload(i, ssGetTaskTime(S,i));
MdlUpdate(i);
}
if (ssGetErrorStatus(S) != NULL) return;
ssSetLogOutput(S, FALSE);
if (gblExtModeEnabled) {
rtExtModeCheckEndTrigger();
}
/* Update the timing engine and determine the solver stop time */
rsimUpdateTimingEngineAndSolverStopTime(S);
if (ssGetErrorStatus(S) != NULL) return;
} /* rsimOneStepMT */
/* 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: rsimOutputLogUpdate ===============================================
*
*/
static void rsimOutputLogUpdate(SimStruct* S)
{
double currTime = ssGetT(S);
bool logOutput = !ssGetOutputTimesOnly(S);
#ifdef DEBUG_TIMING
rsimDisplayTimingData(S,
sizeof(struct SimStruct_tag),
sizeof(struct _ssMdlInfo));
#endif
if (gblExtModeEnabled) {
rtExtModeOneStep(ssGetRTWExtModeInfo(S),
ssGetNumSampleTimes(S),
(boolean_T*)&ssGetStopRequested(S));
if (ssGetStopRequested(S)) return;
}
/* Setup the task times and sample hit flags for the discrete rates */
rsimUpdateDiscreteTaskTimesAndSampleHits(S);
if (ssGetErrorStatus(S) != NULL) return;
/*
* See if we are at an outputTime, and if so set logOutput to true and
* increment the next output time index to point to the next entry in
* the outputTimes array.
*/
if ( ssGetNumOutputTimes(S) > 0 &&
ssGetOutputTimesIndex(S) < ssGetNumOutputTimes(S) ) {
time_T nextOutputTime = ssGetNextOutputTime(S);
/* utAssert(currTime <= nextOutputTime); */
if (currTime == nextOutputTime) {
uint_T idx = ssGetOutputTimesIndex(S);
ssSetOutputTimesIndex(S, idx+1);
logOutput = 1; /* this is one of the specified output times */
}
}
ssSetLogOutput(S, logOutput);
MdlOutputs(0);
if (gblExtModeEnabled) {
rtExtModeSingleTaskUpload(S);
}
if (ssGetLogOutput(S)) {
(void)rt_UpdateTXYLogVars(ssGetRTWLogInfo(S), ssGetTPtr(S));
if (ssGetErrorStatus(S) != NULL) return;
}
MdlUpdate(0);
if (ssGetErrorStatus(S) != NULL) return;
ssSetLogOutput(S, FALSE);
ssSetTimeOfLastOutput(S, currTime);
/* Update the timing engine and determine the solver stop time */
rsimUpdateTimingEngineAndSolverStopTime(S);
if (ssGetErrorStatus(S) != NULL) return;
if (gblExtModeEnabled) {
rtExtModeCheckEndTrigger();
}
return;
} /* rsimOutputLogUpdate */
/* 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 */
