/**************************************************************************
*
* 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    Temperature.c
*
* @author  (last)      Vinayakam Mani
* @date    (last)      23-Sep-2024
*
* @author  (original)  Vinayakam Mani
* @date    (original)  23-Sep-2024
*
***************************************************************************/

#include "BalancingChamber.h"
#include "ConductivitySensors.h"
#include "Conductivity.h"
#include "Flow.h"
#include "Messaging.h"
#include "MessageSupport.h"
#include "OperationModes.h"
#include "PersistentAlarm.h"
#include "Pressure.h"
#include "Temperature.h"
#include "Timers.h"
#include "TaskPriority.h"
#include "TDInterface.h"
#include "Utilities.h"

/**
 *  @addtogroup Temperature
 *  @{
 */

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

#define ADC_FPGA_READ_DELAY                                     30U                                             ///< Delay in ms before reading the ADC values from FPGA.

#define TEMP_SENSORS_DATA_PUBLISH_INTERVAL                      ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL )      ///< Temperature sensors publish data time interval.
#define TEMP_SENSORS_FPGA_ERROR_TIMEOUT_MS                      ( 2 * MS_PER_SECOND )                           ///< Temperature sensors FPGA error timeout in milliseconds.
#define D4_TEMP_MOVING_AVG_NUM_OF_SAMPLES                       50                                              ///< D4 temperature sensor moving average number of samples.
#define D50_TEMP_MOVING_AVG_NUM_OF_SAMPLES                      25                                              ///< D50 temperature sensor moving average number of samples ( 250ms filter ).
#define DATA_PUBLISH_COUNTER_START_COUNT                        30                                              ///< Data publish counter start count.
#define DIAL_TEMP_MOVING_AVG_NUM_OF_SAMPLES                     30                                              ///< Dialysate temperature sensors moving average number of samples.
#define D28_D30_DATA_COLLECTION_TIME_MS                         ( 1 * MS_PER_SECOND )                           ///< Dialysate temperature sensors data collection time in milliseconds.
#define D28_D30_TEMP_SENSORS_MAX_DEVIATION_C                    3.0F                                            ///< Dialysate temperature sensors maximum allowed deviation in C.
#define DIALYSATE_TEMP_SNSRS_OUT_OF_RANGE_TIMEOUT_MS            ( 10 * MS_PER_SECOND )                          ///< Dialysate temperature sensors drift timeout in milliseconds.
#define D28_D30_TEMP_SENSORS_MAX_DEVIATION_IN_HEAT_DIS_C        5.0F                                            ///< Dialysate temperature sensors maximum allowed deviation in heat disinfect in C.

/// Dialysate temperature sensors enums
typedef enum dial_Temps_Sensors
{
    DIAL_TEMP_D28 = 0,                                                                                          ///< Dialysate temperature D28.
    DIAL_TEMP_FIRST = DIAL_TEMP_D28,                                                                            ///< Dialysate temperature first.
    DIAL_TEMP_D30,                                                                                              ///< Dialysate temperature D30.
    NUM_OF_DIAL_TEMPS                                                                                           ///< Number of Dialysate temperature sensors.
} DIAL_TEMPERATURE_SENSORS_T;

/// Temperature sensor exec states.
typedef enum tempSensors_Exec_States
{
    TEMPSENSORS_EXEC_STATE_START = 0,                                                                           ///< Temperature sensors exec start
    TEMPSENSORS_EXEC_STATE_GET_ADC_VALUES,                                                                      ///< Temperature sensors exec get ADC values
    NUM_OF_TEMPSENSORS_EXEC_STATES,                                                                             ///< Total number of exec states
} TEMPSENSORS_EXEC_STATES_T;

