/**************************************************************************
*
* Copyright (c) 2024-2024 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    ModeGenDialysate.c
*
* @author  (last)      Vinayakam Mani
* @date    (last)      30-Oct-2024
*
* @author  (original)  Vinayakam Mani
* @date    (original)  30-Oct-2024
*
***************************************************************************/

#include "BalancingChamber.h"
#include "ConcentratePumps.h"
#include "Conductivity.h"
#include "DialysatePumps.h"
#include "FpgaDD.h"
#include "Level.h"
#include "ModeGenDialysate.h"
#include "ModeStandby.h"
#include "OperationModes.h"
#include "Pressure.h"
#include "TaskGeneral.h"
#include "TDInterface.h"
#include "Temperature.h"
#include "Timers.h"
#include "Valves.h"

/**
 *  @addtogroup DDGenDialysateMode
 *  @{
 */

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

#define FRESH_DIAL_PUMP_INITIAL_RPM             2500                                        ///< Nominal RPM target for fresh dialysate pump to maintain required pressure.
#define SPENT_DIAL_PUMP_INITIAL_RPM             2500                                        ///< Nominal RPM target for spent dialysate pump to maintain required pressure.
#define HYD_CHAMBER_FLUID_TEMP_C_MIN            35.0F                                       ///< Minimum hydraulics fluid temperature in deg celcius
#define HYD_CHAMBER_PRES_CHECK_TIME_OUT         ( 1 * SEC_PER_MIN * MS_PER_SECOND )         ///< Time out period when hydraulics chamber pressure check initiated
#define SPENT_DIAL_PRES_CHECK_TIME_OUT          ( 1 * SEC_PER_MIN * MS_PER_SECOND )         ///< Time out period when spent dialysate pressure check initiated
#define HYD_CHAMBER_TARGET_NEG_PRESS_MIN_PSI    (-11.7877F)                                 ///< Hydraulics chamber minimum negative pressure(D9/PHo) in psi.
#define HYD_CHAMBER_TARGET_NEG_PRESS_MAX_PSI    (-12.2789F)                                 ///< Hydraulics chamber maximum negative pressure(D9/PHo) in psi.
#define HYD_CHAMBER_TARGET_POS_PRESS_MIN_PSI    ( 23.0F )                                   ///< Hydraulics chamber or fresh dialysate minimum positive pressure(D18/PDf) in psi.
#define HYD_CHAMBER_TARGET_POS_PRESS_MAX_PSI    ( 25.0F )                                   ///< Hydraulics chamber or fresh dialysate maximum positive pressure(D18/PDf) in psi.
#define SPENT_DIAL_TARGET_POS_PRESS_MIN_PSI     ( 29.0F )                                   ///< Spent dialysate minimum positive pressure(D51/PDs) in psi.
#define SPENT_DIAL_TARGET_POS_PRESS_MAX_PSI     ( 30.0F )                                   ///< Spent dialysate maximum positive pressure(D18/PDs) in psi.
#define GEN_DIALYSATE_DATA_PUBLISH_INTERVAL     ( MS_PER_SECOND / TASK_GENERAL_INTERVAL )   ///< Interval (ms/task time) at which the gen dialysate mode data published.

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

static DD_GEND_MODE_STATE_T genDialysateState = DD_GEND_STATE_START;                        ///< Currently active gen dialysate state.
//static OVERRIDE_F32_T targetHydChamberFluidTemp;                                          ///< Target hydraulics chamber fluid temperature.
//static BOOL isHydChamberTempinRange = FALSE;                                              ///< Flag indicating hydraulics chamber water temperature is in range.
static U32 hydChamberPressureCheckStartTimeMS;                                              ///< Current time when hydraulics chamber pressure check satrted in milliseconds.
static U32 spentDialPressureCheckStartTimeMS;                                               ///< Current time when spent dialysate pressure check started in milliseconds.
static OVERRIDE_U32_T isDialDeliveryInProgress;                                             ///< To indicate dialysate started delivering to dialyzer for treatment (overrideable)
static OVERRIDE_U32_T isDialysateGoodtoDeliver;                                             ///< Flag indicating whether ready to deliver dialysate or not.
static U32 genDialysateDataPublicationTimerCounter;                                         ///< Used to schedule generate dialysate data publication to CAN bus.
static OVERRIDE_U32_T genDialysateDataPublishInterval;                                      ///< Generate dialysate mode data publish interval.

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

