/************************************************************************** * * 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 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. 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( 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 unit. * @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].readExecState = CONDUCTIVITY_READ_INITIATE; conductivitySensorControl[i].writeExecState = CONDUCTIVITY_WRITE_INITIATE; conductivitySensorControl[i].writeEnable = FALSE; conductivitySensorControl[i].writeInProgress = FALSE; } // 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 ) //{ // CONDUCTIVITY_SENSORS_T sensor; // // for ( sensor = CONDUCTIVITYSENSORS_CD1_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) // { // // write state machine // switch ( conductivitySensorControl[sensor].writeExecState ) // { // case CONDUCTIVITY_WRITE_INITIATE: // conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteInitiate(); // break; // // case CONDUCTIVITY_WRITE_COMPLETE: // conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteComplete(); // break; // // default: // SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_WR_INVALID_EXEC_STATE, 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 * @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 ) { CONDUCTIVITY_SENSORS_T sensor; for ( sensor = CONDUCTIVITYSENSORS_CD1_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { // Read state machine switch ( conductivitySensorControl[sensor].readExecState ) { case CONDUCTIVITY_READ_INITIATE: conductivitySensorControl[sensor].readExecState = handleConductivitySensorsReadInitiate(); break; case CONDUCTIVITY_READ_COMPLETE: conductivitySensorControl[sensor].readExecState = handleConductivitySensorsReadComplete(); break; default: // SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_RD_INVALID_EXEC_STATE, 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 * @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 = 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; } /**@}*/