app.c

Go to the documentation of this file.

 
//STM Remote Module
#include "ObjDict.h"
#include "states.h"
#include "app.h"
#include "main.h"
 
#include "can_stm.h"
 
//Application Specific
volatile UNS8 f_syncPulse = 0;
 
void initAppTask( void )
{
    //Initialize any required variables or peripherals here
}
 
void updateAppTask()
{
    //This function gets called in the main.c while loop
 
    UNS32 i = 0x00;
 
    runAppTask(i);
}
 
void runAppTask( UNS32 param )
{
    // Rate limit the task so its not running constantly
    static UNS8 taskDelaySecsApp = 1; // Can be linked to the OD
    static UNS32 tDelayRefApp = 0;
    CO_Data * d = &ObjDict_Data;
 
    if( !isTimedOut( &tDelayRefApp, TIMEOUT_sec( taskDelaySecsApp ) ) )
    {
        return;
    }
    //ELSE.. reading delay is over
    resetTimeOut( &tDelayRefApp );
 
    // Continue onto do the rest of the application task
    // Update or read from the OD to cause changes in program
 
    if(f_syncPulse){
        // Runs on sync pulse in the main application loop
        // Can either process sync pulse in the applicaiton, or in processSYNCMessageForApp
        f_syncPulse = 0;
    }
    
    
    switch( d->nodeState )
    {
        case Waiting:
            break;
        case Stopped:
            break;
        case Mode_Patient_Control:
            break;
        case Mode_Patient_Manual:
            break;
        case Mode_X_Manual:
            break;
        case Mode_Produce_X_Manual:
            break;
        case Mode_Y_Manual:
            break;
        case Mode_Record_X:
            break;
        default:
            break;
    }
}
 
void processSYNCMessageForApp(Message* m)
{
    // syncPulse is included as an example of setting a flag
    // to be used in the app task and is not required for functionality
    f_syncPulse = 1;
}
 
void sleepApplication(void)
{
 
}
 
void InitAppTaskValues(void)
{
    f_syncPulse = 0;
}
 
void StartNodesFunc(CO_Data* d, Message *m)
{
  if ( d->nodeState == Hibernate)
    setState(d,Waiting);
  else
    setState(d,Unknown_state);
}
 
void StopNodesFunc(CO_Data* d, Message *m)
{
  //no restrictions on state entry
  setState(d,Stopped);
  InitAppTaskValues();
}
 
void EnterWaitingFunc(CO_Data* d, Message *m)
{
  //no restrictions on state entry
  setState(d,Waiting);
  StopWatchDog( d );
  InitAppTaskValues();
}
 
void EnterPatientOperationFunc(CO_Data* d, Message *m)
{
  if (d->nodeState == Waiting && (*m).data[1] == 0) //must be NMT broadcast and in waiting
  {
    setState(d, Mode_Patient_Control);
  }
}
 
void EnterXManualFunc(CO_Data* d, Message *m)
{
  if (d->nodeState == Waiting) //must be in waiting
  {
    setState(d, Mode_X_Manual);
    StartWatchDog(d, 10000);
  }
}
 
void EnterYManualFunc(CO_Data* d, Message *m)
{
  if (d->nodeState == Waiting) //must be in waiting
  {
    setState(d, Mode_Y_Manual);
    StartWatchDog(d, 10000);
  }
}
 
void EnterStopStimFunc(CO_Data* d, Message *m)
{
  //no restrictions on state entry
  setState(d, Stopped);
  InitAppTaskValues();
}
 
void EnterPatientManualFunc(CO_Data* d, Message *m)
{
  if (d->nodeState == Waiting && (*m).data[1] == 0) //must be NMT broadcast and in waiting
  {
    setState(d, Mode_Patient_Manual);
    StartWatchDog(d, 10000);
  }
}
 
void EnterProduceXManualFunc(CO_Data* d, Message *m)
{
  if (d->nodeState == Waiting && (*m).data[1] == 0) //must be NMT broadcast and in waiting
  {
     setState(d, Mode_Produce_X_Manual);
  }
}
 
void EnterRecordXFunc(CO_Data* d, Message *m)
{
  if (d->nodeState == Waiting)  //must be in waiting
  {
    setState(d, Mode_Record_X);
  }
}