static void setModeGenDStateTransition( DD_GEND_MODE_STATE_T state );
static BOOL hydChamberWaterInletControl( void );
static DD_GEND_MODE_STATE_T handleGenDHydraulicsChamberWaterInletCheckState( void );
static DD_GEND_MODE_STATE_T handleGenDHydChamberPressureCheckState( void );
static DD_GEND_MODE_STATE_T handleGenDFreshDialysatePressureCheckState( void );
static DD_GEND_MODE_STATE_T handleGenDSpentDialysatePressureCheckState( void );
static DD_GEND_MODE_STATE_T handleGenDProduceDialysateState( void );
static DD_GEND_MODE_STATE_T handleGenDDialysateDeliveryState( void );
static DD_GEND_MODE_STATE_T handleGenDDialysateDeliveryPauseState( void );
static void publishGenDialysateModeData( void );

/*********************************************************************//**
 * @brief
 * The initGenDialysateMode function initializes the dialysis generation mode unit.
 * @details \b Inputs: none
 * @details \b Outputs: Gen dialysate mode unit initialized
 * @return none
 *************************************************************************/
void initGenDialysateMode( void )
{
//    targetHydChamberFluidTemp.data            = HYD_CHAMBER_FLUID_TEMP_C_MIN;
//    targetHydChamberFluidTemp.ovInitData      = HYD_CHAMBER_FLUID_TEMP_C_MIN;
//    targetHydChamberFluidTemp.ovData          = HYD_CHAMBER_FLUID_TEMP_C_MIN;
//    targetHydChamberFluidTemp.override        = OVERRIDE_RESET;
//    isHydChamberTempinRange                   = FALSE;
    genDialysateState                           = DD_GEND_STATE_START;
    isDialysateGoodtoDeliver.data               = FALSE;
    isDialysateGoodtoDeliver.ovData             = FALSE;
    isDialysateGoodtoDeliver.ovInitData         = FALSE;
    isDialysateGoodtoDeliver.override           = OVERRIDE_RESET;
    isDialDeliveryInProgress.data               = FALSE;
    isDialDeliveryInProgress.ovData             = FALSE;
    isDialDeliveryInProgress.ovInitData         = FALSE;
    isDialDeliveryInProgress.override           = OVERRIDE_RESET;
    hydChamberPressureCheckStartTimeMS          = 0;
    spentDialPressureCheckStartTimeMS           = 0;
    genDialysateDataPublishInterval.data        = GEN_DIALYSATE_DATA_PUBLISH_INTERVAL;
    genDialysateDataPublishInterval.ovData      = GEN_DIALYSATE_DATA_PUBLISH_INTERVAL;
    genDialysateDataPublishInterval.ovInitData  = 0;
    genDialysateDataPublishInterval.override    = OVERRIDE_RESET;
    genDialysateDataPublicationTimerCounter     = 0;

    //Initialize balancing chamber module
    initBalanceChamber();
}

/*********************************************************************//**
 * @brief
 * The transitionToGenDialysateMode function prepares for transition to gen
 * dialysate mode.
 * @details \b Inputs: none
 * @details \b Outputs: none
 * @return initial state
 *************************************************************************/
U32 transitionToGenDialysateMode( void )
{
    initGenDialysateMode();
    setCurrentSubState( NO_SUB_STATE );

    return genDialysateState;
}

/*********************************************************************//**
 * @brief
 * The execGenDialysateMonitor function monitors the balancing chamber fill
 * operations and alarm if temperature and conductivity is not in range.
 * @details \b Inputs: isBalChamberFillInProgress
 * @details \b Outputs: isDialysateGoodtoDeliver
 * @return none.
 *************************************************************************/
