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

#include "BalancingChamber.h"
#include "Conductivity.h"
#include "ConcentratePumps.h"
#include "FpgaDD.h"
#include "OperationModes.h"
#include "Pressure.h"
#include "Temperature.h"
#include "TDInterface.h"
#include "TaskGeneral.h"
#include "Valves.h"

/**
 *  @addtogroup BalancingChamber
 *  @{
 */

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

#define BAL_CHAMBER_FILL_VOLUME_ML                  30.0F                                       ///< Balancing chamber fill/drain volume per batch operation.
#define FRESH_DIAL_PRESSURE_MIN_PSIG                23.0F                                       ///< Minimum fresh dialysate pressure (PDf) limit for balancing chamber fill operations.
#define FRESH_DIAL_PRESSURE_MAX_PSIG                25.0F                                       ///< Maximum fresh dialysate pressure (PDf) limit for balancing chamber fill operations.
#define SPENT_DIAL_PRESSURE_MIN_PSIG                29.0F                                       ///< Minimum spent dialysate pressure (PDs) limit for balancing chamber fill operations.
#define SPENT_DIAL_PRESSURE_MAX_PSIG                30.0F                                       ///< Maximum spent dialysate pressure (PDs) limit for balancing chamber fill operations.
#define BAL_CHAMBER_DATA_PUBLISH_INTERVAL           ( 250 / TASK_GENERAL_INTERVAL )             ///< Interval (ms/task time) at which the balancing chamber data published.

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

static BAL_CHAMBER_EXEC_STATE_T balChamberExecState;                                            ///< Current balancing chamber executive state.
static OVERRIDE_F32_T balChamberSwitchingFreq;                                                  ///< Balancing chamber switching rate ( switches per min) based on the dialysate flow rate ( overrideable)
static U32 balChamberSwitchingPeriod;                                                           ///< Periodic balancing chamber switching time in task interval count.
static U32 currentBalChamberSwitchingCounter;                                                   ///< Counter (in task interval) to monitor the timing spent during balancing chamber fill/drain operation.
static BOOL isBalChamberFillInProgress;                                                         ///< Flag indicating balancing chamber fill/drain is in progress.
static BOOL isPressureStalbilizedDuringFill;                                                    ///< Flag indicating that the pressure is stablized due to fill complete.
static BAL_CHAMBER_SW_STATE_T balChamberSWState;                                                ///< Current balancing chamber switching state ( state 1 or state 2).
static U32 balChamberDataPublicationTimerCounter;                                               ///< Used to schedule balancing chamber data publication to CAN bus.
static OVERRIDE_U32_T balChamberDataPublishInterval;                                            ///< Balancing chamber data publish interval.

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

static BAL_CHAMBER_EXEC_STATE_T handleBalChamberState1FillStart( void );
static BAL_CHAMBER_EXEC_STATE_T handleBalChamberConcentrateControl(void);
static BAL_CHAMBER_EXEC_STATE_T handleBalChamberState1FillEnd(void);
static BAL_CHAMBER_EXEC_STATE_T handleBalChamberState2FillStart( void );
static BAL_CHAMBER_EXEC_STATE_T handleBalChamberState2FillEnd(void);
static void publishBalChamberData( void );
static U32 getBalChamberDataPublishInterval( void );

/*********************************************************************//**
 * @brief
 * The initBalanceChamber function initializes the balancing chamber unit.
 * @details \b Inputs: none
 * @details \b Outputs: unit variables initialized
 * @return none
 *************************************************************************/
void initBalanceChamber( void )
{
    balChamberExecState                         = BAL_CHAMBER_STATE_START;
    balChamberSWState                           = BAL_CHAMBER_SW_STATE1;
    balChamberSwitchingFreq.data                = 0.0F;
    balChamberSwitchingFreq.ovData              = 0.0F;
    balChamberSwitchingFreq.ovInitData          = 0.0F;
    balChamberSwitchingFreq.override            = OVERRIDE_RESET;
    balChamberDataPublishInterval.data          = BAL_CHAMBER_DATA_PUBLISH_INTERVAL;
    balChamberDataPublishInterval.ovData        = BAL_CHAMBER_DATA_PUBLISH_INTERVAL;
    balChamberDataPublishInterval.ovInitData    = 0;
    balChamberDataPublishInterval.override      = OVERRIDE_RESET;
    balChamberSwitchingPeriod                   = 0;
    isBalChamberFillInProgress                  = FALSE;
    currentBalChamberSwitchingCounter           = 0;
    isPressureStalbilizedDuringFill             = FALSE;
    balChamberDataPublicationTimerCounter       = 0;
}

