/**************************************************************************
*
* Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved.
*
* THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
* WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
*
* @file SelfTests.c
*
* @author (last) Quang Nguyen
* @date (last) 28-Jan-2021
*
* @author (original) Quang Nguyen
* @date (original) 28-Jan-2021s
*
***************************************************************************/

#include "AirTrap.h"
#include "BloodFlow.h"
#include "BloodLeak.h"
#include "DGInterface.h"
#include "DialInFlow.h"
#include "DialOutFlow.h"
#include "FPGA.h"
#include "PresOccl.h"
#include "SelfTests.h"
#include "TaskGeneral.h"
#include "Timers.h"
#include "Valves.h"

/**
 *  @addtogroup SelfTests
 *  @{
 */

// ********** private definitions **********

#define PUMP_RUN_SELF_TEST_TIME_MS                          ( 15 * MS_PER_SECOND )                  ///< Self-test time to run pumps in ms.
#define PUMP_SELF_TEST_FLOW_RATE_ML_MIN                     100                                     ///< Self-test pump flow rate in mL/min.

#define BLOOD_PUMP_RUN_TIME_PRESSURE_SELF_TEST              ( 5 * MS_PER_SECOND )                   ///< Pressure self-test time to run blood pump in ms.

#define ARTERIAL_PRESSURE_SELF_TEST_LOW_LIMIT_MMHG          -50.0                                   ///< Arterial pressure low limit after running blood pump.
#define VENOUS_PRESSURE_SELF_TEST_HIGH_LIMIT_MMHG           400                                     ///< Venous pressure high limit after running blood pump.

#define NORMAL_PRESSURE_DIFF_TOLERANCE_MMHG                 5                                       ///< Difference in pressure readings after return to normal state tolerance (in mmHg).

#define DIP_FLOW_RATE_SETUP_ML_MIN                          100                                     ///< Dialysate inlet pump flow rate during the setup for wet self-test.
#define DIP_FLOW_RATE_FIRST_DISPLACEMENT_ML_MIN             100                                     ///< Dialysate inlet pump flow rate during the first displacement in wet self-test.
#define DIP_FLOW_RATE_SECOND_DISPLACEMENT_ML_MIN            300                                     ///< Dialysate inlet pump flow rate during the second displacement in wet self-test.

#define WET_SELF_TEST_RESERVOIR_ONE_SETUP_VOLUME_ML         1500                                    ///< Setup volume for reservoir one before wet self-test in ml.
#define WET_SELF_TEST_FIRST_DISPLACEMENT_TARGET_VOLUME_ML   100                                     ///< Target of first displacement volume in ml.
#define WET_SELF_TEST_SECOND_DISPLACEMENT_TARGET_VOLUME_ML  300                                     ///< Target of second displacement volume in ml.
#define WET_SELF_TEST_INTEGRATED_VOLUME_TOLERANCE           5                                       ///< Tolerance on integrated volume in percentage.
#define WET_SELF_TEST_DISPLACEMENT_TOLERANCE_G              1.5                                     ///< Tolerance in the load cell readings of the displacement in grams.
#define WET_SELF_TEST_DISPLACEMENT_TIME_MS                  ( SEC_PER_MIN * MS_PER_SECOND )         ///< Time to displace dialysate in wet self-test in ms.
#define RESERVOIR_SETTLE_TIME_MS                            ( 4 * SEC_PER_MIN * MS_PER_SECOND )     ///< Time allotted for reservoir to settle in ms.

/// Multiplier to conver flow (mL/min) into volume (mL) for period of general task interval.
static const F32 SELF_TEST_FLOW_INTEGRATOR = ( ( 1.0 * TASK_GENERAL_INTERVAL ) / ( SEC_PER_MIN * MS_PER_SECOND ) );

/// Wet self-tests state machine.
typedef enum Wet_Self_Tests_State
{
    WET_SELF_TESTS_START_STATE = 0,                         ///< Wet self-tests starting state.
    WET_SELF_TESTS_SETUP_STATE,                             ///< Setup reservoirs for wet self-tests.
    WET_SELF_TESTS_BUBBLE_DETECTOR_STATE,                   ///< Bubble detectors wet self-tests state.
    WET_SELF_TESTS_FIRST_DISPLACEMENT_SETUP_STATE,          ///< Setup valve and start dialysate pump for first displacement.
    WET_SELF_TESTS_FIRST_DISPLACEMENT_STATE,                ///< Fill reservoir 2 with 100 mL of dialysate from reservoir 1 state.
    WET_SELF_TESTS_FIRST_DISPLACEMENT_VERIFY_STATE,         ///< After first displacement completed verify state.
    WET_SELF_TESTS_SECOND_DISPLACEMENT_SETUP_STATE,         ///< Setup valve and start dialysate pump for second displacement.
    WET_SELF_TESTS_SECOND_DISPLACEMENT_STATE,               ///< Fill reservoir 1 with 300 mL of dialysate from reservoir 2 state.
    WET_SELF_TESTS_SECOND_DISPLACEMENT_VERIFY_STATE,        ///< After first displacement completed verify state.
    WET_SELF_TESTS_STOPPED_STATE,                           ///< Wet self-test stopped state.
    WET_SELF_TESTS_COMPLETE_STATE,                          ///< Wet self-test complete state.
    NUM_OF_WET_SELF_TESTS_STATES                            ///< Number of wet self-tests states.
} WET_SELF_TESTS_STATE_T;