/// Dialysate temperature moving average structure
typedef struct
{
    BOOL dialTempColHasTimerBeenSet;                                                                            ///< Dialysate temperature has data collection timer started boolean flag.
    U32 dialTempDataColStartTimeMS;                                                                             ///< Dialysate temperature data collection start time in milliseconds.
    F32 dialTempRunningSumC;                                                                                    ///< Dialysate temperature running sum in C.
    F32 dialTempAvgC;                                                                                           ///< Dialysate temperature average in C.
    F32 dialTempSamplesC[ DIAL_TEMP_MOVING_AVG_NUM_OF_SAMPLES ];                                                ///< Dialysate temperature samples array in C.
    U32 dialTempSamplesNextIndex;                                                                               ///< Dialysate temperature sample next index number.
} DIAL_TEMP_MOVING_AVG_DATA_T;

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

static TEMPSENSORS_EXEC_STATES_T tempSensorsExecState;                                                          ///< TemperatureSensor exec state.
static U32 startTime;                                                                                           ///< start time to read FPGA values.
static BOOL tempDriftEventCheck;                                                                                ///< Temperature sensor drift event boolean.
static DIAL_TEMP_MOVING_AVG_DATA_T dialTempMovingAvgData[ NUM_OF_DIAL_TEMPS ];                                  ///< Dialysate temperature moving average data.

static F32 d4TempAvgC;                                                                                          ///< D4 temperature average in C.
static F32 d4TempRunningSumC;                                                                                   ///< D4 temperature running sum in C.
static F32 d4TempSamplesC[ D4_TEMP_MOVING_AVG_NUM_OF_SAMPLES ];                                                 ///< D4 temperature samples array in C.
static U32 d4TempSamplesNextIndex;                                                                              ///< D4 temperature sample next index number.
static U32 d4TempCount;                                                                                         ///< D4 Number of samples in average buffer.
static U32 tempDataColTimeInterval;                                                                             ///< Temperature data collection time interval in milliseconds.
static U32 d4TempSampleIntervalCounter;                                                                         ///< D4 temperature sensor sample collection timer counter.

static F32 d50TempAvgC;                                                                                         ///< D50 temperature average in C.
static F32 d50TempRunningSumC;                                                                                  ///< D50 temperature running sum in C.
static F32 d50TempSamplesC[ D50_TEMP_MOVING_AVG_NUM_OF_SAMPLES ];                                               ///< D50 temperature samples array in C.
static U32 d50TempSamplesNextIndex;                                                                             ///< D50 temperature sample next index number.
static U32 d50TempCount;                                                                                        ///< D50 Number of samples in average buffer.

static U32 ddTempDataPublicationTimerCounter;                                                                   ///< DD Temperature sensors data publish timer counter.
static U32 fpTempDataPublicationTimerCounter;                                                                   ///< FP Temperature sensors data publish timer counter.
static OVERRIDE_U32_T ddTempSensorsPublishInterval;                                                             ///< DD Temperature sensors publish time interval override.
static OVERRIDE_U32_T fpTempSensorsPublishInterval;                                                             ///< FP Temperature sensors publish time interval override.

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

static TEMPSENSORS_EXEC_STATES_T handleExecStart( void );
static TEMPSENSORS_EXEC_STATES_T handleExecGetADCValues( void );
static void filterTemperatureReadings( void );
static void filterDialTemperatureReadings( void );
static void getTempMovingAverageTimeInterval( void );
static void publishTemperatureSensorsData( void );

/*********************************************************************//**
 * @brief
 * The initTemperature function initializes the temperature unit.
 * @details \b Inputs: none
 * @details \b Outputs: temperature unit variables initialized.
 * @return none
 *************************************************************************/
