Index: firmware/App/Modes/Prime.c =================================================================== diff -u -r174c9ba02da6790f01ea9141ab1cc1d28388f2f8 -r6419179374edcd65da462de84e8aeaefb7e20320 --- firmware/App/Modes/Prime.c (.../Prime.c) (revision 174c9ba02da6790f01ea9141ab1cc1d28388f2f8) +++ firmware/App/Modes/Prime.c (.../Prime.c) (revision 6419179374edcd65da462de84e8aeaefb7e20320) @@ -38,22 +38,14 @@ #define MAX_PRIME_TIME ( 10 * SEC_PER_MIN ) ///< Maximum prime time (in seconds). #define PRIME_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the prime data is published on the CAN bus. -#define BLOOD_PUMP_FLOW_RATE_PURGE_AIR 100 ///< Blood pump flow rate during prime purge air state. +#define BLOOD_PUMP_FLOW_RATE_PURGE_AIR 500 ///< Blood pump flow rate during prime purge air state. #define BLOOD_PUMP_FLOW_RATE_CIRC_BLOOD_CIRCUIT 300 ///< Blood pump flow rate during prime recirculate blood circuit state. #define DIALYSATE_PUMP_PRIME_FLOW_RATE 300 ///< Dialysate pump flow rate during priming fluid path. #define LOAD_CELL_VOLUME_NOISE_TOLERANCE 0.05 ///< Allow 5% tolerance on load cell readings. -#define PRIME_DRAIN_RESERVOIR_TO_VOLUME_ML 0 ///< Drain reservoir to this volume (in mL) during prime. - -#define PRIME_CONSUMED_DIALYSATE_VOLUME_ML 100 ///< Volume of dialysate consumed during prime. - -/// Fill reservoir 1 to this volume (in mL) during prime. -#define PRIME_FILL_RESERVOIR_ONE_VOLUME_ML ( FILL_RESERVOIR_TO_VOLUME_ML - PRIME_CONSUMED_DIALYSATE_VOLUME_ML ) -#define PRIME_FILL_RESERVOIR_TWO_VOLUME_ML 500 ///< Fill reservoir 2 to this volume (in mL) during prime. - -#define NO_AIR_DETECTED_COUNT ( 10 * MS_PER_SECOND ) ///< No air detected time period count. -#define PURGE_AIR_TIME_OUT_COUNT ( 30 * MS_PER_SECOND ) ///< Time period count for purge air time out. +#define NO_AIR_DETECTED_COUNT ( 20 * MS_PER_SECOND ) ///< No air detected time period count. +#define PURGE_AIR_TIME_OUT_COUNT ( 60 * MS_PER_SECOND ) ///< Time period count for purge air time out. #define MIN_LOAD_CELL_STEADY_VOLUME_TIME ( 10 * MS_PER_SECOND ) ///< Minimum time load cell reading need to remain steady in ms. #define PRIME_DIALYSATE_DIALYZER_TIME_LIMIT ( 120 * MS_PER_SECOND ) ///< Time limit for priming dialysate dialyzer circuit. #define PRIME_DIALYSATE_BYPASS_TIME_LIMIT ( 120 * MS_PER_SECOND ) ///< Time limit for priming dialysate bypass circuit. @@ -79,29 +71,26 @@ static HD_PRE_TREATMENT_PRIME_STATE_T previousPrimeState; ///< Previous state of the prime sub-mode, to use when resuming from pause. static PRIME_RESERVOIR_MGMT_STATE_T currentReservoirMgmtState; ///< Current reservoir management state. -static BOOL primeCompleted; ///< Prime complete status. static U32 primeStartTime; ///< Starting time of priming (in ms). static U32 primePauseStartTime; ///< Priming pause start time (in ms). static U32 primeStatusBroadcastTimerCounter; ///< Prime status data broadcast timer counter used to schedule when to transmit data. static BOOL primeStartRequested; ///< Flag indicates user requesting to start prime. -static BOOL primeStopRequested; ///< Flag indicates alarm requesting to stop prime. static BOOL primeResumeRequested; ///< Flag indicates user requesting prime resume. -static BOOL reservoirFilledStatus[ NUM_OF_DG_RESERVOIRS ]; ///< Flag indicates a reservoir has been filled. static U32 noAirDetectedStartTime; ///< starting time when detecting no air. static U32 purgeAirTimeOutStartTime; ///< Starting time for purge air state time out. static U32 primeDialysateDialyzerStartTime; ///< Starting time of priming dialysate dialyzer circuit. static U32 primeDialysateBypassStartTime; ///< Starting time of priming dialysate bypass circuit. static U32 previousLoadCellReading; ///< Previous load cell reading. static U32 loadcellSteadyVolumeStartTime; ///< Load cell steady volume starting time. +static BOOL runBloodCircuitPrimeAgain; ///< Flag indicates HD should run blood circuit prime once more time. // ********** private function prototypes ********** static void resetPrimeFlags(); -static void handlePrimePauseRequest( void ); +static void setupForPrimePause( void ); static void broadcastPrimingStatus( void ); -static void execPrimeReservoirMgmt( void ); static void purgeAirValvesBloodPumpControl( void ); static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeWaitForUserStartState( void ); @@ -141,14 +130,11 @@ currentPrimeState = HD_PRIME_START_STATE; currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_START_STATE; - primeCompleted = FALSE; primeStartTime = getMSTimerCount(); primePauseStartTime = 0; primeStatusBroadcastTimerCounter = 0; + runBloodCircuitPrimeAgain = TRUE; - reservoirFilledStatus[ DG_RESERVOIR_1 ] = FALSE; - reservoirFilledStatus[ DG_RESERVOIR_2 ] = FALSE; - setAlarmUserActionEnabled( ALARM_USER_ACTION_RESUME, TRUE ); setAlarmUserActionEnabled( ALARM_USER_ACTION_RINSEBACK, FALSE ); setAlarmUserActionEnabled( ALARM_USER_ACTION_END_TREATMENT, TRUE ); @@ -169,7 +155,6 @@ switch ( currentPrimeState ) { case HD_PRIME_START_STATE: - cmdSetDGActiveReservoir( DG_RESERVOIR_2 ); #ifdef SKIP_PRIMING currentPrimeState = HD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE; #else @@ -214,7 +199,6 @@ break; case HD_PRIME_COMPLETE: - primeCompleted = TRUE; break; case HD_PRIME_PAUSE: @@ -230,52 +214,56 @@ // Prime flags should be handled by now resetPrimeFlags(); - // Handle prime pause request - handlePrimePauseRequest(); - // Broadcast priming data broadcastPrimingStatus(); - - // Exec reservoir management for priming - execPrimeReservoirMgmt(); } /*********************************************************************//** * @brief - * The isPrimeCompleted function returns the status of prime. - * @details Inputs: none + * The getPrimeState function returns the current state of prime sub-mode. + * @details Inputs: currentPrimeState * @details Outputs: none - * @return TRUE if prime has completed succesfully, otherwise FALSE + * @return current prime state *************************************************************************/ -BOOL isPrimeCompleted( void ) +U32 getPrimeState( void ) { - return primeCompleted; + return (U32)currentPrimeState; } /*********************************************************************//** * @brief - * The signalResumePrime function signals the prime sub-mode to resume - * previous operation. + * The signalStartPrime function signals the prime sub-mode the user requested + * to start priming operation. * @details Inputs: none - * @details Outputs: primeResumeRequested + * @details Outputs: primeStartRequested * @return none *************************************************************************/ -void signalResumePrime( void ) +void signalStartPrime( void ) { - primeResumeRequested = TRUE; + BOOL accepted = FALSE; + REQUEST_REJECT_REASON_CODE_T rejReason = REQUEST_REJECT_REASON_NOT_ALLOWED_IN_CURRENT_MODE; + + if ( HD_PRIME_WAIT_FOR_USER_START_STATE == currentPrimeState ) + { + primeStartRequested = TRUE; + accepted = TRUE; + rejReason = REQUEST_REJECT_REASON_NONE; + } + + sendStartPrimeCmdResponse( accepted, rejReason ); } /*********************************************************************//** * @brief - * The signalStopPrime function signals the prime sub-mode to stop when an - * alarm with stop property has been triggered. + * The signalResumePrime function signals the prime sub-mode to resume + * previous operation. * @details Inputs: none - * @details Outputs: primeStopRequested + * @details Outputs: primeResumeRequested * @return none *************************************************************************/ -void signalStopPrime( void ) +void signalResumePrime( void ) { - primeStopRequested = TRUE; + primeResumeRequested = TRUE; } /*********************************************************************//** @@ -287,32 +275,25 @@ *************************************************************************/ static void resetPrimeFlags( void ) { - // TODO: set to false after integration with UI - primeStartRequested = TRUE; + primeStartRequested = FALSE; primeResumeRequested = FALSE; - primeStopRequested = FALSE; } /*********************************************************************//** * @brief - * The handlePrimePauseRequest function handles prime pause request. + * The setupForPrimePause function stop pumps handles prime pause request. * @details Inputs: none * @details Outputs: stop all pumps, switch to prime pause state. * @return none *************************************************************************/ -static void handlePrimePauseRequest( void ) +static void setupForPrimePause( void ) { - if ( ( TRUE == primeStopRequested ) && ( HD_PRIME_PAUSE != currentPrimeState ) ) - { - signalDialOutPumpHardStop(); - signalDialInPumpHardStop(); - signalBloodPumpHardStop(); + signalDialOutPumpHardStop(); + signalDialInPumpHardStop(); + signalBloodPumpHardStop(); - primeStopRequested = FALSE; - primePauseStartTime = getMSTimerCount(); - previousPrimeState = currentPrimeState; - currentPrimeState = HD_PRIME_PAUSE; - } + primePauseStartTime = getMSTimerCount(); + previousPrimeState = currentPrimeState; } /*********************************************************************//** @@ -335,7 +316,6 @@ if ( ++primeStatusBroadcastTimerCounter >= PRIME_DATA_PUB_INTERVAL ) { PRIMING_DATA_PAYLOAD_T primeData; - primeData.currentPrimeState = currentPrimeState; primeData.totalTime = MAX_PRIME_TIME; primeData.remainingTime = MAX_PRIME_TIME - elapsedPrimeTimeInSecs; @@ -346,126 +326,6 @@ /*********************************************************************//** * @brief - * The execPrimeReservoirMgmt function executes the state machine for the - * reservoir management during pre-treatment prime sub-mode. - * @details Inputs: currentReservoirMgmtState - * @details Outputs: DG reservoirs' fills managed. - * @return none - *************************************************************************/ -static void execPrimeReservoirMgmt( void ) -{ - DG_CMD_RESPONSE_T dgCmdResp; - DG_OP_MODE_T dgOpMode = getDGOpMode(); - U32 dgSubMode = getDGSubMode(); - - // treatment reservoir mgmt. state machine - switch ( currentReservoirMgmtState ) - { - case PRIME_RESERVOIR_MGMT_START_STATE: - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_FLUSH_DG_LINES_STATE; - break; - - case PRIME_RESERVOIR_MGMT_FLUSH_DG_LINES_STATE: - if ( DG_MODE_CIRC == dgOpMode ) - { - if ( DG_RECIRCULATE_MODE_STATE_RECIRC_WATER == dgSubMode ) - { - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_WAIT_FOR_DRAIN_CMD_RESP; - cmdStartDGDrain( PRIME_DRAIN_RESERVOIR_TO_VOLUME_ML, TRUE ); - } - } - else - { - // TODO Handle when DG mode is out of sync - } - break; - - case PRIME_RESERVOIR_MGMT_WAIT_FOR_DRAIN_CMD_RESP: - if ( ( TRUE == getDGCommandResponse( DG_CMD_START_DRAIN, &dgCmdResp ) ) && ( DG_CMD_REQUEST_REJECT_REASON_INVALID_MODE == dgCmdResp.rejected ) ) - { - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_FLUSH_DG_LINES_STATE; - } - - if ( DG_MODE_DRAI == dgOpMode ) - { - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_DRAIN_STATE; - } - break; - - case PRIME_RESERVOIR_MGMT_DRAIN_STATE: - if ( DG_MODE_CIRC == dgOpMode ) - { - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_START_FILL_STATE; - } - break; - - case PRIME_RESERVOIR_MGMT_START_FILL_STATE: - if ( ( DG_MODE_CIRC == dgOpMode ) && ( DG_RECIRCULATE_MODE_STATE_RECIRC_WATER == dgSubMode ) ) - { - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_WAIT_FOR_FILL_CMD_RESP; - - if ( DG_RESERVOIR_1 == getDGInactiveReservoir() ) - { - cmdStartDGFill( PRIME_FILL_RESERVOIR_ONE_VOLUME_ML ); - } - else - { - cmdStartDGFill( PRIME_FILL_RESERVOIR_TWO_VOLUME_ML ); - } - } - break; - - case PRIME_RESERVOIR_MGMT_WAIT_FOR_FILL_CMD_RESP: - if ( ( TRUE == getDGCommandResponse( DG_CMD_START_FILL, &dgCmdResp ) ) && ( DG_CMD_REQUEST_REJECT_REASON_INVALID_MODE == dgCmdResp.rejected ) ) - { - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_START_FILL_STATE; - } - - if ( DG_MODE_FILL == dgOpMode ) - { - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_FILL_STATE; - } - break; - - case PRIME_RESERVOIR_MGMT_FILL_STATE: - if ( DG_MODE_CIRC == dgOpMode ) - { - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_FILL_COMPLETE_STATE; - } - break; - - case PRIME_RESERVOIR_MGMT_FILL_COMPLETE_STATE: - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_FILL_COMPLETE_STATE; - - if ( FALSE == reservoirFilledStatus[ DG_RESERVOIR_1 ] ) - { - reservoirFilledStatus[ DG_RESERVOIR_1 ] = TRUE; - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_WAIT_RESERVOIR_TWO_INACTIVE; - } - else if ( ( TRUE == reservoirFilledStatus[ DG_RESERVOIR_1 ] ) && ( FALSE == reservoirFilledStatus[ DG_RESERVOIR_2 ] ) ) - { - reservoirFilledStatus[ DG_RESERVOIR_2 ] = TRUE; - } - break; - - case PRIME_RESERVOIR_MGMT_WAIT_RESERVOIR_TWO_INACTIVE: - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_WAIT_RESERVOIR_TWO_INACTIVE; - - if ( DG_RESERVOIR_2 == getDGInactiveReservoir() ) - { - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_FLUSH_DG_LINES_STATE; - } - break; - - default: - currentReservoirMgmtState = PRIME_RESERVOIR_MGMT_START_STATE; - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_MODE_PRIME_RESERVOIR_MGMT_INVALID_STATE, (U32)currentReservoirMgmtState ); - break; - } -} - -/*********************************************************************//** - * @brief * The purgeAirValvesBloodPumpControl function controls valves and blood pump * to purge air. * @details Inputs: none @@ -480,6 +340,8 @@ setValvePosition( VBV, VALVE_POSITION_C_CLOSE ); setValveAirTrap( STATE_OPEN ); + signalDialOutPumpHardStop(); + signalDialInPumpHardStop(); setBloodPumpTargetFlowRate( BLOOD_PUMP_FLOW_RATE_PURGE_AIR, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); } @@ -495,7 +357,12 @@ { HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_WAIT_FOR_USER_START_STATE; + // Keep updating start time until the user requested priming + primeStartTime = getMSTimerCount(); + +#ifndef SKIP_UI_INTERACTION if ( TRUE == primeStartRequested ) +#endif { primeStartRequested = FALSE; state = HD_PRIME_SALINE_SETUP_STATE; @@ -514,10 +381,18 @@ *************************************************************************/ static HD_PRE_TREATMENT_PRIME_STATE_T handlePrimeSalineSetupState( void ) { + HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_SALINE_PURGE_AIR_STATE; + purgeAirValvesBloodPumpControl(); purgeAirTimeOutStartTime = getMSTimerCount(); - return HD_PRIME_SALINE_PURGE_AIR_STATE; + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + setupForPrimePause(); + state = HD_PRIME_PAUSE; + } + + return state; } /*********************************************************************//** @@ -550,6 +425,12 @@ state = HD_PRIME_SALINE_CIRC_BLOOD_CIRCUIT_STATE; } + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + setupForPrimePause(); + state = HD_PRIME_PAUSE; + } + return state; } @@ -579,6 +460,12 @@ state = HD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE; } + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + setupForPrimePause(); + state = HD_PRIME_PAUSE; + } + return state; } @@ -594,30 +481,39 @@ { HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_RESERVOIR_ONE_FILL_COMPLETE_STATE; - if ( TRUE == reservoirFilledStatus[ DG_RESERVOIR_1 ] ) + if ( TRUE == getReservoirFillStatus( DG_RESERVOIR_1 ) ) { cmdSetDGActiveReservoir( DG_RESERVOIR_1 ); - setValvePosition( VDI, VALVE_POSITION_B_OPEN ); - setValvePosition( VDO, VALVE_POSITION_B_OPEN ); - setValvePosition( VBA, VALVE_POSITION_C_CLOSE ); - setValvePosition( VBV, VALVE_POSITION_C_CLOSE ); - setValveAirTrap( STATE_CLOSED ); + if ( TRUE == hasDGCompletedReservoirSwitch() ) + { + setValvePosition( VDI, VALVE_POSITION_B_OPEN ); + setValvePosition( VDO, VALVE_POSITION_B_OPEN ); + setValvePosition( VBA, VALVE_POSITION_C_CLOSE ); + setValvePosition( VBV, VALVE_POSITION_C_CLOSE ); + setValveAirTrap( STATE_CLOSED ); - setDialInPumpTargetFlowRate( DIALYSATE_PUMP_PRIME_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); - setDialOutPumpTargetRate( DIALYSATE_PUMP_PRIME_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); + setDialInPumpTargetFlowRate( DIALYSATE_PUMP_PRIME_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); + setDialOutPumpTargetRate( DIALYSATE_PUMP_PRIME_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); - previousLoadCellReading = 0; - loadcellSteadyVolumeStartTime = getMSTimerCount(); - primeDialysateDialyzerStartTime = getMSTimerCount(); + previousLoadCellReading = 0; + loadcellSteadyVolumeStartTime = getMSTimerCount(); + primeDialysateDialyzerStartTime = getMSTimerCount(); -#ifdef SKIP_PRIMING - state = HD_PRIME_WET_SELF_TESTS_STATE; -#else - state = HD_PRIME_DIALYSATE_DIALYZER_STATE; -#endif + #ifdef SKIP_PRIMING + state = HD_PRIME_WET_SELF_TESTS_STATE; + #else + state = HD_PRIME_DIALYSATE_DIALYZER_STATE; + #endif + } } + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + setupForPrimePause(); + state = HD_PRIME_PAUSE; + } + return state; } @@ -640,7 +536,15 @@ { if ( TRUE == didTimeout( loadcellSteadyVolumeStartTime, MIN_LOAD_CELL_STEADY_VOLUME_TIME ) ) { - state = HD_PRIME_RESERVOIR_TWO_FILL_COMPLETE_STATE; + if ( TRUE == runBloodCircuitPrimeAgain ) + { + runBloodCircuitPrimeAgain = FALSE; + state = HD_PRIME_SALINE_SETUP_STATE; + } + else + { + state = HD_PRIME_RESERVOIR_TWO_FILL_COMPLETE_STATE; + } } } else @@ -654,6 +558,12 @@ SET_ALARM_WITH_1_U32_DATA( ALARM_ID_PRIME_DIALYSATE_DIALYZER_TIME_OUT, PRIME_DIALYSATE_DIALYZER_TIME_LIMIT ); } + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + setupForPrimePause(); + state = HD_PRIME_PAUSE; + } + return state; } @@ -669,24 +579,34 @@ { HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_RESERVOIR_TWO_FILL_COMPLETE_STATE; - if ( TRUE == reservoirFilledStatus[ DG_RESERVOIR_2 ] ) + if ( TRUE == getReservoirFillStatus( DG_RESERVOIR_2 ) ) { cmdSetDGActiveReservoir( DG_RESERVOIR_2 ); - signalDialOutPumpHardStop(); - setDialInPumpTargetFlowRate( DIALYSATE_PUMP_PRIME_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); - setValvePosition( VDI, VALVE_POSITION_C_CLOSE ); - setValvePosition( VDO, VALVE_POSITION_C_CLOSE ); - setValvePosition( VBA, VALVE_POSITION_C_CLOSE ); - setValvePosition( VBV, VALVE_POSITION_C_CLOSE ); - setValveAirTrap( STATE_CLOSED ); + if ( TRUE == hasDGCompletedReservoirSwitch() ) + { + signalDialOutPumpHardStop(); + setDialInPumpTargetFlowRate( DIALYSATE_PUMP_PRIME_FLOW_RATE, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP ); - previousLoadCellReading = 0; - primeDialysateBypassStartTime = getMSTimerCount(); - loadcellSteadyVolumeStartTime = getMSTimerCount(); - state = HD_PRIME_DIALYSATE_BYPASS_STATE; + setValvePosition( VDI, VALVE_POSITION_C_CLOSE ); + setValvePosition( VDO, VALVE_POSITION_C_CLOSE ); + setValvePosition( VBA, VALVE_POSITION_C_CLOSE ); + setValvePosition( VBV, VALVE_POSITION_C_CLOSE ); + setValveAirTrap( STATE_CLOSED ); + + previousLoadCellReading = 0; + primeDialysateBypassStartTime = getMSTimerCount(); + loadcellSteadyVolumeStartTime = getMSTimerCount(); + state = HD_PRIME_DIALYSATE_BYPASS_STATE; + } } + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + setupForPrimePause(); + state = HD_PRIME_PAUSE; + } + return state; } @@ -723,6 +643,12 @@ SET_ALARM_WITH_1_U32_DATA( ALARM_ID_PRIME_DIALYSATE_BYPASS_TIME_OUT, PRIME_DIALYSATE_BYPASS_TIME_LIMIT ); } + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + setupForPrimePause(); + state = HD_PRIME_PAUSE; + } + return state; } @@ -738,23 +664,26 @@ { HD_PRE_TREATMENT_PRIME_STATE_T state = HD_PRIME_WET_SELF_TESTS_STATE; - if ( TRUE == primeStopRequested ) + if ( TRUE == primeResumeRequested ) { signalResumeSelfTests(); } - if ( TRUE == primeResumeRequested ) - { - signalStopSelfTests(); - } - +#ifndef SKIP_WET_SELF_TESTS execWetSelfTests(); if ( TRUE == isWetSelfTestsPassed() ) +#endif { state = HD_PRIME_COMPLETE; } + if ( TRUE == doesAlarmStatusIndicateStop() ) + { + setupForPrimePause(); + state = HD_PRIME_PAUSE; + } + return state; }