// ********** private data **********

static BOOL noCartSelfTestsResult;                                  ///< Result of no cartridge self-tests.
static NO_CART_SELF_TESTS_STATE_T currentNoCartSelfTestsState;      ///< Current state of the no cartridge self-tests state machine.
static U32 runPumpStartTime;                                        ///< Beginning time when pumps start running
static BOOL hasPumpsStarted;                                        ///< Flag indicates if pumps have started running for self-test.

static BOOL drySelfTestsResult;                                     ///< Result of dry self-tests.
static DRY_SELF_TESTS_STATE_T currentDrySelfTestsState;             ///< Current state of the dry self-tests state machine.

static BOOL wetSelfTestsResult;                                     ///< Result of wet self-tests.
static WET_SELF_TESTS_STATE_T currentWetSelfTestsState;             ///< Current state of the wet self-tests state machine.
static U32 settleStartTime;                                         ///< Wait for reservoir to settle start time.
static U32 displacementStartTime;                                   ///< Dialysate displacement starting time.
static F32 fmdIntegratedVolume;                                     ///< FMD integrated volume over displacement time.
static F32 reservoirVolume[ NUM_OF_DG_RESERVOIRS ];                 ///< Hold the current volume of all reservoirs.
static F32 setupDisplacementVolume;                                 ///< Hold the setup displacement volume to get reservoir one to target volume.
static BOOL isValvesSettingSent;                                    ///< Flag indicates valve setting change has been send to DG.

static BOOL selfTestsResumeRequested;                               ///< Flag indicates user requesting self-tests resume.
static BOOL selfTestsStopRequested;                                 ///< Flag indicates alarm requesting to stop self-test.

// ********** private function prototypes **********

static void resetSelfTestsFlags( void );
static void setupForSelfTestsStop( void );

static void handleNoCartSelfTestsStopRequest( void );
static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestsWaitForClosedDoor( void );
static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestPumpsState( void );
static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestHomeValvesAndPumpState( void );
static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestLeakDetectorsState( void );
static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestStoppedState( void );

static void handleWetSelfTestsStopRequest( void );
static WET_SELF_TESTS_STATE_T handleWetSelfTestStartState( void );
static WET_SELF_TESTS_STATE_T handleWetSelfTestSetupState( void );
static WET_SELF_TESTS_STATE_T handleWetSelfTestBubbleDetectorsState( SELF_TEST_STATUS_T *result );
static WET_SELF_TESTS_STATE_T handleWetSelfTestFirstDisplacementSetupState( void );
static WET_SELF_TESTS_STATE_T handleWetSelfTestFirstDisplacementState( void );
static WET_SELF_TESTS_STATE_T handleWetSelfTestFirstDisplacementVerifyState( SELF_TEST_STATUS_T *result );
static WET_SELF_TESTS_STATE_T handleWetSelfTestSecondDisplacementSetupState( void );
static WET_SELF_TESTS_STATE_T handleWetSelfTestSecondDisplacementState( void );
static WET_SELF_TESTS_STATE_T handleWetSelfTestSecondDisplacementVerifyState( SELF_TEST_STATUS_T *result );
static WET_SELF_TESTS_STATE_T handleWetSelfTestStoppedState( void );

/*********************************************************************//**
 * @brief
 * The initSelfTests function initializes the SelfTests module.
 * @details Inputs: none
 * @details Outputs: SelfTests module initialized.
 * @return none
 *************************************************************************/
void initSelfTests( void )
{
}

/*********************************************************************//**
 * @brief
 * The signalResumeSelfTests function signals the self-tests to resume
 * previous operation.
 * @details Inputs: none
 * @details Outputs: primeResumeRequested
 * @return none
 *************************************************************************/
void signalResumeSelfTests( void )
{
    selfTestsResumeRequested = TRUE;
}

/*********************************************************************//**
 * @brief
 * The signalStopPrime function signals self-tests to stop when an
 * alarm with stop property has been triggered.
 * @details Inputs: none
 * @details Outputs: primeStopRequested
 * @return none
 *************************************************************************/
void signalStopSelfTests( void )
{
    selfTestsStopRequested = TRUE;
}

/*********************************************************************//**
 * @brief
 * The resetSelfTestsFlags function resets all self-tests signal flags.
 * @details Inputs: none
 * @details Outputs: signal flags set to FALSE
 * @return none
 *************************************************************************/
static void resetSelfTestsFlags( void )
{
    selfTestsResumeRequested = FALSE;
    selfTestsStopRequested = FALSE;
}

/*********************************************************************//**
 * @brief
 * The setupForSelfTestsStop function sets actuators appropriately for self-tests
 * states.
 * @details Inputs: none
 * @details Outputs: All pumps stopped
 * @return none
 *************************************************************************/