void initTemperature( void )
{
    startTime                               = 0;
    tempSensorsExecState                    = TEMPSENSORS_EXEC_STATE_START;
    ddTempDataPublicationTimerCounter       = DATA_PUBLISH_COUNTER_START_COUNT;
    fpTempDataPublicationTimerCounter       = DATA_PUBLISH_COUNTER_START_COUNT;
    d4TempRunningSumC                       = 0.0F;
    d4TempAvgC                              = 0.0F;
    d4TempSamplesNextIndex                  = 0;
    d4TempCount                             = 0;
    d50TempRunningSumC                      = 0.0F;
    d50TempAvgC                             = 0.0F;
    d50TempSamplesNextIndex                 = 0;
    d50TempCount                            = 0;
    d4TempSampleIntervalCounter             = 0;
    tempDataColTimeInterval                 = 0;
    tempDriftEventCheck                     = FALSE;

    dialTempMovingAvgData[ DIAL_TEMP_D28 ].dialTempColHasTimerBeenSet = FALSE;
    dialTempMovingAvgData[ DIAL_TEMP_D30 ].dialTempColHasTimerBeenSet = FALSE;

    ddTempSensorsPublishInterval.data       = TEMP_SENSORS_DATA_PUBLISH_INTERVAL;
    ddTempSensorsPublishInterval.ovData     = TEMP_SENSORS_DATA_PUBLISH_INTERVAL;
    ddTempSensorsPublishInterval.ovInitData = 0;
    ddTempSensorsPublishInterval.override   = OVERRIDE_RESET;

    fpTempSensorsPublishInterval.data       = TEMP_SENSORS_DATA_PUBLISH_INTERVAL;
    fpTempSensorsPublishInterval.ovData     = TEMP_SENSORS_DATA_PUBLISH_INTERVAL;
    fpTempSensorsPublishInterval.ovInitData = 0;
    fpTempSensorsPublishInterval.override   = OVERRIDE_RESET;
    // Initialize the temperature sensors
    initTemperatureSensors();

    // Persistent alarm for the temperature sensors range check
    initPersistentAlarm( ALARM_ID_DD_DIALYSATE_TEMPERATURE_SENSORS_OUT_OF_RANGE, 0, DIALYSATE_TEMP_SNSRS_OUT_OF_RANGE_TIMEOUT_MS );
}

/*********************************************************************//**
 * @brief
 * The execTemperatureSensorsSelfTest function runs the TemperatureSensors
 * POST during the self-test.
 * @details \b Inputs: none
 * @details \b Outputs: none
 * @return tempSensorsSelfTestState which is the status of the self test
 *************************************************************************/
SELF_TEST_STATUS_T execTemperatureSensorsSelfTest( void )
{
    SELF_TEST_STATUS_T result = SELF_TEST_STATUS_IN_PROGRESS;

    //TODO: Uncomment below once Non volatile record is implemented.
    //BOOL calStatus = getNVRecord2Driver( GET_CAL_TEMP_SENSORS, (U08*)&tempSensorCalRecord, sizeof( DD_TEMP_SENSORS_CAL_RECORD_T ),
    //                                      NUM_OF_CAL_DATA_TEMP_SENSORS, ALARM_ID_DD_TEMPERATURE_SENSORS_INVALID_CAL_RECORD );
    BOOL calStatus = TRUE;

    if ( TRUE == calStatus )
    {
        result = SELF_TEST_STATUS_PASSED;
    }
    else
    {
        result = SELF_TEST_STATUS_FAILED;
    }

    return result;
}

/*********************************************************************//**
 * @brief
 * The execTemperatureSensors function executes the temperature sensors'
 * state machine.
 * @details \b Inputs: tempSensorsExecState
 * @details \b Outputs: tempSensorsExecState
 * @details \b Alarms: ALARM_ID_DD_SOFTWARE_FAULT when invalid temperature
 * sensor state is seen.
 * @return none
 *************************************************************************/
void execTemperatureSensors( void )
{
    // Check if a new calibration is available
//    if ( TRUE == isNewCalibrationRecordAvailable() )
//    {
//        getNVRecord2Driver( GET_CAL_TEMP_SENSORS, (U08*)&tempSensorCalRecord, sizeof( DD_TEMP_SENSORS_CAL_RECORD_T ),
//                            NUM_OF_CAL_DATA_TEMP_SENSORS, ALARM_ID_DD_TEMPERATURE_SENSORS_INVALID_CAL_RECORD );
//    }

    // Read the sensors all the time
    switch ( tempSensorsExecState )
    {
        case TEMPSENSORS_EXEC_STATE_START:
            tempSensorsExecState = handleExecStart();
            break;

        case TEMPSENSORS_EXEC_STATE_GET_ADC_VALUES:
            tempSensorsExecState = handleExecGetADCValues();
            break;

        default:
            SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_TEMPERATURE_SENSORS_EXEC_INVALID_STATE, tempSensorsExecState );
            tempSensorsExecState = TEMPSENSORS_EXEC_STATE_GET_ADC_VALUES;
            break;
    }

    // Monitor the temperature values
    monitorTemperatureSenors();

    //Update the timeinterval
    getTempMovingAverageTimeInterval();

    // Filter D4/D50 temperature readings
    filterTemperatureReadings();

    // Publish the data
    publishTemperatureSensorsData();
}