void execGenDialysateMonitor( void )
{
    // Read temperature and conducitivity
    //F32 hydChamberTemperature     = getTemperatureValue( TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER );
    //F32 biCarbConductivity        = getConductivityValue( CONDUCTIVITYSENSORS_CD1_SENSOR );
    //F32 acidBicarbMixConductivity = getConductivityValue( CONDUCTIVITYSENSORS_CD3_SENSOR );

    // Monitor critical parameter while balancing chamber fill is in progress
    if ( TRUE == getBalancingChamberFillinProgressStatus() )
    {
        // Temperature range check

        // Coductivity range check
         isDialysateGoodtoDeliver.data = TRUE;
    }
}

/*********************************************************************//**
 * @brief
 * The setModeGenDStateTransition function sets the actuators and variables
 * for the state transition in generate dialysis mode.
 * @details Inputs: Valve states, Pump speed
 * @details Outputs: Actuate valves, pumps as desired.
 * @param state gen dialysate state enum
 * @return none
 *************************************************************************/
static void setModeGenDStateTransition( DD_GEND_MODE_STATE_T state )
{
    // Execute on running state
    switch( state )
    {
        case DD_GEND_STATE_START:
            // Do nothing
            break;

        case DD_GEND_HYD_CHAMBER_WATER_INLET_CHECK_STATE:
            // Close all balancing chamber and hydraulics valves
            valveControlForBCClosedState();
            setHydValvesStatetoClosedState();
            setUFValvesStatetoClosedState();

            // Get the target temperature from TD
            //targetHydChamberFluidTemp.data = HYD_CHAMBER_FLUID_TEMP_C_MIN;
            break;

        case DD_GEND_HYD_CHAMBER_PRESSURE_CHECK_STATE:
            // Open up VHo valve
            setValveState( VHO, VALVE_STATE_OPEN );   //D14
            // Start timer for hyd chamber negative pressure check state
            hydChamberPressureCheckStartTimeMS = getMSTimerCount();
            // Start D12/DGP pump
            setDialysatePumpTargetRPM( FRESH_DIALYSATE_PUMP, FRESH_DIAL_PUMP_INITIAL_RPM );
            break;

        case DD_GEND_FRESH_DIALYSATE_PRESSURE_CHECK_STATE:
            // Lets be DGP continue running since pressure relief valve was set/ tuned part of priming process
            hydChamberPressureCheckStartTimeMS = getMSTimerCount();
            break;

        case DD_GEND_SPENT_DIALYSATE_PRESSURE_CHECK_STATE:
            // Start the timer for spent dialysate pressure check
            spentDialPressureCheckStartTimeMS = getMSTimerCount();

            // Open all balancing chamber valves for free flow
            valveControlForBCOpenState();

            // Make sure valves are in correct position
            setValveState( VDR, VALVE_STATE_OPEN );   // Drain valve : D53
            setValveState( VDI, VALVE_STATE_CLOSED );
            setValveState( VDO, VALVE_STATE_CLOSED );
            setValveState( VDB2, VALVE_STATE_OPEN );

            // Start D48/SDP pump
            setDialysatePumpTargetRPM( SPENT_DIALYSATE_PUMP, SPENT_DIAL_PUMP_INITIAL_RPM );
            break;

        case DD_GEND_PRODUCE_DIALYSATE_STATE:
            // Enable bypass valve
            setValveState( VDI, VALVE_STATE_CLOSED );
            setValveState( VDO, VALVE_STATE_CLOSED );
            setValveState( VDB2, VALVE_STATE_OPEN );
            break;

        case DD_GEND_DIALYSATE_DELIVERY_STATE:
            // Disable bypass valve
            setValveState( VDB2, VALVE_STATE_CLOSED );
            setValveState( VDI, VALVE_STATE_OPEN );
            setValveState( VDO, VALVE_STATE_OPEN );
            break;

        case DD_GEND_DIALYSATE_DELIVERY_PAUSE:
            // stop the motor during pause conditions
            signalDialysatePumpHardStop( FRESH_DIALYSATE_PUMP );
            signalDialysatePumpHardStop( SPENT_DIALYSATE_PUMP );

            //close the DD - water inlet and drain valves?
            break;

        default:
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_GEND_MODE_INVALID_EXEC_STATE1, state )
            break;
    }
}