static void setupForSelfTestsStop( void )
{
    signalBloodPumpHardStop();
    signalDialInPumpHardStop();
    signalDialOutPumpHardStop();
}

/*********************************************************************//**
 * @brief
 * The transitionToNoCartSelfTests function resets anything required before
 * the start of no cartridge self-tests.
 * @details Inputs: none
 * @details Outputs: No cartridge self-tests re-initialized.
 * @return none
 *************************************************************************/
void transitionToNoCartSelfTests( void )
{
    noCartSelfTestsResult = FALSE;
    currentNoCartSelfTestsState = NO_CART_SELF_TESTS_START_STATE;
    runPumpStartTime = 0;
    hasPumpsStarted = FALSE;

    resetSelfTestsFlags();
}

/*********************************************************************//**
 * @brief
 * The execNoCartSelfTests function executes the no cartridge self-tests
 * state machine.
 * @details Inputs: currentNoCartSelfTestsState
 * @details Outputs: currentNoCartSelfTestsState, noCartSelfTestsResult
 * @return none
 *************************************************************************/
void execNoCartSelfTests( void )
{
    SELF_TEST_STATUS_T result = SELF_TEST_STATUS_PASSED;

    // execute no cartridge self-tests state machine
    switch ( currentNoCartSelfTestsState )
    {
        case NO_CART_SELF_TESTS_START_STATE:
#ifdef SKIP_SELF_TESTS
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_HOME_VALVES_AND_PUMPS_STATE;
#else
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE;
#endif
            break;

        case NO_CART_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE:
            currentNoCartSelfTestsState = handleNoCartSelfTestsWaitForClosedDoor();
            break;

        case NO_CART_SELF_TESTS_OCCLUSION_SENSORS_STATE:
            result = execPresOcclTest();

            if ( SELF_TEST_STATUS_PASSED == result )
            {
                currentNoCartSelfTestsState = NO_CART_SELF_TESTS_BLOOD_FLOW_METERS_STATE;
            }
            break;

        case NO_CART_SELF_TESTS_BLOOD_FLOW_METERS_STATE:
            result = execBloodFlowTest();

            if ( SELF_TEST_STATUS_PASSED == result )
            {
                currentNoCartSelfTestsState = NO_CART_SELF_TESTS_DIALYSATE_FLOW_METERS_STATE;
            }
            break;

        case NO_CART_SELF_TESTS_DIALYSATE_FLOW_METERS_STATE:
            result = execDialInFlowTest();

            if ( SELF_TEST_STATUS_PASSED == result )
            {
                currentNoCartSelfTestsState = NO_CART_SELF_TESTS_PUMPS_STATE;
            }
            break;

        case NO_CART_SELF_TESTS_PUMPS_STATE:
            currentNoCartSelfTestsState = handleNoCartSelfTestPumpsState();
            break;

        case NO_CART_SELF_TESTS_LEAK_DETECTORS_STATE:
            currentNoCartSelfTestsState = handleNoCartSelfTestLeakDetectorsState();
            break;

        case NO_CART_SELF_TESTS_HOME_VALVES_AND_PUMPS_STATE:
            currentNoCartSelfTestsState = handleNoCartSelfTestHomeValvesAndPumpState();
            break;

        case NO_CART_SELF_TESTS_HOME_IDLE_STATE:
            if ( ( FALSE == isDialInPumpRunning() ) && ( FALSE == isDialOutPumpRunning() ) && ( FALSE == isBloodPumpRunning() ) )
            {
                currentNoCartSelfTestsState = NO_CART_SELF_TESTS_COMPLETE_STATE;
            }
            break;

        case NO_CART_SELF_TESTS_STOPPED_STATE:
            currentNoCartSelfTestsState = handleNoCartSelfTestStoppedState();
            break;

        case NO_CART_SELF_TESTS_COMPLETE_STATE:
            noCartSelfTestsResult = TRUE;
            break;

        default:
            currentNoCartSelfTestsState = NO_CART_SELF_TESTS_START_STATE;
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_HD_INVALID_NO_CARTRIDGE_SELF_TEST_STATE, (U32)currentNoCartSelfTestsState );
            break;
    }

    // Transition to stopped state when alarm with stop property has been triggered
    handleNoCartSelfTestsStopRequest();

    // Self-tests flags should be handled by now, reset if flags not handled with current state
    resetSelfTestsFlags();

    if ( SELF_TEST_STATUS_FAILED == result )
    {
        SET_ALARM_WITH_1_U32_DATA( ALARM_ID_PRE_TREATMENT_NO_CART_SELF_TEST_FAILURE, currentNoCartSelfTestsState );
    }
}

/*********************************************************************//**
 * @brief
 * The isNoCartSelfTestsPassed function returns the status of no cartridge self-tests.
 * @details Inputs: none
 * @details Outputs: none
 * @return TRUE if no cartridge self-tests passed, otherwise FALSE
 *************************************************************************/
BOOL isNoCartSelfTestsPassed( void )
{
    return noCartSelfTestsResult;
}