/*********************************************************************//**
 * @brief
 * The handleExecStart function waits for a period of time and switches to
 * the state that reads the ADC values from FPGA.
 * @details \b Inputs: startTime
 * @details \b Outputs: startTime
 * @return the next state of the state machine
 *************************************************************************/
static TEMPSENSORS_EXEC_STATES_T handleExecStart( void )
{
    TEMPSENSORS_EXEC_STATES_T state = TEMPSENSORS_EXEC_STATE_START;

    if ( 0 == startTime )
    {
        startTime = getMSTimerCount();
    }
    // A delay to let FPGA to boot up
    else if ( TRUE == didTimeout( startTime, ADC_FPGA_READ_DELAY ) )
    {
        startTime                            = 0;
        state                                = TEMPSENSORS_EXEC_STATE_GET_ADC_VALUES;
    }

    return state;
}

/*********************************************************************//**
 * @brief
 * The handleExecGetADCValues function reads the ADC values from FPGA and
 * at the specified time intervals and calls required functions to calculate
 * the actual tempetature from the raw ADC values.
 * @details \b Inputs: FPGA
 * @details \b Outputs: temperature value.
 * @return the next state of the state machine
 *************************************************************************/
static TEMPSENSORS_EXEC_STATES_T handleExecGetADCValues( void )
{
    // Read temperature sensors
    readTemperatureSensors();

    return TEMPSENSORS_EXEC_STATE_GET_ADC_VALUES;
}

/*********************************************************************//**
 * @brief
 * The filterTemperatureReadings function adds a new temperature sensor
 * sample to the filters.
 * @details \b Inputs: D4 and D50 Temperature
 * @details \b Outputs: d4TempSamplesC[], d4TempSamplesNextIndex, d4TempRunningSumC,
 * d4TempCount, d4TempAvgC, d50TempSamplesC, d50TempRunningSumC, d50TempSamplesNextIndex,
 * d50TempCount, d50TempAvgC
 * @return none
 *************************************************************************/
static void filterTemperatureReadings( void )
{
    // Moving average sample collection interval varies based on the dialysate flow rate
    if ( ++d4TempSampleIntervalCounter >= tempDataColTimeInterval )
    {
        // Filter D4 Temperature for AC heater
        if ( d4TempCount >= D4_TEMP_MOVING_AVG_NUM_OF_SAMPLES )
        {
            d4TempRunningSumC -= d4TempSamplesC[ d4TempSamplesNextIndex ];
        }

        F32 d4Temp                                  = getTemperatureValue( D4_TEMP );
        d4TempSamplesC[ d4TempSamplesNextIndex ]    = d4Temp;
        d4TempRunningSumC                           += d4Temp;
        d4TempSamplesNextIndex                      = INC_WRAP( d4TempSamplesNextIndex, 0, D4_TEMP_MOVING_AVG_NUM_OF_SAMPLES - 1 );
        d4TempCount                                 = INC_CAP( d4TempCount, D4_TEMP_MOVING_AVG_NUM_OF_SAMPLES );
        d4TempAvgC                                  = d4TempRunningSumC / (F32)d4TempCount;
        d4TempSampleIntervalCounter                 = 0;
    }

    // Filter D50 Temperature ( 250 ms filter ) for trimmer heater
    if ( d50TempCount >= D50_TEMP_MOVING_AVG_NUM_OF_SAMPLES )
    {
        d50TempRunningSumC -= d50TempSamplesC[ d50TempSamplesNextIndex ];
    }

    F32 d50Temp                                  = getTemperatureValue( D50_TEMP );
    d50TempSamplesC[ d50TempSamplesNextIndex ]   = d50Temp;
    d50TempRunningSumC                           += d50Temp;
    d50TempSamplesNextIndex                      = INC_WRAP( d50TempSamplesNextIndex, 0, D50_TEMP_MOVING_AVG_NUM_OF_SAMPLES - 1 );
    d50TempCount                                 = INC_CAP( d50TempCount, D50_TEMP_MOVING_AVG_NUM_OF_SAMPLES );
    d50TempAvgC                                  = d50TempRunningSumC / (F32)d50TempCount;

    // dailysate temperature moving average
    filterDialTemperatureReadings();
}

