/************************************************************************** * * 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 ConductivitySensors.c * * @author (last) Vinayakam Mani * @date (last) 10-Sep-2024 * * @author (original) Vinayakam Mani * @date (original) 10-Sep-2024 * ***************************************************************************/ #include // Used for calculating the polynomial calibration equation. #include // For memcpy #include "ConductivitySensors.h" #include "FpgaDD.h" #include "MessageSupport.h" #include "Messaging.h" #include "OperationModes.h" #include "PersistentAlarm.h" #include "Utilities.h" /** * @addtogroup ConductivitySensors * @{ */ // ********** private definitions ********** #define SIEMENS_TO_MICROSIEMENS_CONVERSION 1000000 ///< Siemens to microSiemens conversion factor. #define COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Conductivity sensors FPGA error timeout in milliseconds. /// Conductivity Sensor Control group typedef struct { BOOL resetRequested; ///< Flag indicates a reset command for the given conducitvity sensor. BOOL initEnable; ///< Flag indicates a enables initialization procedure for the given conductivity sensor. BOOL writeEnable; ///< Flag indicates a enables write transaction for the given conductivity sensor. BOOL readEnable; ///< Flag indicates a enables read transaction for the given conductivity sensor. BOOL writeInProgress; ///< Flag indicates write transaction in progress BOOL readInProgress; ///< Flag indicates read transaction in progress BOOL writeComplete; ///< Flag indicates write transaction complete state. BOOL readComplete; ///< Flag indicates read transaction complete state. U32 writeData; ///< Data to write for the given conductivity sensor. U32 readData; ///< Read data from the given conductivity sensor. U16 writeAddress; ///< Write address where the data needs to be written. U16 readAddress; ///< Read address to read the data. } CONDUCTIVITY_SENSOR_CONTROL_T; /// Defined states for the conductivity write transaction. typedef enum Conductvity_write_tx_states { CONDUCTIVITY_WRITE_INITIATE = 0, ///< Conductivity sensor write initiate state. CONDUCTIVITY_WRITE_COMPLETE, ///< Conductivity sensor write complete state. NUM_OF_CONDUCTIVITY_WR_STATES ///< Number of conductivity write states. } CONDUCTIVITY_WRITE_STATE_T; /// Defined states for the conductivity read transaction. typedef enum Conductvity_read_tx_states { CONDUCTIVITY_READ_INITIATE = 0, ///< Conductivity sensor read initiate state. CONDUCTIVITY_READ_COMPLETE, ///< Conductivity sensor read complete state. NUM_OF_CONDUCTIVITY_RD_STATES ///< Number of conductivity write states. } CONDUCTIVITY_READ_STATE_T; // ********** private data ********** static OVERRIDE_F32_T currentConductivityReadings[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Current conductivity sensor conductivity readings (overrideable). static OVERRIDE_F32_T currentTemperatureReadings[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Current conductivity sensor temperature readings (overrideable). static OVERRIDE_U32_T lastConductivityReadCounter[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Last conductivity sensor read count (Overrideable). static OVERRIDE_U32_T lastConductivityErrorCounter[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Last conductivity sensor error count (Overrideable). static CONDUCTIVITY_SENSOR_CONTROL_T conductivitySensorControl[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Conductivity sensor Control static CONDUCTIVITY_WRITE_STATE_T conductivitySensorWriteState; ///< Conductivity sensor write state machine static CONDUCTIVITY_READ_STATE_T conductivitySensorReadState; ///< Conductivity sensor read state machine // ********** private function prototypes ********** static void checkConductivitySensors( void ); static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( void ); static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( void ); static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( void ); static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( void ); /*********************************************************************//** * @brief * The initConductivitySensors function initializes the ConductivitySensors module. * @details \b Inputs: none * @details \b Outputs: ConductivitySensors unit variables initialized * @return none *************************************************************************/ void initConductivitySensors( void ) { U08 i; // Initialize override structures for each conductivity sensor for ( i = 0; i < NUM_OF_CONDUCTIVITY_SENSORS; i++ ) { currentConductivityReadings[ i ].data = 0.0F; currentConductivityReadings[ i ].ovData = 0.0F; currentConductivityReadings[ i ].ovInitData = 0.0F; currentConductivityReadings[ i ].override = OVERRIDE_RESET; currentTemperatureReadings[ i ].data = 0.0F; currentTemperatureReadings[ i ].ovData = 0.0F; currentTemperatureReadings[ i ].ovInitData = 0.0F; currentTemperatureReadings[ i ].override = OVERRIDE_RESET; lastConductivityReadCounter[ i ].data = 0; lastConductivityReadCounter[ i ].ovData = 0; lastConductivityReadCounter[ i ].ovInitData = 0; lastConductivityReadCounter[ i ].override = OVERRIDE_RESET; lastConductivityErrorCounter[ i ].data = 0; lastConductivityErrorCounter[ i ].ovData = 0; lastConductivityErrorCounter[ i ].ovInitData = 0; lastConductivityErrorCounter[ i ].override = OVERRIDE_RESET; conductivitySensorControl[i].initEnable = FALSE; conductivitySensorControl[i].readAddress = 0; conductivitySensorControl[i].readComplete = FALSE; conductivitySensorControl[i].readData = 0; conductivitySensorControl[i].readEnable = FALSE; conductivitySensorControl[i].readInProgress = FALSE; conductivitySensorControl[i].resetRequested = FALSE; conductivitySensorControl[i].writeAddress = 0; conductivitySensorControl[i].writeComplete = 0; conductivitySensorControl[i].writeData = 0; conductivitySensorControl[i].writeEnable = FALSE; conductivitySensorControl[i].writeInProgress = FALSE; } //Initialize the conductivity sensor read and write state conductivitySensorWriteState = CONDUCTIVITY_WRITE_INITIATE; conductivitySensorReadState = CONDUCTIVITY_READ_INITIATE; // Initialize the conductivity sensor FPGA alarms initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD1_COND_SENSOR, ALARM_ID_DD_CD1_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD2_COND_SENSOR, ALARM_ID_DD_CD2_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD3_COND_SENSOR, ALARM_ID_DD_CD3_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD4_COND_SENSOR, ALARM_ID_DD_CD4_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); } /*********************************************************************//** * @brief * The readConductivitySensors function gets the current conductivity reading * for all conductivity sensors from the FPGA and also reads the freshness * and error counters to verify that the conductivity sensors are being read * by the FPGA without issue. * @note This function should be called periodically to maintain fresh * sensor readings for all conductivity sensors. * @details \b Inputs: FPGA * @details \b Outputs: currentConductivityReadings[],currentTemperatureReadings[], * lastConductivityReadCounter[],lastConductivityErrorCounter[]. * @return none *************************************************************************/ void readConductivitySensors( void ) { // Read raw conductivity currentConductivityReadings[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (F32)getFPGACD1(); currentConductivityReadings[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (F32)getFPGACD2(); currentConductivityReadings[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (F32)getFPGACD3(); currentConductivityReadings[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (F32)getFPGACD4(); // Read temperature associated to conductivity sensor currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (F32)getFPGACD1Temp(); currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (F32)getFPGACD2Temp(); currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (F32)getFPGACD3Temp(); currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (F32)getFPGACD4Temp(); // Update read and error counters for each conductivity sensor lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (U32)getFPGACD1ReadCount(); lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (U32)getFPGACD2ReadCount(); lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (U32)getFPGACD3ReadCount(); lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (U32)getFPGACD4ReadCount(); lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (U32)getFPGACD1ErrorCount(); lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (U32)getFPGACD2ErrorCount(); lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (U32)getFPGACD3ErrorCount(); lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (U32)getFPGACD4ErrorCount(); // Monitor conductivity sensor health checkConductivitySensors(); } /*********************************************************************//** * @brief * The checkConductivitySensors function checks the read and error counters for * each conductivity sensor. * @details \b Alarm: ALARM_ID_DD_CD1_SENSOR_FPGA_FAULT if the * CD1 conductivity sensor is not able to be read. * @details \b Alarm: ALARM_ID_DD_CD2_SENSOR_FPGA_FAULT if the * CD2 conductivity sensor is not able to be read. * @details \b Alarm: ALARM_ID_DD_CD3_SENSOR_FPGA_FAULT if the * CD3 conductivity sensor is not able to be read. * @details \b Alarm: ALARM_ID_DD_CD4_SENSOR_FPGA_FAULT if the * CD4 conductivity sensor is not able to be read. * @details \b Inputs: lastConductivityReadCounter, lastConductivityErrorCounter * @details \b Outputs: none * @return none *************************************************************************/ static void checkConductivitySensors( void ) { checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD1_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD1_SENSOR) ); checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD2_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD2_SENSOR) ); checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD3_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD3_SENSOR) ); checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD4_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD4_SENSOR) ); checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD1_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD1_SENSOR ) ); checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD2_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD2_SENSOR ) ); checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD3_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD3_SENSOR ) ); checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD4_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD4_SENSOR ) ); } /*********************************************************************//** * @brief * The getConductivityValue function gets the conductivity * value for a given conductivity sensor id. * @details \b Inputs: currentConductivityReadings[] * @details \b Outputs: none * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. * @param sensorId conductivity sensor id * @return conductivity value *************************************************************************/ F32 getConductivityValue( CONDUCTIVITY_SENSORS_T sensor ) { F32 result = 0.0F; if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { result = currentConductivityReadings[ sensor ].data; if ( OVERRIDE_KEY == currentConductivityReadings[ sensor ].override ) { result = currentConductivityReadings[ sensor ].ovData; } } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID, sensor ); } return result; } /*********************************************************************//** * @brief * The getConductivityTemperatureValue function gets the temperature * value for a given conductivity sensor id. * @details \b Inputs: currentTemperatureReadings[] * @details \b Outputs: none * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. * @param sensorId conductivity sensor id * @return temperature value *************************************************************************/ F32 getConductivityTemperatureValue( CONDUCTIVITY_SENSORS_T sensor ) { F32 result = 0.0F; if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { result = currentTemperatureReadings[ sensor ].data; if ( OVERRIDE_KEY == currentTemperatureReadings[ sensor ].override ) { result = currentTemperatureReadings[ sensor ].ovData; } } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID1, sensor ); } return result; } /*********************************************************************//** * @brief * The getConductivitySensorReadCount function gets the current conductivity sensor * read count for a given conductivity sensor. * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. * @details \b Inputs: lastConductivityReadCounter * @details \b Outputs: none * @param sensor ID of conductivity sensor to get read count for. * @return The current conductivity sensor read count of a given conductivity sensor. *************************************************************************/ U32 getConductivitySensorReadCount( CONDUCTIVITY_SENSORS_T sensor ) { U32 result = 0; if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { result = lastConductivityReadCounter[ sensor ].data; if ( OVERRIDE_KEY == lastConductivityReadCounter[ sensor ].override ) { result = lastConductivityReadCounter[ sensor ].ovData; } } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID2, sensor ) } return result; } /*********************************************************************//** * @brief * The getConductivitySensorErrorCount function gets the current conductivity sensor * error count for a given conductivity sensor. * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. * @details \b Inputs: lastConductivityErrorCounter * @details \b Outputs: none * @param sensor ID of conductivity sensor to get error count for. * @return The current conductivity sensor error count of a given conductivity sensor. *************************************************************************/ U32 getConductivitySensorErrorCount( CONDUCTIVITY_SENSORS_T sensor ) { U32 result = 0; if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { result = lastConductivityErrorCounter[ sensor ].data; if ( OVERRIDE_KEY == lastConductivityErrorCounter[ sensor ].override ) { result = lastConductivityErrorCounter[ sensor ].ovData; } } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID3, sensor ) } return result; } /*********************************************************************//** * @brief * The requestConductivitySensorReset function commands the given * the conductivity sensor to go for reset. * @details \b Inputs: none * @details \b Outputs: conductivitySensorControl * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. * @param sensor conductivity sensor id * @return none *************************************************************************/ void requestConductivitySensorReset( CONDUCTIVITY_SENSORS_T sensor ) { if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { conductivitySensorControl[ sensor ].resetRequested = TRUE; } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID4, sensor ); } } /*********************************************************************//** * @brief * The setConductivitySensorInitEnable function enables the given * the conductivity sensor (re)initialization procedure. * @details \b Inputs: none * @details \b Outputs: conductivitySensorControl * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. * @param sensor conductivity sensor id * @return none *************************************************************************/ void setConductivitySensorInitEnable( CONDUCTIVITY_SENSORS_T sensor ) { if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { conductivitySensorControl[ sensor ].initEnable = TRUE; } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID5, sensor ); } } /*********************************************************************//** * @brief * The conductivitySensorWriteRequest function requests the write transaction * for the given conductivity sensor. * @details \b Inputs: none * @details \b Outputs: conductivitySensorControl * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. * @param sensor conductivity sensor id * @param writeAddr address to write for the given conductivity sensor. * @param data data to write in write address of given conductivity sensor. * @return none *************************************************************************/ void conductivitySensorWriteRequest( CONDUCTIVITY_SENSORS_T sensor, U16 writeAddr, U32 data ) { if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { conductivitySensorControl[ sensor ].writeAddress = writeAddr; conductivitySensorControl[ sensor ].writeData = data; conductivitySensorControl[ sensor ].writeEnable = TRUE; } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID6, sensor ); } } /*********************************************************************//** * @brief * The conductivitySensorReadRequest function requests the read transaction * for the given conductivity sensor. * @details \b Inputs: none * @details \b Outputs: conductivitySensorControl * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. * @param sensor conductivity sensor id * @param readAddr for sensor read transaction. * @return none *************************************************************************/ void conductivitySensorReadRequest( CONDUCTIVITY_SENSORS_T sensor, U16 readAddr ) { if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { conductivitySensorControl[ sensor ].readAddress = readAddr; conductivitySensorControl[ sensor ].readEnable = TRUE; } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID7, sensor ); } } /*********************************************************************//** * @brief * The conductivitySensorReadData function returns the read data * for the given conductivity sensor. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: none * @param sensor conductivity sensor id * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. * @return read data for the last request *************************************************************************/ U32 conductivitySensorReadData( CONDUCTIVITY_SENSORS_T sensor ) { U32 data; if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { data = conductivitySensorControl[ sensor ].readData; } else { SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID8, sensor ); } return data; } /*********************************************************************//** * @brief * The handleConductivitySensorsReset function checks the reset requested * for all conductivity sensors and perform the sensor reset. * @note This function should be called periodically to handle any * reset request for all conductivity sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl * @return none *************************************************************************/ void handleConductivitySensorsReset( void ) { if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].resetRequested ) { // CD1 reset setFPGACD1Reset(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].resetRequested = FALSE; } else { // clear CD1 reset clearFPGACD1Reset(); } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].resetRequested ) { // CD2 reset setFPGACD2Reset(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].resetRequested = FALSE; } else { // clear CD2 reset clearFPGACD2Reset(); } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].resetRequested ) { // CD3 reset setFPGACD3Reset(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].resetRequested = FALSE; } else { // clear CD3 reset clearFPGACD3Reset(); } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].resetRequested ) { // CD4 reset setFPGACD4Reset(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].resetRequested = FALSE; } else { // clear CD4 reset clearFPGACD4Reset(); } } /*********************************************************************//** * @brief * The handleConductivitySensorsInitProcedure function checks the (re)initialization * of conducitviy sensors request and may perform the sensor sequencing to * complete the initialization. * @note This function should be called periodically to handle any * Init request for all conductivity sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl * @return none *************************************************************************/ void handleConductivitySensorsInitProcedure( void ) { if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].initEnable ) { // CD1 initialization setFPGACD1InitEnable(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].initEnable = FALSE; } else { // clear CD1 Init command clearFPGACD1InitEnable(); } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].initEnable ) { // CD2 initialization setFPGACD2InitEnable(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].initEnable = FALSE; } else { // clear CD2 Init command clearFPGACD2InitEnable(); } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].initEnable ) { // CD3 initialization setFPGACD3InitEnable(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].initEnable = FALSE; } else { // clear CD3 Init command clearFPGACD3InitEnable(); } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].initEnable ) { // CD4 initialization setFPGACD4InitEnable(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].initEnable = FALSE; } else { // clear CD4 Init command clearFPGACD4InitEnable(); } } /*********************************************************************//** * @brief * The execConductivitySensorWrite function executes the conductivity sensor write * state machine. * @details \b Inputs: conductivitySensorWriteState * @details \b Outputs: conductivitySensorWriteState * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if invalid conductivity sensor write * state seen * @return none *************************************************************************/ void execConductivitySensorWrite( void ) { // state machine switch ( conductivitySensorWriteState ) { case CONDUCTIVITY_WRITE_INITIATE: conductivitySensorWriteState = handleConductivitySensorsWriteInitiate(); break; case CONDUCTIVITY_WRITE_COMPLETE: conductivitySensorWriteState = handleConductivitySensorsWriteComplete(); break; default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_WR_INVALID_EXEC_STATE, conductivitySensorWriteState ) conductivitySensorWriteState = CONDUCTIVITY_WRITE_INITIATE; break; } } /*********************************************************************//** * @brief * The handleConductivitySensorsWriteInitiate function initiates the write * transaction of given conducitviy sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl * @return CONDUCTIVITY_WRITE_STATE_T current state of write transaction *************************************************************************/ static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( void ) { CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_INITIATE; if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeEnable && FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress ) { // CD1 write request conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeComplete = FALSE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress = TRUE; setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeAddress ); setFPGACD12Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeData ); setFPGACD1WriteEnable(); state = CONDUCTIVITY_WRITE_COMPLETE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeEnable && FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress ) { // CD2 write request conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeComplete = FALSE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress = TRUE; setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeAddress ); setFPGACD12Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeData ); setFPGACD2WriteEnable(); state = CONDUCTIVITY_WRITE_COMPLETE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeEnable && FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress ) { // CD3 write request conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeComplete = FALSE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress = TRUE; setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeAddress ); setFPGACD34Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeData ); setFPGACD3WriteEnable(); state = CONDUCTIVITY_WRITE_COMPLETE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeEnable && FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress ) { // CD4 write request conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeComplete = FALSE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress = TRUE; setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeAddress ); setFPGACD34Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeData ); setFPGACD4WriteEnable(); state = CONDUCTIVITY_WRITE_COMPLETE; } return state; } /*********************************************************************//** * @brief * The handleConductivitySensorsWriteComplete function updates the write * transaction completion of given conducitviy sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl * @return CONDUCTIVITY_WRITE_STATE_T current state of write transaction *************************************************************************/ static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( void ) { CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_COMPLETE; if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress ) { conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeComplete = TRUE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeEnable = FALSE; clearFPGACD1WriteEnable(); state = CONDUCTIVITY_WRITE_INITIATE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress ) { conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeComplete = TRUE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeEnable = FALSE; clearFPGACD2WriteEnable(); state = CONDUCTIVITY_WRITE_INITIATE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress ) { conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeComplete = TRUE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeEnable = FALSE; clearFPGACD3WriteEnable(); state = CONDUCTIVITY_WRITE_INITIATE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress ) { conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeComplete = TRUE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeEnable = FALSE; clearFPGACD4WriteEnable(); state = CONDUCTIVITY_WRITE_INITIATE; } return state; } /*********************************************************************//** * @brief * The execConductivitySensorRead function executes the conductivity sensor read * state machine. * @details \b Inputs: conductivitySensorReadState * @details \b Outputs: conductivitySensorReadState * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if invalid conductivity sensor read * state seen * @return none *************************************************************************/ void execConductivitySensorRead( void ) { // state machine switch ( conductivitySensorReadState ) { case CONDUCTIVITY_READ_INITIATE: conductivitySensorReadState = handleConductivitySensorsReadInitiate(); break; case CONDUCTIVITY_READ_COMPLETE: conductivitySensorReadState = handleConductivitySensorsReadComplete(); break; default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_RD_INVALID_EXEC_STATE, conductivitySensorReadState ) conductivitySensorReadState = CONDUCTIVITY_READ_INITIATE; break; } } /*********************************************************************//** * @brief * The handleConductivitySensorsReadInitiate function initiates the read * transaction of given conducitviy sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl * @return CONDUCTIVITY_READ_STATE_T current state of read transaction *************************************************************************/ static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( void ) { CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_INITIATE; if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readEnable && FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress ) { // CD1 read request conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readComplete = FALSE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress = TRUE; setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readAddress ); setFPGACD1ReadEnable(); state = CONDUCTIVITY_READ_COMPLETE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readEnable && FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress ) { // CD2 read request conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readComplete = FALSE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress = TRUE; setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readAddress ); setFPGACD2ReadEnable(); state = CONDUCTIVITY_READ_COMPLETE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readEnable && FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress ) { // CD3 read request conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readComplete = FALSE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress = TRUE; setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readAddress ); setFPGACD3ReadEnable(); state = CONDUCTIVITY_READ_COMPLETE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readEnable && FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress ) { // CD4 read request conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readComplete = FALSE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress = TRUE; setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readAddress ); setFPGACD4ReadEnable(); state = CONDUCTIVITY_READ_COMPLETE; } return state; } /*********************************************************************//** * @brief * The handleConductivitySensorsReadComplete function updates the read * request completion of given conducitviy sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl * @return CONDUCTIVITY_READ_STATE_T current state of write transaction *************************************************************************/ static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( void ) { CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_COMPLETE; if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress ) { conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readData = getFPGACD1Data(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readComplete = TRUE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readEnable = FALSE; clearFPGACD1ReadEnable(); state = CONDUCTIVITY_READ_INITIATE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress ) { conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readData = getFPGACD2Data(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readComplete = TRUE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readEnable = FALSE; clearFPGACD2ReadEnable(); state = CONDUCTIVITY_READ_INITIATE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress ) { conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readData = getFPGACD3Data(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readComplete = TRUE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readEnable = FALSE; clearFPGACD3ReadEnable(); state = CONDUCTIVITY_READ_INITIATE; } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress ) { conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readData = getFPGACD4Data(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readComplete = TRUE; conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readEnable = FALSE; clearFPGACD4ReadEnable(); state = CONDUCTIVITY_READ_INITIATE; } return state; } /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ /*********************************************************************//** * @brief * The testConductivitySensorReadingsOverride function overrides the value of the * specified conductivity sensor with a given value. * @details \b Inputs: none * @details \b Outputs: currentConductivityReadings[] * @param message Override message from Dialin which includes an sensor * ID and override value of the conductivity sensor. * @return TRUE if override successful, FALSE if not *************************************************************************/ BOOL testConductivitySensorReadingsOverride( MESSAGE_T *message ) { BOOL result = FALSE; TEST_OVERRIDE_ARRAY_PAYLOAD_T override; OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &override ); // Verify tester has logged in with TD and override type is valid if ( ( TRUE == isTestingActivated() ) && ( ovType != OVERRIDE_INVALID ) && ( ovType < NUM_OF_OVERRIDE_TYPES ) ) { U32 sensor = override.index; // Verify bubble detector index of override if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { if ( OVERRIDE_OVERRIDE == ovType ) { F32 value = override.state.f32; currentConductivityReadings[ sensor ].ovData = value; currentConductivityReadings[ sensor ].override = OVERRIDE_KEY; result = TRUE; } else { currentConductivityReadings[ sensor ].override = OVERRIDE_RESET; currentConductivityReadings[ sensor ].ovData = currentConductivityReadings[ sensor ].ovInitData; result = TRUE; } } } return result; } /*********************************************************************//** * @brief * The testConductivitySensorTemperatureReadingsOverride function overrides * the value of the specified conductivity sensor temperature with a given value. * @details \b Inputs: none * @details \b Outputs: currentPresTempReadings[] * @param message Override message from Dialin which includes an sensor * ID and override value of the conductivity sensor temperature. * @return TRUE if override successful, FALSE if not *************************************************************************/ BOOL testConductivitySensorTemperatureReadingsOverride( MESSAGE_T *message ) { BOOL result = FALSE; TEST_OVERRIDE_ARRAY_PAYLOAD_T override; OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &override ); // Verify tester has logged in with TD and override type is valid if ( ( TRUE == isTestingActivated() ) && ( ovType != OVERRIDE_INVALID ) && ( ovType < NUM_OF_OVERRIDE_TYPES ) ) { U32 sensor = override.index; // Verify bubble detector index of override if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { if ( OVERRIDE_OVERRIDE == ovType ) { F32 value = override.state.f32; currentTemperatureReadings[ sensor ].ovData = value; currentTemperatureReadings[ sensor ].override = OVERRIDE_KEY; result = TRUE; } else { currentTemperatureReadings[ sensor ].override = OVERRIDE_RESET; currentTemperatureReadings[ sensor ].ovData = currentTemperatureReadings[ sensor ].ovInitData; result = TRUE; } } } return result; } /**@}*/