/*********************************************************************//**
 * @brief
 * The execGenDialysateMode function executes the Gen dialysate mode state machine.
 * @details \b Inputs: none
 * @details \b Outputs: Gen dialysate mode state machine executed
 * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when wrong gen dialysate state invoked.
 * @return current state.
 *************************************************************************/
U32 execGenDialysateMode( void )
{
    // Continuous water inlet pressure check
    if ( genDialysateState != DD_GEND_DIALYSATE_DELIVERY_PAUSE )
    {
        if ( TRUE == areInletWaterConditionsAlarmsActive() )      // Check RO alarms as required
        {
            setModeGenDStateTransition( DD_GEND_DIALYSATE_DELIVERY_PAUSE );
            genDialysateState = DD_GEND_DIALYSATE_DELIVERY_PAUSE;
        }
    }

    if ( genDialysateState > DD_GEND_HYD_CHAMBER_WATER_INLET_CHECK_STATE )
    {
        hydChamberWaterInletControl();
    }

    // execute current gen dialysate state
    switch ( genDialysateState )
    {
        case DD_GEND_STATE_START:
            setModeGenDStateTransition( DD_GEND_HYD_CHAMBER_WATER_INLET_CHECK_STATE );
            genDialysateState = DD_GEND_HYD_CHAMBER_WATER_INLET_CHECK_STATE;
            break;

        case DD_GEND_HYD_CHAMBER_WATER_INLET_CHECK_STATE:
            genDialysateState = handleGenDHydraulicsChamberWaterInletCheckState();
            break;

        case DD_GEND_HYD_CHAMBER_PRESSURE_CHECK_STATE:
            genDialysateState = handleGenDHydChamberPressureCheckState();
            break;

        case DD_GEND_FRESH_DIALYSATE_PRESSURE_CHECK_STATE:
            genDialysateState = handleGenDFreshDialysatePressureCheckState();
            break;

        case DD_GEND_SPENT_DIALYSATE_PRESSURE_CHECK_STATE:
            genDialysateState = handleGenDSpentDialysatePressureCheckState();
            break;

        case DD_GEND_PRODUCE_DIALYSATE_STATE:
            genDialysateState = handleGenDProduceDialysateState();
            break;

        case DD_GEND_DIALYSATE_DELIVERY_STATE:
            genDialysateState = handleGenDDialysateDeliveryState();
            break;

        case DD_GEND_DIALYSATE_DELIVERY_PAUSE:
            genDialysateState = handleGenDDialysateDeliveryPauseState();
            break;

        default:
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_GEND_MODE_INVALID_EXEC_STATE, genDialysateState )
            genDialysateState = DD_GEND_STATE_START;
            break;
    }

    //Publish Gen dialysate mode data
    publishGenDialysateModeData();

    return genDialysateState;
}

/*********************************************************************//**
 * @brief
 * The hydChamberWaterInletControl function checks the water level and allow
 * the water into hydraulics for dialysate generation.
 * @details \b Inputs: floater levels.
 * @details \b Outputs: none
 * @return the current state of gen dialysate mode
 *************************************************************************/