/*********************************************************************//**
 * @brief
 * The filterDialTemperatureReadings function adds a new dialysate temperature
 * sensor sample to the filters.
 * @details \b Inputs: dialysate temperature
 * @details \b Outputs: dialTempMovingAvgData[]
 * @return none
 *************************************************************************/
static void filterDialTemperatureReadings( void )
{
    DIAL_TEMPERATURE_SENSORS_T i;

    for ( i = DIAL_TEMP_FIRST; i < NUM_OF_DIAL_TEMPS; i++ )
    {
        if ( FALSE == dialTempMovingAvgData[ i ].dialTempColHasTimerBeenSet )
        {
            dialTempMovingAvgData[ i ].dialTempDataColStartTimeMS = getMSTimerCount();
            dialTempMovingAvgData[ i ].dialTempColHasTimerBeenSet = TRUE;
        }
        else if ( TRUE == didTimeout( dialTempMovingAvgData[ i ].dialTempDataColStartTimeMS, D28_D30_DATA_COLLECTION_TIME_MS ) )
        {
            CONDUCTIVITY_SENSORS_T sensor = ( DIAL_TEMP_D28 == i ? D27_COND : D29_COND );
            F32 temperatureC             = getConductivityTemperatureValue( sensor );
            U32 currentIndex             = dialTempMovingAvgData[ i ].dialTempSamplesNextIndex;
            F32 prevSampleToRemoveC      = dialTempMovingAvgData[ i ].dialTempSamplesC[ currentIndex ];

            dialTempMovingAvgData[ i ].dialTempDataColStartTimeMS       = getMSTimerCount();
            dialTempMovingAvgData[ i ].dialTempColHasTimerBeenSet       = TRUE;
            dialTempMovingAvgData[ i ].dialTempSamplesC[ currentIndex ] = temperatureC;
            dialTempMovingAvgData[ i ].dialTempRunningSumC              = dialTempMovingAvgData[ i ].dialTempRunningSumC + temperatureC - prevSampleToRemoveC;
            dialTempMovingAvgData[ i ].dialTempSamplesNextIndex         = INC_WRAP( dialTempMovingAvgData[ i ].dialTempSamplesNextIndex, 0, DIAL_TEMP_MOVING_AVG_NUM_OF_SAMPLES - 1 );
            dialTempMovingAvgData[ i ].dialTempAvgC                     = dialTempMovingAvgData[ i ].dialTempRunningSumC / (F32)DIAL_TEMP_MOVING_AVG_NUM_OF_SAMPLES;
        }
    }
}

/*********************************************************************//**
 * @brief
 * The checkDialysateTemperatureSensors function checks whether the
 * dialysate temperature sensors have drifted. If they are drifted, it raises
 * an alarm.
 * @details \b Inputs: dialysate temperature
 * @details \b Outputs: None
 * @return none
 *************************************************************************/
