/************************************************************************** * * 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) Sean Nash * @date (last) 09-Nov-2024 * * @author (original) Sean Nash * @date (original) 09-Nov-2024 * ***************************************************************************/ #include // Used for calculating the polynomial calibration equation. #include // For memcpy #include "ConductivitySensors.h" #include "FpgaRO.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. #define COND_SENSORS_READ_ERR_MAX_CNT 255 ///< Conductivity sensors read and error count max value /// 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 read states. } CONDUCTIVITY_READ_STATE_T; /// Conductivity Sensor Control group typedef struct { BOOL resetRequested; ///< Flag indicates a reset command for the given conductivity 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. CONDUCTIVITY_READ_STATE_T readExecState; ///< Read executive state from the given conductivity sensor. CONDUCTIVITY_WRITE_STATE_T writeExecState; ///< Write executive state 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; // ********** 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 for reset, init, read and write operations. // ********** private function prototypes ********** //static void checkConductivitySensors( void ); static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( CONDUCTIVITY_SENSORS_T sensorID ); static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( CONDUCTIVITY_SENSORS_T sensorID ); static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( CONDUCTIVITY_SENSORS_T sensorID ); static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( CONDUCTIVITY_SENSORS_T sensorID ); /*********************************************************************//** * @brief * The initConductivitySensors function initializes the ConductivitySensors unit. * @details \b Inputs: none * @details \b Outputs: ConductivitySensors unit variables initialized * @return none *************************************************************************/ void initConductivitySensors( void ) { CONDUCTIVITY_SENSORS_T sensor; // Initialize override structures for each conductivity sensor for ( sensor = CONDUCTIVITYSENSORS_FIRST; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { currentConductivityReadings[ sensor ].data = 0.0F; currentConductivityReadings[ sensor ].ovData = 0.0F; currentConductivityReadings[ sensor ].ovInitData = 0.0F; currentConductivityReadings[ sensor ].override = OVERRIDE_RESET; currentTemperatureReadings[ sensor ].data = 0.0F; currentTemperatureReadings[ sensor ].ovData = 0.0F; currentTemperatureReadings[ sensor ].ovInitData = 0.0F; currentTemperatureReadings[ sensor ].override = OVERRIDE_RESET; lastConductivityReadCounter[ sensor ].data = 0; lastConductivityReadCounter[ sensor ].ovData = 0; lastConductivityReadCounter[ sensor ].ovInitData = 0; lastConductivityReadCounter[ sensor ].override = OVERRIDE_RESET; lastConductivityErrorCounter[ sensor ].data = 0; lastConductivityErrorCounter[ sensor ].ovData = 0; lastConductivityErrorCounter[ sensor ].ovInitData = 0; lastConductivityErrorCounter[ sensor ].override = OVERRIDE_RESET; conductivitySensorControl[ sensor ].initEnable = FALSE; conductivitySensorControl[ sensor ].readAddress = 0; conductivitySensorControl[ sensor ].readComplete = FALSE; conductivitySensorControl[ sensor ].readData = 0; conductivitySensorControl[ sensor ].readEnable = FALSE; conductivitySensorControl[ sensor ].readInProgress = FALSE; conductivitySensorControl[ sensor ].resetRequested = FALSE; conductivitySensorControl[ sensor ].writeAddress = 0; conductivitySensorControl[ sensor ].writeComplete = 0; conductivitySensorControl[ sensor ].writeData = 0; conductivitySensorControl[ sensor ].readExecState = CONDUCTIVITY_READ_INITIATE; conductivitySensorControl[ sensor ].writeExecState = CONDUCTIVITY_WRITE_INITIATE; conductivitySensorControl[ sensor ].writeEnable = FALSE; conductivitySensorControl[ sensor ].writeInProgress = FALSE; } // Initialize the conductivity sensor FPGA alarms // initFPGAPersistentAlarm( FPGA_PERS_ERROR_CPI_COND_SENSOR, ALARM_ID_RO_CPI_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); // initFPGAPersistentAlarm( FPGA_PERS_ERROR_CPO_COND_SENSOR, ALARM_ID_RO_CPO_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_CPI_SENSOR ].data = (F32)getFPGACPiConductivity(); currentConductivityReadings[ CONDUCTIVITYSENSORS_CPO_SENSOR ].data = (F32)getFPGACPoConductivity(); // Read temperature associated to conductivity sensor currentTemperatureReadings[ CONDUCTIVITYSENSORS_CPI_SENSOR ].data = (F32)getFPGACPiTemperature(); currentTemperatureReadings[ CONDUCTIVITYSENSORS_CPO_SENSOR ].data = (F32)getFPGACPoTemperature(); // Update read and error counters for each conductivity sensor lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CPI_SENSOR ].data = (U32)getFPGACPiReadCount(); lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CPO_SENSOR ].data = (U32)getFPGACPoReadCount(); lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CPI_SENSOR ].data = (U32)getFPGACPiErrorCount(); lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CPO_SENSOR ].data = (U32)getFPGACPoErrorCount(); // 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. * @details \b Inputs: currentConductivityReadings[] * @details \b Outputs: none * @details \b Alarm: ALARM_ID_RO_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_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID, (U32)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_RO_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_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID1, (U32)sensor ); } return result; } /*********************************************************************//** * @brief * The getConductivitySensorReadCount function gets the current conductivity sensor * read count for a given conductivity sensor. * @details \b Alarm: ALARM_ID_RO_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_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID2, (U32)sensor ) } return result; } /*********************************************************************//** * @brief * The getConductivitySensorErrorCount function gets the current conductivity sensor * error count for a given conductivity sensor. * @details \b Alarm: ALARM_ID_RO_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_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID3, (U32)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_RO_SOFTWARE_FAULT if given sensor is invalid. * @param sensor ID of conductivity sensor to request reset for * @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_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID4, (U32)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_RO_SOFTWARE_FAULT if given sensor is invalid. * @param sensor ID of conductivity sensor to enable initialization for * @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_RO_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_RO_SOFTWARE_FAULT if given sensor is invalid. * @param sensor ID of conductivity sensor to request write for * @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_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID6, (U32)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_RO_SOFTWARE_FAULT if given sensor is invalid. * @param sensor ID of conductivity sensor to request read for * @param readAddr Address to read from the given sensor. * @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_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID7, (U32)sensor ); } } /*********************************************************************//** * @brief * The conductivitySensorReadData function returns the read data for the * given conductivity sensor. * @details \b Inputs: conductivitySensorControl[] * @details \b Outputs: none * @param sensor ID conductivity sensor to read data from * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if given sensor is invalid. * @return read data for the last read 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_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID8, (U32)sensor ); } return data; } /*********************************************************************//** * @brief * The handleConductivitySensorsReset function checks the reset requested * for all conductivity sensors and performs the sensor reset if requested. * @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_CPI_SENSOR ].resetRequested ) { // CPi reset setFPGACPiReset(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CPI_SENSOR ].resetRequested = FALSE; } else { // clear CPi reset clearFPGACPiReset(); } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CPO_SENSOR ].resetRequested ) { // CPo reset setFPGACPoReset(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CPO_SENSOR ].resetRequested = FALSE; } else { // clear CPo reset clearFPGACPoReset(); } } /*********************************************************************//** * @brief * The handleConductivitySensorsInitProcedure function checks the (re)initialization * requested for all conductivity sensors request and performs the sensor initialization * sequencing if requested. * @note This function should be called periodically to handle any initialization * request for all conductivity sensors. * @details \b Inputs: conductivitySensorControl[] * @details \b Outputs: conductivitySensorControl[] * @return none *************************************************************************/ void handleConductivitySensorsInitProcedure( void ) { if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CPI_SENSOR ].initEnable ) { // CPi initialization setFPGACPiInitEnable(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CPI_SENSOR ].initEnable = FALSE; } else { // clear CPi Init command clearFPGACPiInitEnable(); } if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CPO_SENSOR ].initEnable ) { // CPo initialization setFPGACPoInitEnable(); conductivitySensorControl[ CONDUCTIVITYSENSORS_CPO_SENSOR ].initEnable = FALSE; } else { // clear CPo Init command clearFPGACPoInitEnable(); } } /*********************************************************************//** * @brief * The execConductivitySensorWrite function executes the conductivity sensor write * state machine. * @details \b Inputs: conductivitySensorWriteState * @details \b Outputs: conductivitySensorWriteState * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT if invalid conductivity sensor write * state seen * @return none *************************************************************************/ void execConductivitySensorWrite( void ) { CONDUCTIVITY_SENSORS_T sensor; for ( sensor = CONDUCTIVITYSENSORS_FIRST; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { // write state machine switch ( conductivitySensorControl[sensor].writeExecState ) { case CONDUCTIVITY_WRITE_INITIATE: conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteInitiate( sensor ); break; case CONDUCTIVITY_WRITE_COMPLETE: conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteComplete( sensor ); break; default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_WR_INVALID_EXEC_STATE, (U32)conductivitySensorControl[sensor].writeExecState ) conductivitySensorControl[sensor].writeExecState = CONDUCTIVITY_WRITE_INITIATE; break; } } } /*********************************************************************//** * @brief * The handleConductivitySensorsWriteInitiate function initiates the write * transaction of given conducitviy sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl * @param sensorID ID of conductivity sensor to handle write initiate state for * @return CONDUCTIVITY_WRITE_STATE_T current state of write transaction *************************************************************************/ static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( CONDUCTIVITY_SENSORS_T sensorID ) { CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_INITIATE; if ( TRUE == conductivitySensorControl[ sensorID ].writeEnable && FALSE == conductivitySensorControl[ sensorID ].writeInProgress ) { conductivitySensorControl[ sensorID ].writeComplete = FALSE; conductivitySensorControl[ sensorID ].writeInProgress = TRUE; if ( CONDUCTIVITYSENSORS_CPI_SENSOR == sensorID ) { setFPGACPiAddress( conductivitySensorControl[ sensorID ].writeAddress ); setFPGACPiData( conductivitySensorControl[ sensorID ].writeData ); setFPGACPiWriteEnable(); } else { setFPGACPoAddress( conductivitySensorControl[ sensorID ].writeAddress ); setFPGACPoData( conductivitySensorControl[ sensorID ].writeData ); setFPGACPoWriteEnable(); } 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 * @param sensorID ID of conductivity sensor to handle write complete state for * @return CONDUCTIVITY_WRITE_STATE_T current state of write transaction *************************************************************************/ static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( CONDUCTIVITY_SENSORS_T sensorID ) { CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_COMPLETE; if ( TRUE == conductivitySensorControl[ sensorID ].writeInProgress ) { conductivitySensorControl[ sensorID ].writeComplete = TRUE; conductivitySensorControl[ sensorID ].writeEnable = FALSE; if ( CONDUCTIVITYSENSORS_CPI_SENSOR == sensorID ) { clearFPGACPiWriteEnable(); } else { clearFPGACPoWriteEnable(); } 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_RO_SOFTWARE_FAULT if invalid conductivity sensor read * state seen * @return none *************************************************************************/ void execConductivitySensorRead( void ) { CONDUCTIVITY_SENSORS_T sensor; for ( sensor = CONDUCTIVITYSENSORS_FIRST; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { // Read state machine switch ( conductivitySensorControl[sensor].readExecState ) { case CONDUCTIVITY_READ_INITIATE: conductivitySensorControl[sensor].readExecState = handleConductivitySensorsReadInitiate( sensor ); break; case CONDUCTIVITY_READ_COMPLETE: conductivitySensorControl[sensor].readExecState = handleConductivitySensorsReadComplete( sensor ); break; default: SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_RD_INVALID_EXEC_STATE, (U32)conductivitySensorControl[sensor].readExecState ) conductivitySensorControl[sensor].readExecState = CONDUCTIVITY_READ_INITIATE; break; } } } /*********************************************************************//** * @brief * The handleConductivitySensorsReadInitiate function initiates the read * transaction of given conducitviy sensors. * @details \b Inputs: conductivitySensorControl * @details \b Outputs: conductivitySensorControl * @param sensorID ID of conductivity sensor to handle read initiate state for * @return CONDUCTIVITY_READ_STATE_T current state of read transaction *************************************************************************/ static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( CONDUCTIVITY_SENSORS_T sensorID ) { CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_INITIATE; if ( TRUE == conductivitySensorControl[ sensorID ].readEnable && FALSE == conductivitySensorControl[ sensorID ].readInProgress ) { conductivitySensorControl[ sensorID ].readComplete = FALSE; conductivitySensorControl[ sensorID ].readInProgress = TRUE; if ( CONDUCTIVITYSENSORS_CPI_SENSOR == sensorID ) { setFPGACPiAddress( conductivitySensorControl[ sensorID ].readAddress ); setFPGACPiReadEnable(); } else { setFPGACPoAddress( conductivitySensorControl[ sensorID ].readAddress ); setFPGACPoReadEnable(); } 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 * @param sensorID ID of conductivity sensor to handle read complete state for * @return CONDUCTIVITY_READ_STATE_T current state of write transaction *************************************************************************/ static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( CONDUCTIVITY_SENSORS_T sensorID ) { CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_COMPLETE; if ( TRUE == conductivitySensorControl[ sensorID ].readInProgress ) { if ( CONDUCTIVITYSENSORS_CPI_SENSOR == sensorID ) { conductivitySensorControl[ sensorID ].readData = getFPGACPiData(); clearFPGACPiReadEnable(); } else { conductivitySensorControl[ sensorID ].readData = getFPGACPoData(); clearFPGACPoReadEnable(); } conductivitySensorControl[ sensorID ].readComplete = TRUE; conductivitySensorControl[ sensorID ].readEnable = FALSE; 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 = f32ArrayOverride( message, ¤tConductivityReadings[0], NUM_OF_CONDUCTIVITY_SENSORS - 1 ); 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 = f32ArrayOverride( message, ¤tTemperatureReadings[0], NUM_OF_CONDUCTIVITY_SENSORS - 1 ); return result; } /*********************************************************************//** * @brief * The testConductivitySensorReadCounterOverride function overrides * the value of the specified conductivity sensor read counter with a given value. * @details \b Inputs: none * @details \b Outputs: lastConductivityReadCounter[] * @param message Override message from Dialin which includes an sensor * ID and override value of the conductivity sensor read counter. * @return TRUE if override successful, FALSE if not *************************************************************************/ BOOL testConductivitySensorReadCounterOverride( MESSAGE_T *message ) { BOOL result = u32ArrayOverride( message, &lastConductivityReadCounter[0], NUM_OF_CONDUCTIVITY_SENSORS - 1, 0, COND_SENSORS_READ_ERR_MAX_CNT ); return result; } /*********************************************************************//** * @brief * The testConductivitySensorErrorCounterOverride function overrides * the value of the specified conductivity sensor error counter with a given value. * @details \b Inputs: none * @details \b Outputs: lastConductivityErrorCounter[] * @param message Override message from Dialin which includes an sensor * ID and override value of the conductivity sensor error counter. * @return TRUE if override successful, FALSE if not *************************************************************************/ BOOL testConductivitySensorErrorCounterOverride( MESSAGE_T *message ) { BOOL result = u32ArrayOverride( message, &lastConductivityErrorCounter[0], NUM_OF_CONDUCTIVITY_SENSORS - 1, 0, COND_SENSORS_READ_ERR_MAX_CNT ); return result; } /**@}*/