/**************************************************************************
*
* 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)      Sean Nash
* @date    (last)      09-Nov-2024
*
* @author  (original)  Sean Nash
* @date    (original)  09-Nov-2024
*
***************************************************************************/

#include "Messaging.h"
#include "MessageSupport.h"
#include "OperationModes.h"
#include "Temperature.h"
#include "Timers.h"
#include "TaskPriority.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 DATA_PUBLISH_COUNTER_START_COUNT                        30                                              ///< Data publish counter start count.

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

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

static TEMPSENSORS_EXEC_STATES_T tempSensorsExecState;                                                          ///< TemperatureSensor exec state.
static U32 startTime;                                                                                           ///< star time to read FPGA values.
static U32 dataPublicationTimerCounter;                                                                         ///< Temperature sensors data publish timer counter.
static OVERRIDE_U32_T tempSensorsPublishInterval;                                                               ///< 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 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;
    dataPublicationTimerCounter            = DATA_PUBLISH_COUNTER_START_COUNT;

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

    // Initialize the temperature sensors
    initTemperatureSensors();
}

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

    // 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, baroCoeffsWaitToRcvStartTime
 * @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 publishTemperatureSensorsData function broadcasts the temperature
 * sensors data at the publication interval.
 * @details \b Inputs: dataPublicationTimerCounter and publish interval time.
 * @details \b Outputs: dataPublicationTimerCounter
 * @details \b Message \b Sent: MSG_ID_DD_TEMPERATURE_DATA publishes the temperature
 * data in a periodic interval.
 * @return none
 *************************************************************************/
static void publishTemperatureSensorsData( void )
{
    if ( ++dataPublicationTimerCounter >= getU32OverrideValue( &tempSensorsPublishInterval ) )
    {
        TEMPERATURE_SENSORS_DATA_T data;

        data.tempTRO1  = getTemperatureValue( TEMP_SENSOR_TRO1 );
        data.tempTRO1  = getTemperatureValue( TEMP_SENSOR_TRO2 );
        data.boardTemp = 0.0F; // TODO

        broadcastData( MSG_ID_RO_TEMPERATURE_DATA, COMM_BUFFER_OUT_CAN_RO_BROADCAST, (U08*)&data, sizeof( TEMPERATURE_SENSORS_DATA_T ) );
        dataPublicationTimerCounter = 0;
    }
}


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


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

    return result;
}


/**@}*/