void checkDialysateTemperatureSensors( void )
{
    DD_OP_MODE_T op = getCurrentOperationMode();

    if ( ( DD_MODE_GEND == op ) || ( DD_MODE_HEAT == op ) )
    {
        F32 d28Temp         = dialTempMovingAvgData[ DIAL_TEMP_D28 ].dialTempAvgC;
        F32 d30Temp         = dialTempMovingAvgData[ DIAL_TEMP_D30 ].dialTempAvgC;
        F32 driftC          = ( DD_MODE_HEAT == op ? D28_D30_TEMP_SENSORS_MAX_DEVIATION_IN_HEAT_DIS_C : D28_D30_TEMP_SENSORS_MAX_DEVIATION_C );
        BOOL isDriftOut     = ( fabs( d28Temp - d30Temp ) > driftC ? TRUE : FALSE );

        checkPersistentAlarm( ALARM_ID_DD_DIALYSATE_TEMPERATURE_SENSORS_OUT_OF_RANGE, isDriftOut, fabs( d28Temp - d30Temp ), driftC );

        if ( ( FALSE == tempDriftEventCheck ) && ( TRUE == isDriftOut ) )
        {
            // Send event only condition trigger, not continuously.
            tempDriftEventCheck = TRUE;
            SEND_EVENT_WITH_2_U32_DATA(DD_EVENT_TEMPERATURE_DRIFT, d28Temp, d30Temp)
        }

        if ( ( TRUE == tempDriftEventCheck ) && ( FALSE == isDriftOut ) )
        {
            tempDriftEventCheck = FALSE;
        }
    }
}

/*********************************************************************//**
 * @brief
 * The getD4AverageTemperature function returns the average temperature
 * for D4 temp sensor.
 * @details \b Inputs: none
 * @details \b Outputs: none
 * @return the D4 average temperature
 *************************************************************************/
F32 getD4AverageTemperature( void )
{
    return d4TempAvgC;
}

/*********************************************************************//**
 * @brief
 * The getD50AverageTemperature function returns the average temperature
 * for D50 temp sensor.
 * @details \b Inputs: none
 * @details \b Outputs: none
 * @return the D50 average temperature
 *************************************************************************/
F32 getD50AverageTemperature( void )
{
    return d50TempAvgC;
}

/*********************************************************************//**
 * @brief
 * The getTempMovingAverageTimeInterval function calculates the temperature
 * interval used for sample collection based on the dialysate flow rate,
 * to find the average value.
 * @details \b Inputs: dialysate flow rate
 * @details \b Outputs: none
 * @return the temperature interval for sample collection in task interval
 *************************************************************************/
static void getTempMovingAverageTimeInterval( void )
{
    F32 period = (F32)SEC_PER_MIN / ( getTDDialysateFlowrate() / BAL_CHAMBER_FILL_VOLUME_ML ) ;

    U32 sampleInterval = (U32)( ( period / (F32)D4_TEMP_MOVING_AVG_NUM_OF_SAMPLES ) * MS_PER_SECOND );

    tempDataColTimeInterval = (U32) ( sampleInterval / TASK_PRIORITY_INTERVAL );
}

/*********************************************************************//**
 * @brief
 * The publishTemperatureSensorsData function broadcasts the
 * temperature sensors data at the publication interval.
 * @details \b Inputs: ddTempDataPublicationTimerCounter
 * fpTempDataPublicationTimerCounter and publish interval time.
 * @details \b Outputs: ddTempDataPublicationTimerCounter, fpTempDataPublicationTimerCounter
 * @details \b Message \b Sent: MSG_ID_DD_TEMPERATURE_DATA, MSG_ID_FP_TEMPERATURE_DATA
 *  publishes the temperature data in a periodic interval.
 * @return none
 *************************************************************************/
