Index: firmware/App/Modes/OperationModes.c =================================================================== diff -u -reb877ae36c28eb83553ee11ccccf42e2c4a5b4d2 -rf30a99b478605fd52e1048c826906bf4a73a9bdf --- firmware/App/Modes/OperationModes.c (.../OperationModes.c) (revision eb877ae36c28eb83553ee11ccccf42e2c4a5b4d2) +++ firmware/App/Modes/OperationModes.c (.../OperationModes.c) (revision f30a99b478605fd52e1048c826906bf4a73a9bdf) @@ -1,299 +1,503 @@ /************************************************************************** - * - * Copyright (c) 2019-2019 Diality Inc. - All Rights Reserved. - * - * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN - * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. - * - * @file OperationModes.c - * - * @date 19-Sep-2019 - * @author S. Nash - * - * @brief Top-level state machine for the HD operation modes. - * - **************************************************************************/ +* +* Copyright (c) 2019-2023 Diality Inc. - All Rights Reserved. +* +* THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +* WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +* +* @file OperationModes.c +* +* @author (last) Dara Navaei +* @date (last) 17-Jan-2023 +* +* @author (original) Dara Navaei +* @date (original) 05-Nov-2019 +* +***************************************************************************/ #include "gio.h" -#include "Common.h" -#include "OperationModes.h" - +#include "MessageSupport.h" +#include "ModeChemicalDisinfect.h" +#include "ModeChemicalDisinfectFlush.h" +#include "ModeDrain.h" +#include "ModeFault.h" +#include "ModeFill.h" +#include "ModeFlush.h" +#include "ModeGenIdle.h" +#include "ModeHeatDisinfect.h" +#include "ModeHeatDisinfectActiveCool.h" #include "ModeInitPOST.h" #include "ModeService.h" -#include "ModeFault.h" +#include "ModeSolo.h" #include "ModeStandby.h" -#include "ModePrescription.h" -#include "ModeOpParams.h" -#include "ModePreTreat.h" -#include "ModeTreatment.h" -#include "ModePostTreat.h" +#include "NVDataMgmt.h" +#include "OperationModes.h" +#include "ROPump.h" +#include "SystemCommMessages.h" +#include "TaskGeneral.h" +/** + * @addtogroup DGOperationModes + * @{ + */ + +// ********** private definitions ********** + +#define BROADCAST_DG_OP_MODE_INTERVAL ( 250 / TASK_GENERAL_INTERVAL ) ///< interval (ms/task time) at which the operation mode is published on the CAN bus. +// The data publish counter offset is a lower number to make sure DG is sending its status to the HD from the beginning and alarm 140 is not raised +#define DATA_PUBLISH_COUNTER_START_COUNT 2 ///< Data publish counter start count. + // ********** private data ********** -static volatile BOOL modeRequest[NUM_OF_MODES - 1]; -static OP_MODE currentMode = MODE_INIT; +static volatile BOOL modeRequest[ NUM_OF_DG_MODES - 1 ]; ///< Array of mode request flags. +static DG_OP_MODE_T lastMode; ///< Last operation mode prior to current mode. +static DG_OP_MODE_T currentMode; ///< The currently active mode. +static U32 currentSubMode; ///< The currently active state of the active mode. +/// DG operation mode data publish interval. +static OVERRIDE_U32_T dgOpModePublishInterval = { BROADCAST_DG_OP_MODE_INTERVAL, BROADCAST_DG_OP_MODE_INTERVAL, 0, 0 }; +static U32 dataPublishCounter; ///< Interval counter used to determine when to broadcast operation mode. Initialize to 11 to stagger broadcast. -// this matrix determines legal transitions from one mode to another -static const OP_MODE MODE_TRANSITION_TABLE[NUM_OF_MODES - 1][NUM_OF_MODES - 1] = { -// from to-> FAULT SERVICE INIT STANBY PRESCRIP. OP.PARAMS PRE-TREAT TREATMENT POST_TREA - /* FAUL */{ MODE_FAUL, MODE_SERV, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, - MODE_NLEG, }, - /* SERV */{ MODE_FAUL, MODE_SERV, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, - MODE_NLEG, }, - /* INIT */{ MODE_FAUL, MODE_NLEG, MODE_INIT, MODE_STAN, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, - MODE_NLEG, }, - /* STAN */{ MODE_FAUL, MODE_SERV, MODE_NLEG, MODE_STAN, MODE_PRES, MODE_NLEG, MODE_NLEG, MODE_NLEG, - MODE_NLEG, }, - /* PRES */{ MODE_FAUL, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_PRES, MODE_OPAR, MODE_NLEG, MODE_NLEG, - MODE_NLEG, }, - /* OPAR */{ MODE_FAUL, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_PRES, MODE_OPAR, MODE_PRET, MODE_NLEG, - MODE_NLEG, }, - /* PRET */{ MODE_FAUL, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_PRET, MODE_TREA, - MODE_NLEG, }, - /* TREA */{ MODE_FAUL, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_TREA, - MODE_POST, }, - /* POST */{ MODE_FAUL, MODE_NLEG, MODE_NLEG, MODE_STAN, MODE_NLEG, MODE_NLEG, MODE_NLEG, MODE_NLEG, - MODE_POST, }, }; +/// This matrix determines legal transitions from one mode to another. +static const DG_OP_MODE_T MODE_TRANSITION_TABLE[ NUM_OF_DG_MODES - 1 ][ NUM_OF_DG_MODES - 1 ] = +{ + // from to-> FAULT SERVICE INIT STANBY STBY-SOLO GEN-IDLE FILL DRAIN FLUSH HEAT DIS CHEM DIS CHEM_FLUSH HEAT_COOL + /* FAUL */{ DG_MODE_FAUL, DG_MODE_SERV, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG }, + /* SERV */{ DG_MODE_FAUL, DG_MODE_SERV, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG }, + /* INIT */{ DG_MODE_FAUL, DG_MODE_NLEG, DG_MODE_INIT, DG_MODE_STAN, DG_MODE_SOLO, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG }, + /* STAN */{ DG_MODE_FAUL, DG_MODE_SERV, DG_MODE_INIT, DG_MODE_STAN, DG_MODE_SOLO, DG_MODE_GENE, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_FLUS, DG_MODE_HEAT, DG_MODE_CHEM, DG_MODE_CHFL, DG_MODE_HCOL }, + /* SOLO */{ DG_MODE_FAUL, DG_MODE_SERV, DG_MODE_INIT, DG_MODE_STAN, DG_MODE_SOLO, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_FLUS, DG_MODE_HEAT, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG }, + /* GENE */{ DG_MODE_FAUL, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_STAN, DG_MODE_NLEG, DG_MODE_GENE, DG_MODE_FILL, DG_MODE_DRAI, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG }, + /* FILL */{ DG_MODE_FAUL, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_STAN, DG_MODE_NLEG, DG_MODE_GENE, DG_MODE_FILL, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG }, + /* DRAI */{ DG_MODE_FAUL, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_STAN, DG_MODE_NLEG, DG_MODE_GENE, DG_MODE_NLEG, DG_MODE_DRAI, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG }, + /* FLUS */{ DG_MODE_FAUL, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_STAN, DG_MODE_SOLO, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_FLUS, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG }, + /* HEAT */{ DG_MODE_FAUL, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_STAN, DG_MODE_SOLO, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_HEAT, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_HCOL }, + /* CHEM */{ DG_MODE_FAUL, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_STAN, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_CHEM, DG_MODE_CHFL, DG_MODE_NLEG }, + /* CHFL */{ DG_MODE_FAUL, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_STAN, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_CHFL, DG_MODE_NLEG }, + /* HCOL */{ DG_MODE_FAUL, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_STAN, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_NLEG, DG_MODE_HCOL }, +}; // ********** private function prototypes ********** -static OP_MODE arbitrateModeRequest( void ); -static void transitionToNewOperationMode( OP_MODE newMode ); +static DG_OP_MODE_T arbitrateModeRequest( void ); +static void transitionToNewOperationMode( DG_OP_MODE_T newMode ); +static U32 getDGOpModePublishInterval( void ); +static void broadcastOperationMode( void ); -/************************************************************************* - * @brief execOperationModes - * The execOperationModes function initializes the Operation Modes module. - * @details - * Inputs : none - * Outputs : Operation Modes module initialized. - * @param none +/*********************************************************************//** + * @brief + * The initOperationModes function initializes the operation modes module. + * @details Inputs: none + * @details Outputs: modeRequest, lastMode, currentMode, currentSubMode, + * dataPublishCounter * @return none *************************************************************************/ void initOperationModes( void ) { U32 i; // initialize mode requests to none pending - for ( i = 0; i < ( NUM_OF_MODES - 1 ); i++ ) + for ( i = 0; i < ( NUM_OF_DG_MODES - 1 ); i++ ) { - modeRequest[i] = FALSE; + modeRequest[ i ] = FALSE; } // start in init mode - currentMode = MODE_INIT; - transitionToNewOperationMode( MODE_INIT ); + lastMode = DG_MODE_INIT; + currentMode = DG_MODE_INIT; + currentSubMode = 0; + dataPublishCounter = DATA_PUBLISH_COUNTER_START_COUNT; + transitionToNewOperationMode( DG_MODE_INIT ); + // call initializers for the individual modes initFaultMode(); initServiceMode(); initInitAndPOSTMode(); initStandbyMode(); - initPrescriptionMode(); - initOpParamsMode(); - initPreTreatmentMode(); - initTreatmentMode(); - initPostTreatmentMode(); + initSoloMode(); + initGenIdleMode(); + initFillMode(); + initDrainMode(); + initFlushMode(); + initHeatDisinfectMode(); + initChemicalDisinfectMode(); + initHeatDisinfectActiveCoolMode(); + initChemicalDisinfectFlushMode(); } -/************************************************************************* - * @brief execOperationModes - * The execOperationModes function executes the Operation Modes state machine. - * @details - * Inputs : none - * Outputs : currentMode is set by state machine. - * @param none +/*********************************************************************//** + * @brief + * The execOperationModes function executes the operation modes state machine. + * @details Inputs: currentMode + * @details Outputs: Operation modes' state machine executed * @return none *************************************************************************/ void execOperationModes( void ) { - OP_MODE newMode; + DG_OP_MODE_T newMode; + U32 priorSubMode = currentSubMode; + // any new mode requests? newMode = arbitrateModeRequest(); // will return current mode if no pending requests - newMode = MODE_TRANSITION_TABLE[currentMode][newMode]; + newMode = MODE_TRANSITION_TABLE[ currentMode ][ newMode ]; // is requested new mode valid and legal at this time? - if ( newMode >= MODE_NLEG ) + if ( newMode >= DG_MODE_NLEG ) { - // TODO - s/w fault + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_OP_MODES_ILLEGAL_MODE_TRANSITION_REQUESTED, (U32)newMode ) newMode = currentMode; } // has mode changed? if ( currentMode != newMode ) { // handle transition to new mode + lastMode = currentMode; transitionToNewOperationMode( newMode ); currentMode = newMode; } // mode specific processing to be done continuously switch ( currentMode ) { - case MODE_FAUL: - execFaultMode(); + case DG_MODE_FAUL: + currentSubMode = execFaultMode(); break; - case MODE_SERV: - execServiceMode(); + case DG_MODE_SERV: + currentSubMode = execServiceMode(); break; - case MODE_INIT: - execInitAndPOSTMode(); + case DG_MODE_INIT: + currentSubMode = execInitAndPOSTMode(); break; - case MODE_STAN: - execStandbyMode(); + case DG_MODE_STAN: + currentSubMode = execStandbyMode(); break; - case MODE_PRES: - execPrescriptionMode(); + case DG_MODE_SOLO: + currentSubMode = execSoloMode(); break; - case MODE_OPAR: - execOpParamsMode(); + case DG_MODE_GENE: + currentSubMode = execGenIdleMode(); break; - case MODE_PRET: - execPreTreatmentMode(); + case DG_MODE_FILL: + currentSubMode = execFillMode(); break; - case MODE_TREA: - execTreatmentMode(); + case DG_MODE_DRAI: + currentSubMode = execDrainMode(); break; - case MODE_POST: - execPostTreatmentMode(); + case DG_MODE_FLUS: + currentSubMode = execFlushMode(); break; + case DG_MODE_HEAT: + currentSubMode = execHeatDisinfectMode(); + break; + + case DG_MODE_CHEM: + currentSubMode = execChemicalDisinfectMode(); + break; + + case DG_MODE_HCOL: + currentSubMode = execHeatDisinfectActiveCoolMode(); + break; + + case DG_MODE_CHFL: + currentSubMode = execChemicalDisinfectFlushMode(); + break; + default: - currentMode = MODE_FAUL; - // TODO - trigger s/w fault + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_OP_MODES_INVALID_MODE_STATE, (U32)currentMode ) + currentMode = DG_MODE_FAUL; + currentSubMode = 0; break; - } // end switch + } + + // Send sub-mode change event when appropriate + if ( priorSubMode != currentSubMode ) + { + SEND_EVENT_WITH_2_U32_DATA( DG_EVENT_SUB_MODE_CHANGE, priorSubMode, currentSubMode ) + } + + // publish op mode on interval + broadcastOperationMode(); } -/************************************************************************* - * @brief requestNewOperationMode - * The requestNewOperationMode function initializes the Operation Modes module. - * @details - * Inputs : none - * Outputs : Initializes the Operation Modes module. - * @param none +/*********************************************************************//** + * @brief + * The requestNewOperationMode function requests a new operation mode. + * @details Inputs: none + * @details Outputs: makes the requested mode "pending" + * @param newMode requested mode * @return none *************************************************************************/ -void requestNewOperationMode( OP_MODE newMode ) +void requestNewOperationMode( DG_OP_MODE_T newMode ) { // validate requested mode - if ( newMode < MODE_NLEG ) + if ( newMode < DG_MODE_NLEG ) { // make request - modeRequest[newMode] = TRUE; + modeRequest[ newMode ] = TRUE; } else { // invalid mode requested - // TODO - trigger s/w fault + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_OP_MODES_INVALID_MODE_REQUESTED, (U32)newMode ) } } -/************************************************************************* - * @brief getCurrentOperationMode - * The getCurrentOperationMode function initializes the Operation Modes module. - * @details - * Inputs : none - * Outputs : Initializes the Operation Modes module. - * @param none - * @return none +/*********************************************************************//** + * @brief + * The getCurrentOperationMode function returns the current operation mode. + * @details Inputs: none + * @details Outputs: none + * @return current mode *************************************************************************/ -OP_MODE getCurrentOperationMode( void ) +DG_OP_MODE_T getCurrentOperationMode( void ) { return currentMode; } -/************************************************************************* - * @brief arbitrateModeRequest - * The arbitrateModeRequest function initializes the Operation Modes module. - * @details - * Inputs : none - * Outputs : Initializes the Operation Modes module. - * @param none - * @return none +/*********************************************************************//** + * @brief + * The getPreviousOperationMode function gets the previous operation mode. + * @details Inputs: lastMode + * @details Outputs: none + * @return the previous operation mode *************************************************************************/ -static OP_MODE arbitrateModeRequest( void ) +DG_OP_MODE_T getPreviousOperationMode( void ) { - OP_MODE reqMode = currentMode; + return lastMode; +} + +/*********************************************************************//** + * @brief + * The arbitrateModeRequest function selects highest priority mode request + * and clear all requests. + * @details Inputs: none + * @details Outputs: Arbitrated mode requests + * @return highest priority requested mode + *************************************************************************/ +static DG_OP_MODE_T arbitrateModeRequest( void ) +{ + DG_OP_MODE_T reqMode = currentMode; U32 i; // block additional requests until after mode arbitration - // TODO - disable priority task + _disable_IRQ(); // select highest priority mode request -or- current mode if no requests pending - for ( i = 0; i < MODE_NLEG; i++ ) + for ( i = 0; i < DG_MODE_NLEG; i++ ) { if ( modeRequest[i] != FALSE ) { - reqMode = (OP_MODE)i; + reqMode = (DG_OP_MODE_T)i; break; } } // clear all requests now that an arbitration winner is selected - for ( i = 0; i < MODE_NLEG; i++ ) + for ( i = 0; i < DG_MODE_NLEG; i++ ) { modeRequest[i] = FALSE; } // un-block requests - // TODO - enable priority task + _enable_IRQ(); return reqMode; } -/************************************************************************* - * @brief transitionToNewOperationMode - * The transitionToNewOperationMode function initializes the Operation Modes module. - * @details - * Inputs : none - * Outputs : Initializes the Operation Modes module. - * @param none +/*********************************************************************//** + * @brief + * The transitionToNewOperationMode function undergo the process of transition + * to new operation mode. + * @details Inputs: none + * @details Outputs: Transition to new mode + * @param newMode new op mode to transition to * @return none *************************************************************************/ -static void transitionToNewOperationMode( OP_MODE newMode ) +static void transitionToNewOperationMode( DG_OP_MODE_T newMode ) { + SEND_EVENT_WITH_2_U32_DATA( DG_EVENT_OP_MODE_CHANGE, lastMode, newMode ) + // setup for new operating mode switch ( newMode ) { - case MODE_FAUL: - transitionToFaultMode(); + case DG_MODE_FAUL: + currentSubMode = transitionToFaultMode(); break; - case MODE_SERV: - transitionToServiceMode(); + case DG_MODE_SERV: + currentSubMode = transitionToServiceMode(); break; - case MODE_INIT: - transitionToInitAndPOSTMode(); + case DG_MODE_INIT: + currentSubMode = transitionToInitAndPOSTMode(); break; - case MODE_STAN: - transitionToStandbyMode(); + case DG_MODE_STAN: + currentSubMode = transitionToStandbyMode(); break; - case MODE_PRES: - transitionToPrescriptionMode(); + case DG_MODE_SOLO: + currentSubMode = transitionToSoloMode(); break; - case MODE_OPAR: - transitionToOpParamsMode(); + case DG_MODE_GENE: + currentSubMode = transitionToGenIdleMode(); break; - case MODE_PRET: - transitionToPreTreatmentMode(); + case DG_MODE_FILL: + currentSubMode = transitionToFillMode(); break; - case MODE_TREA: - transitionToTreatmentMode(); + case DG_MODE_DRAI: + currentSubMode = transitionToDrainMode(); break; - case MODE_POST: - transitionToPostTreatmentMode(); + case DG_MODE_FLUS: + currentSubMode = transitionToFlushMode(); break; + case DG_MODE_HEAT: + currentSubMode = transitionToHeatDisinfectMode(); + break; + case DG_MODE_CHEM: + currentSubMode = transitionToChemicalDisinfectMode(); + break; + case DG_MODE_HCOL: + currentSubMode = transitionToHeatDisinfectActiveCoolMode(); + break; + case DG_MODE_CHFL: + currentSubMode = transitionToChemicalDisinfectFlushMode(); + break; default: - // TODO - s/w fault + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DG_SOFTWARE_FAULT, SW_FAULT_ID_OP_MODES_INVALID_MODE_TO_TRANSITION_TO, (U32)newMode ) break; } } +/*********************************************************************//** + * @brief + * The broadcastOperationMode function broadcasts the current operation mode at + * the prescribed interval. + * @details Inputs: broadcastModeIntervalCtr + * @details Outputs: DG operation mode broadcast message sent + * @return none + *************************************************************************/ +static void broadcastOperationMode( void ) +{ + if ( ++dataPublishCounter >= getDGOpModePublishInterval() ) + { + OP_MODES_DATA_T data; + + data.currentMode = (U32)currentMode; + data.currentSubMode = currentSubMode; + + broadcastData( MSG_ID_DG_OP_MODE, COMM_BUFFER_OUT_CAN_DG_BROADCAST, (U08*)&data, sizeof( OP_MODES_DATA_T ) ); + + dataPublishCounter = 0; + } +} + +/*********************************************************************//** + * @brief + * The getDGOpModePublishInterval function gets the current DG operation mode + * data publish interval. + * @details Inputs: dgOpModePublishInterval + * @details Outputs: DG operation mode broadcast message sent + * @return none + *************************************************************************/ +static U32 getDGOpModePublishInterval( void ) +{ + U32 result = dgOpModePublishInterval.data; + + if ( OVERRIDE_KEY == dgOpModePublishInterval.override ) + { + result = dgOpModePublishInterval.ovData; + } + + return result; +} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testSetOperationMode function will transition to a given operation + * mode if the transition is legal. + * @details Inputs: MODE_TRANSITION_TABLE[][] + * @details Outputs: modeRequest[], result + * @param newMode ID of requested mode to transition to + * @return TRUE if request successful, FALSE if not + *************************************************************************/ +BOOL testSetOperationMode( DG_OP_MODE_T newMode ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + DG_OP_MODE_T check = MODE_TRANSITION_TABLE[ currentMode ][ newMode ]; + + // Is mode transition legal? + if ( check == newMode ) + { + requestNewOperationMode( newMode ); + result = TRUE; + } + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testSetDGOpModePublishIntervalOverride function overrides the + * DG operation mode publish interval. + * @details Inputs: none + * @details Outputs: dgOpModePublishInterval + * @param value override DG operation mode publish interval with (in ms) + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testSetDGOpModePublishIntervalOverride( U32 value ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + U32 intvl = value / TASK_GENERAL_INTERVAL; + + result = TRUE; + dgOpModePublishInterval.ovData = intvl; + dgOpModePublishInterval.override = OVERRIDE_KEY; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testResetDGOpModePublishIntervalOverride function resets the + * override of the DG operation mode publish interval. + * @details Inputs: none + * @details Outputs: dgOpModePublishInterval + * @return TRUE if override reset successful, FALSE if not + *************************************************************************/ +BOOL testResetDGOpModePublishIntervalOverride( void ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + dgOpModePublishInterval.override = OVERRIDE_RESET; + dgOpModePublishInterval.ovData = dgOpModePublishInterval.ovInitData; + } + + return result; +} + +/**@}*/