/*********************************************************************//**
 * @brief
 * The transitionToBalChamberFill function prepares for transition to
 * balancing chamber fill/switching operations.
 * @details \b Inputs: none
 * @details \b Outputs: balChamberSwitchingFreq ,balChamberSwitchingPeriod
 * @return none
 *************************************************************************/
void transitionToBalChamberFill( void )
{
    initBalanceChamber();
    updateBalChamberSwitchingPeriod();
}

/*********************************************************************//**
 * @brief
 * The updateBalChamberSwitchingPeriod function updates the  periodic
 * balancing chamber switching time based on the dialysis flow rate.
 * @details \b Inputs: Dialysis flow rate.
 * @details \b Outputs: balChamberSwitchingFreq,balChamberSwitchingPeriod
 * @return none
 *************************************************************************/
void updateBalChamberSwitchingPeriod( void )
{
    // update the balancing chamber switching frequency
    balChamberSwitchingFreq.data = getTDDialysateFlowrate() / BAL_CHAMBER_FILL_VOLUME_ML;

    //update the switching period in task interval for balancing chamber fill timeout check
    balChamberSwitchingPeriod = (U32)( (F32)SEC_PER_MIN / getBalChamberSwitchingFreq() * ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) );

    // finish the balancing chamber fill 50 ms prior completing the regular cycle time.
    balChamberSwitchingPeriod -= 1;
}

/*********************************************************************//**
 * @brief
 * The execBalancingChamberControl function executes the balancing chamber state machine.
 * @details \b Inputs: balChamberExecState
 * @details \b Outputs: balChamberExecState
 * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when wrong balancing chamber state invoked.
 * @return current state.
 *************************************************************************/
U32 execBalancingChamberControl( void )
{
    // Increment counter during fill time only, Also check dialysate needs to be bypassed.
    if ( TRUE == isBalChamberFillInProgress )
    {
       currentBalChamberSwitchingCounter += 1;
    }

    // execute current balancing chamber exec state
    switch ( balChamberExecState )
    {
        case BAL_CHAMBER_STATE_START:
            balChamberExecState = BAL_CHAMBER_STATE1_FILL_START;
            break;

        case BAL_CHAMBER_STATE1_FILL_START:
            balChamberExecState = handleBalChamberState1FillStart();
            break;

        case BAL_CHAMBER_STATE1_BICARB_ACID_DOSING_CNTRL:
            balChamberExecState = handleBalChamberConcentrateControl();
            break;

        case BAL_CHAMBER_STATE1_FILL_END:
            balChamberExecState = handleBalChamberState1FillEnd();
            break;

        case BAL_CHAMBER_STATE2_FILL_START:
            balChamberExecState = handleBalChamberState2FillStart();
            break;

        case BAL_CHAMBER_STATE2_BICARB_ACID_DOSING_CNTRL:
            balChamberExecState = handleBalChamberConcentrateControl();
            break;

        case BAL_CHAMBER_STATE2_FILL_END:
            balChamberExecState = handleBalChamberState2FillEnd();
            break;

        default:
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_BAL_CHAMBER_INVALID_EXEC_STATE, balChamberExecState )
            balChamberExecState = BAL_CHAMBER_STATE_START;
            break;
    }

    //Publish balancing chamber data
    publishBalChamberData();

    return balChamberExecState;
}

/*********************************************************************//**
 * @brief
 * The valveControlForBCState1FillStart function actuates the valve combination
 * for state 1 fill/drain process.
 * @details \b Inputs: none
 * @details \b Outputs: valve states
 * @return none.
 *************************************************************************/
static void valveControlForBCState1FillStart( void )
{
    // Close balancing chamber valve combinations V1,V6 and V4,V7
    setValveState( BCV1, VALVE_STATE_CLOSED );
    setValveState( BCV6, VALVE_STATE_CLOSED );
    setValveState( BCV4, VALVE_STATE_CLOSED );
    setValveState( BCV7, VALVE_STATE_CLOSED );

    //Open balancing chamber valve combinations V2,V5 and V3,V8
    setValveState( BCV2, VALVE_STATE_OPEN );
    setValveState( BCV5, VALVE_STATE_OPEN );
    setValveState( BCV3, VALVE_STATE_OPEN );
    setValveState( BCV8, VALVE_STATE_OPEN );
}