static void publishTemperatureSensorsData( void )
{
    // publish DD temperature data on interval
    if ( ++ddTempDataPublicationTimerCounter >= getU32OverrideValue( &ddTempSensorsPublishInterval ) )
    {
        TEMPERATURE_SENSORS_DD_DATA_T data;

        data.d1Temp         = getTemperatureValue( D1_TEMP );
        data.d78Temp         = getTemperatureValue( D78_TEMP );
        data.d4Temp         = getTemperatureValue( D4_TEMP );
        data.d50Temp        = getTemperatureValue( D50_TEMP );
        data.boardTemp      = getTemperatureValue( BRD_TEMP );
        // TODO: update the following lines after Baro Sensor data is read from TD
        data.baroTemp       = 0.0F;
//        data.baroTemp       = getTemperatureValue( BARO_TEMP );
        data.d16CondTemp    = getConductivityTemperatureValue( D17_COND );
        data.d28CondTemp    = getConductivityTemperatureValue( D27_COND );
        data.d30CondTemp    = getConductivityTemperatureValue( D29_COND );
        data.d44CondTemp    = getConductivityTemperatureValue( D43_COND );
        data.d75CondTemp    = getConductivityTemperatureValue( D74_COND );
        data.d4AvgTemp      = getD4AverageTemperature();
        data.d50AvgTemp     = getD50AverageTemperature();
        data.d28AvgTemp     = dialTempMovingAvgData[ DIAL_TEMP_D28 ].dialTempAvgC;
        data.d30AvgTemp     = dialTempMovingAvgData[ DIAL_TEMP_D30 ].dialTempAvgC;
        data.d9PresTemp     = getFilteredPressureSensorTemperature( D9_PRES );
        data.d66PresTemp    = getFilteredPressureSensorTemperature( D66_PRES );
        data.d51PresTemp    = getFilteredPressureSensorTemperature( D51_PRES );
        data.d18PresTemp    = getFilteredPressureSensorTemperature( D18_PRES );
        data.d41PresTemp    = getFilteredPressureSensorTemperature( D41_PRES );

        broadcastData( MSG_ID_DD_TEMPERATURE_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( TEMPERATURE_SENSORS_DD_DATA_T ) );
        ddTempDataPublicationTimerCounter = 0;
    }
    // publish FP temperature data on interval
    if ( ++fpTempDataPublicationTimerCounter >= getU32OverrideValue( &fpTempSensorsPublishInterval ) )
    {
        TEMPERATURE_SENSORS_FP_DATA_T data;

        data.m1Temp         = getFilteredPressureSensorTemperature( M1_PRES );
        data.m3Temp         = getFilteredPressureSensorTemperature( M3_PRES );
        data.p10Temp        = getFilteredConductivitySensorTemperature( P9_COND );
        data.p19Temp        = getFilteredConductivitySensorTemperature( P18_COND );
        data.p8Temp         = getFilteredPressureSensorTemperature( P8_PRES );
        data.p13Temp        = getFilteredPressureSensorTemperature( P13_PRES );
        data.p17Temp        = getFilteredPressureSensorTemperature( P17_PRES );
        data.p7Temp         = getFilteredFlowSensorTemperature( P7_FLOW );
        data.p16Temp        = getFilteredFlowSensorTemperature( P16_FLOW );

        broadcastData( MSG_ID_FP_TEMPERATURE_DATA, COMM_BUFFER_OUT_CAN_FP_BROADCAST, (U08*)&data, sizeof( TEMPERATURE_SENSORS_FP_DATA_T ) );
        fpTempDataPublicationTimerCounter = 0;
    }
}


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


/*********************************************************************//**
 * @brief
 * The testDDTemperatureSensorsDataPublishIntervalOverride function
 * overrides the DD temperature sensor data publish interval.
 * @details \b Inputs: none
 * @details \b Outputs: ddTempSensorsPublishInterval
 * @param Override message from Dialin which includes the interval
 * (in ms) to override the DD temperature sensor data broadcast interval to.
 * @return TRUE if override successful, FALSE if not
 *************************************************************************/
BOOL testDDTemperatureSensorsDataPublishIntervalOverride( MESSAGE_T *message )
{
    BOOL result = u32BroadcastIntervalOverride( message, &ddTempSensorsPublishInterval, TASK_PRIORITY_INTERVAL );

    return result;
}

/*********************************************************************//**
 * @brief
 * The testIOFPTemperatureSensorsDataPublishIntervalOverride function
 * overrides the IOFP temperature sensors data publish interval.
 * @details \b Inputs: none
 * @details \b Outputs: fpTempSensorsPublishInterval
 * @param Override message from Dialin which includes the interval
 * (in ms) to override the IOFP temperature sensor data broadcast interval to.
 * @return TRUE if override successful, FALSE if not
 *************************************************************************/
BOOL testIOFPTemperatureSensorsDataPublishIntervalOverride( MESSAGE_T *message )
{
    BOOL result = u32BroadcastIntervalOverride( message, &fpTempSensorsPublishInterval, TASK_PRIORITY_INTERVAL );

    return result;
}

/**@}*/