Index: firmware/App/Modes/ModeStandby.c =================================================================== diff -u -rfcbf16998f91c7c14ac952badfef65f3e012f160 -r2de8d8e0962237bc863ec0c8b69ac7e6ee50e9ff --- firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision fcbf16998f91c7c14ac952badfef65f3e012f160) +++ firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision 2de8d8e0962237bc863ec0c8b69ac7e6ee50e9ff) @@ -52,20 +52,25 @@ #define FLUSH_TIME_INTERVAL_S ( 30 * SEC_PER_MIN * MS_PER_SECOND ) ///< Flush time interval in seconds. #define MAX_ALLOWED_RO_FILTER_TEMP_FOR_TX_C 44.0F ///< Maximum allowed temperature to start a treatment in C. +/// DG cleaning mode status data structure +typedef struct +{ + BOOL startCleaningMode; ///< Flag to indicate to start cleaning mode. + DG_COMMAND_T startRequestCmdID; ///< DG cleaning mode start request command ID. + ALARM_ID_T alarmID; ///< The informative alarm to trigger for each cleaning mode. + DG_OP_MODE_T dgOpMode; ///< DG operation mode. + BOOL sampleAlarmTrgrd; ///< Flag to indicate the sample alarm has been triggered (for RO perm and chem flush). + GENERIC_CONFIRM_ID_T sampleRequestID; ///< Sample request pass/fail message status. + GENERIC_CONFIRM_ID_T stopRequestCmdID; ///< Stop DG cleaning request command ID +} DG_CLEANING_MODE_STATUS_T; + // ********** private data ********** static HD_STANDBY_STATE_T currentStandbyState; ///< Current state (sub-mode) of standby mode. static BOOL treatStartReqReceived; ///< Flag indicates user has requested initiation of a treatment. -static BOOL flushStartReqReceived; ///< Flag indicates user has requested initiation of flush mode. -static BOOL heatDisinfectStartReqReceived; ///< Flag indicates user has requested initiation of heat disinfect mode. -static BOOL chemDisinfectStartReqReceived; ///< Flag indicates user has requested initiation of chemical disinfect mode. -static BOOL chemDisinfectFlushStartReqReceived; ///< Flag indicates user has requested initiation of chemical disinfect flush mode. static GENERIC_CONFIRM_ID_T disinfectCancelReqID; ///< ID of requested cancel disinfect mode. -static DG_DISINFECT_STATE_T dgDisinfectState; ///< DG disinfect state to be boadcast to UI. -static U32 dataPublishCounter; ///< Disinfects data publish counter. static BOOL homingInitiated; ///< Boolean flag to indicate homing is initiated. -static BOOL hasChemFlushSampleAlarmBeenTrgrd; ///< Boolean flag to indicate whether chem flush sample alarm has been triggered or not. -static GENERIC_CONFIRM_ID_T chemFlushSampleID; ///< Chemical disinfect flush sample ID. +static DG_CLEANING_MODE_STATUS_T currentDGCleaningMode; ///< Current DG cleaning mode status. /// Interval (in task intervals) at which to publish standby mode data to CAN bus. static OVERRIDE_U32_T standbyModePublishInterval = { DISINFECTS_DATA_PUB_INTERVAL, DISINFECTS_DATA_PUB_INTERVAL, DISINFECTS_DATA_PUB_INTERVAL, 0 }; @@ -81,51 +86,30 @@ static HD_STANDBY_STATE_T handleStandbyModeWaitForTreatmentState( void ); static HD_STANDBY_STATE_T handleStandbyModeWaitForDisinfectState( void ); -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGFlushCmdResponseState( void ); -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGFlushToStartState( void ); -static HD_STANDBY_STATE_T handleStandbyModeDGFlushInProgressState( void ); +static HD_STANDBY_STATE_T handleStandbyModeWaitForDGCleaningModeCmdResponseState( void ); +static HD_STANDBY_STATE_T handleStandbyModeWaitForDGCleaningModeStartState( void ); +static HD_STANDBY_STATE_T handleStandbyModeDGCleaningModeInProgressState( void ); -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGHeatDisinfectCmdResponseState( void ); -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGHeatDisinfectStartState( void ); -static HD_STANDBY_STATE_T handleStandbyModeDGHeatDisinfectInProgressState( void ); - -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGChemDisinfectCmdResponseState( void ); -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGChemDisinfectStartState( void ); -static HD_STANDBY_STATE_T handleStandbyModeDGChemDisininfectInProgressState( void ); - -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGChemDisinfectFlushCmdResponseState( void ); -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGChemDisinfectFlushStartState( void ); -static HD_STANDBY_STATE_T handleStandbyModeDGChemDisininfectFlushInProgressState( void ); - +static void setRequestedCleaningMode( DG_OP_MODE_T opMode ); +static void clearCurrentCleaningModeStatus( void ); +static void handleChemFlushSampleCollection( void ); static BOOL isDGDisinfectValid( void ); static BOOL haveHDDGServicesBeenExpired( REQUEST_REJECT_REASON_CODE_T* rejReason ); -static void publishDisinfectData( void ); /*********************************************************************//** * @brief * The initStandbyMode function initializes the Standby Mode module. * @details Inputs: none * @details Outputs: currentStandbyState, treatStartReqReceived, - * flushStartReqReceived, dataPublishCounter, heatDisinfectStartReqReceived, - * chemDisinfectStartReqReceived, dgDisinfectState, homingInitiated, - * chemDisinfectFlushStartReqReceived, hasChemFlushSampleAlarmBeenTrgrd, - * chemFlushSampleID + * homingInitiated * @return none *************************************************************************/ void initStandbyMode( void ) { - currentStandbyState = STANDBY_START_STATE; - treatStartReqReceived = FALSE; - flushStartReqReceived = FALSE; - dataPublishCounter = 0; - heatDisinfectStartReqReceived = FALSE; - chemDisinfectStartReqReceived = FALSE; - chemDisinfectFlushStartReqReceived = FALSE; - disinfectCancelReqID = GENERIC_CONFIRM_ID_NONE; - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - homingInitiated = FALSE; - hasChemFlushSampleAlarmBeenTrgrd = FALSE; - chemFlushSampleID = GENERIC_CONFIRM_ID_NONE; + currentStandbyState = STANDBY_START_STATE; + treatStartReqReceived = FALSE; + disinfectCancelReqID = GENERIC_CONFIRM_ID_NONE; + homingInitiated = FALSE; } /*********************************************************************//** @@ -150,6 +134,7 @@ setVenousBubbleDetectionEnabled( FALSE ); setCurrentSubState( NO_SUB_STATE ); clearNoRetriggerFlag(); + clearCurrentCleaningModeStatus(); // Set user alarm recovery actions allowed in this mode setAlarmUserActionEnabled( ALARM_USER_ACTION_RESUME, FALSE ); @@ -228,54 +213,18 @@ currentStandbyState = handleStandbyModeWaitForDisinfectState(); break; - case STANDBY_WAIT_FOR_DG_FLUSH_CMD_RESPONSE_STATE: - currentStandbyState = handleStandbyModeWaitForDGFlushCmdResponseState(); + case STANDBY_WAIT_FOR_DG_CLEANING_MODE_CMD_RESPONSE_STATE: + currentStandbyState = handleStandbyModeWaitForDGCleaningModeCmdResponseState(); break; - case STANDBY_WAIT_FOR_DG_FLUSH_TO_START_STATE: - currentStandbyState = handleStandbyModeWaitForDGFlushToStartState(); + case STANDBY_WAIT_FOR_DG_CLEANING_MODE_TO_START_STATE: + currentStandbyState = handleStandbyModeWaitForDGCleaningModeStartState(); break; - case STANDBY_DG_FLUSH_IN_PROGRESS_STATE: - currentStandbyState = handleStandbyModeDGFlushInProgressState(); + case STANDBY_CLEANING_MODE_IN_PROGRESS_STATE: + currentStandbyState = handleStandbyModeDGCleaningModeInProgressState(); break; - case STANDBY_WAIT_FOR_DG_HEAT_DISINFECT_CMD_RESPONSE_STATE: - currentStandbyState = handleStandbyModeWaitForDGHeatDisinfectCmdResponseState(); - break; - - case STANDBY_WAIT_FOR_DG_HEAT_DISINFECT_TO_START_STATE: - currentStandbyState = handleStandbyModeWaitForDGHeatDisinfectStartState(); - break; - - case STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE: - currentStandbyState = handleStandbyModeDGHeatDisinfectInProgressState(); - break; - - case STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_CMD_RESPONSE_STATE: - currentStandbyState = handleStandbyModeWaitForDGChemDisinfectCmdResponseState(); - break; - - case STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_TO_START_STATE: - currentStandbyState = handleStandbyModeWaitForDGChemDisinfectStartState(); - break; - - case STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE: - currentStandbyState = handleStandbyModeDGChemDisininfectInProgressState(); - break; - - case STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_FLUSH_CMD_RESPONSE_STATE: - currentStandbyState = handleStandbyModeWaitForDGChemDisinfectFlushCmdResponseState(); - break; - - case STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_FLUSH_TO_START_STATE: - currentStandbyState = handleStandbyModeWaitForDGChemDisinfectFlushStartState(); - break; - - case STANDBY_DG_CHEM_DISINFECT_FLUSH_IN_PROGRESS_STATE: - currentStandbyState = handleStandbyModeDGChemDisininfectFlushInProgressState(); - break; - default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_STANDBY_INVALID_STATE, currentStandbyState ); currentStandbyState = STANDBY_START_STATE; @@ -420,10 +369,10 @@ { if ( TRUE == isDGCommunicating() ) { - flushStartReqReceived = TRUE; - result = TRUE; - currentStandbyState = STANDBY_WAIT_FOR_DISINFECT_STATE; - rejReason = REQUEST_REJECT_REASON_NONE; + setRequestedCleaningMode( DG_MODE_FLUS ); + result = TRUE; + currentStandbyState = STANDBY_WAIT_FOR_DISINFECT_STATE; + rejReason = REQUEST_REJECT_REASON_NONE; } else { @@ -456,10 +405,10 @@ { if ( TRUE == isDGCommunicating() ) { - heatDisinfectStartReqReceived = TRUE; - result = TRUE; - currentStandbyState = STANDBY_WAIT_FOR_DISINFECT_STATE; - rejReason = REQUEST_REJECT_REASON_NONE; + setRequestedCleaningMode( DG_MODE_HEAT ); + result = TRUE; + currentStandbyState = STANDBY_WAIT_FOR_DISINFECT_STATE; + rejReason = REQUEST_REJECT_REASON_NONE; } else { @@ -492,10 +441,10 @@ { if ( TRUE == isDGCommunicating() ) { - chemDisinfectStartReqReceived = TRUE; - result = TRUE; - currentStandbyState = STANDBY_WAIT_FOR_DISINFECT_STATE; - rejReason = REQUEST_REJECT_REASON_NONE; + setRequestedCleaningMode( DG_MODE_CHEM ); + result = TRUE; + currentStandbyState = STANDBY_WAIT_FOR_DISINFECT_STATE; + rejReason = REQUEST_REJECT_REASON_NONE; } else { @@ -514,7 +463,7 @@ * The signalUserInitiateChemcialDisinfectFlushMode function handles user * initiation of chemical disinfect flush mode. * @details Inputs: currentStandbyState - * @details Outputs: chemDisinfectFlushStartReqReceived + * @details Outputs: chemDisinfectFlushStartReqReceived, currentStandbyState * @return TRUE if signal accepted, FALSE if not *************************************************************************/ BOOL signalUserInitiateChemcialDisinfectFlushMode( void ) @@ -528,10 +477,10 @@ { if ( TRUE == isDGCommunicating() ) { - chemDisinfectFlushStartReqReceived = TRUE; - result = TRUE; - currentStandbyState = STANDBY_WAIT_FOR_DISINFECT_STATE; - rejReason = REQUEST_REJECT_REASON_NONE; + setRequestedCleaningMode( DG_MODE_CHFL ); + result = TRUE; + currentStandbyState = STANDBY_WAIT_FOR_DISINFECT_STATE; + rejReason = REQUEST_REJECT_REASON_NONE; } else { @@ -547,6 +496,42 @@ /*********************************************************************//** * @brief + * The signalUserInitiateROPermeateSampleMode function handles user + * initiation of RO permeate sample mode. + * @details Inputs: currentStandbyState + * @details Outputs: roPermeateSampleStartReqReceived, currentStandbyState + * @return TRUE if signal accepted, FALSE if not + *************************************************************************/ +BOOL signalUserInitiateROPermeateSampleMode( void ) +{ + BOOL result = FALSE; + REQUEST_REJECT_REASON_CODE_T rejReason = REQUEST_REJECT_REASON_NOT_ALLOWED_IN_CURRENT_MODE; + + if ( MODE_STAN == getCurrentOperationMode() ) + { + if ( ( STANDBY_WAIT_FOR_DISINFECT_STATE == currentStandbyState ) || ( STANDBY_WAIT_FOR_TREATMENT_STATE == currentStandbyState ) ) + { + if ( TRUE == isDGCommunicating() ) + { + setRequestedCleaningMode( DG_MODE_ROPS ); + result = TRUE; + currentStandbyState = STANDBY_WAIT_FOR_DISINFECT_STATE; + rejReason = REQUEST_REJECT_REASON_NONE; + } + else + { + rejReason = REQUEST_REJECT_REASON_DG_COMM_LOST; + } + } + } + + sendDisinfectConfirmResponse( result, rejReason ); + + return result; +} + +/*********************************************************************//** + * @brief * The signalInitiateStandbyDisinfectSubmode function handles user * initiation of setting the disinfects submode. * @details Inputs: currentStandbyState @@ -612,65 +597,48 @@ static void handleDisinfectCancel( BOOL stop ) { CONFIRMATION_REQUEST_STATUS_T confirm_status; - GENERIC_CONFIRM_ID_T confirm_id; - if ( ( STANDBY_DG_FLUSH_IN_PROGRESS_STATE == currentStandbyState ) || - ( STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE == currentStandbyState ) || - ( STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE == currentStandbyState ) || - ( STANDBY_DG_CHEM_DISINFECT_FLUSH_IN_PROGRESS_STATE == currentStandbyState ) ) + if ( STANDBY_CLEANING_MODE_IN_PROGRESS_STATE == currentStandbyState ) { if ( ( TRUE == stop ) && ( GENERIC_CONFIRM_ID_NONE == disinfectCancelReqID ) ) { - if ( STANDBY_DG_FLUSH_IN_PROGRESS_STATE == currentStandbyState ) - { - confirm_id = GENERIC_CONFIRM_ID_DISINFECT_STOP_WATERFLUSH; - } - else if ( STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE == currentStandbyState ) - { - confirm_id = GENERIC_CONFIRM_ID_DISINFECT_STOP_HEAT; - } - else if ( STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE == currentStandbyState ) - { - confirm_id = GENERIC_CONFIRM_ID_DISINFECT_STOP_CHEMICAL; - } - else if ( STANDBY_DG_CHEM_DISINFECT_FLUSH_IN_PROGRESS_STATE == currentStandbyState ) - { - confirm_id = GENERIC_CONFIRM_ID_DISINFECT_STOP_CHEMICAL_FLUSH; - } - // Send message to UI to indicate user request to cancel disinfect - disinfectCancelReqID = addConfirmationRequest( confirm_id, GENERIC_CONFIRM_CMD_REQUEST_OPEN, 0 ); + disinfectCancelReqID = addConfirmationRequest( currentDGCleaningMode.stopRequestCmdID, GENERIC_CONFIRM_CMD_REQUEST_OPEN, 0 ); } - else if ( GENERIC_CONFIRM_ID_NONE != disinfectCancelReqID ) + else if ( disinfectCancelReqID != GENERIC_CONFIRM_ID_NONE ) { - // Get the confirmation request. It consumes the request if completed and responds to UI. + // Get the confirmation request. It consumes the request if completed and responds to UI. confirm_status = getConfirmationRequestStatus( disinfectCancelReqID ); switch ( confirm_status ) { case CONFIRMATION_REQUEST_STATUS_ACCEPTED: // Clear request active status disinfectCancelReqID = GENERIC_CONFIRM_ID_NONE; - switch ( currentStandbyState ) + switch ( currentDGCleaningMode.dgOpMode ) { - case STANDBY_DG_FLUSH_IN_PROGRESS_STATE: + case DG_MODE_FLUS: cmdStopDGFlush(); break; - case STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE: + case DG_MODE_HEAT: cmdStopDGHeatDisinfect(); break; - case STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE: + case DG_MODE_CHEM: cmdStopDGChemicalDisinfect(); break; - case STANDBY_DG_CHEM_DISINFECT_FLUSH_IN_PROGRESS_STATE: + case DG_MODE_CHFL: cmdStopDGChemFlushDisinfect(); break; - default: - // UI Confirm already closed. Nothing to do. + case DG_MODE_HCOL: + cmdStopDGActiveCool(); break; + + case DG_MODE_ROPS: + cmdStopDGROPermeateSampleMode(); + break; } break; @@ -761,16 +729,32 @@ HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_TREATMENT_STATE; DG_OP_MODE_T dgOperationMode = getDGOpMode(); - // If DG is filling while we are in standby mode, abort the fill - if ( DG_MODE_FILL == dgOperationMode ) + switch ( dgOperationMode ) { - cmdStopDGFill(); - } + case DG_MODE_FILL: + // If DG is filling while we are in standby mode, abort the fill + cmdStopDGFill(); + break; - // If DG is in idle generation state while we are in standby mode, transition DG to standby too - if ( DG_MODE_GENE == dgOperationMode ) - { - cmdStopDG(); + case DG_MODE_GENE: + // If DG is in idle generation state while we are in standby mode, transition DG to standby too + cmdStopDG(); + break; + + // If DG is any of the cleaning modes, set the HD standby to be in the corresponding cleaning mode + case DG_MODE_FLUS: + case DG_MODE_HEAT: + case DG_MODE_CHEM: + case DG_MODE_CHFL: + case DG_MODE_HCOL: + case DG_MODE_ROPS: + setRequestedCleaningMode( dgOperationMode ); + state = STANDBY_WAIT_FOR_DG_CLEANING_MODE_TO_START_STATE; + break; + + default: + // Do nothing. There are other DG modes that HD standby does not need to act upon them. + break; } // If DG is communicating and we don't yet have DG version info, request it @@ -813,135 +797,60 @@ { HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DISINFECT_STATE; - if ( TRUE == flushStartReqReceived ) + if ( TRUE == currentDGCleaningMode.startCleaningMode ) { - cmdStartDGFlush(); - state = STANDBY_WAIT_FOR_DG_FLUSH_CMD_RESPONSE_STATE; - } - else if ( TRUE == heatDisinfectStartReqReceived ) - { - cmdStartDGHeatDisinfect(); - state = STANDBY_WAIT_FOR_DG_HEAT_DISINFECT_CMD_RESPONSE_STATE; - } - else if ( TRUE == chemDisinfectStartReqReceived ) - { - cmdStartDGChemicalDisinfect(); - state = STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_CMD_RESPONSE_STATE; - } - else if ( TRUE == chemDisinfectFlushStartReqReceived ) - { - cmdStartDGChememicalFlushDisinfect(); - state = STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_FLUSH_CMD_RESPONSE_STATE; - } + switch ( currentDGCleaningMode.dgOpMode ) + { + case DG_MODE_FLUS: + cmdStartDGFlush(); + break; - return state; -} + case DG_MODE_HEAT: + cmdStartDGHeatDisinfect(); + break; -/*********************************************************************//** - * @brief - * The handleStandbyModeWaitForDGFlushCmdResponseState function handles DG flush - * command response state. - * @details Inputs: none - * @details Outputs: flushStartReqReceived, dgDisinfectState - * @return next state of the standby mode state machine - *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGFlushCmdResponseState( void ) -{ - DG_CMD_RESPONSE_T dgCmdResp; - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_FLUSH_CMD_RESPONSE_STATE; - BOOL result = FALSE; + case DG_MODE_CHEM: + cmdStartDGChemicalDisinfect(); + break; - // Check if DG has responded to the start DG flush command - if ( TRUE == getDGCommandResponse( DG_CMD_START_FLUSH, &dgCmdResp ) ) - { - // Assume the command will be rejected and it goes back to wait for disinfect command - state = STANDBY_WAIT_FOR_DISINFECT_STATE; - flushStartReqReceived = FALSE; + case DG_MODE_CHFL: + cmdStartDGChemicalFlushDisinfect(); + break; - if ( DG_CMD_REQUEST_REJECT_REASON_NONE == dgCmdResp.rejectCode ) - { - // If the command has not been rejected, transition to the next state - dgDisinfectState = DG_DISINFECT_FLUSH_STATE; - state = STANDBY_WAIT_FOR_DG_FLUSH_TO_START_STATE; - result = TRUE; + case DG_MODE_ROPS: + cmdStartDGROPermeateSampleMode(); + break; } - - sendDisinfectConfirmResponse( result, dgCmdResp.rejectCode ); + state = STANDBY_WAIT_FOR_DG_CLEANING_MODE_CMD_RESPONSE_STATE; } return state; } /*********************************************************************//** * @brief - * The handleStandbyModeWaitForDGFlushToStartState function handles DG flush - * wait to start state. - * @details Inputs: none - * @details Outputs: dgDisinfectState + * The handleStandbyModeWaitForDGCleaningModeCmdResponseState function handles + * the standby mode wait for DG cleaning mode command response state. + * @details Inputs: currentDGCleaningMode + * @details Outputs: currentDGCleaningMode * @return next state of the standby mode state machine *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGFlushToStartState( void ) +static HD_STANDBY_STATE_T handleStandbyModeWaitForDGCleaningModeCmdResponseState( void ) { - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_FLUSH_TO_START_STATE; - - if ( DG_MODE_FLUS == getDGOpMode() ) - { - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - state = STANDBY_DG_FLUSH_IN_PROGRESS_STATE; - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_DISINFECT_FLUSH, 0 ); - } - - return state; -} - -/*********************************************************************//** - * @brief - * The handleStandbyModeDGFlushInProgressState function handles DG flush - * in progress state. - * @details Inputs: none - * @details Outputs: dgDisinfectState, currentStandbyState - * @return next state of the standby mode state machine - *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeDGFlushInProgressState( void ) -{ - HD_STANDBY_STATE_T state = STANDBY_DG_FLUSH_IN_PROGRESS_STATE; - - if ( getDGOpMode() != DG_MODE_FLUS ) - { - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - state = STANDBY_WAIT_FOR_TREATMENT_STATE; - clearAlarm( ALARM_ID_HD_DISINFECT_FLUSH ); - } - - publishDisinfectData(); - - return state; -} - -/*********************************************************************//** - * @brief - * The handleStandbyModeWaitForDGHeatDisinfectCmdResponseState function handles - * DG heat disinfect command response state. - * @details Inputs: none - * @details Outputs: heatDisinfectStartReqReceived, dgDisinfectState - * @return next state of the standby mode state machine - *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGHeatDisinfectCmdResponseState( void ) -{ DG_CMD_RESPONSE_T dgCmdResp; - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_HEAT_DISINFECT_CMD_RESPONSE_STATE; + HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_CLEANING_MODE_CMD_RESPONSE_STATE; BOOL result = FALSE; - if ( TRUE == getDGCommandResponse( DG_CMD_START_HEAT_DISINFECT, &dgCmdResp ) ) + if ( TRUE == getDGCommandResponse( currentDGCleaningMode.startRequestCmdID, &dgCmdResp ) ) { - state = STANDBY_WAIT_FOR_DISINFECT_STATE; - heatDisinfectStartReqReceived = FALSE; + // Assume the command will be rejected and it goes back to wait for disinfect command + state = STANDBY_WAIT_FOR_DISINFECT_STATE; + currentDGCleaningMode.startCleaningMode = FALSE; if ( DG_CMD_REQUEST_REJECT_REASON_NONE == dgCmdResp.rejectCode ) { - dgDisinfectState = DG_DISINFECT_HEAT_STATE; - state = STANDBY_WAIT_FOR_DG_HEAT_DISINFECT_TO_START_STATE; - result = TRUE; + state = STANDBY_WAIT_FOR_DG_CLEANING_MODE_TO_START_STATE; + result = TRUE; } sendDisinfectConfirmResponse( result, dgCmdResp.rejectCode ); @@ -952,228 +861,181 @@ /*********************************************************************//** * @brief - * The handleStandbyModeWaitForDGHeatDisinfectStartState function handles - * DG heat disinfect wait for start state. - * @details Inputs: none - * @details Outputs: dgDisinfectState + * The handleStandbyModeWaitForDGCleaningModeStartState function handles + * the standby mode wait for DG cleaning mode start state. + * @details Inputs: currentDGCleaningMode + * @details Outputs: none * @return next state of the standby mode state machine *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGHeatDisinfectStartState( void ) +static HD_STANDBY_STATE_T handleStandbyModeWaitForDGCleaningModeStartState( void ) { - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_HEAT_DISINFECT_TO_START_STATE; + HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_CLEANING_MODE_TO_START_STATE; - if ( DG_MODE_HEAT == getDGOpMode() ) + if ( currentDGCleaningMode.dgOpMode == getDGOpMode() ) { - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - state = STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE; - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_DISINFECT_HEAT, 0 ); + state = STANDBY_CLEANING_MODE_IN_PROGRESS_STATE; + activateAlarmNoData( currentDGCleaningMode.alarmID ); } return state; } /*********************************************************************//** * @brief - * The handleStandbyModeDGHeatDisinfectInProgressState function handles DG - * heat disinfect in progress state. - * @details Inputs: none - * @details Outputs: dgDisinfectState, currentStandbyState + * The handleStandbyModeDGCleaningModeInProgressState function handles + * the standby mode DG cleaning mode in progress state. + * @details Inputs: currentDGCleaningMode + * @details Outputs: none * @return next state of the standby mode state machine *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeDGHeatDisinfectInProgressState( void ) +static HD_STANDBY_STATE_T handleStandbyModeDGCleaningModeInProgressState( void ) { - HD_STANDBY_STATE_T state = STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE; + HD_STANDBY_STATE_T state = STANDBY_CLEANING_MODE_IN_PROGRESS_STATE; - if ( getDGOpMode() != DG_MODE_HEAT ) + if ( DG_MODE_CHFL == currentDGCleaningMode.dgOpMode ) { - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - state = STANDBY_WAIT_FOR_TREATMENT_STATE; - clearAlarm( ALARM_ID_HD_DISINFECT_HEAT ); + handleChemFlushSampleCollection(); } - - publishDisinfectData(); - - return state; -} - -/*********************************************************************//** - * @brief - * The handleStandbyModeWaitForDGChemDisinfectCmdResponseState function handles - * DG chemical disinfect wait for command response state. - * @details Inputs: none - * @details Outputs: chemDisinfectStartReqReceived, dgDisinfectState - * @return next state of the standby mode state machine - *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGChemDisinfectCmdResponseState( void ) -{ - DG_CMD_RESPONSE_T dgCmdResp; - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_CMD_RESPONSE_STATE; - BOOL result = FALSE; - - if ( TRUE == getDGCommandResponse( DG_CMD_START_CHEM_DISINFECT, &dgCmdResp ) ) + else if ( DG_MODE_ROPS == currentDGCleaningMode.dgOpMode ) { - state = STANDBY_WAIT_FOR_DISINFECT_STATE; - chemDisinfectStartReqReceived = FALSE; - - if ( DG_CMD_REQUEST_REJECT_REASON_NONE == dgCmdResp.rejectCode ) - { - dgDisinfectState = DG_DISINFECT_CHEM_STATE; - state = STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_TO_START_STATE; - result = TRUE; - } - - sendDisinfectConfirmResponse( result, dgCmdResp.rejectCode ); + // TODO a function to handle the ROPS sampling message } - return state; - -} - -/*********************************************************************//** - * @brief - * The handleStandbyModeWaitForDGChemDisinfectStartState function handles - * DG chemical disinfect wait for start state. - * @details Inputs: none - * @details Outputs: dgDisinfectState - * @return next state of the standby mode state machine - *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGChemDisinfectStartState( void ) -{ - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_TO_START_STATE; - - if ( DG_MODE_CHEM == getDGOpMode() ) + if ( getDGOpMode() != currentDGCleaningMode.dgOpMode ) { - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - state = STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE; - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_DISINFECT_CHEM, 0 ); + state = STANDBY_WAIT_FOR_TREATMENT_STATE; + clearAlarm( currentDGCleaningMode.alarmID ); + clearCurrentCleaningModeStatus(); } return state; } /*********************************************************************//** * @brief - * The handleStandbyModeDGChemDisininfectInProgressState function handles - * DG chemical disinfect in progress state. - * @details Inputs: none - * @details Outputs: dgDisinfectState, currentStandbyState - * @return next state of the standby mode state machine + * The setRequestedCleaningMode function sets the variables for the requested + * DG cleaning mode. + * @details Inputs: currentDGCleaningMode + * @details Outputs: none + * @param opMode DG operation mode that has been requested (i.e. heat disinfect) + * @return none *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeDGChemDisininfectInProgressState( void ) +static void setRequestedCleaningMode( DG_OP_MODE_T opMode ) { - HD_STANDBY_STATE_T state = STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE; - - if ( getDGOpMode() != DG_MODE_CHEM ) + switch ( opMode ) { - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - state = STANDBY_WAIT_FOR_TREATMENT_STATE; - clearAlarm( ALARM_ID_HD_DISINFECT_CHEM ); - } + case DG_MODE_FLUS: + currentDGCleaningMode.startCleaningMode = TRUE; + currentDGCleaningMode.startRequestCmdID = DG_CMD_START_FLUSH; + currentDGCleaningMode.dgOpMode = DG_MODE_FLUS; + currentDGCleaningMode.alarmID = ALARM_ID_HD_DISINFECT_FLUSH; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_WATERFLUSH; + break; - publishDisinfectData(); + case DG_MODE_HEAT: + currentDGCleaningMode.startCleaningMode = TRUE; + currentDGCleaningMode.startRequestCmdID = DG_CMD_START_HEAT_DISINFECT; + currentDGCleaningMode.dgOpMode = DG_MODE_HEAT; + currentDGCleaningMode.alarmID = ALARM_ID_HD_DISINFECT_HEAT; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_HEAT; + break; - return state; -} + case DG_MODE_CHEM: + currentDGCleaningMode.startCleaningMode = TRUE; + currentDGCleaningMode.startRequestCmdID = DG_CMD_START_CHEM_DISINFECT; + currentDGCleaningMode.dgOpMode = DG_MODE_CHEM; + currentDGCleaningMode.alarmID = ALARM_ID_HD_DISINFECT_CHEM; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_CHEMICAL; + break; -/*********************************************************************//** - * @brief - * The handleStandbyModeWaitForDGChemDisinfectFlushCmdResponseState function handles - * DG chemical disinfect flush wait for command response state. - * @details Inputs: none - * @details Outputs: dgDisinfectState, chemDisinfectFlushStartReqReceived - * @return next state of the standby mode state machine - *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGChemDisinfectFlushCmdResponseState( void ) -{ - DG_CMD_RESPONSE_T dgCmdResp; - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_FLUSH_CMD_RESPONSE_STATE; - BOOL result = FALSE; + case DG_MODE_CHFL: + currentDGCleaningMode.startCleaningMode = TRUE; + currentDGCleaningMode.startRequestCmdID = DG_CMD_START_CHEM_DISINFECT_FLUSH; + currentDGCleaningMode.dgOpMode = DG_MODE_CHFL; + currentDGCleaningMode.alarmID = ALARM_ID_HD_DISINFECT_CHEM_FLUSH; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_CHEMICAL_FLUSH; + break; - if ( TRUE == getDGCommandResponse( DG_CMD_START_CHEM_DISINFECT_FLUSH, &dgCmdResp ) ) - { - state = STANDBY_WAIT_FOR_DISINFECT_STATE; - chemDisinfectFlushStartReqReceived = FALSE; + case DG_MODE_HCOL: + // Cannot start active cool from settings in the UI + currentDGCleaningMode.startCleaningMode = FALSE; + currentDGCleaningMode.startRequestCmdID = DG_CMD_NONE; + currentDGCleaningMode.dgOpMode = DG_MODE_HCOL; + currentDGCleaningMode.alarmID = ALARM_ID_HD_DISINFECT_HEAT_COOL; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_ACTIVE_COOL; + break; - if ( DG_CMD_REQUEST_REJECT_REASON_NONE == dgCmdResp.rejectCode ) - { - dgDisinfectState = DG_DISINFECT_CHEM_FLUSH_STATE; - state = STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_FLUSH_TO_START_STATE; - result = TRUE; - } - - sendDisinfectConfirmResponse( result, dgCmdResp.rejectCode ); + case DG_MODE_ROPS: + currentDGCleaningMode.startCleaningMode = TRUE; + currentDGCleaningMode.startRequestCmdID = DG_CMD_START_RO_PERMEATE_SAMPLE; + currentDGCleaningMode.dgOpMode = DG_MODE_ROPS; + currentDGCleaningMode.alarmID = ALARM_ID_HD_RO_PERMEATE_SAMPLE; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_RO_PERMEATE_SAMPLE; + break; } - - return state; } /*********************************************************************//** * @brief - * The handleStandbyModeWaitForDGChemDisinfectFlushStartState function handles - * DG chemical disinfect flush wait for start state. + * The clearCurrentCleaningModeStatus function clears the DG cleaning mode + * variables. * @details Inputs: none - * @details Outputs: dgDisinfectState - * @return next state of the standby mode state machine + * @details Outputs: currentDGCleaningMode + * @return none *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGChemDisinfectFlushStartState( void ) +static void clearCurrentCleaningModeStatus( void ) { - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_FLUSH_TO_START_STATE; - - if ( DG_MODE_CHFL == getDGOpMode() ) - { - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - state = STANDBY_DG_CHEM_DISINFECT_FLUSH_IN_PROGRESS_STATE; - SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_DISINFECT_CHEM_FLUSH, 0 ); - } - - return state; + currentDGCleaningMode.startCleaningMode = FALSE; + currentDGCleaningMode.alarmID = ALARM_ID_NO_ALARM; + currentDGCleaningMode.startRequestCmdID = DG_CMD_NONE; + currentDGCleaningMode.dgOpMode = DG_MODE_FAUL; + currentDGCleaningMode.sampleAlarmTrgrd = FALSE; + currentDGCleaningMode.sampleRequestID = GENERIC_CONFIRM_ID_NONE; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_NONE; } - /*********************************************************************//** * @brief - * The handleStandbyModeDGChemDisininfectFlushInProgressState function handles - * DG chemical disinfect flush in progress state. - * @details Inputs: hasChemFlushSampleAlarmBeenTrgrd, chemFlushSampleID - * @details Outputs: dgDisinfectState, hasChemFlushSampleAlarmBeenTrgrd, - * chemFlushSampleID - * @return next state of the standby mode state machine + * The handleChemFlushSampleCollection function handle the chemical disinfect + * flush mode's sample collection. In this state of the chemical disinfect + * flush mode, user interaction is needed. + * @details Inputs: currentDGCleaningMode + * @details Outputs: currentDGCleaningMode + * @return none *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeDGChemDisininfectFlushInProgressState( void ) +static void handleChemFlushSampleCollection( void ) { - HD_STANDBY_STATE_T state = STANDBY_DG_CHEM_DISINFECT_FLUSH_IN_PROGRESS_STATE; - - if ( ( FALSE == hasChemFlushSampleAlarmBeenTrgrd ) && ( TRUE == isAlarmActive( ALARM_ID_DG_CHEM_DISINFECT_FLUSH_FLUSH_SAMPLE ) ) ) + if ( ( FALSE == currentDGCleaningMode.sampleAlarmTrgrd ) && ( TRUE == isAlarmActive( ALARM_ID_DG_CHEM_DISINFECT_FLUSH_FLUSH_SAMPLE ) ) ) { // Check if the flush sample alarm has been raised for the first time in the sample flush state - hasChemFlushSampleAlarmBeenTrgrd = TRUE; + currentDGCleaningMode.sampleAlarmTrgrd = TRUE; } - else if ( ( TRUE == hasChemFlushSampleAlarmBeenTrgrd ) && ( FALSE == isAlarmActive( ALARM_ID_DG_CHEM_DISINFECT_FLUSH_FLUSH_SAMPLE ) ) ) + else if ( ( TRUE == currentDGCleaningMode.sampleAlarmTrgrd ) && ( FALSE == isAlarmActive( ALARM_ID_DG_CHEM_DISINFECT_FLUSH_FLUSH_SAMPLE ) ) ) { // Sample flush alarm has been triggered and the user has cleared the alarm by pressing Ok. The user is collecting sample. // Send the notification to the UI to prompt the pass/fail screen so the user can choose whether the sampling after flush passed or failed - hasChemFlushSampleAlarmBeenTrgrd = FALSE; - chemFlushSampleID = addConfirmationRequest( GENERIC_CONFIRM_ID_DISINFECT_CHEM_FLUSH_SAMPLE_PASS_FAIL, GENERIC_CONFIRM_CMD_REQUEST_OPEN, 0 ); + currentDGCleaningMode.sampleAlarmTrgrd = FALSE; + currentDGCleaningMode.sampleRequestID = addConfirmationRequest( GENERIC_CONFIRM_ID_DISINFECT_CHEM_FLUSH_SAMPLE_PASS_FAIL, GENERIC_CONFIRM_CMD_REQUEST_OPEN, 0 ); } - if ( chemFlushSampleID != GENERIC_CONFIRM_ID_NONE ) + if ( currentDGCleaningMode.sampleRequestID != GENERIC_CONFIRM_ID_NONE ) { // There is a user confirm - CONFIRMATION_REQUEST_STATUS_T status = getConfirmationRequestStatus( chemFlushSampleID ); + CONFIRMATION_REQUEST_STATUS_T status = getConfirmationRequestStatus( currentDGCleaningMode.sampleRequestID ); U32 sampleStatus = 0; switch( status ) { // If the request status is accepted send a 1 to DG case CONFIRMATION_REQUEST_STATUS_ACCEPTED: - sampleStatus = (U32)CONFIRMATION_REQUEST_STATUS_ACCEPTED; - chemFlushSampleID = GENERIC_CONFIRM_ID_NONE; + sampleStatus = (U32)CONFIRMATION_REQUEST_STATUS_ACCEPTED; + currentDGCleaningMode.sampleRequestID = GENERIC_CONFIRM_ID_NONE; handleSendChemFlushPassFailToDG( sampleStatus ); break; // If the request timed out or rejected, it is 0 or failure to DG case CONFIRMATION_REQUEST_STATUS_TIMEOUT: case CONFIRMATION_REQUEST_STATUS_REJECTED: - chemFlushSampleID = GENERIC_CONFIRM_ID_NONE; + currentDGCleaningMode.sampleRequestID = GENERIC_CONFIRM_ID_NONE; handleSendChemFlushPassFailToDG( sampleStatus ); break; @@ -1184,17 +1046,6 @@ break; } } - - if ( getDGOpMode() != DG_MODE_CHFL ) - { - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - state = STANDBY_WAIT_FOR_TREATMENT_STATE; - clearAlarm( ALARM_ID_HD_DISINFECT_CHEM_FLUSH ); - } - - publishDisinfectData(); - - return state; } /*********************************************************************//** @@ -1291,49 +1142,7 @@ return status; } -/*********************************************************************//** - * @brief - * The publishDisinfectData function publishes disinfects data at - * the set interval. - * @details Inputs: dataPublishCounter - * @details Outputs: dataPublishCounter - * @return: none - *************************************************************************/ -static void publishDisinfectData( void ) -{ - if ( ++dataPublishCounter >= DISINFECTS_DATA_PUB_INTERVAL ) - { - DG_DISINFECT_UI_STATES_T state = getDGDisinfectsStates(); - DISINFECTS_DATA_T data; - switch( currentStandbyState ) - { - case STANDBY_DG_FLUSH_IN_PROGRESS_STATE: - data.disinfectDGFlushState = state.flushUIState; - break; - - case STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE: - data.disinfectDGHeatState = state.heatDisinfectUIState; - break; - - case STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE: - data.disinfectDGChemState = state.chemDisinfectUIState; - break; - - case STANDBY_DG_CHEM_DISINFECT_FLUSH_IN_PROGRESS_STATE: - data.disinfectDGChemState = state.chemDisinfectUIState; // TDOD add chem flush - break; - } - - data.disinfectSubModeHDState = (U32)dgDisinfectState; - - broadcastData( MSG_ID_HD_DISINFECT_STANDBY_DATA, COMM_BUFFER_OUT_CAN_HD_BROADCAST, (U08*)&data, sizeof( DISINFECTS_DATA_T ) ); - - dataPublishCounter = 0; - } -} - - /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/