/*********************************************************************//**
 * @brief
 * The execDrySelfTests function executes the dry self-tests state machine.
 * @details Inputs: currentDrySelfTestsState
 * @details Outputs: currentDrySelfTestsState, drySelfTestsResult
 * @return none
 *************************************************************************/
void execDrySelfTests( void )
{
    SELF_TEST_STATUS_T result = SELF_TEST_STATUS_PASSED;

    // execute dry self-tests state machine
    switch ( currentDrySelfTestsState )
    {
        case DRY_SELF_TESTS_START_STATE:
#ifdef SKIP_SELF_TESTS
            currentDrySelfTestsState = DRY_SELF_TESTS_COMPLETE_STATE;
#else
            currentDrySelfTestsState = DRY_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE;
#endif
            break;

        case DRY_SELF_TESTS_OCCLUSION_SENSORS_STATE:
            if ( SELF_TEST_STATUS_PASSED == execPresOcclDryTest() )
            {
                currentDrySelfTestsState = DRY_SELF_TESTS_PRESSURE_SENSORS_SETUP_STATE;
            }
            break;

        case DRY_SELF_TESTS_COMPLETE_STATE:
            drySelfTestsResult = TRUE;
            break;

        default:
            currentDrySelfTestsState = DRY_SELF_TESTS_START_STATE;
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_HD_INVALID_DRY_SELF_TEST_STATE, (U32)currentDrySelfTestsState );
            break;
    }

    // Self-tests flags should be handled by now, reset if flags not handled with current state
    resetSelfTestsFlags();

    if ( SELF_TEST_STATUS_FAILED == result )
    {
        SET_ALARM_WITH_1_U32_DATA( ALARM_ID_PRE_TREATMENT_DRY_SELF_TEST_FAILURE, currentDrySelfTestsState );
    }
}

/*********************************************************************//**
 * @brief
 * The isDrySelfTestsPassed function returns the status of dry self-tests.
 * @details Inputs: none
 * @details Outputs: none
 * @return TRUE if dry self-tests passed, otherwise FALSE
 *************************************************************************/
BOOL isDrySelfTestsPassed( void )
{
    return drySelfTestsResult;
}

/*********************************************************************//**
 * @brief
 * The transitionToWetSelfTests function resets anything required before
 * the start of wet self-tests.
 * @details Inputs: none
 * @details Outputs: Wet self-tests re-initialized.
 * @return none
 *************************************************************************/
void transitionToWetSelfTests()
{
    wetSelfTestsResult = FALSE;
    currentWetSelfTestsState = WET_SELF_TESTS_START_STATE;
    settleStartTime = 0;
    displacementStartTime = 0;
    fmdIntegratedVolume = 0.0;
    isValvesSettingSent = FALSE;

    resetSelfTestsFlags();
}

/*********************************************************************//**
 * @brief
 * The execWetSelfTests function executes the wet self-tests state machine.
 * @details Inputs: currentWetSelfTestsState
 * @details Outputs: currentWetSelfTestsState, wetSelfTestsResult
 * @return none
 *************************************************************************/
void execWetSelfTests( void )
{
    SELF_TEST_STATUS_T result = SELF_TEST_STATUS_PASSED;

    // execute wet self-tests state machine
    switch ( currentWetSelfTestsState )
    {
        case WET_SELF_TESTS_START_STATE:
            currentWetSelfTestsState = handleWetSelfTestStartState();
            break;

        case WET_SELF_TESTS_SETUP_STATE:
            currentWetSelfTestsState = handleWetSelfTestSetupState();
            break;

        case WET_SELF_TESTS_BUBBLE_DETECTOR_STATE:
            currentWetSelfTestsState = handleWetSelfTestBubbleDetectorsState( &result );
            break;

        case WET_SELF_TESTS_FIRST_DISPLACEMENT_SETUP_STATE:
            currentWetSelfTestsState = handleWetSelfTestFirstDisplacementSetupState();
            break;

        case WET_SELF_TESTS_FIRST_DISPLACEMENT_STATE:
            currentWetSelfTestsState = handleWetSelfTestFirstDisplacementState();
            break;

        case WET_SELF_TESTS_FIRST_DISPLACEMENT_VERIFY_STATE:
            currentWetSelfTestsState = handleWetSelfTestFirstDisplacementVerifyState( &result );
            break;

        case WET_SELF_TESTS_SECOND_DISPLACEMENT_SETUP_STATE:
            currentWetSelfTestsState = handleWetSelfTestSecondDisplacementSetupState();
            break;

        case WET_SELF_TESTS_SECOND_DISPLACEMENT_STATE:
            currentWetSelfTestsState = handleWetSelfTestSecondDisplacementState();
            break;

        case WET_SELF_TESTS_SECOND_DISPLACEMENT_VERIFY_STATE:
            currentWetSelfTestsState = handleWetSelfTestSecondDisplacementVerifyState( &result );
            break;

        case WET_SELF_TESTS_STOPPED_STATE:
            currentWetSelfTestsState = handleWetSelfTestStoppedState();
            break;

        case WET_SELF_TESTS_COMPLETE_STATE:
            wetSelfTestsResult = TRUE;
            break;

        default:
            currentWetSelfTestsState = WET_SELF_TESTS_START_STATE;
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_HD_INVALID_WET_SELF_TEST_STATE, (U32)currentWetSelfTestsState );
            break;
    }

    // Transition to stopped state when alarm with stop property has been triggered
    handleWetSelfTestsStopRequest();

    // Self-tests flags should be handled by now, reset if flags not handled with current state
    resetSelfTestsFlags();

    if ( SELF_TEST_STATUS_FAILED == result )
    {
        SET_ALARM_WITH_1_U32_DATA( ALARM_ID_PRE_TREATMENT_WET_SELF_TEST_FAILURE, currentWetSelfTestsState );
    }
}

