/**************************************************************************
*
* 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 "Heaters.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             2000                                        ///< 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
//TODO : Needs further finetuning. currently max negative pressure reaches around 11.5 psi +/- 5% values defined for now
//#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_NEG_PRESS_MIN_PSI    (-10.000F)                                  ///< Hydraulics chamber minimum negative pressure(D9/PHo) in psi.
#define HYD_CHAMBER_TARGET_NEG_PRESS_MAX_PSI    (-12.075F)                                  ///< Hydraulics chamber maximum negative pressure(D9/PHo) 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 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.
static F32 lastDialTargetTemperatureSet;                                                    ///< last dialysate target temperature set for heater control
static BOOL isTreatementParamUpdated;                                                       ///< To indicate change in treatment parameters

// ********** 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 F32 getGenDilaysateTargetTemperature( 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;
    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;
    lastDialTargetTemperatureSet                = 0.0F;
    isTreatementParamUpdated                    = FALSE;

    //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( D4_TEMP );
    //F32 biCarbConductivity        = getConductivityValue( D17_COND );
    //F32 acidBicarbMixConductivity = getConductivityValue( D29_COND );

    // 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();
            setValveState( M4_VALV, VALVE_STATE_OPEN );   //M4

            // Get the target temperature from TD
            targetHydChamberFluidTemp.data = getTDTargetDialysateTemperature();

            // Turn on the primary heater
            setHeaterTargetTemperature( D5_HEAT, getGenDilaysateTargetTemperature() );
            startHeater( D5_HEAT );
            lastDialTargetTemperatureSet = getGenDilaysateTargetTemperature();
            break;

        case DD_GEND_HYD_CHAMBER_PRESSURE_CHECK_STATE:
            // Open up VHo valve
            setValveState( D14_VALV, VALVE_STATE_OPEN );   //D14
            // Start timer for hyd chamber negative pressure check state
            hydChamberPressureCheckStartTimeMS = getMSTimerCount();
            // Start D12/DGP pump
            setDialysatePumpTargetRPM( D12_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();

            // Open fresh balancing chamber valves D19,D20,D21,D22
            setValveState( D19_VALV, VALVE_STATE_OPEN );
            setValveState( D20_VALV, VALVE_STATE_OPEN );
            setValveState( D21_VALV, VALVE_STATE_OPEN );
            setValveState( D22_VALV, VALVE_STATE_OPEN );

            // Close spent side valves D23,D24,D25,D26
            setValveState( D23_VALV, VALVE_STATE_CLOSED );
            setValveState( D25_VALV, VALVE_STATE_CLOSED );
            setValveState( D24_VALV, VALVE_STATE_CLOSED );
            setValveState( D26_VALV, VALVE_STATE_CLOSED );


            // Make sure valves are in correct position
            setValveState( D53_VALV, VALVE_STATE_OPEN );   // Drain valve : D53
            setValveState( D35_VALV, VALVE_STATE_CLOSED ); // VDI
            setValveState( D40_VALV, VALVE_STATE_CLOSED ); // VDO
            setValveState( D34_VALV, VALVE_STATE_OPEN );   // Bypass valve

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

        case DD_GEND_PRODUCE_DIALYSATE_STATE:
            //Close previously opened BC valves
            valveControlForBCClosedState();

            // Make sure bypass valve open condition
            setValveState( D35_VALV, VALVE_STATE_CLOSED );  // VDI
            setValveState( D40_VALV, VALVE_STATE_CLOSED );  // VDO
            setValveState( D34_VALV, VALVE_STATE_OPEN );    // Bypass valve
            break;

        case DD_GEND_DIALYSATE_DELIVERY_STATE:
            // Disable bypass valve
            setValveState( D34_VALV, VALVE_STATE_CLOSED );  // Bypass valve
            setValveState( D35_VALV, VALVE_STATE_OPEN );    // VDI
            setValveState( D40_VALV, VALVE_STATE_OPEN );    // VDO
            break;

        case DD_GEND_DIALYSATE_DELIVERY_PAUSE:
            // stop the motor during pause conditions
            signalDialysatePumpHardStop( D12_PUMP );
            signalDialysatePumpHardStop( D48_PUMP );
            requestConcentratePumpOff( D11_PUMP, FALSE );
            requestConcentratePumpOff( D10_PUMP, FALSE );

            stopHeater( D5_HEAT );
            stopHeater( D45_HEAT );

            //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;
        }
    }

    // Manage water inlet temperature
    if ( genDialysateState > DD_GEND_HYD_CHAMBER_WATER_INLET_CHECK_STATE )
    {
        hydChamberWaterInletControl();
    }

    // Update any dynamic treatment parameter changes
    if ( TRUE == isTreatementParamUpdated )
    {
        updateTreatementSettings();
        //reset the flag
        isTreatementParamUpdated = FALSE;
    }

    // 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 floaterLevel  = getLevelStatus( D6_LEVL );
    //LEVEL_STATE_T spentDialLevel = getLevelStatus( D46_LEVL );

    // Get the target temperature from TD
    targetHydChamberFluidTemp.data = getTDTargetDialysateTemperature();

    // High level is met
    if ( LEVEL_STATE_HIGH == floaterLevel )
    {
        // Get the target dialysate temperature
        F32 targetTemperature = getGenDilaysateTargetTemperature();

        //turn off inlet water valve
        setValveState( D3_VALV, VALVE_STATE_CLOSED );

        if ( lastDialTargetTemperatureSet != targetTemperature )
        {
            // Update the target temperature for heater control
            setHeaterTargetTemperature( D5_HEAT, targetTemperature );
            lastDialTargetTemperatureSet = targetTemperature;
        }

        // Water level reached high.
        result = TRUE;
    }
    else
    {
        // if level is not met,allow inlet water to hydraulics chamber
        setValveState( D3_VALV, VALVE_STATE_OPEN );
    }

    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 is met, 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( D9_PRES );

    // 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( D18_PRES );

    // Hydraulics chamber postive pressure is in range
    if ( ( hydPressure >= FRESH_DIAL_PRESSURE_MIN_PSIG ) && ( hydPressure <= FRESH_DIAL_PRESSURE_MAX_PSIG ) )
    {
        // 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( D51_PRES );

    // Spent dialysate pressure is in range
    if ( ( spentdialPressure >= SPENT_DIAL_PRESSURE_MIN_PSIG ) && ( spentdialPressure <= SPENT_DIAL_PRESSURE_MAX_PSIG ) )
    {
        // 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 setTreatementParamUpdate function sets the flag to indicate one or more
 * treatement parameters updated.
 * gen dialysate mode.
 * @details \b Inputs: none
 * @details \b Outputs: isTreatementParamUpdated
 * @return none
 *************************************************************************/