static BOOL hydChamberWaterInletControl( void )
{
    // Read floater switch
    BOOL result                 = FALSE;
    LEVEL_STATE_T floaterLevel1 = getLevelStatus( FLOATER_1 );
    //LEVEL_STATE_T floaterLevel2 = getLevelStatus( FLOATER_2 );
    //F32 hydChamberTemperature   = getTemperatureValue( TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER );

    // High level is met
    if ( STATE_HIGH == floaterLevel1 )
    {
        //turn off inlet water valve
        setValveState( VHI, VALVE_STATE_CLOSED );

//        // read latest fluid temperature
//        hydChamberTemperature = getTemperatureValue( TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER );
//
//        if ( hydChamberTemperature < HYD_CHAMBER_FLUID_TEMP_C_MIN )
//        {
//            //if fluid temp is lesser, turn on heater
//            setHeaterTargetTemperature( DD_PRIMARY_HEATER, targetHydChamberFluidTemp );
//            startHeater( DD_PRIMARY_HEATER );
//        }
//        else
//        {
//            //Turn heater off
//            if ( TRUE == isHeaterOn( DD_PRIMARY_HEATER ) )
//            {
//                stopHeater( DD_PRIMARY_HEATER );
//            }
//        }

        // For now, lets not wait for temperature to reach target, as soon as water level is high
        // enough, update results to true.
        result = TRUE;
    }
    else
    {
        // if level is not met,allow inlet water to hydraulics chamber
        setValveState( VHI, VALVE_STATE_OPEN );
    }

    // Invalid levels
//    if ( ( STATE_LOW == floaterLevel1 ) && ( STATE_HIGH == floaterLevel2 ) )
//    {
//        //TODO : check for invalid levels and trigger alarm
//    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The handleGenDHydraulicsChamberWaterInletCheckState function checks the
 * water level and allow the water into hydraulics for dialysate generation.
 * @details \b Inputs: floater levels.
 * @details \b Outputs: none
 * @return the current state of gen dialysate mode
 *************************************************************************/
static DD_GEND_MODE_STATE_T handleGenDHydraulicsChamberWaterInletCheckState( void )
{
    DD_GEND_MODE_STATE_T state  = DD_GEND_HYD_CHAMBER_WATER_INLET_CHECK_STATE;

    // Allow water inlet to hydraulics chamber
    if ( TRUE == hydChamberWaterInletControl() )
    {
        // if water level, temp is range, move to pressure check state
        setModeGenDStateTransition( DD_GEND_HYD_CHAMBER_PRESSURE_CHECK_STATE );
        state = DD_GEND_HYD_CHAMBER_PRESSURE_CHECK_STATE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleGenDHydChamberPressureCheckState function checks the
 * hydraulics chamber pressure at chamber 4 of hydraulics.
 * @details \b Inputs: pressure sensor readings, hydChamberPressureCheckStartTimeMS
 * @details \b Outputs: none
 * @return the current state of gen dialysate mode
 *************************************************************************/
static DD_GEND_MODE_STATE_T handleGenDHydChamberPressureCheckState( void )
{
    DD_GEND_MODE_STATE_T state  = DD_GEND_HYD_CHAMBER_PRESSURE_CHECK_STATE;
    F32 hydPressure = getFilteredPressure( PRESSURE_SENSOR_HYDRAULICS_OUTLET );

    // Hydraulics chamber negative pressure is in range ( -24 to -25 inHg )
    if ( ( hydPressure >= HYD_CHAMBER_TARGET_NEG_PRESS_MIN_PSI ) && ( hydPressure <= HYD_CHAMBER_TARGET_NEG_PRESS_MAX_PSI ) )
    {
        // Proceed to next state
        setModeGenDStateTransition( DD_GEND_FRESH_DIALYSATE_PRESSURE_CHECK_STATE );
        state = DD_GEND_FRESH_DIALYSATE_PRESSURE_CHECK_STATE;
    }
    else if ( TRUE == didTimeout( hydChamberPressureCheckStartTimeMS, HYD_CHAMBER_PRES_CHECK_TIME_OUT ) )
    {
        // time out alarm and pause the dialysate generation?
        SET_ALARM_WITH_1_F32_DATA( ALARM_ID_DD_GEND_HYD_CHAMBER_PRESS_OUT_OF_RANGE, hydPressure );
        state = DD_GEND_DIALYSATE_DELIVERY_PAUSE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleGenDFreshDialysatePressureCheckState function checks the
 * positive pressure level ( chamber 5) of hydraulics chamber or fresh
 * dialysate side.
 * @details \b Inputs: pressure sensor readings,hydChamberPressureCheckStartTimeMS
 * @details \b Outputs: none
 * @return the current state of gen dialysate mode
 *************************************************************************/
static DD_GEND_MODE_STATE_T handleGenDFreshDialysatePressureCheckState( void )
{
    DD_GEND_MODE_STATE_T state  = DD_GEND_FRESH_DIALYSATE_PRESSURE_CHECK_STATE;
    F32 hydPressure = getFilteredPressure( PRESSURE_SENSOR_FRESH_DIALYSATE );

    // Hydraulics chamber postive pressure is in range ( 23 to 25 psi )
    if ( ( hydPressure >= HYD_CHAMBER_TARGET_POS_PRESS_MIN_PSI ) && ( hydPressure <= HYD_CHAMBER_TARGET_POS_PRESS_MAX_PSI ) )
    {
        // Proceed to next state
        setModeGenDStateTransition( DD_GEND_SPENT_DIALYSATE_PRESSURE_CHECK_STATE );
        state = DD_GEND_SPENT_DIALYSATE_PRESSURE_CHECK_STATE;
    }
    else if ( TRUE == didTimeout( hydChamberPressureCheckStartTimeMS, HYD_CHAMBER_PRES_CHECK_TIME_OUT ) )
    {
        // time out alarm and pause the dialysate generation?
        SET_ALARM_WITH_1_F32_DATA( ALARM_ID_DD_GEND_FRESH_DIAL_PRESS_OUT_OF_RANGE, hydPressure );
        state = DD_GEND_DIALYSATE_DELIVERY_PAUSE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleGenDSpentDialysatePressureCheckState function checks the
 * spent dialyaste pressure is in range to begin balancing chamber dialysate
 * delivery.
 * @details \b Inputs: pressure sensor readings,spentDialPressureCheckStartTimeMS.
 * @details \b Outputs: none
 * @return the current state of gen dialysate mode
 *************************************************************************/
static DD_GEND_MODE_STATE_T handleGenDSpentDialysatePressureCheckState( void )
{
    DD_GEND_MODE_STATE_T state  = DD_GEND_SPENT_DIALYSATE_PRESSURE_CHECK_STATE;
    F32 spentdialPressure = getFilteredPressure( PRESSURE_SENSOR_SPENT_DIALYSATE );

    // Spent dialysate pressure is in range ( 29 to 30 psi )
    if ( ( spentdialPressure >= SPENT_DIAL_TARGET_POS_PRESS_MIN_PSI ) && ( spentdialPressure <= SPENT_DIAL_TARGET_POS_PRESS_MAX_PSI ) )
    {
        // Proceed to next state
        transitionToBalChamberFill();
        setModeGenDStateTransition( DD_GEND_PRODUCE_DIALYSATE_STATE );
        state = DD_GEND_PRODUCE_DIALYSATE_STATE;
    }
    else if ( TRUE == didTimeout( spentDialPressureCheckStartTimeMS, SPENT_DIAL_PRES_CHECK_TIME_OUT ) )
    {
        // time out alarm and pause the dialysate generation?
        SET_ALARM_WITH_1_F32_DATA( ALARM_ID_DD_GEND_SPENT_DIAL_PRESS_OUT_OF_RANGE, spentdialPressure );
        state = DD_GEND_DIALYSATE_DELIVERY_PAUSE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleGenDProduceDialysateState function produces dialysate
 * by executing balancing chamber and decides to pass the dialysate
 * for treatment.
 * @details \b Inputs: none
 * @details \b Outputs: balancing chamber state.
 * @return the current state of gen dialysate mode
 *************************************************************************/
static DD_GEND_MODE_STATE_T handleGenDProduceDialysateState( void )
{
    DD_GEND_MODE_STATE_T state  = DD_GEND_PRODUCE_DIALYSATE_STATE;

    //Execute balancing chamber
    execBalancingChamberControl();

    //if the produced dialysate is good and TD asks for dialysate delivery
    // move to next state
    if ( ( TRUE == getDialGoodToDeliverStatus() ) && ( FALSE == getTDDialyzerBypass() ) )
    {
        setModeGenDStateTransition( DD_GEND_DIALYSATE_DELIVERY_STATE );
        state = DD_GEND_DIALYSATE_DELIVERY_STATE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleGenDDialysateDeliveryState function performing dialysate
 * delivery by executing balancing chamber.
 * @details \b Inputs: none
 * @details \b Outputs: balancing chamber state.
 * @return the current state of gen dialysate mode
 *************************************************************************/
static DD_GEND_MODE_STATE_T handleGenDDialysateDeliveryState( void )
{
    DD_GEND_MODE_STATE_T state  = DD_GEND_DIALYSATE_DELIVERY_STATE;

    //Execute balancing chamber
    execBalancingChamberControl();

    // if TD asks for bypass or dialysate is not good to deliver
    //transition to produce dialystate state
    if ( ( FALSE == getDialGoodToDeliverStatus() ) || ( TRUE == getTDDialyzerBypass() ) )
    {
        setModeGenDStateTransition( DD_GEND_PRODUCE_DIALYSATE_STATE );
        state = DD_GEND_PRODUCE_DIALYSATE_STATE;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleGenDDialysateDeliveryPauseState function pause the dialysate
 * delivery due to alarms conditions or some control asked to be in
 * paused state.
 * @details \b Inputs: none
 * @details \b Outputs: none
 * @return the current state of gen dialysate mode
 *************************************************************************/
static DD_GEND_MODE_STATE_T handleGenDDialysateDeliveryPauseState( void )
{
    DD_GEND_MODE_STATE_T state  = DD_GEND_DIALYSATE_DELIVERY_PAUSE;

    //TODO : Handle pause state.

    return state;
}

/*********************************************************************//**
 * @brief
 * The getCurrentGenDialysateState function returns the current state of the
 * gen dialysate mode.
 * @details \b Inputs: genDialysateState
 * @details \b Outputs: none
 * @return the current state of gen dialysate mode
 *************************************************************************/
DD_GEND_MODE_STATE_T getCurrentGenDialysateState( void )
{
    return genDialysateState;
}

/*********************************************************************//**
 * @brief
 * The getDialGoodToDeliverStatus function gets the dialysate good to deliver
 * status.
 * @details \b Inputs: isDialysateGoodtoDeliver
 * @details \b Outputs: none
 * @return the current status of dialysate delivery
 *************************************************************************/
U32 getDialGoodToDeliverStatus( void )
{
    U32 result = isDialysateGoodtoDeliver.data;

    if ( OVERRIDE_KEY == isDialysateGoodtoDeliver.override )
    {
        result = isDialysateGoodtoDeliver.ovData;
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The getDialDeliveryProgressStatus function gets the dialysate delivery
 * progress status.
 * @details \b Inputs: isDialDeliveryInProgress
 * @details \b Outputs: none
 * @return the current status of dialysate delivery
 *************************************************************************/
U32 getDialDeliveryProgressStatus( void )
{
    U32 result = isDialDeliveryInProgress.data;

    if ( OVERRIDE_KEY == isDialDeliveryInProgress.override )
    {
        result = isDialDeliveryInProgress.ovData;
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The getGenDilaysateDataPublishInterval function gets the generate dialysate
 * mode data publish interval.
 * @details \b Inputs: genDialysateDataPublishInterval
 * @details \b Outputs: none
 * @return the interval at generate dialysate mode data being published.
 *************************************************************************/
static U32 getGenDilaysateDataPublishInterval( void )
{
    U32 result = genDialysateDataPublishInterval.data;

    if ( OVERRIDE_KEY == genDialysateDataPublishInterval.override )
    {
        result = genDialysateDataPublishInterval.ovData;
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The publishGenDialysateModeData function broadcasts the generate dialysate
 * mode data at defined interval.
 * @details \b Inputs: genDialysateDataPublicationTimerCounter
 * @details \b Outputs: DD generate dialysate data broadcast message sent
 * @details \b Message \Sent: MSG_ID_DD_GEN_DIALYSATE_MODE_DATA to publish the
 * generate dialysate mode data.
 * @return none
 *************************************************************************/
static void publishGenDialysateModeData( void )
{
    if ( ++genDialysateDataPublicationTimerCounter >= getGenDilaysateDataPublishInterval() )
    {
        GEN_DIALYSATE_MODE_DATA_T data;

        data.genDialysateExecState              = (U32)getCurrentGenDialysateState();
        data.isDialDelInProgress                = (BOOL)getDialDeliveryProgressStatus();
        data.floaterLevel1                      = (U32)getLevelStatus( FLOATER_1 );
        data.floaterLevel2                      = (U32)getLevelStatus( FLOATER_2 );
        data.BiCarbLevel                        = (U32)getLevelStatus( BICARB_LEVEL );
        data.SpentChamberLevel                  = (U32)getLevelStatus( SPENT_DIALYSATE_LEVEL );
        data.hydNegativePressure                = getFilteredPressure( PRESSURE_SENSOR_HYDRAULICS_OUTLET );
        data.hydPositivePressure                = getFilteredPressure( PRESSURE_SENSOR_FRESH_DIALYSATE );
        data.spentDialysatePressure             = getFilteredPressure( PRESSURE_SENSOR_SPENT_DIALYSATE );
        data.isDialysateGoodtoDeliver           = (BOOL)getDialGoodToDeliverStatus();

        broadcastData( MSG_ID_DD_GEN_DIALYSATE_MODE_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( GEN_DIALYSATE_MODE_DATA_T ) );

        genDialysateDataPublicationTimerCounter = 0;
    }
}


/*************************************************************************
 *                       TEST SUPPORT FUNCTIONS
 *************************************************************************/


/*********************************************************************//**
 * @brief
 * The testDDGenDialysateDataPublishIntervalOverride function overrides the
 * DD generate dialysate mode data publish interval.
 * @details \b Inputs: genDialysateDataPublishInterval
 * @details \b Outputs: genDialysateDataPublishInterval
 * @param Override message from Dialin which includes the interval
 * (in ms) to override the DD generate dialysate data publish interval to.
 * @return TRUE if override successful, FALSE if not
 *************************************************************************/
BOOL testDDGenDialysateDataPublishIntervalOverride( MESSAGE_T *message )
{
    BOOL result = u32BroadcastIntervalOverride( message, &genDialysateDataPublishInterval, TASK_GENERAL_INTERVAL );

    return result;
}

/*********************************************************************//**
 * @brief
 * The testDialDeliveryInProgressOverride function sets the override value
 * of the dialysate delivery In progress flag.
 * @details Inputs: isDialDeliveryInProgress
 * @details Outputs: isDialDeliveryInProgress
 * @param message Override message from Dialin which includes the override
 * value to override the dialysate delivery in progress flag.
 * @return TRUE if override successful, FALSE if not
 *************************************************************************/
BOOL testDialDeliveryInProgressOverride( MESSAGE_T *message )
{
    BOOL result = u32Override( message, &isDialDeliveryInProgress, 0, TRUE );

    return result;
}

/*********************************************************************//**
 * @brief
 * The testDialGoodToDeliverStatusOverride function sets the override value
 * of the dialysate good to deliver status flag.
 * @details Inputs: isDialysateGoodtoDeliver
 * @details Outputs: isDialysateGoodtoDeliver
 * @param message Override message from Dialin which includes the override
 * value to override the dialysate delivery in progress flag.
 * @return TRUE if override successful, FALSE if not
 *************************************************************************/
BOOL testDialGoodToDeliverStatusOverride( MESSAGE_T *message )
{
    BOOL result = u32Override( message, &isDialysateGoodtoDeliver, 0, TRUE );

    return result;
}

/*********************************************************************//**
 * @brief
 * The testGenDHydChamberFluidTempOverride function sets the override value
 * of the hydraulics chamber fluid temperature.
 * @details Inputs: targetHydChamberFluidTemp
 * @details Outputs: targetHydChamberFluidTemp
 * @param message Override message from Dialin which includes the override
 * value of the hydraulics chamber fluid temperature.
 * @return TRUE if override successful, FALSE if not
 *************************************************************************/
//BOOL testGenDHydChamberFluidTempOverride( MESSAGE_T *message )
//{
//    BOOL result = f32Override( message, &targetHydChamberFluidTemp );
//
//    return result;
//}
/**@}*/