Index: firmware/App/Modes/OperationModes.c =================================================================== diff -u -rd5574e12aa9638c933d11b9bee8d5cf024864440 -r410afd26b3ae5e372310c696c82f58c59235e10d --- firmware/App/Modes/OperationModes.c (.../OperationModes.c) (revision d5574e12aa9638c933d11b9bee8d5cf024864440) +++ firmware/App/Modes/OperationModes.c (.../OperationModes.c) (revision 410afd26b3ae5e372310c696c82f58c59235e10d) @@ -15,52 +15,59 @@ * ***************************************************************************/ + #include "Messaging.h" #include "ModeInitPOST.h" #include "ModeFault.h" +#include "ModeGenPermeateDefeatured.h" +#include "ModePreGenPermeateDefeatured.h" +#include "ModeGenPermeate.h" +#include "ModePreGenPermeate.h" #include "ModeStandby.h" -#include "ModeWaterGen.h" -#include "ModeWaterPreGen.h" #include "OperationModes.h" #include "TaskGeneral.h" /** - * @addtogroup ROOperationModes + * @addtogroup FPOperationModes * @{ */ // ********** private definitions ********** -#define BROADCAST_TD_OP_MODE_INTERVAL ( 250 / TASK_GENERAL_INTERVAL ) ///< RO operation mode broadcast interval (in task interval/sec). +#define BROADCAST_TD_OP_MODE_INTERVAL ( 250 / TASK_GENERAL_INTERVAL ) ///< FP operation mode broadcast interval (in task interval/sec). #define DATA_PUBLISH_COUNTER_START_COUNT 11 ///< Data publish counter start count. // ********** private data ********** -static volatile BOOL modeRequest[ NUM_OF_RO_MODES - 1 ]; ///< Pending operation mode change requests. -static RO_OP_MODE_T lastMode; ///< Last operation mode prior to current mode. -static RO_OP_MODE_T currentMode; ///< Current operation mode. +static volatile BOOL modeRequest[ NUM_OF_FP_MODES - 1 ]; ///< Pending operation mode change requests. +static FP_OP_MODE_T lastMode; ///< Last operation mode prior to current mode. +static FP_OP_MODE_T currentMode; ///< Current operation mode. static U32 currentSubMode; ///< The currently active state of the active mode. static U32 broadcastModeIntervalCtr; ///< Interval counter used to determine when to broadcast operation mode. Initialize to 11 to stagger broadcast. static U32 currentSubState; ///< current sub state. static U32 current4thLevelState; ///< current 4th level state. +static BOOL isDeviceDefeatured; ///< bool to determine defeatured status +static BOOL isBoostInstalled; ///< bool to determine boost pump status /// Interval (in task intervals) at which to publish operation mode data to CAN bus. static OVERRIDE_U32_T opModePublishInterval = { BROADCAST_TD_OP_MODE_INTERVAL, BROADCAST_TD_OP_MODE_INTERVAL, BROADCAST_TD_OP_MODE_INTERVAL, 0 }; /// This matrix determines legal transitions from one mode to another -static const RO_OP_MODE_T MODE_TRANSITION_TABLE[ NUM_OF_RO_MODES - 1 ][ NUM_OF_RO_MODES - 1 ] = { -// From to-> FAULT SERVICE INIT STANBY PGEN GENW -/* FAUL */{ RO_MODE_FAUL, RO_MODE_SERV, RO_MODE_NLEG, RO_MODE_NLEG, RO_MODE_NLEG, RO_MODE_NLEG }, -/* SERV */{ RO_MODE_FAUL, RO_MODE_SERV, RO_MODE_NLEG, RO_MODE_NLEG, RO_MODE_NLEG, RO_MODE_NLEG }, -/* INIT */{ RO_MODE_FAUL, RO_MODE_NLEG, RO_MODE_INIT, RO_MODE_STAN, RO_MODE_NLEG, RO_MODE_NLEG }, -/* STAN */{ RO_MODE_FAUL, RO_MODE_SERV, RO_MODE_NLEG, RO_MODE_STAN, RO_MODE_NLEG, RO_MODE_GENW }, -/* PGEN */{ RO_MODE_FAUL, RO_MODE_NLEG, RO_MODE_NLEG, RO_MODE_STAN, RO_MODE_PGEN, RO_MODE_GENW }, -/* GENW */{ RO_MODE_FAUL, RO_MODE_NLEG, RO_MODE_NLEG, RO_MODE_STAN, RO_MODE_NLEG, RO_MODE_GENW } }; +static const FP_OP_MODE_T MODE_TRANSITION_TABLE[ NUM_OF_FP_MODES - 1 ][ NUM_OF_FP_MODES - 1 ] = { +// From to-> FAULT SERVICE INIT STANBY PGEN GENW DPGW DEGW +/* FAUL */{ FP_MODE_FAUL, FP_MODE_SERV, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_NLEG }, +/* SERV */{ FP_MODE_FAUL, FP_MODE_SERV, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_NLEG }, +/* INIT */{ FP_MODE_FAUL, FP_MODE_NLEG, FP_MODE_INIT, FP_MODE_STAN, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_NLEG }, +/* STAN */{ FP_MODE_FAUL, FP_MODE_SERV, FP_MODE_NLEG, FP_MODE_STAN, FP_MODE_NLEG, FP_MODE_GENP, FP_MODE_NLEG, FP_MODE_DEGW }, +/* PGEN */{ FP_MODE_FAUL, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_STAN, FP_MODE_PGEN, FP_MODE_GENP, FP_MODE_NLEG, FP_MODE_NLEG }, +/* GENW */{ FP_MODE_FAUL, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_STAN, FP_MODE_NLEG, FP_MODE_GENP, FP_MODE_NLEG, FP_MODE_NLEG }, +/* DPGW */{ FP_MODE_FAUL, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_STAN, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_DPGW, FP_MODE_DEGW }, +/* DEGW */{ FP_MODE_FAUL, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_STAN, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_NLEG, FP_MODE_DEGW } }; // ********** private function prototypes ********** -static RO_OP_MODE_T arbitrateModeRequest( void ); -static void transitionToNewOperationMode( RO_OP_MODE_T newMode ); +static FP_OP_MODE_T arbitrateModeRequest( void ); +static void transitionToNewOperationMode( FP_OP_MODE_T newMode ); static void broadcastOperationMode( void ); /*********************************************************************//** @@ -75,41 +82,43 @@ U32 i; // Initialize mode requests to none pending - for ( i = 0; i < ( NUM_OF_RO_MODES - 1 ); i++ ) + for ( i = 0; i < ( NUM_OF_FP_MODES - 1 ); i++ ) { modeRequest[ i ] = FALSE; } // Start in init mode - lastMode = RO_MODE_INIT; - currentMode = RO_MODE_INIT; + lastMode = FP_MODE_INIT; + currentMode = FP_MODE_INIT; currentSubMode = 0; currentSubState = NO_SUB_STATE; current4thLevelState = NO_SUB_STATE; broadcastModeIntervalCtr = DATA_PUBLISH_COUNTER_START_COUNT; + isDeviceDefeatured = FALSE; + isBoostInstalled = FALSE; - transitionToNewOperationMode( RO_MODE_INIT ); + transitionToNewOperationMode( FP_MODE_INIT ); // Call initializers for the individual modes initFaultMode(); // initServiceMode(); initInitAndPOSTMode(); initStandbyMode(); - initPreGenWMode(); - initGenWaterMode(); + initPreGenPMode(); + initGenPermeateMode(); } /*********************************************************************//** * @brief * The execOperationModes function executes the Operation Modes state machine. - * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if current mode is invalid. + * @details \b Alarm: ALARM_ID_FP_SOFTWARE_FAULT if current mode is invalid. * @details \b Inputs: none * @details \b Outputs: currentMode is set by state machine. * @return none *************************************************************************/ void execOperationModes( void ) { - RO_OP_MODE_T newMode; + FP_OP_MODE_T newMode; U32 priorSubMode = currentSubMode; U32 priorSubState = currentSubState; U32 prior4thLevelState = current4thLevelState; @@ -119,7 +128,7 @@ newMode = MODE_TRANSITION_TABLE[ currentMode ][ newMode ]; // Is requested new mode valid and legal at this time? - if ( ( newMode >= RO_MODE_NLEG ) && ( isTestingActivated() != TRUE ) ) + if ( ( newMode >= FP_MODE_NLEG ) && ( isTestingActivated() != TRUE ) ) { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_TD_SOFTWARE_FAULT, SW_FAULT_ID_OP_MODES_ILLEGAL_MODE_TRANSITION_REQUESTED, newMode ) newMode = currentMode; @@ -138,33 +147,33 @@ // Mode specific processing to be done continuously switch ( currentMode ) { - case RO_MODE_FAUL: + case FP_MODE_FAUL: currentSubMode = execFaultMode(); break; - case RO_MODE_SERV: + case FP_MODE_SERV: // currentSubMode = execServiceMode(); break; - case RO_MODE_INIT: + case FP_MODE_INIT: currentSubMode = execInitAndPOSTMode(); break; - case RO_MODE_STAN: + case FP_MODE_STAN: currentSubMode = execStandbyMode(); break; - case RO_MODE_PGEN: - currentSubMode = execPreGenWMode(); + case FP_MODE_PGEN: + currentSubMode = execPreGenPMode(); break; - case RO_MODE_GENW: - currentSubMode = execGenWaterMode(); + case FP_MODE_GENP: + currentSubMode = execGenPermeateMode(); break; default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_OP_MODES_INVALID_MODE_STATE, currentMode ) - currentMode = RO_MODE_FAUL; + currentMode = FP_MODE_FAUL; currentSubMode = 0; break; } // End switch @@ -175,7 +184,7 @@ #endif { // sendOperationStatusEvent(); - SEND_EVENT_WITH_2_U32_DATA( RO_EVENT_SUB_MODE_CHANGE, priorSubMode, currentSubMode ) + SEND_EVENT_WITH_2_U32_DATA( FP_EVENT_SUB_MODE_CHANGE, priorSubMode, currentSubMode ) } // Broadcast current operation mode on interval @@ -187,15 +196,15 @@ * The requestNewOperationMode function requests transition to a new * operation mode. The request will be arbitrated when the state machine * is next executed. - * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given new mode is invalid. + * @details \b Alarm: ALARM_ID_FP_SOFTWARE_FAULT if given new mode is invalid. * @details \b Inputs: none * @details \b Outputs: modeRequest[] * @return none *************************************************************************/ -void requestNewOperationMode( RO_OP_MODE_T newMode ) +void requestNewOperationMode( FP_OP_MODE_T newMode ) { // Validate requested mode - if ( newMode < RO_MODE_NLEG ) + if ( newMode < FP_MODE_NLEG ) { // Make request modeRequest[ newMode ] = TRUE; @@ -213,7 +222,7 @@ * @details \b Outputs: none * @return the current operation mode *************************************************************************/ -RO_OP_MODE_T getCurrentOperationMode( void ) +FP_OP_MODE_T getCurrentOperationMode( void ) { return currentMode; } @@ -225,7 +234,7 @@ * @details \b Outputs: none * @return the previous operation mode *************************************************************************/ -RO_OP_MODE_T getPreviousOperationMode( void ) +FP_OP_MODE_T getPreviousOperationMode( void ) { return lastMode; } @@ -252,26 +261,26 @@ * @details \b Outputs: modeRequest[] is reset * @return the next operation mode (current mode if no requests pending) *************************************************************************/ -static RO_OP_MODE_T arbitrateModeRequest( void ) +static FP_OP_MODE_T arbitrateModeRequest( void ) { - RO_OP_MODE_T reqMode = currentMode; + FP_OP_MODE_T reqMode = currentMode; U32 i; // Block additional requests until after mode arbitration _disable_IRQ(); // Select highest priority mode request -or- current mode if no requests pending - for ( i = 0; i < RO_MODE_NLEG; i++ ) + for ( i = 0; i < FP_MODE_NLEG; i++ ) { if ( modeRequest[ i ] != FALSE ) { - reqMode = (RO_OP_MODE_T)i; + reqMode = (FP_OP_MODE_T)i; break; } } // Clear all requests now that an arbitration winner is selected - for ( i = 0; i < RO_MODE_NLEG; i++ ) + for ( i = 0; i < FP_MODE_NLEG; i++ ) { modeRequest[ i ] = FALSE; } @@ -286,40 +295,49 @@ * @brief * The transitionToNewOperationMode function calls the transition to function * for a new operation mode that we are transitioning to. - * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given new mode is invalid. + * @details \b Alarm: ALARM_ID_FP_SOFTWARE_FAULT if given new mode is invalid. * @details \b Inputs: none * @details \b Outputs: transition function called for new mode * @return none *************************************************************************/ -static void transitionToNewOperationMode( RO_OP_MODE_T newMode ) +static void transitionToNewOperationMode( FP_OP_MODE_T newMode ) { // Setup for new operating mode switch ( newMode ) { - case RO_MODE_FAUL: + case FP_MODE_FAUL: currentSubMode = transitionToFaultMode(); break; - case RO_MODE_SERV: + case FP_MODE_SERV: // currentSubMode = transitionToServiceMode(); break; - case RO_MODE_INIT: + case FP_MODE_INIT: currentSubMode = transitionToInitAndPOSTMode(); break; - case RO_MODE_STAN: + case FP_MODE_STAN: currentSubMode = transitionToStandbyMode(); break; - case RO_MODE_PGEN: - currentSubMode = transitionToPreGenWMode(); + case FP_MODE_PGEN: + currentSubMode = transitionToPreGenPMode(); break; - case RO_MODE_GENW: - currentSubMode = transitionToGenWaterMode(); + case FP_MODE_GENP: + currentSubMode = transitionToGenPermeateMode(); break; + case FP_MODE_DPGW: + //currentSubMode = transitionToPreGenWMode(); + break; + + case FP_MODE_DEGW: + //currentSubMode = transitionToGenWaterMode(); + break; + + default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_FP_SOFTWARE_FAULT, SW_FAULT_ID_OP_MODES_INVALID_MODE_TO_TRANSITION_TO, newMode ) break; @@ -331,7 +349,7 @@ * The broadcastOperationMode function sends the current operation mode at * the prescribed interval. * @details \b Inputs: broadcastModeIntervalCtr - * @details \b Outputs: RO operation mode broadcast message sent. + * @details \b Outputs: FP operation mode broadcast message sent. * @return none *************************************************************************/ static void broadcastOperationMode( void ) @@ -343,7 +361,7 @@ broadcastModeIntervalCtr = 0; data.opMode = (U32)currentMode; data.subMode = currentSubMode; - broadcastData( MSG_ID_FP_OP_MODE_DATA, COMM_BUFFER_OUT_CAN_RO_BROADCAST, (U08*)&data, sizeof( OP_MODE_PAYLOAD_T ) ); + broadcastData( MSG_ID_FP_OP_MODE_DATA, COMM_BUFFER_OUT_CAN_FP_BROADCAST, (U08*)&data, sizeof( OP_MODE_PAYLOAD_T ) ); } } @@ -373,7 +391,33 @@ current4thLevelState = state; } +/*********************************************************************//** + * @brief + * The getDefeatured function returns if the Leahi device is defeatured. + * @details \b Inputs: none + * @details \b Outputs: none + * @return the current state of standby mode. + *************************************************************************/ +BOOL isDefeatured( void ) +{ + // TODO - pull status from NV mem. + return isDeviceDefeatured; +} +/*********************************************************************//** + * @brief + * The isBoostPumpInstalled function returns if the Leahi device + * has a boost pump installed. + * @details \b Inputs: none + * @details \b Outputs: none + * @return the current state of standby mode. + *************************************************************************/ +BOOL isBoostPumpInstalled( void ) +{ + // TODO - pull status from NV mem. + return isBoostInstalled; +} + /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ @@ -399,9 +443,9 @@ U32 newMode; memcpy( &newMode, message->payload, sizeof( U32 ) ); - if ( (RO_OP_MODE_T)newMode < NUM_OF_RO_MODES ) + if ( (FP_OP_MODE_T)newMode < NUM_OF_FP_MODES ) { - RO_OP_MODE_T reqMode = (RO_OP_MODE_T)newMode; + FP_OP_MODE_T reqMode = (FP_OP_MODE_T)newMode; requestNewOperationMode( reqMode ); result = TRUE;