void setTreatementParamUpdate( void )
{
    isTreatementParamUpdated = TRUE;
}

/*********************************************************************//**
 * @brief
 * The updateTreatementSettings function updates the switching rate post the
 * treatement parameters updated during treatement.
 * @details \b Inputs: none
 * @details \b Outputs: balChamberSwitchingPeriod.
 * @return none
 *************************************************************************/
void updateTreatementSettings( void )
{
    // Update the Balancing chamber switching rate based on dialysis rate
    updateBalChamberSwitchingPeriod();

    //TODO: update others parameters setting as needed.
}


/*********************************************************************//**
 * @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 getGenDilaysateTargetTemperature function gets the target dialysate
 * temperature.
 * @details \b Inputs: getGenDilaysateTargetTemperature
 * @details \b Outputs: none
 * @return the target dialysate temperature for the treatment.
 *************************************************************************/
static F32 getGenDilaysateTargetTemperature( void )
{
    F32 result = targetHydChamberFluidTemp.data;

    if ( OVERRIDE_KEY == targetHydChamberFluidTemp.override )
    {
        result = targetHydChamberFluidTemp.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.d6Level                            = (U32)getLevelStatus( D6_LEVL );
        data.d63Level                           = (U32)getLevelStatus( D63_LEVL );
        data.d46Level                           = (U32)getLevelStatus( D46_LEVL );
        data.d9Pressure                         = getFilteredPressure( D9_PRES );
        data.d18Pressure                        = getFilteredPressure( D18_PRES );
        data.d51Pressure                        = getFilteredPressure( D51_PRES );
        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;
//}
/**@}*/