/*********************************************************************//**
 * @brief
 * The valveControlForBCState1FillEnd function closes the valve opened
 * for state 1 fill/drain process.
 * @details \b Inputs: none
 * @details \b Outputs: valve states
 * @return none.
 *************************************************************************/
static void valveControlForBCState1FillEnd( void )
{
    //Close balancing chamber valve combinations V2,V5 and V3,V8
    setValveState( BCV2, VALVE_STATE_CLOSED );
    setValveState( BCV5, VALVE_STATE_CLOSED );
    setValveState( BCV3, VALVE_STATE_CLOSED );
    setValveState( BCV8, VALVE_STATE_CLOSED );
}

/*********************************************************************//**
 * @brief
 * The valveControlForBCState2FillStart function actuates the valve combination
 * for state 2 fill/drain process.
 * @details \b Inputs: none
 * @details \b Outputs: valve states
 * @return none.
 *************************************************************************/
static void valveControlForBCState2FillStart( void )
{
    //Close balancing chamber valve combinations V2,V5 and V3,V8
    setValveState( BCV2, VALVE_STATE_CLOSED );
    setValveState( BCV5, VALVE_STATE_CLOSED );
    setValveState( BCV3, VALVE_STATE_CLOSED );
    setValveState( BCV8, VALVE_STATE_CLOSED );

    // Open balancing chamber valve combinations V1,V6 and V4,V7
    setValveState( BCV1, VALVE_STATE_OPEN );
    setValveState( BCV6, VALVE_STATE_OPEN );
    setValveState( BCV4, VALVE_STATE_OPEN );
    setValveState( BCV7, VALVE_STATE_OPEN );
}

/*********************************************************************//**
 * @brief
 * The valveControlForBCState2FillEnd function closes the valve opened
 * for state 2 fill/drain process.
 * @details \b Inputs: none
 * @details \b Outputs: valve states
 * @return none.
 *************************************************************************/
static void valveControlForBCState2FillEnd( void )
{
    // Close balancing chamber valve combinations V1,V6 and V4,V7
    setValveState( BCV1, VALVE_STATE_CLOSED );
    setValveState( BCV6, VALVE_STATE_CLOSED );
    setValveState( BCV4, VALVE_STATE_CLOSED );
    setValveState( BCV7, VALVE_STATE_CLOSED );
}

/*********************************************************************//**
 * @brief
 * The valveControlForBCClosedState function closes the all balancing
 * chamber valves.
 * @details \b Inputs: none
 * @details \b Outputs: valve states
 * @return none.
 *************************************************************************/
void valveControlForBCClosedState( void )
{
    // Close balancing chamber valve combinations V1,V6 and V4,V7
    setValveState( BCV1, VALVE_STATE_CLOSED );
    setValveState( BCV6, VALVE_STATE_CLOSED );
    setValveState( BCV4, VALVE_STATE_CLOSED );
    setValveState( BCV7, VALVE_STATE_CLOSED );

    //Close balancing chamber valve combinations V2,V5 and V3,V8
    setValveState( BCV2, VALVE_STATE_CLOSED );
    setValveState( BCV5, VALVE_STATE_CLOSED );
    setValveState( BCV3, VALVE_STATE_CLOSED );
    setValveState( BCV8, VALVE_STATE_CLOSED );
}

/*********************************************************************//**
 * @brief
 * The valveControlForBCOpenState function open the all balancing
 * chamber valves.
 * @details \b Inputs: none
 * @details \b Outputs: valve states
 * @return none.
 *************************************************************************/
void valveControlForBCOpenState( void )
{
    // Open balancing chamber valve combinations V1,V6 and V4,V7
    setValveState( BCV1, VALVE_STATE_OPEN );
    setValveState( BCV6, VALVE_STATE_OPEN );
    setValveState( BCV4, VALVE_STATE_OPEN );
    setValveState( BCV7, VALVE_STATE_OPEN );

    //Open balancing chamber valve combinations V2,V5 and V3,V8
    setValveState( BCV2, VALVE_STATE_OPEN );
    setValveState( BCV5, VALVE_STATE_OPEN );
    setValveState( BCV3, VALVE_STATE_OPEN );
    setValveState( BCV8, VALVE_STATE_OPEN );
}

