Index: firmware/App/Modes/ModeStandby.c =================================================================== diff -u -r82bd1d24c050e79690a7f5b236e49dd7db7e2a91 -rfebf34ac531641da5c58262c56d3be6aeff3b209 --- firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision 82bd1d24c050e79690a7f5b236e49dd7db7e2a91) +++ firmware/App/Modes/ModeStandby.c (.../ModeStandby.c) (revision febf34ac531641da5c58262c56d3be6aeff3b209) @@ -7,8 +7,8 @@ * * @file ModeStandby.c * -* @author (last) Dara Navaei -* @date (last) 16-May-2023 +* @author (last) Sean Nash +* @date (last) 31-May-2023 * * @author (original) Dara Navaei * @date (original) 05-Nov-2019 @@ -49,82 +49,64 @@ #define DISINFECTS_DATA_PUB_INTERVAL ( 1 * MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< Disinfects data publish interval in counts. #define DISINFECTS_TIME_INTERVAL_S ( 3 * SECONDS_IN_A_DAY ) ///< HD/DG 3-day service interval in seconds. -#define FLUSH_TIME_INTERVAL_S ( 30 * SEC_PER_MIN * MS_PER_SECOND ) ///< Flush time interval in seconds. +#define FLUSH_TIME_INTERVAL_S ( 30 * SEC_PER_MIN ) ///< 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 sampleRqstTrgrd; ///< 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 }; -static const U32 SERVICE_TIME_INTERVAL_S = (U32)( 365 * 0.5 * SECONDS_IN_A_DAY ); ///< HD/DG 6-month service interval in seconds. - // ********** private function prototypes ********** -static void handleDisinfectCancel( BOOL stop ); - static HD_STANDBY_STATE_T handleStandbyModeStartState( void ); 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 handleDisinfectCancel( BOOL stop ); +static void setRequestedCleaningMode( DG_OP_MODE_T opMode ); +static void clearCurrentCleaningModeStatus( void ); +static void handleChemFlushSampleCollection( void ); +static void handleROPermeateSampleCollection( 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 + * disinfectCancelReqID, 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; } /*********************************************************************//** @@ -148,6 +130,8 @@ resetPreLoadStatus(); setVenousBubbleDetectionEnabled( FALSE ); setCurrentSubState( NO_SUB_STATE ); + clearNoRetriggerFlag(); + clearCurrentCleaningModeStatus(); // Set user alarm recovery actions allowed in this mode setAlarmUserActionEnabled( ALARM_USER_ACTION_RESUME, FALSE ); @@ -199,13 +183,16 @@ handleDisinfectCancel( stop ); - // if no active alarms anymore, restore to default valve states for standby mode - if ( ( FALSE == doesAlarmStatusIndicateStop() ) && ( VALVE_POSITION_C_CLOSE == getValvePosition( VDI ) ) ) + if ( TRUE == getVenousBubbleDetectionEnabled() ) { - setValvePosition( VDI, VALVE_POSITION_A_INSERT_EJECT ); - setValvePosition( VDO, VALVE_POSITION_A_INSERT_EJECT ); - setValvePosition( VBA, VALVE_POSITION_A_INSERT_EJECT ); - setValvePosition( VBV, VALVE_POSITION_A_INSERT_EJECT ); + // if no active alarms anymore, restore to default valve states for standby mode + if ( ( FALSE == doesAlarmStatusIndicateStop() ) && ( VALVE_POSITION_C_CLOSE == getValvePosition( VDI ) ) ) + { + setValvePosition( VDI, VALVE_POSITION_A_INSERT_EJECT ); + setValvePosition( VDO, VALVE_POSITION_A_INSERT_EJECT ); + setValvePosition( VBA, VALVE_POSITION_A_INSERT_EJECT ); + setValvePosition( VBV, VALVE_POSITION_A_INSERT_EJECT ); + } } // State machine to get DG to prep a reservoir so we can start a treatment @@ -223,54 +210,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; @@ -368,18 +319,26 @@ switch ( action ) { case ALARM_ACTION_STOP: - // Pumps should be off - signalBloodPumpHardStop(); - signalDialInPumpHardStop(); - signalDialOutPumpHardStop(); - stopSyringePump(); + if ( isAlarmActive( ALARM_ID_HD_VENOUS_BUBBLE_DETECTED ) != TRUE ) + { + // no stop action in standby mode + } + // if Dialin enabled bubble detection, stop on venous bubble detection alarm + else + { + // Pumps should be off + signalBloodPumpHardStop(); + signalDialInPumpHardStop(); + signalDialOutPumpHardStop(); + stopSyringePump(); - // Set valves to safe positions - setValveAirTrap( STATE_CLOSED ); - setValvePosition( VDI, VALVE_POSITION_C_CLOSE ); - setValvePosition( VDO, VALVE_POSITION_C_CLOSE ); - setValvePosition( VBA, VALVE_POSITION_C_CLOSE ); - setValvePosition( VBV, VALVE_POSITION_C_CLOSE ); + // Set valves to safe positions + setValveAirTrap( STATE_CLOSED ); + setValvePosition( VDI, VALVE_POSITION_C_CLOSE ); + setValvePosition( VDO, VALVE_POSITION_C_CLOSE ); + setValvePosition( VBA, VALVE_POSITION_C_CLOSE ); + setValvePosition( VBV, VALVE_POSITION_C_CLOSE ); + } break; default: @@ -393,7 +352,7 @@ * The signalUserInitiateFlushMode function handles user initiation of flush * mode. * @details Inputs: currentStandbyState - * @details Outputs: flushStartReqReceived + * @details Outputs: flushStartReqReceived, currentStandbyState * @return TRUE if signal accepted, FALSE if not *************************************************************************/ BOOL signalUserInitiateFlushMode( void ) @@ -407,10 +366,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 { @@ -443,10 +402,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 { @@ -479,10 +438,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 { @@ -501,7 +460,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 ) @@ -515,10 +474,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 { @@ -534,6 +493,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 @@ -585,98 +580,21 @@ return result; } -// ********** private functions ********** - /*********************************************************************//** * @brief - * The handleDisinfectCancel function handles - * DG disinfect cancel UI interaction. + * The signalROPermeateSampleDGReadyToDispense function set the signal + * that DG is ready for more RO permeate dispensing * @details Inputs: none - * @details Outputs: none - * @param stop button status + * @details Outputs: currentDGCleaningMode * @return none *************************************************************************/ -static void handleDisinfectCancel( BOOL stop ) +void signalROPermeateSampleDGReadyToDispense( void ) { - 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 ( ( 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 ); - } - else if ( GENERIC_CONFIRM_ID_NONE != disinfectCancelReqID ) - { - // 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 ) - { - case STANDBY_DG_FLUSH_IN_PROGRESS_STATE: - cmdStopDGFlush(); - break; - - case STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE: - cmdStopDGHeatDisinfect(); - break; - - case STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE: - cmdStopDGChemicalDisinfect(); - break; - - case STANDBY_DG_CHEM_DISINFECT_FLUSH_IN_PROGRESS_STATE: - cmdStopDGChemFlushDisinfect(); - break; - - default: - // UI Confirm already closed. Nothing to do. - break; - } - break; - - case CONFIRMATION_REQUEST_STATUS_TIMEOUT: - case CONFIRMATION_REQUEST_STATUS_REJECTED: - // Clear request active status - disinfectCancelReqID = GENERIC_CONFIRM_ID_NONE; - break; - - case CONFIRMATION_REQUEST_STATUS_PENDING: - case CONFIRMATION_REQUEST_STATUS_UNUSED: - default: - // Nothing to do - break; - } - } - } + currentDGCleaningMode.sampleRqstTrgrd = TRUE; } +// ********** private functions ********** + /*********************************************************************//** * @brief * The handleStandbyModeStartState function handles the standby start state. @@ -748,16 +666,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 @@ -800,57 +734,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; + switch ( currentDGCleaningMode.dgOpMode ) + { + case DG_MODE_FLUS: + cmdStartDGFlush(); + break; + + case DG_MODE_HEAT: + cmdStartDGHeatDisinfect(); + break; + + case DG_MODE_CHEM: + cmdStartDGChemicalDisinfect(); + break; + + case DG_MODE_CHFL: + cmdStartDGChemicalFlushDisinfect(); + break; + + case DG_MODE_ROPS: + cmdStartDGROPermeateSampleMode(); + break; + } + state = STANDBY_WAIT_FOR_DG_CLEANING_MODE_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; - } return state; } /*********************************************************************//** * @brief - * The handleStandbyModeWaitForDGFlushCmdResponseState function handles DG flush - * command response state. - * @details Inputs: none - * @details Outputs: flushStartReqReceived, 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 handleStandbyModeWaitForDGFlushCmdResponseState( void ) +static HD_STANDBY_STATE_T handleStandbyModeWaitForDGCleaningModeCmdResponseState( void ) { DG_CMD_RESPONSE_T dgCmdResp; - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_FLUSH_CMD_RESPONSE_STATE; + HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_CLEANING_MODE_CMD_RESPONSE_STATE; BOOL result = FALSE; - // Check if DG has responded to the start DG flush command - if ( TRUE == getDGCommandResponse( DG_CMD_START_FLUSH, &dgCmdResp ) ) + if ( TRUE == getDGCommandResponse( currentDGCleaningMode.startRequestCmdID, &dgCmdResp ) ) { // Assume the command will be rejected and it goes back to wait for disinfect command - state = STANDBY_WAIT_FOR_DISINFECT_STATE; - flushStartReqReceived = FALSE; + state = STANDBY_WAIT_FOR_DISINFECT_STATE; + currentDGCleaningMode.startCleaningMode = FALSE; 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; + state = STANDBY_WAIT_FOR_DG_CLEANING_MODE_TO_START_STATE; + result = TRUE; } sendDisinfectConfirmResponse( result, dgCmdResp.rejectCode ); @@ -861,307 +798,317 @@ /*********************************************************************//** * @brief - * The handleStandbyModeWaitForDGFlushToStartState function handles DG flush - * wait to 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 handleStandbyModeWaitForDGFlushToStartState( void ) +static HD_STANDBY_STATE_T handleStandbyModeWaitForDGCleaningModeStartState( void ) { - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_FLUSH_TO_START_STATE; + HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_CLEANING_MODE_TO_START_STATE; - if ( DG_MODE_FLUS == getDGOpMode() ) + if ( currentDGCleaningMode.dgOpMode == 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 ); + state = STANDBY_CLEANING_MODE_IN_PROGRESS_STATE; + activateAlarmNoData( currentDGCleaningMode.alarmID ); } return state; } /*********************************************************************//** * @brief - * The handleStandbyModeDGFlushInProgressState function handles DG flush - * 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 handleStandbyModeDGFlushInProgressState( void ) +static HD_STANDBY_STATE_T handleStandbyModeDGCleaningModeInProgressState( void ) { - HD_STANDBY_STATE_T state = STANDBY_DG_FLUSH_IN_PROGRESS_STATE; + HD_STANDBY_STATE_T state = STANDBY_CLEANING_MODE_IN_PROGRESS_STATE; - if ( getDGOpMode() != DG_MODE_FLUS ) + if ( DG_MODE_CHFL == currentDGCleaningMode.dgOpMode ) { - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - state = STANDBY_WAIT_FOR_TREATMENT_STATE; - clearAlarm( ALARM_ID_HD_DISINFECT_FLUSH ); + handleChemFlushSampleCollection(); } + else if ( DG_MODE_ROPS == currentDGCleaningMode.dgOpMode ) + { + handleROPermeateSampleCollection(); + } - publishDisinfectData(); + if ( getDGOpMode() != currentDGCleaningMode.dgOpMode ) + { + state = STANDBY_WAIT_FOR_TREATMENT_STATE; + clearAlarm( currentDGCleaningMode.alarmID ); + clearCurrentCleaningModeStatus(); + } 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 + * The handleDisinfectCancel function handles + * DG disinfect cancel UI interaction. + * @details Inputs: disinfectCancelReqID, currentDGCleaningMode, + * currentStandbyState + * @details Outputs: disinfectCancelReqID + * @param stop button status + * @return none *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGHeatDisinfectCmdResponseState( void ) +static void handleDisinfectCancel( BOOL stop ) { - DG_CMD_RESPONSE_T dgCmdResp; - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_HEAT_DISINFECT_CMD_RESPONSE_STATE; - BOOL result = FALSE; + CONFIRMATION_REQUEST_STATUS_T confirm_status; - if ( TRUE == getDGCommandResponse( DG_CMD_START_HEAT_DISINFECT, &dgCmdResp ) ) + if ( STANDBY_CLEANING_MODE_IN_PROGRESS_STATE == currentStandbyState ) { - state = STANDBY_WAIT_FOR_DISINFECT_STATE; - heatDisinfectStartReqReceived = FALSE; - - if ( DG_CMD_REQUEST_REJECT_REASON_NONE == dgCmdResp.rejectCode ) + if ( ( TRUE == stop ) && ( GENERIC_CONFIRM_ID_NONE == disinfectCancelReqID ) ) { - dgDisinfectState = DG_DISINFECT_HEAT_STATE; - state = STANDBY_WAIT_FOR_DG_HEAT_DISINFECT_TO_START_STATE; - result = TRUE; + disinfectCancelReqID = addConfirmationRequest( currentDGCleaningMode.stopRequestCmdID, GENERIC_CONFIRM_CMD_REQUEST_OPEN, 0 ); } + else if ( disinfectCancelReqID != GENERIC_CONFIRM_ID_NONE ) + { + // 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; - sendDisinfectConfirmResponse( result, dgCmdResp.rejectCode ); - } + switch ( currentDGCleaningMode.dgOpMode ) + { + case DG_MODE_FLUS: + cmdStopDGFlush(); + break; - return state; -} + case DG_MODE_HEAT: + cmdStopDGHeatDisinfect(); + break; -/*********************************************************************//** - * @brief - * The handleStandbyModeWaitForDGHeatDisinfectStartState function handles - * DG heat 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 handleStandbyModeWaitForDGHeatDisinfectStartState( void ) -{ - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_HEAT_DISINFECT_TO_START_STATE; + case DG_MODE_CHEM: + cmdStopDGChemicalDisinfect(); + break; - if ( DG_MODE_HEAT == 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 ); - } + case DG_MODE_CHFL: + cmdStopDGChemFlushDisinfect(); + break; - return state; -} + case DG_MODE_HCOL: + cmdStopDGActiveCool(); + break; -/*********************************************************************//** - * @brief - * The handleStandbyModeDGHeatDisinfectInProgressState function handles DG - * heat disinfect in progress state. - * @details Inputs: none - * @details Outputs: dgDisinfectState, currentStandbyState - * @return next state of the standby mode state machine - *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeDGHeatDisinfectInProgressState( void ) -{ - HD_STANDBY_STATE_T state = STANDBY_DG_HEAT_DISINFECT_IN_PROGRESS_STATE; + case DG_MODE_ROPS: + cmdStopDGROPermeateSampleMode(); + break; + } + break; - if ( getDGOpMode() != DG_MODE_HEAT ) - { - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - state = STANDBY_WAIT_FOR_TREATMENT_STATE; - clearAlarm( ALARM_ID_HD_DISINFECT_HEAT ); - } + case CONFIRMATION_REQUEST_STATUS_TIMEOUT: + case CONFIRMATION_REQUEST_STATUS_REJECTED: + // Clear request active status + disinfectCancelReqID = GENERIC_CONFIRM_ID_NONE; + break; - publishDisinfectData(); - - return state; + case CONFIRMATION_REQUEST_STATUS_PENDING: + case CONFIRMATION_REQUEST_STATUS_UNUSED: + default: + // Nothing to do + break; + } + } + } } /*********************************************************************//** * @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 + * 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 handleStandbyModeWaitForDGChemDisinfectCmdResponseState( void ) +static void setRequestedCleaningMode( DG_OP_MODE_T opMode ) { - 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 ) ) + switch ( opMode ) { - state = STANDBY_WAIT_FOR_DISINFECT_STATE; - chemDisinfectStartReqReceived = FALSE; + case DG_MODE_FLUS: + currentDGCleaningMode.startCleaningMode = TRUE; + currentDGCleaningMode.startRequestCmdID = DG_CMD_START_FLUSH; + currentDGCleaningMode.dgOpMode = DG_MODE_FLUS; + currentDGCleaningMode.sampleRqstTrgrd = FALSE; + currentDGCleaningMode.alarmID = ALARM_ID_HD_DISINFECT_FLUSH; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_WATERFLUSH; + break; - 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; - } + case DG_MODE_HEAT: + currentDGCleaningMode.startCleaningMode = TRUE; + currentDGCleaningMode.startRequestCmdID = DG_CMD_START_HEAT_DISINFECT; + currentDGCleaningMode.dgOpMode = DG_MODE_HEAT; + currentDGCleaningMode.sampleRqstTrgrd = FALSE; + currentDGCleaningMode.alarmID = ALARM_ID_HD_DISINFECT_HEAT; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_HEAT; + break; - sendDisinfectConfirmResponse( result, dgCmdResp.rejectCode ); - } + case DG_MODE_CHEM: + currentDGCleaningMode.startCleaningMode = TRUE; + currentDGCleaningMode.startRequestCmdID = DG_CMD_START_CHEM_DISINFECT; + currentDGCleaningMode.dgOpMode = DG_MODE_CHEM; + currentDGCleaningMode.sampleRqstTrgrd = FALSE; + currentDGCleaningMode.alarmID = ALARM_ID_HD_DISINFECT_CHEM; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_CHEMICAL; + break; - return state; + case DG_MODE_CHFL: + currentDGCleaningMode.startCleaningMode = TRUE; + currentDGCleaningMode.startRequestCmdID = DG_CMD_START_CHEM_DISINFECT_FLUSH; + currentDGCleaningMode.dgOpMode = DG_MODE_CHFL; + currentDGCleaningMode.sampleRqstTrgrd = FALSE; + currentDGCleaningMode.alarmID = ALARM_ID_HD_DISINFECT_CHEM_FLUSH; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_CHEMICAL_FLUSH; + break; + 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.sampleRqstTrgrd = FALSE; + currentDGCleaningMode.alarmID = ALARM_ID_HD_DISINFECT_HEAT_COOL; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_ACTIVE_COOL; + break; + + case DG_MODE_ROPS: + currentDGCleaningMode.startCleaningMode = TRUE; + currentDGCleaningMode.startRequestCmdID = DG_CMD_START_RO_PERMEATE_SAMPLE; + currentDGCleaningMode.dgOpMode = DG_MODE_ROPS; + currentDGCleaningMode.sampleRqstTrgrd = FALSE; + currentDGCleaningMode.alarmID = ALARM_ID_HD_RO_PERMEATE_SAMPLE; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_DISINFECT_STOP_RO_PERMEATE_SAMPLE; + break; + } } /*********************************************************************//** * @brief - * The handleStandbyModeWaitForDGChemDisinfectStartState function handles - * DG chemical disinfect 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 handleStandbyModeWaitForDGChemDisinfectStartState( void ) +static void clearCurrentCleaningModeStatus( void ) { - HD_STANDBY_STATE_T state = STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_TO_START_STATE; - - if ( DG_MODE_CHEM == getDGOpMode() ) - { - 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 ); - } - - return state; + currentDGCleaningMode.startCleaningMode = FALSE; + currentDGCleaningMode.alarmID = ALARM_ID_NO_ALARM; + currentDGCleaningMode.startRequestCmdID = DG_CMD_NONE; + currentDGCleaningMode.dgOpMode = DG_MODE_FAUL; + currentDGCleaningMode.sampleRqstTrgrd = FALSE; + currentDGCleaningMode.sampleRequestID = GENERIC_CONFIRM_ID_NONE; + currentDGCleaningMode.stopRequestCmdID = GENERIC_CONFIRM_ID_NONE; } /*********************************************************************//** * @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 handleChemFlushSampleCollection function handles 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 handleStandbyModeDGChemDisininfectInProgressState( void ) +static void handleChemFlushSampleCollection( void ) { - HD_STANDBY_STATE_T state = STANDBY_DG_CHEM_DISINFECT_IN_PROGRESS_STATE; - - if ( getDGOpMode() != DG_MODE_CHEM ) + if ( ( FALSE == currentDGCleaningMode.sampleRqstTrgrd ) && ( TRUE == isAlarmActive( ALARM_ID_DG_CHEM_DISINFECT_FLUSH_FLUSH_SAMPLE ) ) ) { - dgDisinfectState = DG_DISINFECT_NOT_RUNNING_STATE; - state = STANDBY_WAIT_FOR_TREATMENT_STATE; - clearAlarm( ALARM_ID_HD_DISINFECT_CHEM ); + // Check if the flush sample alarm has been raised for the first time in the sample flush state + currentDGCleaningMode.sampleRqstTrgrd = TRUE; } + else if ( ( TRUE == currentDGCleaningMode.sampleRqstTrgrd ) && ( 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 + currentDGCleaningMode.sampleRqstTrgrd = FALSE; + currentDGCleaningMode.sampleRequestID = addConfirmationRequest( GENERIC_CONFIRM_ID_DISINFECT_CHEM_FLUSH_SAMPLE_PASS_FAIL, GENERIC_CONFIRM_CMD_REQUEST_OPEN, 0 ); + } - publishDisinfectData(); - - return state; -} - -/*********************************************************************//** - * @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; - - if ( TRUE == getDGCommandResponse( DG_CMD_START_CHEM_DISINFECT_FLUSH, &dgCmdResp ) ) + if ( currentDGCleaningMode.sampleRequestID != GENERIC_CONFIRM_ID_NONE ) { - state = STANDBY_WAIT_FOR_DISINFECT_STATE; - chemDisinfectFlushStartReqReceived = FALSE; + // There is a user confirm + CONFIRMATION_REQUEST_STATUS_T status = getConfirmationRequestStatus( currentDGCleaningMode.sampleRequestID ); + U32 sampleStatus = 0; - if ( DG_CMD_REQUEST_REJECT_REASON_NONE == dgCmdResp.rejectCode ) + switch( status ) { - dgDisinfectState = DG_DISINFECT_CHEM_FLUSH_STATE; - state = STANDBY_WAIT_FOR_DG_CHEM_DISINFECT_FLUSH_TO_START_STATE; - result = TRUE; - } + // If the request status is accepted send a 1 to DG + case CONFIRMATION_REQUEST_STATUS_ACCEPTED: + sampleStatus = (U32)CONFIRMATION_REQUEST_STATUS_ACCEPTED; + currentDGCleaningMode.sampleRequestID = GENERIC_CONFIRM_ID_NONE; + handleSendChemFlushPassFailToDG( sampleStatus ); + break; - sendDisinfectConfirmResponse( result, dgCmdResp.rejectCode ); - } + // If the request timed out or rejected, it is 0 or failure to DG + case CONFIRMATION_REQUEST_STATUS_TIMEOUT: + case CONFIRMATION_REQUEST_STATUS_REJECTED: + currentDGCleaningMode.sampleRequestID = GENERIC_CONFIRM_ID_NONE; + handleSendChemFlushPassFailToDG( sampleStatus ); + break; - return state; -} - -/*********************************************************************//** - * @brief - * The handleStandbyModeWaitForDGChemDisinfectFlushStartState function handles - * DG chemical disinfect flush wait for start state. - * @details Inputs: none - * @details Outputs: dgDisinfectState - * @return next state of the standby mode state machine - *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeWaitForDGChemDisinfectFlushStartState( 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 ); + case CONFIRMATION_REQUEST_STATUS_PENDING: + case CONFIRMATION_REQUEST_STATUS_UNUSED: + default: + // Nothing to do + break; + } } - - return state; } /*********************************************************************//** * @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 handleROPermeateSampleCollection function handles the RO permeate + * sample collection with the user + * @details Inputs: currentDGCleaningMode + * @details Outputs: currentDGCleaningMode + * @return none *************************************************************************/ -static HD_STANDBY_STATE_T handleStandbyModeDGChemDisininfectFlushInProgressState( void ) +static void handleROPermeateSampleCollection( 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.sampleRqstTrgrd ) && ( TRUE == isAlarmActive( ALARM_ID_DG_RO_PERMEATE_SAMPLE_REMOVE_DIA_CAP ) ) ) { // Check if the flush sample alarm has been raised for the first time in the sample flush state - hasChemFlushSampleAlarmBeenTrgrd = TRUE; + currentDGCleaningMode.sampleRqstTrgrd = TRUE; } - else if ( ( TRUE == hasChemFlushSampleAlarmBeenTrgrd ) && ( FALSE == isAlarmActive( ALARM_ID_DG_CHEM_DISINFECT_FLUSH_FLUSH_SAMPLE ) ) ) + else if ( ( TRUE == currentDGCleaningMode.sampleRqstTrgrd ) && ( FALSE == isAlarmActive( ALARM_ID_DG_RO_PERMEATE_SAMPLE_REMOVE_DIA_CAP ) ) ) { // 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.sampleRqstTrgrd = FALSE; + currentDGCleaningMode.sampleRequestID = addConfirmationRequest( GENERIC_CONFIRM_ID_RO_PERMEATE_SAMPLE_STOP_OR_DISPENSE, 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; - handleSendChemFlushPassFailToDG( sampleStatus ); + sampleStatus = (U32)CONFIRMATION_REQUEST_STATUS_ACCEPTED; + currentDGCleaningMode.sampleRequestID = GENERIC_CONFIRM_ID_NONE; + sendRequestROPermeateSampleCollectionToDG( 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; - handleSendChemFlushPassFailToDG( sampleStatus ); + currentDGCleaningMode.sampleRequestID = GENERIC_CONFIRM_ID_NONE; + sendRequestROPermeateSampleCollectionToDG( sampleStatus ); break; case CONFIRMATION_REQUEST_STATUS_PENDING: @@ -1171,17 +1118,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; } /*********************************************************************//** @@ -1204,28 +1140,29 @@ HD_USAGE_INFO_RECORD_T usageRecord; getNVRecord2Driver( GET_USAGE_RECORD, (U08*)&usageRecord, sizeof( HD_USAGE_INFO_RECORD_T ), 0, ALARM_ID_NO_ALARM ); - U32 lastChemCompleteDate = data.dgUsageInfo.lastChemDisCompleteDateEpoch; - U32 lastChemFlushCompleteDate = data.dgUsageInfo.lastChemDisFlushCompleteDateEpoch; - U32 lastHeatCompleteDate = data.dgUsageInfo.lastHeatDisCompleteDateEpoch; - U32 lastFlushCompleteDate = data.dgUsageInfo.lastBasicFlushCompleteDateEpoch; - U32 lastHeatCoolCompleteDate = data.dgUsageInfo.lastHeatActiveCoolCompleteDateEpoch; - U32 lastStartTxTimeDate = usageRecord.txLastStartTimeEpoch; + U32 lastChemCompleteDateS = data.dgUsageInfo.lastChemDisCompleteDateEpoch; + U32 lastChemFlushCompleteDateS = data.dgUsageInfo.lastChemDisFlushCompleteDateEpoch; + U32 lastHeatCompleteDateS = data.dgUsageInfo.lastHeatDisCompleteDateEpoch; + U32 lastFlushCompleteDateS = data.dgUsageInfo.lastBasicFlushCompleteDateEpoch; + U32 lastHeatCoolCompleteDateS = data.dgUsageInfo.lastHeatActiveCoolCompleteDateEpoch; + U32 lastStartTxTimeDateS = usageRecord.txLastStartTimeEpoch; + U32 currentRTCEpochTimeS = getRTCTimestamp(); // Last Treatment Start < Last Heat Disinfect Complete or Last Treatment Start < Last Chem Disinfect Complete so it means at least a heat disinfect // or a chemical disinfect has been done since the last treatment - BOOL hasDisBeenDone = ( ( ( lastStartTxTimeDate < lastChemCompleteDate ) || ( lastStartTxTimeDate < lastHeatCompleteDate ) ) ? TRUE : FALSE ); + BOOL hasDisBeenDone = ( ( ( lastStartTxTimeDateS < lastChemCompleteDateS ) || ( lastStartTxTimeDateS < lastHeatCompleteDateS ) ) ? TRUE : FALSE ); // Last Heat Disinfect Complete < Current Time – Heat Disinfect Interval, so the heat disinfect that has been done has not been expired - BOOL isHeatDisValid = ( lastHeatCompleteDate < ( getRTCTimestamp() - DISINFECTS_TIME_INTERVAL_S ) ? TRUE : FALSE ); + BOOL isHeatDisValid = ( ( currentRTCEpochTimeS - lastHeatCompleteDateS ) < DISINFECTS_TIME_INTERVAL_S ? TRUE : FALSE ); // Last Chem Flush Complete < Last Chem Disinfect Start, so after running a chemical disinfect, a chemical disinfect flush has been done - BOOL isChemFlushComplete = ( lastChemFlushCompleteDate > lastChemCompleteDate ? TRUE : FALSE ); + BOOL isChemFlushComplete = ( lastChemFlushCompleteDateS > lastChemCompleteDateS ? TRUE : FALSE ); // If either of the basic flush, heat disinfect, or chemical disinfect flush have been done within the interval, it means the filters have been flushed - BOOL isBasicFlushValid = ( lastFlushCompleteDate < ( getRTCTimestamp() - FLUSH_TIME_INTERVAL_S ) ? TRUE : TRUE ); - BOOL isChemFlushValid = ( lastChemFlushCompleteDate < ( getRTCTimestamp() - FLUSH_TIME_INTERVAL_S ) ? TRUE : TRUE ); - BOOL isHeatDisCoolFlushValid = ( lastHeatCoolCompleteDate < ( getRTCTimestamp() - FLUSH_TIME_INTERVAL_S ) ? TRUE : TRUE ); - BOOL isFlushValid = ( isBasicFlushValid || isChemFlushValid || isHeatDisCoolFlushValid ); + BOOL isBasicFlushValid = ( ( currentRTCEpochTimeS - lastFlushCompleteDateS ) < FLUSH_TIME_INTERVAL_S ? TRUE : FALSE ); + BOOL isChemFlushValid = ( ( currentRTCEpochTimeS - lastChemFlushCompleteDateS ) < FLUSH_TIME_INTERVAL_S ? TRUE : FALSE ); + BOOL isHeatDisCoolFlushValid = ( ( currentRTCEpochTimeS - lastHeatCoolCompleteDateS ) < FLUSH_TIME_INTERVAL_S ? TRUE : FALSE ); + BOOL isFlushValid = ( ( TRUE == isBasicFlushValid ) || ( TRUE == isChemFlushValid ) || ( TRUE == isHeatDisCoolFlushValid ) ? TRUE : FALSE ); // If all of the above conditions are true, it means we can start a treatment if ( ( TRUE == hasDisBeenDone ) && ( TRUE == isHeatDisValid ) && ( TRUE == isChemFlushComplete ) && ( TRUE == isFlushValid ) ) @@ -1248,19 +1185,20 @@ ***********************************************************************/ static BOOL haveHDDGServicesBeenExpired( REQUEST_REJECT_REASON_CODE_T* rejReason ) { - BOOL status = FALSE; DG_SERVICE_AND_USAGE_DATA_T dgData; HD_SERVICE_RECORD_T hdServiceRecord; + BOOL status = FALSE; + U32 currentRTCEpochTime = getRTCTimestamp(); getHDVersionDGServiceAndUsageData( &dgData ); getNVRecord2Driver( GET_SRV_RECORD, (U08*)&hdServiceRecord, sizeof( HD_SERVICE_RECORD_T ), 0, ALARM_ID_NO_ALARM ); if ( TRUE == dgData.isDGServiceRecordAvailable ) { - U32 dgSrvcElapsedTimeS = getRTCTimestamp() - dgData.dgServiceRecord.lastServiceEpochDate; - U32 hdSrvcElapsedTimeS = getRTCTimestamp() - hdServiceRecord.lastServiceEpochDate; - BOOL hasDGSrvcBeenExpired = ( dgSrvcElapsedTimeS > SERVICE_TIME_INTERVAL_S ? TRUE : FALSE ); - BOOL hasHDSrvcBeenExpied = ( hdSrvcElapsedTimeS > SERVICE_TIME_INTERVAL_S ? TRUE : FALSE ); + U32 dgSrvcElapsedTimeS = currentRTCEpochTime - dgData.dgServiceRecord.lastServiceEpochDate; + U32 hdSrvcElapsedTimeS = currentRTCEpochTime - hdServiceRecord.lastServiceEpochDate; + BOOL hasDGSrvcBeenExpired = ( dgSrvcElapsedTimeS > dgData.dgServiceRecord.serviceIntervalSeconds ? TRUE : FALSE ); + BOOL hasHDSrvcBeenExpied = ( hdSrvcElapsedTimeS > hdServiceRecord.serviceIntervalSeconds ? TRUE : FALSE ); if ( TRUE == hasDGSrvcBeenExpired ) { @@ -1278,49 +1216,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 *************************************************************************/