/*********************************************************************//**
 * @brief
 * The isDrySelfTestsPassed function returns the status of wet self-tests.
 * @details Inputs: none
 * @details Outputs: none
 * @return TRUE if wet self-tests passed, otherwise FALSE
 *************************************************************************/
BOOL isWetSelfTestsPassed( void )
{
    return wetSelfTestsResult;
}

/*********************************************************************//**
 * @brief
 * The handleNoCartSelfTestsStopRequest function handles stop request from alarm
 * and transition to stopped state.
 * @details Inputs: none
 * @details Outputs: none
 * @return the next state of no cart self-tests state machine
 *************************************************************************/
static void handleNoCartSelfTestsStopRequest( void )
{
    if ( TRUE == selfTestsStopRequested )
    {
        setupForSelfTestsStop();

        currentNoCartSelfTestsState = NO_CART_SELF_TESTS_STOPPED_STATE;
        selfTestsStopRequested = FALSE;
    }
}

/*********************************************************************//**
 * @brief
 * The handleNoCartridgeWaitForClosedDoor function executes the wait for
 * door to be closed state of no cartridge self-tests state machine.
 * @details Inputs: none
 * @details Outputs: none
 * @return the next state of no cartridge self-tests state machine
 *************************************************************************/
static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestsWaitForClosedDoor( void )
{
    NO_CART_SELF_TESTS_STATE_T state = NO_CART_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE;

    signalBloodPumpHardStop();
    signalDialInPumpHardStop();
    signalDialOutPumpHardStop();

    if ( STATE_CLOSED == getFPGADoorState() )
    {
        state = NO_CART_SELF_TESTS_OCCLUSION_SENSORS_STATE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleNoCartSelfTestPumpsState function runs blood, dialysate inlet,
 * dialysate outlet pumps for certain time to make sure no alarms occur.
 * @details Inputs: none
 * @details Outputs: none
 * @return the next state of no cartridge self-tests state machine
 *************************************************************************/
static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestPumpsState( void )
{
    NO_CART_SELF_TESTS_STATE_T state = NO_CART_SELF_TESTS_PUMPS_STATE;

    if ( FALSE == hasPumpsStarted )
    {
        hasPumpsStarted = TRUE;

        setBloodPumpTargetFlowRate( PUMP_SELF_TEST_FLOW_RATE_ML_MIN, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
        setDialInPumpTargetFlowRate( PUMP_SELF_TEST_FLOW_RATE_ML_MIN, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
        setDialOutPumpTargetRate( PUMP_SELF_TEST_FLOW_RATE_ML_MIN, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
        runPumpStartTime = getMSTimerCount();
    }

    if ( TRUE == didTimeout( runPumpStartTime, PUMP_RUN_SELF_TEST_TIME_MS ) )
    {
        signalBloodPumpHardStop();
        signalDialInPumpHardStop();
        signalDialOutPumpHardStop();

        zeroBloodLeak();
        state = NO_CART_SELF_TESTS_LEAK_DETECTORS_STATE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleNoCartSelfTestHomeValvesAndPumpState function homes all valves
 * and pumps.
 * @details Inputs: none
 * @details Outputs: none
 * @return the next state of no cartridge self-tests state machine
 *************************************************************************/
static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestHomeValvesAndPumpState( void )
{
    VALVE_T valve;

    for ( valve = VDI; valve < NUM_OF_VALVES; ++valve )
    {
        homeValve( valve );
    }

    homeBloodPump();
    homeDialInPump();
    homeDialOutPump();

    return NO_CART_SELF_TESTS_HOME_IDLE_STATE;
}

/*********************************************************************//**
 * @brief
 * The handleNoCartSelfTestLeakDetectorsState function verify leak detectors status.
 * @details Inputs: none
 * @details Outputs: none
 * @return the next state of no cartridge self-tests state machine
 *************************************************************************/
static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestLeakDetectorsState( void )
{
    NO_CART_SELF_TESTS_STATE_T state = NO_CART_SELF_TESTS_LEAK_DETECTORS_STATE;

    if ( SELF_TEST_STATUS_PASSED == getBloodLeakSelfTestStatus() )
    {
        state = NO_CART_SELF_TESTS_BOARD_TEMPERATURE_STATE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleNoCartSelfTestStoppedState function handles the stopped no
 * cartridge self-tests operation.
 * @details Inputs: none
 * @details Outputs: none
 * @return the next state of no cart self-tests state machine
 *************************************************************************/
static NO_CART_SELF_TESTS_STATE_T handleNoCartSelfTestStoppedState( void )
{
    NO_CART_SELF_TESTS_STATE_T state = NO_CART_SELF_TESTS_STOPPED_STATE;

    if ( TRUE == selfTestsResumeRequested )
    {
        selfTestsResumeRequested = FALSE;
        state = NO_CART_SELF_TESTS_WAIT_FOR_DOOR_CLOSE_STATE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleWetSelfTestsStopRequest function handles stop request from alarm
 * and transition to stopped state.
 * @details Inputs: none
 * @details Outputs: none
 * @return the next state of wet self-tests state machine
 *************************************************************************/
static void handleWetSelfTestsStopRequest( void )
{
    if ( TRUE == selfTestsStopRequested )
    {
        setupForSelfTestsStop();

        currentWetSelfTestsState = WET_SELF_TESTS_STOPPED_STATE;
        selfTestsStopRequested = FALSE;
    }
}

/*********************************************************************//**
 * @brief
 * The handleWetSelfTestStartState function handles setup state for wet
 * self-tests sub-mode.
 * @details Inputs: reservoir one weight
 * @details Outputs: setup valves and dialysate inlet pump
 * @return the next state of wet self-tests state machine
 *************************************************************************/
static WET_SELF_TESTS_STATE_T handleWetSelfTestStartState( void )
{
    WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_START_STATE;
    DG_CMD_RESPONSE_T cmdResp;

    F32 const resOneWeight = getReservoirWeightLargeFilter( DG_RESERVOIR_1 );
    setupDisplacementVolume = fabs( resOneWeight - WET_SELF_TEST_RESERVOIR_ONE_SETUP_VOLUME_ML );

    if ( FALSE == isValvesSettingSent )
    {
        if ( resOneWeight > WET_SELF_TEST_RESERVOIR_ONE_SETUP_VOLUME_ML )
        {
            setValvePosition( VDI, VALVE_POSITION_C_CLOSE );
            setValvePosition( VDO, VALVE_POSITION_C_CLOSE );
            cmdChangeDGValveSetting( DG_VALVE_SETTING_R1_TO_R2 );
        }
        else
        {
            setValvePosition( VDI, VALVE_POSITION_C_CLOSE );
            setValvePosition( VDO, VALVE_POSITION_C_CLOSE );
            cmdChangeDGValveSetting( DG_VALVE_SETTING_R2_TO_R1 );
        }

        isValvesSettingSent = TRUE;
    }

    if ( ( TRUE == isValvesSettingSent ) && ( TRUE == getDGCommandResponse( DG_CMD_VALVE_SETTING, &cmdResp ) ) )
    {
        // Re-send command if DG rejects
        isValvesSettingSent = FALSE;

        if ( FALSE == cmdResp.rejected )
        {
            setDialInPumpTargetFlowRate( DIP_FLOW_RATE_SETUP_ML_MIN, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
            fmdIntegratedVolume = 0;
            state = WET_SELF_TESTS_SETUP_STATE;
        }
    }

#ifdef SKIP_SELF_TESTS
    state = WET_SELF_TESTS_COMPLETE_STATE;
#endif

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleWetSelfTestSetupState function setup reservoir one before
 * the start of wet self-tests.
 * @details Inputs: dialysate inlet flow rate
 * @details Outputs: stop dialysate inlet pump
 * @return the next state of wet self-tests state machine
 *************************************************************************/
static WET_SELF_TESTS_STATE_T handleWetSelfTestSetupState( void )
{
    WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_SETUP_STATE;

    setupDisplacementVolume -= ( SELF_TEST_FLOW_INTEGRATOR * getMeasuredDialInFlowRate() );

    if ( setupDisplacementVolume <= 0 )
    {
        signalDialInPumpHardStop();
        state = WET_SELF_TESTS_BUBBLE_DETECTOR_STATE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleWetSelfTestBubbleDetectorsState function handles the wet self-test
 * for bubble detectors.
 * @details Inputs: Arterial and venous air bubble status
 * @details Outputs: Test pass/fail
 * @param result self-test result
 * @return the next state of wet self-tests state machine
 *************************************************************************/
static WET_SELF_TESTS_STATE_T handleWetSelfTestBubbleDetectorsState( SELF_TEST_STATUS_T *result )
{
    WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_BUBBLE_DETECTOR_STATE;

    BOOL const isADADetectedAir = getFPGAArterialAirBubbleStatus();
    BOOL const isADVDetectedAir = getFPGAVenousAirBubbleStatus();

    if ( ( FALSE == isADADetectedAir ) && ( FALSE == isADVDetectedAir ) )
    {
        settleStartTime = getMSTimerCount();
        currentWetSelfTestsState = WET_SELF_TESTS_FIRST_DISPLACEMENT_SETUP_STATE;
    }
    else
    {
        *result = SELF_TEST_STATUS_FAILED;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleWetSelfTestStartFirstDisplacementState function setups the valves
 * and pumps to start first dialysate displacement.
 * @details Inputs: settleStartTime
 * @details Outputs: setup valves and pump, reservoirVolume[]
 * @return the next state of wet self-tests state machine
 *************************************************************************/
static WET_SELF_TESTS_STATE_T handleWetSelfTestFirstDisplacementSetupState( void )
{
    WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_FIRST_DISPLACEMENT_SETUP_STATE;
    DG_CMD_RESPONSE_T cmdResp;

    if ( ( FALSE == isValvesSettingSent ) && ( TRUE == didTimeout( settleStartTime, RESERVOIR_SETTLE_TIME_MS ) ) )
    {
        reservoirVolume[ DG_RESERVOIR_1 ] = getReservoirWeightLargeFilter( DG_RESERVOIR_1 );
        reservoirVolume[ DG_RESERVOIR_2 ] = getReservoirWeightLargeFilter( DG_RESERVOIR_2 );

        setValvePosition( VDI, VALVE_POSITION_C_CLOSE );
        setValvePosition( VDO, VALVE_POSITION_C_CLOSE );
        cmdChangeDGValveSetting( DG_VALVE_SETTING_R1_TO_R2 );
        isValvesSettingSent = TRUE;
    }

    if ( ( TRUE == isValvesSettingSent ) && ( TRUE == getDGCommandResponse( DG_CMD_VALVE_SETTING, &cmdResp ) ) )
    {
        // Re-send command if DG rejects
        isValvesSettingSent = FALSE;

        if ( FALSE == cmdResp.rejected )
        {
            setDialInPumpTargetFlowRate( DIP_FLOW_RATE_FIRST_DISPLACEMENT_ML_MIN, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
            displacementStartTime = getMSTimerCount();
            fmdIntegratedVolume = 0;
            state = WET_SELF_TESTS_FIRST_DISPLACEMENT_STATE;
        }
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleWetSelfTestFirstDisplacementState function handles the first
 * dialysate displacement from reservoir 1 to reservoir 2.
 * @details Inputs: firstDisplacementStartTime, measured dialysate flow rate
 * @details Outputs: integrated volume
 * @return the next state of wet self-tests state machine
 *************************************************************************/
static WET_SELF_TESTS_STATE_T handleWetSelfTestFirstDisplacementState( void )
{
    WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_FIRST_DISPLACEMENT_STATE;

    fmdIntegratedVolume += getMeasuredDialInFlowRate();

    if ( TRUE == didTimeout( displacementStartTime, WET_SELF_TEST_DISPLACEMENT_TIME_MS ) )
    {
        signalDialInPumpHardStop();
        fmdIntegratedVolume = ( ( fmdIntegratedVolume * TASK_GENERAL_INTERVAL ) / ( SEC_PER_MIN * MS_PER_SECOND ) );

        settleStartTime = getMSTimerCount();
        state = WET_SELF_TESTS_FIRST_DISPLACEMENT_VERIFY_STATE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleWetSelfTestFirstDisplacementVerifyState function checks the load cell
 * readings and FMD integrated volume after the first dialysate displacement.
 * @details Inputs: settleStartTime, reservoirVolume[], reservoirs' weights
 * @details Outputs: verify correctness of dialysate flow meter and load cell
 * @return the next state of wet self-tests state machine
 *************************************************************************/
static WET_SELF_TESTS_STATE_T handleWetSelfTestFirstDisplacementVerifyState( SELF_TEST_STATUS_T *result )
{
    WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_FIRST_DISPLACEMENT_VERIFY_STATE;

    if ( TRUE == didTimeout( settleStartTime, RESERVOIR_SETTLE_TIME_MS ) )
    {
        F32 const resOneDiffAfterDisplacement = fabs( getReservoirWeightLargeFilter( DG_RESERVOIR_1 ) - reservoirVolume[ DG_RESERVOIR_1 ] );
        F32 const resTwoDiffAfterDisplacement = fabs( getReservoirWeightLargeFilter( DG_RESERVOIR_2 ) - reservoirVolume[ DG_RESERVOIR_2 ] );
        F32 const integratedVolumeToTargetPercent = 1 - ( fmdIntegratedVolume / WET_SELF_TEST_FIRST_DISPLACEMENT_TARGET_VOLUME_ML );

        if ( ( fabs( resOneDiffAfterDisplacement - resTwoDiffAfterDisplacement) <= WET_SELF_TEST_DISPLACEMENT_TOLERANCE_G ) &&
             ( integratedVolumeToTargetPercent <= WET_SELF_TEST_INTEGRATED_VOLUME_TOLERANCE ) )
        {
            state = WET_SELF_TESTS_SECOND_DISPLACEMENT_SETUP_STATE;
        }
        else
        {
            *result = SELF_TEST_STATUS_FAILED;
        }
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleWetSelfTestSecondDisplacementSetupState function setups the valves
 * and pumps to start second dialysate displacement.
 * @details Inputs: settleStartTime
 * @details Outputs: setup valves and pump, reservoirVolume[]
 * @return the next state of wet self-tests state machine
 *************************************************************************/
static WET_SELF_TESTS_STATE_T handleWetSelfTestSecondDisplacementSetupState( void )
{
    WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_SECOND_DISPLACEMENT_SETUP_STATE;
    DG_CMD_RESPONSE_T cmdResp;

    if ( ( FALSE == isValvesSettingSent ) && ( TRUE == didTimeout( settleStartTime, RESERVOIR_SETTLE_TIME_MS ) ) )
    {
        reservoirVolume[ DG_RESERVOIR_1 ] = getReservoirWeightLargeFilter( DG_RESERVOIR_1 );
        reservoirVolume[ DG_RESERVOIR_2 ] = getReservoirWeightLargeFilter( DG_RESERVOIR_2 );

        setValvePosition( VDI, VALVE_POSITION_C_CLOSE );
        setValvePosition( VDO, VALVE_POSITION_C_CLOSE );
        cmdChangeDGValveSetting( DG_VALVE_SETTING_R1_TO_R2 );
        isValvesSettingSent = TRUE;
    }

    if ( ( TRUE == isValvesSettingSent ) && ( TRUE == getDGCommandResponse( DG_CMD_VALVE_SETTING, &cmdResp ) ) )
    {
        // Re-send command if DG rejects
        isValvesSettingSent = FALSE;

        if ( FALSE == cmdResp.rejected )
        {
            setDialInPumpTargetFlowRate( DIP_FLOW_RATE_SECOND_DISPLACEMENT_ML_MIN, MOTOR_DIR_FORWARD, PUMP_CONTROL_MODE_OPEN_LOOP );
            displacementStartTime = getMSTimerCount();
            fmdIntegratedVolume = 0;
            state = WET_SELF_TESTS_SECOND_DISPLACEMENT_STATE;
        }
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleWetSelfTestSecondDisplacementState function handles the first
 * dialysate displacement from reservoir 2 to reservoir 1.
 * @details Inputs: firstDisplacementStartTime, measured dialysate flow rate
 * @details Outputs: integrated volume
 * @return the next state of wet self-tests state machine
 *************************************************************************/
static WET_SELF_TESTS_STATE_T handleWetSelfTestSecondDisplacementState( void )
{
    WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_SECOND_DISPLACEMENT_STATE;

    fmdIntegratedVolume += getMeasuredDialInFlowRate();

    if ( TRUE == didTimeout( displacementStartTime, WET_SELF_TEST_DISPLACEMENT_TIME_MS ) )
    {
        signalDialInPumpHardStop();
        // Convert flow into volume for period of general task interval
        fmdIntegratedVolume = ( ( fmdIntegratedVolume * TASK_GENERAL_INTERVAL ) / ( SEC_PER_MIN * MS_PER_SECOND ) );

        settleStartTime = getMSTimerCount();
        state = WET_SELF_TESTS_SECOND_DISPLACEMENT_VERIFY_STATE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleWetSelfTestSecondDisplacementVerifyState function checks the load cell
 * readings and FMD integrated volume after the second dialysate displacement.
 * @details Inputs: settleStartTime, reservoirVolume[], reservoirs' weights
 * @details Outputs: verify correctness of dialysate flow meter and load cell
 * @return the next state of wet self-tests state machine
 *************************************************************************/
static WET_SELF_TESTS_STATE_T handleWetSelfTestSecondDisplacementVerifyState( SELF_TEST_STATUS_T *result )
{
    WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_SECOND_DISPLACEMENT_VERIFY_STATE;

    if ( TRUE == didTimeout( settleStartTime, RESERVOIR_SETTLE_TIME_MS ) )
    {
        F32 const resOneDiffAfterDisplacement = fabs( getReservoirWeightLargeFilter( DG_RESERVOIR_1 ) - reservoirVolume[ DG_RESERVOIR_1 ] );
        F32 const resTwoDiffAfterDisplacement = fabs( getReservoirWeightLargeFilter( DG_RESERVOIR_2 ) - reservoirVolume[ DG_RESERVOIR_2 ] );
        F32 const integratedVolumeToTargetPercent = 1 - ( fmdIntegratedVolume / WET_SELF_TEST_FIRST_DISPLACEMENT_TARGET_VOLUME_ML );

        if ( ( fabs( resOneDiffAfterDisplacement - resTwoDiffAfterDisplacement) <= WET_SELF_TEST_DISPLACEMENT_TOLERANCE_G ) &&
             ( integratedVolumeToTargetPercent <= WET_SELF_TEST_INTEGRATED_VOLUME_TOLERANCE ) )
        {
            state = WET_SELF_TESTS_COMPLETE_STATE;
        }
        else
        {
            *result = SELF_TEST_STATUS_FAILED;
        }
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleWetSelfTestStoppedState function handles the stopped wet self-tests
 * operation.
 * @details Inputs: none
 * @details Outputs: none
 * @return the next state of wet self-tests state machine
 *************************************************************************/
static WET_SELF_TESTS_STATE_T handleWetSelfTestStoppedState( void )
{
    WET_SELF_TESTS_STATE_T state = WET_SELF_TESTS_STOPPED_STATE;

    if ( TRUE == selfTestsResumeRequested )
    {
        selfTestsResumeRequested = FALSE;
        state = WET_SELF_TESTS_START_STATE;
    }

    return state;
}

/**@}*/