/*********************************************************************//**
 * @brief
 * The handleBalChamberState1FillStart function handles the balancing chamber
 * state 1 fill and time to fill chamber counter being updated.
 * @details \b Inputs: Pressure
 * @details \b Outputs: valve states
 * @return next balancing chamber state.
 *************************************************************************/
static BAL_CHAMBER_EXEC_STATE_T handleBalChamberState1FillStart( void )
{
    BAL_CHAMBER_EXEC_STATE_T state      = BAL_CHAMBER_STATE1_FILL_START;
    currentBalChamberSwitchingCounter   = 0;
    isBalChamberFillInProgress          = FALSE;
    isPressureStalbilizedDuringFill     = FALSE;
    balChamberSWState                   = BAL_CHAMBER_SW_STATE1;

    F32 freshDialPressure = getFilteredPressure( PRESSURE_SENSOR_FRESH_DIALYSATE );
    F32 spentDialPressure = getFilteredPressure( PRESSURE_SENSOR_SPENT_DIALYSATE );

    // Check fresh and spent dialysate pressure in range
    if ( ( ( freshDialPressure >= FRESH_DIAL_PRESSURE_MIN_PSIG ) && ( freshDialPressure <= FRESH_DIAL_PRESSURE_MAX_PSIG ) ) &&
         ( ( spentDialPressure >= SPENT_DIAL_PRESSURE_MIN_PSIG ) && ( spentDialPressure <= SPENT_DIAL_PRESSURE_MAX_PSIG ) ) )
    {
        //Valve control for state 1 fill
        valveControlForBCState1FillStart();

        // Update fill status flag to true
        isBalChamberFillInProgress = TRUE;

        state = BAL_CHAMBER_STATE1_BICARB_ACID_DOSING_CNTRL;
    }
    else
    {
        //TODO : Alarm handling when pressure is not in range
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleBalChamberConcentrateControl function handles the Acid and Bicarb
 * concentrate doisng and checks the conductivity of the dialysate for the treatment.
 * @details \b Inputs: balChamberSWState , Concentrate volume
 * @details \b Outputs: state
 * @return next balancing chamber state.
 *************************************************************************/
static BAL_CHAMBER_EXEC_STATE_T handleBalChamberConcentrateControl( void )
{
    BAL_CHAMBER_EXEC_STATE_T state;
    // TODO : start acid and bicarb pump with the expected quantity

    // On completion of dosing, transition to next state based on the current switching state
    if ( BAL_CHAMBER_SW_STATE1 == balChamberSWState )
    {
        state = BAL_CHAMBER_STATE1_FILL_END;
    }
    else
    {
        state = BAL_CHAMBER_STATE2_FILL_END;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleBalChamberState1FillEnd function check for the balancing chamber
 * fill complete and close the currently opened valves.
 * @details \b Inputs: balChamberSWState, spent and fresh dialysate pressure
 * @details \b Outputs: isPressureStalbilizedDuringFill,isBalChamberFillInProgress
 * @return next balancing chamber state.
 *************************************************************************/
static BAL_CHAMBER_EXEC_STATE_T handleBalChamberState1FillEnd( void )
{
    BAL_CHAMBER_EXEC_STATE_T state  = BAL_CHAMBER_STATE1_FILL_END;

    F32 freshDialPressure = getFilteredPressure( PRESSURE_SENSOR_FRESH_DIALYSATE );
    F32 spentDialPressure = getFilteredPressure( PRESSURE_SENSOR_SPENT_DIALYSATE );

    // Check fresh and spent dialysate pressure back in range to indicate fill complete.
    if ( ( ( freshDialPressure >= FRESH_DIAL_PRESSURE_MIN_PSIG ) && ( freshDialPressure <= FRESH_DIAL_PRESSURE_MAX_PSIG ) ) &&
         ( ( spentDialPressure >= SPENT_DIAL_PRESSURE_MIN_PSIG ) && ( spentDialPressure <= SPENT_DIAL_PRESSURE_MAX_PSIG ) ) )
    {
        // stabilized pressure indicating fill is complete
        isPressureStalbilizedDuringFill = TRUE;
    }

    // Swithcing time met or pressure in range, close valves
    if ( ( currentBalChamberSwitchingCounter >= balChamberSwitchingPeriod ) ||
         ( TRUE == isPressureStalbilizedDuringFill ) )
    {
        // close the state 1 opened valves
        valveControlForBCState1FillEnd();
    }

    // On completion of cycle time, transition to next state
    if ( currentBalChamberSwitchingCounter >= balChamberSwitchingPeriod )
    {
        if ( TRUE != isPressureStalbilizedDuringFill )
        {
            // TODO : Alarm handling for switching time expired, but still pressure not in range,
        }
        else
        {
            isBalChamberFillInProgress = FALSE;
            state = BAL_CHAMBER_STATE2_FILL_START;
        }
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleBalChamberState2FillStart function handles the balancing chamber
 * state 2 fill and time to fill chamber counter being updated.
 * @details \b Inputs: fresh and spent dialysate pressure
 * @details \b Outputs: valve states
 * @return next balancing chamber state.
 *************************************************************************/
static BAL_CHAMBER_EXEC_STATE_T handleBalChamberState2FillStart( void )
{
    BAL_CHAMBER_EXEC_STATE_T state      = BAL_CHAMBER_STATE2_FILL_START;
    currentBalChamberSwitchingCounter   = 0;
    isBalChamberFillInProgress          = FALSE;
    isPressureStalbilizedDuringFill     = FALSE;
    balChamberSWState                   = BAL_CHAMBER_SW_STATE2;

    F32 freshDialPressure = getFilteredPressure( PRESSURE_SENSOR_FRESH_DIALYSATE );
    F32 spentDialPressure = getFilteredPressure( PRESSURE_SENSOR_SPENT_DIALYSATE );

    // Check fresh and spent dialysate pressure in range
    if ( ( ( freshDialPressure >= FRESH_DIAL_PRESSURE_MIN_PSIG ) && ( freshDialPressure <= FRESH_DIAL_PRESSURE_MAX_PSIG ) ) &&
         ( ( spentDialPressure >= SPENT_DIAL_PRESSURE_MIN_PSIG ) && ( spentDialPressure <= SPENT_DIAL_PRESSURE_MAX_PSIG ) ) )
    {
        // Valve control for state 2 fill
        valveControlForBCState2FillStart();

        // Update fill status flag to true
        isBalChamberFillInProgress = TRUE;

        state = BAL_CHAMBER_STATE2_BICARB_ACID_DOSING_CNTRL;
    }
    else
    {
        //TODO : Alarm handling when pressure is not in range
    }
    return state;
}

/*********************************************************************//**
 * @brief
 * The handleBalChamberState2FillEnd function check for the balancing chamber
 * fill complete and close the currently opened valves.
 * @details \b Inputs: balChamberSWState, spent and fresh dialysate pressure
 * @details \b Outputs: isPressureStalbilizedDuringFill,isBalChamberFillInProgress
 * @return next balancing chamber state.
 *************************************************************************/
static BAL_CHAMBER_EXEC_STATE_T handleBalChamberState2FillEnd( void )
{
    BAL_CHAMBER_EXEC_STATE_T state  = BAL_CHAMBER_STATE2_FILL_END;

    F32 freshDialPressure = getFilteredPressure( PRESSURE_SENSOR_FRESH_DIALYSATE );
    F32 spentDialPressure = getFilteredPressure( PRESSURE_SENSOR_SPENT_DIALYSATE );

    // Check fresh and spent dialysate pressure back in range to indicate fill complete.
    if ( ( ( freshDialPressure >= FRESH_DIAL_PRESSURE_MIN_PSIG ) && ( freshDialPressure <= FRESH_DIAL_PRESSURE_MAX_PSIG ) ) &&
         ( ( spentDialPressure >= SPENT_DIAL_PRESSURE_MIN_PSIG ) && ( spentDialPressure <= SPENT_DIAL_PRESSURE_MAX_PSIG ) ) )
    {
        // stabilized pressure indicating fill is complete
        isPressureStalbilizedDuringFill = TRUE;
    }

    // Check switching cycle time or pressure check for valve closure
    if ( ( currentBalChamberSwitchingCounter >= balChamberSwitchingPeriod ) ||
         ( TRUE == isPressureStalbilizedDuringFill ) )
    {
        // close the valves
        valveControlForBCState2FillEnd();
    }

    // On completion of cycle time, transition to next state
    if ( currentBalChamberSwitchingCounter >= balChamberSwitchingPeriod )
    {
        if ( TRUE != isPressureStalbilizedDuringFill )
        {
            // TODO : Alarm handling for switching time expired, but still pressure not in range,
        }
        else
        {
            isBalChamberFillInProgress = FALSE;
            state = BAL_CHAMBER_STATE1_FILL_START;
        }
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The getCurrentBalancingChamberExecState function returns the current state
 * of the balancing chamber.
 * @details \b Inputs: balChamberExecState
 * @details \b Outputs: none
 * @return the current state of balancing chamber states.
 *************************************************************************/
BAL_CHAMBER_EXEC_STATE_T getCurrentBalancingChamberExecState( void )
{
    return balChamberExecState;
}

/*********************************************************************//**
 * @brief
 * The getBalancingChamberFillinProgressStatus function returns the current
 * balancing chamber fill in progress status.
 * @details \b Inputs: isBalChamberFillInProgress
 * @details \b Outputs: none
 * @return the current balancing chamber fill in progress.
 *************************************************************************/
BOOL getBalancingChamberFillinProgressStatus( void )
{
    return isBalChamberFillInProgress;
}

/*********************************************************************//**
 * @brief
 * The getBalChamberSwitchingFreq function gets the balancing chamber switching
 * frequency value.
 * @details \b Inputs: balChamberSwitchingFreq
 * @details \b Outputs: none
 * @return balancing chamber switching frequency
 *************************************************************************/
F32 getBalChamberSwitchingFreq( void )
{
    F32 result = balChamberSwitchingFreq.data;

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

    return result;
}

/*********************************************************************//**
 * @brief
 * The getBalChamberDataPublishInterval function gets the balancing chamber
 * data publish interval.
 * @details \b Inputs: balChamberDataPublishInterval
 * @details \b Outputs: none
 * @return the interval at balancing chamber data being published.
 *************************************************************************/
static U32 getBalChamberDataPublishInterval( void )
{
    U32 result = balChamberDataPublishInterval.data;

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

    return result;
}

/*********************************************************************//**
 * @brief
 * The publishBalChamberData function broadcasts the balancing chamber
 * execution data at defined interval.
 * @details \b Inputs: balChamberDataPublicationTimerCounter
 * @details \b Outputs: DD balancing chamber data broadcast message sent
 * @details \b Message \Sent: MSG_ID_DD_BAL_CHAMBER_DATA to publish the balancing
 * chamber data.
 * @return none
 *************************************************************************/
static void publishBalChamberData( void )
{
    if ( ++balChamberDataPublicationTimerCounter >= getBalChamberDataPublishInterval() )
    {
        BAL_CHAMBER_DATA_T data;

        data.balChamberExecState                = (U32)balChamberExecState;
        data.balChamberSWState                  = (U32)balChamberSWState;
        data.balChamberSWFreq                   = getBalChamberSwitchingFreq();
        data.balChamberSwPeriod                 = balChamberSwitchingPeriod;
        data.isBalChamberFillInProgress         = isBalChamberFillInProgress;
        data.currentBalChamberSwitchingCounter  = currentBalChamberSwitchingCounter;
        data.isPressureStalbilizedDuringFill    = isPressureStalbilizedDuringFill;

        broadcastData( MSG_ID_DD_BAL_CHAMBER_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( BAL_CHAMBER_DATA_T ) );

        balChamberDataPublicationTimerCounter = 0;
    }
}


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


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

    return result;
}

/*********************************************************************//**
 * @brief
 * The testBalChamberSwFreqOverride function sets the override value
 * of the balancing chamber switching frequency.
 * @details Inputs: balChamberSwitchingFreq
 * @details Outputs: balChamberSwitchingFreq
 * @param message Override message from Dialin which includes the override
 * value to override the balancing chamber switching frequency.
 * @return TRUE if override successful, FALSE if not
 *************************************************************************/
BOOL testBalChamberSwFreqOverride( MESSAGE_T *message )
{
    BOOL result = f32Override( message, &balChamberSwitchingFreq );

    return result;
}

/**@}*/