Index: firmware/App/Drivers/ConductivitySensors.c =================================================================== diff -u -r830213bc6dcc1a684610caf78c79d55f2cb41e93 -re2681bed3a45f89c804ddf2ae607fc416bd61d5d --- firmware/App/Drivers/ConductivitySensors.c (.../ConductivitySensors.c) (revision 830213bc6dcc1a684610caf78c79d55f2cb41e93) +++ firmware/App/Drivers/ConductivitySensors.c (.../ConductivitySensors.c) (revision e2681bed3a45f89c804ddf2ae607fc416bd61d5d) @@ -23,6 +23,7 @@ #include "Messaging.h" #include "OperationModes.h" #include "PersistentAlarm.h" +#include "TaskPriority.h" #include "Utilities.h" /** @@ -32,62 +33,76 @@ // ********** 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 +#define CELL_COEFF_LOW_BOUNDS 3 ///< Low bounds for cell coefficient values. +#define CELL_COEFF_HIGH_BOUNDS 6 ///< High bounds for cell coefficient values. +#define RESISTANCE_OFFSET_LOW_BOUNDS -1000 ///< Low bounds for resistance offset values. +#define RESISTANCE_OFFSET_HIGH_BOUNDS 1000 ///< High bounds for resistance offset values. +#define RESISTANCE_SCALE_LOW_BOUNDS 0.5F ///< Low bounds for resistance scale values. +#define RESISTANCE_SCALE_HIGH_BOUNDS 3.0F ///< High bounds for resistance scale values. +#define TEMPERATURE_CORRECTION_LOW_BOUNDS 0.005F ///< Low bounds for temperature correction values. +#define TEMPERATURE_CORRECTION_HIGH_BOUNDS 0.04F ///< High bounds for temperature correction values. +#define TEMPERATURE_OFFSET_LOW_BOUNDS -10 ///< Low bounds for temperature scale values. +#define TEMPERATURE_OFFSET_HIGH_BOUNDS 10 ///< High bounds for temperature offset values. +#define TEMPERATURE_SCALE_LOW_BOUNDS 0.5F ///< Low bounds for temperature scale values. +#define TEMPERATURE_SCALE_HIGH_BOUNDS 2.0F ///< High bounds for temperature scale values. +#define LOWER_WORD_SIZE 4 ///< Size in bytes of the lower word size for retrieving revision data. +#define MID_WORD_SIZE 4 ///< Size in bytes of the middle word size for retrieving revision data. +#define UPPER_WORD_SIZE 2 ///< Size in bytes of the upper word size for retrieving revision data. +#define MAX_CONDUCTIVITY_SENSOR_FAILURES 2 ///< Number of failures before alarming in timed window count. +#define MAX_CONDUCTIVITY_SENSOR_FAILURE_WINDOW_MS ( 60 * MS_PER_SECOND ) ///< Set time for timed window count. +#define MAX_ALLOWED_UNCHANGED_CONDUCTIVITY_READS ( 500 / TASK_PRIORITY_INTERVAL ) ///< New reading every 333ms, expect to get valid new reading in 500ms. +#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 +typedef enum Conductvity_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; + CONDUCTIVITY_INIT_STATE = 0, ///< Conductivity sensor write initiate state. + CONDUCTIVITY_READ_DATA_STATE, ///< Conductivity sensor write complete state. + NUM_OF_CONDUCTIVITY_STATES ///< Number of conductivity write states. +} CONDUCTIVITY_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 +/// Conductivity Sensor Status 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; + U08 condReadCount; ///< Last conductivity read count. + U08 condErrorCount; ///< Last conductivity error count. + U08 tempReadCount; ///< Last temperature read count. + U08 tempErrorCount; ///< Last temperature error count. + U08 interalCondErrorCount; ///< Internal conductivity error count for stale data. + U08 interalTempErrorCount; ///< Internal temperature error count for stale data. + U08 calMemCount; ///< Cal memory counter. + U32 calData; ///< Cal word data storage. + BOOL hasCalSlotBeenRead[ NUM_OF_CONDUCTIVTY_CAL_IDXS ]; ///< Boolean array tracking which cal mem data has been read. + BOOL haveAllCalSlotsBeenRead; ///< Boolean to determine if all cal values have been read from the FPGA. + BOOL calReadComplete; ///< Boolean to determine if cal values are within range and ready to read data. +} CONDUCTIVITY_SENSOR_STATUS_T; // ********** private data ********** - +static CONDUCTIVITY_STATE_T currentConductivityState; ///< Current conductivity sensor state. 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 OVERRIDE_U32_T lastTemperatureReadCounter[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Last conductivity sensor read count (Overrideable). +static OVERRIDE_U32_T lastTemperatureErrorCounter[ 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. +static CONDUCTIVITY_SENSOR_STATUS_T conductivitySensorStatus[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Conductivity sensor status array for counters and data. +static CONDUCTIVITY_COEFFICIENTS_T conductivitySensorCoefficients[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Conductivity sensor calibration coefficient data. +static CONDUCTIVITY_REVISIONS_T conductivitySensorRevisions[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Conductivity sensor revision and serial data. // ********** private function prototypes ********** +static CONDUCTIVITY_STATE_T handleConductivityReadCalState( void ); +static CONDUCTIVITY_STATE_T handleConductivityReadDataState( void ); +static void checkCondCounters( U32 sensorId, U08 condReadCount, U08 condErrorCount, U08 tempReadCount, U08 tempErrorCount ); +static U32 getConductivitySensorReadCount( CONDUCTIVITY_SENSORS_T sensor ); +static U32 getConductivitySensorErrorCount( CONDUCTIVITY_SENSORS_T sensor ); +static U32 getTemperatureSensorReadCount( CONDUCTIVITY_SENSORS_T sensor ); +static U32 getTemperatureSensorErrorCount( CONDUCTIVITY_SENSORS_T sensor ); +static BOOL monitorCalDataReads( U32 sensorId ); +static BOOL checkConductivityCoefficientRanges( U32 sensorId ); -static void checkConductivitySensors( void ); -static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( CONDUCTIVITY_SENSORS_T sensorID ); -static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( CONDUCTIVITY_SENSORS_T sensorID ); -static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( CONDUCTIVITY_SENSORS_T sensorID ); -static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( CONDUCTIVITY_SENSORS_T sensorID ); - /*********************************************************************//** * @brief * The initConductivitySensors function initializes the ConductivitySensors unit. @@ -97,896 +112,713 @@ *************************************************************************/ void initConductivitySensors( void ) { + currentConductivityState = CONDUCTIVITY_INIT_STATE; CONDUCTIVITY_SENSORS_T sensor; // Initialize override structures for each conductivity sensor for ( sensor = FIRST_DD_COND_SENSOR; 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; + 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; + 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; + 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; + 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; + lastTemperatureReadCounter[ sensor ].data = 0; + lastTemperatureReadCounter[ sensor ].ovData = 0; + lastTemperatureReadCounter[ sensor ].ovInitData = 0; + lastTemperatureReadCounter[ sensor ].override = OVERRIDE_RESET; + + lastTemperatureErrorCounter[ sensor ].data = 0; + lastTemperatureErrorCounter[ sensor ].ovData = 0; + lastTemperatureErrorCounter[ sensor ].ovInitData = 0; + lastTemperatureErrorCounter[ sensor ].override = OVERRIDE_RESET; + + conductivitySensorStatus[ sensor ].interalCondErrorCount = 0; + conductivitySensorStatus[ sensor ].interalTempErrorCount = 0; + conductivitySensorStatus[ sensor ].calMemCount = 0; + conductivitySensorStatus[ sensor ].calData = 0; + conductivitySensorStatus[ sensor ].haveAllCalSlotsBeenRead = FALSE; + memset( conductivitySensorStatus[ sensor ].hasCalSlotBeenRead, 0 ,sizeof( conductivitySensorStatus[ sensor ].hasCalSlotBeenRead ) ); + + conductivitySensorCoefficients[ sensor ].K_high = 0; + conductivitySensorCoefficients[ sensor ].alpha_high = 0.0F; + conductivitySensorCoefficients[ sensor ].eta_high = 0.0F; + conductivitySensorCoefficients[ sensor ].zeta_high = 0; + conductivitySensorCoefficients[ sensor ].K_low = 0; + conductivitySensorCoefficients[ sensor ].alpha_low = 0.0F; + conductivitySensorCoefficients[ sensor ].eta_low = 0.0F; + conductivitySensorCoefficients[ sensor ].zeta_low = 0; + conductivitySensorCoefficients[ sensor ].beta = 0.0F; + conductivitySensorCoefficients[ sensor ].delta = 0; + conductivitySensorCoefficients[ sensor ].reserved1 = 0; + conductivitySensorCoefficients[ sensor ].reserved2 = 0; + + memset( conductivitySensorRevisions[ sensor ].swRev, 0, sizeof( U08 ) * CONDUCTIVITY_CAL_CHAR_LENGTH ); + memset( conductivitySensorRevisions[ sensor ].hwRev, 0, sizeof( U08 ) * CONDUCTIVITY_CAL_CHAR_LENGTH ); + memset( conductivitySensorRevisions[ sensor ].hwSerial, 0, sizeof( U08 ) * CONDUCTIVITY_CAL_CHAR_LENGTH ); } // Initialize the conductivity sensor FPGA alarms + initTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_CONDUCTIVITY_SENSOR_ERROR, MAX_CONDUCTIVITY_SENSOR_FAILURES, MAX_CONDUCTIVITY_SENSOR_FAILURE_WINDOW_MS ); initFPGAPersistentAlarm( FPGA_PERS_ERROR_D17_COND_SENSOR, ALARM_ID_DD_D17_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); initFPGAPersistentAlarm( FPGA_PERS_ERROR_D27_COND_SENSOR, ALARM_ID_DD_D27_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); initFPGAPersistentAlarm( FPGA_PERS_ERROR_D29_COND_SENSOR, ALARM_ID_DD_D29_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); initFPGAPersistentAlarm( FPGA_PERS_ERROR_D43_COND_SENSOR, ALARM_ID_DD_D43_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); initFPGAPersistentAlarm( FPGA_PERS_ERROR_D74_COND_SENSOR, ALARM_ID_DD_D74_COND_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); - //initFPGAPersistentAlarm( FPGA_PERS_ERROR_P9_COND_SENSOR, ALARM_ID_FP_P9_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); - //initFPGAPersistentAlarm( FPGA_PERS_ERROR_P18_COND_SENSOR, ALARM_ID_FP_P18_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. + * The readConductivitySensorData function gets the current conductivity reading + * for all conductivity sensors from the FPGA. * @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 ) +void readConductivitySensorData( void ) { // Read raw conductivity - currentConductivityReadings[ D17_COND ].data = (F32)getFPGAD17Cond(); - currentConductivityReadings[ D27_COND ].data = (F32)getFPGAD27Cond(); - currentConductivityReadings[ D29_COND ].data = (F32)getFPGAD29Cond(); - currentConductivityReadings[ D43_COND ].data = (F32)getFPGAD43Cond(); - currentConductivityReadings[ D74_COND ].data = (F32)getFPGAD74Cond(); - currentConductivityReadings[ P9_COND ].data = (F32)getFPGAP9Conductivity(); - currentConductivityReadings[ P18_COND ].data = (F32)getFPGAP18Conductivity(); + currentConductivityReadings[ D17_COND ].data = (F32)getFPGAD17CondData(); + currentConductivityReadings[ D27_COND ].data = (F32)getFPGAD27CondData(); + currentConductivityReadings[ D29_COND ].data = (F32)getFPGAD29CondData(); + currentConductivityReadings[ D43_COND ].data = (F32)getFPGAD43CondData(); + currentConductivityReadings[ D74_COND ].data = (F32)getFPGAD74CondData(); + currentConductivityReadings[ P9_COND ].data = (F32)getFPGAP9CondData(); + currentConductivityReadings[ P18_COND ].data = (F32)getFPGAP18CondData(); // Read temperature associated to conductivity sensor currentTemperatureReadings[ D17_COND ].data = (F32)getFPGAD17CondTemp(); currentTemperatureReadings[ D27_COND ].data = (F32)getFPGAD27CondTemp(); currentTemperatureReadings[ D29_COND ].data = (F32)getFPGAD29CondTemp(); currentTemperatureReadings[ D43_COND ].data = (F32)getFPGAD43CondTemp(); currentTemperatureReadings[ D74_COND ].data = (F32)getFPGAD74CondTemp(); - currentTemperatureReadings[ P9_COND ].data = (F32)getFPGAP9Temperature(); - currentTemperatureReadings[ P18_COND ].data = (F32)getFPGAP18Temperature(); + currentTemperatureReadings[ P9_COND ].data = (F32)getFPGAP9CondTemp(); + currentTemperatureReadings[ P18_COND ].data = (F32)getFPGAP18CondTemp(); +} - // Update read and error counters for each conductivity sensor +/*********************************************************************//** + * @brief + * The readConductivitySensorReadCounts function gets the current conductivity read + * counters for all conductivity sensors from the FPGA. + * @details \b Inputs: FPGA + * @details \b Outputs: lastConductivityReadCounter[],lastTemperatureReadCounter[], + * @return none + *************************************************************************/ +static void readConductivitySensorReadCounts( void ) +{ + // Update read counters for each conductivity sensor lastConductivityReadCounter[ D17_COND ].data = (U32)getFPGAD17CondReadCount(); lastConductivityReadCounter[ D27_COND ].data = (U32)getFPGAD27CondReadCount(); lastConductivityReadCounter[ D29_COND ].data = (U32)getFPGAD29CondReadCount(); lastConductivityReadCounter[ D43_COND ].data = (U32)getFPGAD43CondReadCount(); lastConductivityReadCounter[ D74_COND ].data = (U32)getFPGAD74CondReadCount(); - lastConductivityReadCounter[ P9_COND ].data = (U32)getFPGAP9ReadCount(); - lastConductivityReadCounter[ P18_COND ].data = (U32)getFPGAP18ReadCount(); + lastConductivityReadCounter[ P9_COND ].data = (U32)getFPGAP9CondReadCount(); + lastConductivityReadCounter[ P18_COND ].data = (U32)getFPGAP18CondReadCount(); + lastTemperatureReadCounter[ D17_COND ].data = (U32)getFPGAD17TempReadCount(); + lastTemperatureReadCounter[ D27_COND ].data = (U32)getFPGAD27TempReadCount(); + lastTemperatureReadCounter[ D29_COND ].data = (U32)getFPGAD29TempReadCount(); + lastTemperatureReadCounter[ D43_COND ].data = (U32)getFPGAD43TempReadCount(); + lastTemperatureReadCounter[ D74_COND ].data = (U32)getFPGAD74TempReadCount(); + lastTemperatureReadCounter[ P9_COND ].data = (U32)getFPGAP9TempReadCount(); + lastTemperatureReadCounter[ P18_COND ].data = (U32)getFPGAP18TempReadCount(); +} + +/*********************************************************************//** + * @brief + * The readConductivitySensorErrorCounts function gets the current conductivity + * error counters for all conductivity sensors from the FPGA. + * @details \b Inputs: FPGA + * @details \b Outputs: lastConductivityReadCounter[],lastTemperatureReadCounter[], + * @return none + *************************************************************************/ +static void readConductivitySensorErrorCounts( void ) +{ + // Update error counters for each conductivity sensor lastConductivityErrorCounter[ D17_COND ].data = (U32)getFPGAD17CondErrorCount(); lastConductivityErrorCounter[ D27_COND ].data = (U32)getFPGAD27CondErrorCount(); lastConductivityErrorCounter[ D29_COND ].data = (U32)getFPGAD29CondErrorCount(); lastConductivityErrorCounter[ D43_COND ].data = (U32)getFPGAD43CondErrorCount(); lastConductivityErrorCounter[ D74_COND ].data = (U32)getFPGAD74CondErrorCount(); - lastConductivityErrorCounter[ P9_COND ].data = (U32)getFPGAP9ErrorCount(); - lastConductivityErrorCounter[ P18_COND ].data = (U32)getFPGAP18ErrorCount(); + lastConductivityErrorCounter[ P9_COND ].data = (U32)getFPGAP9CondErrorCount(); + lastConductivityErrorCounter[ P18_COND ].data = (U32)getFPGAP18CondErrorCount(); -#ifdef ENABLE_ALARM_1 - // Monitor conductivity sensor health - checkConductivitySensors(); -#endif + lastTemperatureErrorCounter[ D17_COND ].data = (U32)getFPGAD17TempErrorCount(); + lastTemperatureErrorCounter[ D27_COND ].data = (U32)getFPGAD27TempErrorCount(); + lastTemperatureErrorCounter[ D29_COND ].data = (U32)getFPGAD29TempErrorCount(); + lastTemperatureErrorCounter[ D43_COND ].data = (U32)getFPGAD43TempErrorCount(); + lastTemperatureErrorCounter[ D74_COND ].data = (U32)getFPGAD74TempErrorCount(); + lastTemperatureErrorCounter[ P9_COND ].data = (U32)getFPGAP9TempErrorCount(); + lastTemperatureErrorCounter[ P18_COND ].data = (U32)getFPGAP18TempErrorCount(); } /*********************************************************************//** * @brief - * The checkConductivitySensors function checks the read and error counters for - * each conductivity sensor. - * @details \b Alarm: ALARM_ID_DD_D17_COND_SENSOR_FPGA_FAULT if the - * D17 conductivity sensor is not able to be read. - * @details \b Alarm: ALARM_ID_DD_D27_COND_SENSOR_FPGA_FAULT if the - * D27 conductivity sensor is not able to be read. - * @details \b Alarm: ALARM_ID_DD_D29_COND_SENSOR_FPGA_FAULT if the - * D29 conductivity sensor is not able to be read. - * @details \b Alarm: ALARM_ID_DD_D43_COND_SENSOR_FPGA_FAULT if the - * D43 conductivity sensor is not able to be read. - * @details \b Alarm: ALARM_ID_DD_D74_COND_SENSOR_FPGA_FAULT if the - * D74 conductivity sensor is not able to be read. - * @details \b Inputs: lastConductivityReadCounter, lastConductivityErrorCounter - * @details \b Outputs: none + * The readConductivitySensorErrorCounts function gets the current conductivity + * cal data and cal memory counter for all conductivity sensors from the FPGA. + * @details \b Inputs: FPGA + * @details \b Outputs: conductivitySensorStatus[] * @return none *************************************************************************/ -static void checkConductivitySensors( void ) +static void readConductivitySensorCalData( void ) { - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D17_COND_SENSOR, getConductivitySensorReadCount( D17_COND ) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D27_COND_SENSOR, getConductivitySensorReadCount( D27_COND ) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D29_COND_SENSOR, getConductivitySensorReadCount( D29_COND ) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D43_COND_SENSOR, getConductivitySensorReadCount( D43_COND ) ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_D74_COND_SENSOR, getConductivitySensorReadCount( D74_COND ) ); - //checkFPGAPersistentAlarms( FPGA_PERS_ERROR_P9_COND_SENSOR, getConductivitySensorReadCount( P9_COND ) ); - //checkFPGAPersistentAlarms( FPGA_PERS_ERROR_P18_COND_SENSOR, getConductivitySensorReadCount( P18_COND ) ); + // Update cal data and counter for each conductivity sensor + conductivitySensorStatus[ D17_COND ].calData = (U32)getFPGAD17CondCalData(); + conductivitySensorStatus[ D27_COND ].calData = (U32)getFPGAD27CondCalData(); + conductivitySensorStatus[ D29_COND ].calData = (U32)getFPGAD29CondCalData(); + conductivitySensorStatus[ D43_COND ].calData = (U32)getFPGAD43CondCalData(); + conductivitySensorStatus[ D74_COND ].calData = (U32)getFPGAD74CondCalData(); + conductivitySensorStatus[ P9_COND ].calData = (U32)getFPGAP9CondCalData(); + conductivitySensorStatus[ P18_COND ].calData = (U32)getFPGAP18CondCalData(); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D17_COND_SENSOR, getConductivitySensorErrorCount( D17_COND ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D27_COND_SENSOR, getConductivitySensorErrorCount( D27_COND ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D29_COND_SENSOR, getConductivitySensorErrorCount( D29_COND ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D43_COND_SENSOR, getConductivitySensorErrorCount( D43_COND ) ); - checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_D74_COND_SENSOR, getConductivitySensorErrorCount( D74_COND ) ); - //checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_P9_COND_SENSOR, getConductivitySensorErrorCount( P9_COND ) ); - //checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_P18_COND_SENSOR, getConductivitySensorErrorCount( P18_COND ) ); + conductivitySensorStatus[ D17_COND ].calMemCount = (U32)getFPGAD17CalMemCounter(); + conductivitySensorStatus[ D27_COND ].calMemCount = (U32)getFPGAD27CalMemCounter(); + conductivitySensorStatus[ D29_COND ].calMemCount = (U32)getFPGAD29CalMemCounter(); + conductivitySensorStatus[ D43_COND ].calMemCount = (U32)getFPGAD43CalMemCounter(); + conductivitySensorStatus[ D74_COND ].calMemCount = (U32)getFPGAD74CalMemCounter(); + conductivitySensorStatus[ P9_COND ].calMemCount = (U32)getFPGAP9CalMemCounter(); + conductivitySensorStatus[ P18_COND ].calMemCount = (U32)getFPGAP18CalMemCounter(); } /*********************************************************************//** * @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 + * The execConductivitySensors function executes the conductivity sensors driver. + * @details \b Inputs: currentConductivityState + * @details \b Outputs: currentConductivityState + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT when the state is not expected. + * @return none *************************************************************************/ -F32 getConductivityValue( CONDUCTIVITY_SENSORS_T sensor ) +void execConductivitySensors( void ) { - F32 result = 0.0F; - - if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + switch ( currentConductivityState ) { - result = currentConductivityReadings[ sensor ].data; - if ( OVERRIDE_KEY == currentConductivityReadings[ sensor ].override ) - { - result = currentConductivityReadings[ sensor ].ovData; - } + case CONDUCTIVITY_INIT_STATE: + currentConductivityState = handleConductivityReadCalState(); + break; + case CONDUCTIVITY_READ_DATA_STATE: + currentConductivityState = handleConductivityReadDataState(); + break; + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID, (U32)currentConductivityState ) + break; } - 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 + * The handleConductivityReadCalState function handles reading the Cal data and + * tracking the Cal mem counter from the FPGA + * @details \b Inputs: FPGA. + * @details \b Outputs: conductivitySensorCoefficients[], conductivitySensorRevisions[] + * conductivitySensorStatus[] + * @return next state of the conductivity state machine. *************************************************************************/ -F32 getConductivityTemperatureValue( CONDUCTIVITY_SENSORS_T sensor ) +static CONDUCTIVITY_STATE_T handleConductivityReadCalState( void ) { - F32 result = 0.0F; + CONDUCTIVITY_STATE_T state = CONDUCTIVITY_INIT_STATE; + CONDUCTIVITY_SENSORS_T sensor; + BOOL calResult = TRUE; - if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + readConductivitySensorCalData(); + + // Check which counter, assign it, and assign read bool to TRUE per sensor + for ( sensor = FIRST_DD_COND_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { - result = currentTemperatureReadings[ sensor ].data; - if ( OVERRIDE_KEY == currentTemperatureReadings[ sensor ].override ) + if ( FALSE == conductivitySensorStatus[ sensor ].haveAllCalSlotsBeenRead ) { - 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 ) + switch( conductivitySensorStatus[ sensor ].calMemCount ) + { + case CAL_DATA_1: + conductivitySensorCoefficients[ sensor ].K_high = (U32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_1 ] = TRUE; + break; + case CAL_DATA_2: + conductivitySensorCoefficients[ sensor ].alpha_high = (F32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_2 ] = TRUE; + break; + case CAL_DATA_3: + conductivitySensorCoefficients[ sensor ].eta_high = (F32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_3 ] = TRUE; + break; + case CAL_DATA_4: + conductivitySensorCoefficients[ sensor ].zeta_high = (S32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_4 ] = TRUE; + break; + case CAL_DATA_5: + conductivitySensorCoefficients[ sensor ].K_low = (U32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_5 ] = TRUE; + break; + case CAL_DATA_6: + conductivitySensorCoefficients[ sensor ].alpha_low = (F32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_6 ] = TRUE; + break; + case CAL_DATA_7: + conductivitySensorCoefficients[ sensor ].eta_low = (F32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_7 ] = TRUE; + break; + case CAL_DATA_8: + conductivitySensorCoefficients[ sensor ].zeta_low = (S32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_8 ] = TRUE; + break; + case CAL_DATA_9: + conductivitySensorCoefficients[ sensor ].beta = (F32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_9 ] = TRUE; + break; + case CAL_DATA_10: + conductivitySensorCoefficients[ sensor ].delta = (S32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_10 ] = TRUE; + break; + case CAL_DATA_11: + conductivitySensorCoefficients[ sensor ].reserved1 = (U32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_11 ] = TRUE; + break; + case CAL_DATA_12: + conductivitySensorCoefficients[ sensor ].reserved2 = (U32)conductivitySensorStatus[ sensor ].calData; + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ CAL_DATA_12 ] = TRUE; + break; + case SW_REV_LOWER_WORD: + memcpy( conductivitySensorRevisions[ sensor ].swRev, &conductivitySensorStatus[ sensor ].calData, sizeof( U32 ) ); + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ SW_REV_LOWER_WORD ] = TRUE; + break; + case SW_REV_MID_WORD: + memcpy( ( conductivitySensorRevisions[ sensor ].swRev + LOWER_WORD_SIZE ), &conductivitySensorStatus[ sensor ].calData, sizeof( U32 ) ); + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ SW_REV_MID_WORD ] = TRUE; + break; + case SW_REV_UPPER_WORD: + memcpy( ( conductivitySensorRevisions[ sensor ].swRev + ( LOWER_WORD_SIZE + MID_WORD_SIZE ) ), &conductivitySensorStatus[ sensor ].calData, sizeof( U16 ) ); + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ SW_REV_UPPER_WORD ] = TRUE; + break; + case HW_REV_LOWER_WORD: + memcpy( conductivitySensorRevisions[ sensor ].hwRev, &conductivitySensorStatus[ sensor ].calData, sizeof( U32 ) ); + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ SW_REV_LOWER_WORD ] = TRUE; + break; + case HW_REV_MID_WORD: + memcpy( ( conductivitySensorRevisions[ sensor ].hwRev + LOWER_WORD_SIZE ), &conductivitySensorStatus[ sensor ].calData, sizeof( U32 ) ); + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ SW_REV_MID_WORD ] = TRUE; + break; + case HW_REV_UPPER_WORD: + memcpy( ( conductivitySensorRevisions[ sensor ].hwRev + ( LOWER_WORD_SIZE + MID_WORD_SIZE ) ), &conductivitySensorStatus[ sensor ].calData, sizeof( U16 ) ); + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ SW_REV_UPPER_WORD ] = TRUE; + break; + case HW_SERIAL_LOWER_WORD: + memcpy( conductivitySensorRevisions[ sensor ].hwSerial, &conductivitySensorStatus[ sensor ].calData, sizeof( U32 ) ); + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ SW_REV_LOWER_WORD ] = TRUE; + break; + case HW_SERIAL_MID_WORD: + memcpy( ( conductivitySensorRevisions[ sensor ].hwSerial + LOWER_WORD_SIZE ), &conductivitySensorStatus[ sensor ].calData, sizeof( U32 ) ); + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ SW_REV_MID_WORD ] = TRUE; + break; + case HW_SERIAL_UPPER_WORD: + memcpy( ( conductivitySensorRevisions[ sensor ].hwRev + ( LOWER_WORD_SIZE + MID_WORD_SIZE ) ), &conductivitySensorStatus[ sensor ].calData, sizeof( U16 ) ); + conductivitySensorStatus[ sensor ].hasCalSlotBeenRead[ SW_REV_UPPER_WORD ] = TRUE; + break; + } + // check if we have finished reading all values. + conductivitySensorStatus[ sensor ].haveAllCalSlotsBeenRead = monitorCalDataReads( sensor ); + } + // Read all cal values. Check ranges. + else { - result = lastConductivityReadCounter[ sensor ].ovData; + conductivitySensorStatus[ sensor ].calReadComplete = checkConductivityCoefficientRanges( sensor ); + + if ( FALSE == conductivitySensorStatus[ sensor ].calReadComplete ) + { + calResult = FALSE; + } } } - else + + if ( TRUE == calResult ) { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID2, sensor ) + // All cal data has been assigned and checks. + state = CONDUCTIVITY_READ_DATA_STATE; } - - return result; + return state; } /*********************************************************************//** * @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. + * The handleConductivityReadDataState function handles reading data, read + * counters and error counters. + * @details \b Inputs: none. + * @details \b Outputs: conductivitySensorCoefficients, conductivitySensorRevisions + * @return next state of the conductivity state machine. *************************************************************************/ -U32 getConductivitySensorErrorCount( CONDUCTIVITY_SENSORS_T sensor ) +static CONDUCTIVITY_STATE_T handleConductivityReadDataState( void ) { - U32 result = 0; + CONDUCTIVITY_STATE_T state = CONDUCTIVITY_READ_DATA_STATE; + CONDUCTIVITY_SENSORS_T sensor; - 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 ) - } + readConductivitySensorData(); + readConductivitySensorReadCounts(); + readConductivitySensorErrorCounts(); - 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 ) + for ( sensor = FIRST_DD_COND_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) { - conductivitySensorControl[ sensor ].resetRequested = TRUE; + checkCondCounters( sensor, getConductivitySensorReadCount( sensor ), getConductivitySensorErrorCount( sensor ), + getTemperatureSensorReadCount( sensor ), getTemperatureSensorErrorCount( sensor ) ); } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID4, sensor ); - } + return state; } -/*********************************************************************//** - * @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 + * The checkCondCounters function handles monitoring read and error counters + * @details \b Inputs: conductivitySensorStatus[] + * @details \b Outputs: conductivitySensorStatus[] + * @return none. *************************************************************************/ -void conductivitySensorWriteRequest( CONDUCTIVITY_SENSORS_T sensor, U16 writeAddr, U32 data ) +static void checkCondCounters( U32 sensorId, U08 condReadCount, U08 condErrorCount, U08 tempReadCount, U08 tempErrorCount ) { - if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + if ( ( 0 == condErrorCount ) && ( 0 == tempErrorCount ) ) { - 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 ); - } -} + if ( conductivitySensorStatus[ sensorId ].condReadCount != condReadCount ) + { + conductivitySensorStatus[ sensorId ].interalCondErrorCount = 0; + conductivitySensorStatus[ sensorId ].condReadCount = condReadCount; + } + else + { + if ( ++conductivitySensorStatus[ sensorId ].interalCondErrorCount > MAX_ALLOWED_UNCHANGED_CONDUCTIVITY_READS ) + { + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, sensorId ) + } + } -/*********************************************************************//** - * @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; + if ( conductivitySensorStatus[ sensorId ].tempReadCount != tempReadCount ) + { + conductivitySensorStatus[ sensorId ].interalTempErrorCount = 0; + conductivitySensorStatus[ sensorId ].tempReadCount = tempReadCount; + } + else + { + if ( ++conductivitySensorStatus[ sensorId ].interalTempErrorCount > MAX_ALLOWED_UNCHANGED_CONDUCTIVITY_READS ) + { + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, sensorId ) + } + } } else { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID7, sensor ); + if ( TRUE == incTimeWindowedCount( TIME_WINDOWED_COUNT_FPGA_CONDUCTIVITY_SENSOR_ERROR ) ) + { + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, sensorId ) + } } } /*********************************************************************//** * @brief - * The conductivitySensorReadData function returns the read data - * for the given conductivity sensor. - * @details \b Inputs: conductivitySensorControl + * The monitorCalDataReads loops through hasCalSlotBeenRead to determine if all + * cal data has been read from the FPGA for a given conductivity sensor. + * @details \b Inputs: conductivitySensorStatus * @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 + * @param sensor ID of the conductivity sensor. + * @return True if all cal data has been read, false if not. *************************************************************************/ -U32 conductivitySensorReadData( CONDUCTIVITY_SENSORS_T sensor ) +static BOOL monitorCalDataReads( U32 sensorId ) { - U32 data; + BOOL result = TRUE; + CONDUCTIVITY_CAL_IDX_T calIdx; - if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + for (calIdx = CAL_DATA_1; calIdx < NUM_OF_CONDUCTIVTY_CAL_IDXS; calIdx++ ) { - data = conductivitySensorControl[ sensor ].readData; + if( FALSE == conductivitySensorStatus[ sensorId ].hasCalSlotBeenRead[ calIdx ] ) + { + result = FALSE; + } } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID8, sensor ); - } - - return data; + return result; } /*********************************************************************//** * @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 + * The checkConductivityCoefficientRanges checks coefficient data to see if they + * are in range. + * @details \b Inputs: conductivitySensorCoefficients[] + * @details \b Outputs: conductivitySensorStatus[] + * @param sensor ID of the conductivity sensor. + * @return True if all cal data is in range, false if not. *************************************************************************/ -void handleConductivitySensorsReset( void ) +static BOOL checkConductivityCoefficientRanges( U32 sensorId ) { - if ( TRUE == conductivitySensorControl[ D17_COND ].resetRequested ) - { - // D17 Cond sensor reset - setFPGAD17CondReset(); - conductivitySensorControl[ D17_COND ].resetRequested = FALSE; - } - else - { - // clear D17 reset - clearFPGAD17CondReset(); - } + BOOL result = TRUE; + CONDUCTIVITY_CAL_IDX_T idx = CAL_DATA_1; - if ( TRUE == conductivitySensorControl[ D27_COND ].resetRequested ) + // Check data for high and low ranges. + if( ( conductivitySensorCoefficients[ sensorId ].K_high <= CELL_COEFF_HIGH_BOUNDS ) && + ( conductivitySensorCoefficients[ sensorId ].K_high >= CELL_COEFF_LOW_BOUNDS ) ) { - // D27 reset - setFPGAD27CondReset(); - conductivitySensorControl[ D27_COND ].resetRequested = FALSE; + result = FALSE; + idx = CAL_DATA_1; } - else - { - // clear D27 reset - clearFPGAD27CondReset(); - } - if ( TRUE == conductivitySensorControl[ D29_COND ].resetRequested ) + if( ( conductivitySensorCoefficients[ sensorId ].K_low <= CELL_COEFF_HIGH_BOUNDS ) && + ( conductivitySensorCoefficients[ sensorId ].K_low >= CELL_COEFF_LOW_BOUNDS ) ) { - // D29 reset - setFPGAD29CondReset(); - conductivitySensorControl[ D29_COND ].resetRequested = FALSE; + result = FALSE; + idx = CAL_DATA_2; } - else - { - // clear D29 reset - clearFPGAD29CondReset(); - } - if ( TRUE == conductivitySensorControl[ D43_COND ].resetRequested ) + if( ( conductivitySensorCoefficients[ sensorId ].alpha_high <= TEMPERATURE_CORRECTION_HIGH_BOUNDS ) && + ( conductivitySensorCoefficients[ sensorId ].alpha_high >= TEMPERATURE_CORRECTION_LOW_BOUNDS ) ) { - // D43 reset - setFPGAD43CondReset(); - conductivitySensorControl[ D43_COND ].resetRequested = FALSE; + result = FALSE; + idx = CAL_DATA_3; } - else - { - // clear D43 reset - clearFPGAD43CondReset(); - } - if ( TRUE == conductivitySensorControl[ D74_COND ].resetRequested ) + if( ( conductivitySensorCoefficients[ sensorId ].alpha_low <= TEMPERATURE_CORRECTION_HIGH_BOUNDS ) && + ( conductivitySensorCoefficients[ sensorId ].alpha_low >= TEMPERATURE_CORRECTION_LOW_BOUNDS ) ) { - // D74 reset - setFPGAD74CondReset(); - conductivitySensorControl[ D74_COND ].resetRequested = FALSE; + result = FALSE; + idx = CAL_DATA_4; } - else - { - // clear D74 reset - clearFPGAD74CondReset(); - } - if ( TRUE == conductivitySensorControl[ P9_COND ].resetRequested ) + if( ( conductivitySensorCoefficients[ sensorId ].eta_high <= RESISTANCE_SCALE_HIGH_BOUNDS ) && + ( conductivitySensorCoefficients[ sensorId ].eta_high >= RESISTANCE_SCALE_LOW_BOUNDS ) ) { - // P9 reset - setFPGAP9Reset(); - conductivitySensorControl[ P9_COND ].resetRequested = FALSE; + result = FALSE; + idx = CAL_DATA_5; } - else - { - // clear P9 reset - clearFPGAP9Reset(); - } - if ( TRUE == conductivitySensorControl[ P18_COND ].resetRequested ) + if( ( conductivitySensorCoefficients[ sensorId ].eta_low <= RESISTANCE_SCALE_HIGH_BOUNDS ) && + ( conductivitySensorCoefficients[ sensorId ].eta_low >= RESISTANCE_SCALE_LOW_BOUNDS ) ) { - // P18 reset - setFPGAP18Reset(); - conductivitySensorControl[ P18_COND ].resetRequested = FALSE; + result = FALSE; + idx = CAL_DATA_6; } - else + if( ( conductivitySensorCoefficients[ sensorId ].zeta_high <= RESISTANCE_OFFSET_HIGH_BOUNDS ) && + ( conductivitySensorCoefficients[ sensorId ].zeta_high >= RESISTANCE_OFFSET_LOW_BOUNDS ) ) { - // clear P18 reset - clearFPGAP18Reset(); + result = FALSE; + idx = CAL_DATA_7; } -} -/*********************************************************************//** - * @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[ D17_COND ].initEnable ) + if( ( conductivitySensorCoefficients[ sensorId ].zeta_low <= RESISTANCE_OFFSET_HIGH_BOUNDS ) && + ( conductivitySensorCoefficients[ sensorId ].zeta_low >= RESISTANCE_OFFSET_LOW_BOUNDS ) ) { - // D17 initialization - setFPGAD17CondInitEnable(); - conductivitySensorControl[ D17_COND ].initEnable = FALSE; + result = FALSE; + idx = CAL_DATA_8; } - else - { - // clear D17 Init command - clearFPGAD17CondInitEnable(); - } - if ( TRUE == conductivitySensorControl[ D27_COND ].initEnable ) + if( ( conductivitySensorCoefficients[ sensorId ].beta <= TEMPERATURE_SCALE_HIGH_BOUNDS ) && + ( conductivitySensorCoefficients[ sensorId ].beta >= TEMPERATURE_SCALE_LOW_BOUNDS ) ) { - // D27 initialization - setFPGAD27CondInitEnable(); - conductivitySensorControl[ D27_COND ].initEnable = FALSE; + result = FALSE; + idx = CAL_DATA_9; } - else - { - // clear D27 Init command - clearFPGAD27CondInitEnable(); - } - if ( TRUE == conductivitySensorControl[ D29_COND ].initEnable ) + if( ( conductivitySensorCoefficients[ sensorId ].delta <= TEMPERATURE_OFFSET_HIGH_BOUNDS ) && + ( conductivitySensorCoefficients[ sensorId ].delta >= TEMPERATURE_OFFSET_LOW_BOUNDS ) ) { - // D29 initialization - setFPGAD29CondInitEnable(); - conductivitySensorControl[ D29_COND ].initEnable = FALSE; + result = FALSE; + idx = CAL_DATA_10; } - else - { - // clear D29 Init command - clearFPGAD29CondInitEnable(); - } - if ( TRUE == conductivitySensorControl[ D43_COND ].initEnable ) + // Alarm if any data is out of range. + if ( FALSE == result ) { - // D43 initialization - setFPGAD43CondInitEnable(); - conductivitySensorControl[ D43_COND ].initEnable = FALSE; + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, sensorId, ( U32 )idx ) } - else - { - // clear D43 Init command - clearFPGAD43CondInitEnable(); - } - - if ( TRUE == conductivitySensorControl[ D74_COND ].initEnable ) - { - // D74 initialization - setFPGAD74CondInitEnable(); - conductivitySensorControl[ D74_COND ].initEnable = FALSE; - } - else - { - // clear D74 Init command - clearFPGAD74CondInitEnable(); - } - - if ( TRUE == conductivitySensorControl[ P9_COND ].initEnable ) - { - // P9 initialization - setFPGAP9InitEnable(); - conductivitySensorControl[ P9_COND ].initEnable = FALSE; - } - else - { - // clear P9 Init command - clearFPGAP9InitEnable(); - } - - if ( TRUE == conductivitySensorControl[ P18_COND ].initEnable ) - { - // P18 initialization - setFPGAP18InitEnable(); - conductivitySensorControl[ P18_COND ].initEnable = FALSE; - } - else - { - // clear P18 Init command - clearFPGAP18InitEnable(); - } + return result; } - /*********************************************************************//** * @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 + * The getConductivitySensorReadCount function gets the current 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 the conductivity sensor. + * @return The current read count for given conductivity sensor. *************************************************************************/ -void execConductivitySensorWrite( void ) +static U32 getConductivitySensorReadCount( CONDUCTIVITY_SENSORS_T sensor ) { - CONDUCTIVITY_SENSORS_T sensor; + U32 result = 0; - for ( sensor = FIRST_DD_COND_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { - // write state machine - switch ( conductivitySensorControl[ sensor ].writeExecState ) + result = lastConductivityReadCounter[ sensor ].data; + if ( OVERRIDE_KEY == lastConductivityReadCounter[ sensor ].override ) { - 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_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_WR_INVALID_EXEC_STATE, conductivitySensorControl[ sensor ].writeExecState ) - conductivitySensorControl[ sensor ].writeExecState = CONDUCTIVITY_WRITE_INITIATE; - break; + result = lastConductivityReadCounter[ 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 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 + * The getConductivitySensorErrorCount function gets the current 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 the conductivity sensor. + * @return The current error count for given conductivity sensor. *************************************************************************/ -static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( CONDUCTIVITY_SENSORS_T sensorID ) +static U32 getConductivitySensorErrorCount( CONDUCTIVITY_SENSORS_T sensor ) { - CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_INITIATE; + U32 result = 0; - if ( TRUE == conductivitySensorControl[ sensorID ].writeEnable && - FALSE == conductivitySensorControl[ sensorID ].writeInProgress ) + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { - conductivitySensorControl[ sensorID ].writeComplete = FALSE; - conductivitySensorControl[ sensorID ].writeInProgress = TRUE; - - if ( D17_COND == sensorID ) + result = lastConductivityErrorCounter[ sensor ].data; + if ( OVERRIDE_KEY == lastConductivityErrorCounter[ sensor ].override ) { - setFPGAD17D74Address( conductivitySensorControl[ sensorID ].writeAddress ); - setFPGAD17D74Data( conductivitySensorControl[ sensorID ].writeData ); - setFPGAD17CondWriteEnable(); + result = lastConductivityErrorCounter[ sensor ].ovData; } - else if ( D27_COND == sensorID ) - { - setFPGAD27D29Address( conductivitySensorControl[ sensorID ].writeAddress ); - setFPGAD27D29Data( conductivitySensorControl[ sensorID ].writeData ); - setFPGAD27CondWriteEnable(); - } - else if ( D29_COND == sensorID ) - { - setFPGAD27D29Address( conductivitySensorControl[ sensorID ].writeAddress ); - setFPGAD27D29Data( conductivitySensorControl[ sensorID ].writeData ); - setFPGAD29CondWriteEnable(); - } - else if ( D43_COND == sensorID ) - { - setFPGAD43Address( conductivitySensorControl[ sensorID ].writeAddress ); - setFPGAD43Data( conductivitySensorControl[ sensorID ].writeData ); - setFPGAD43CondWriteEnable(); - } - else if ( D74_COND == sensorID ) - { - setFPGAD17D74Address( conductivitySensorControl[ sensorID ].writeAddress ); - setFPGAD17D74Data( conductivitySensorControl[ sensorID ].writeData ); - setFPGAD74CondWriteEnable(); - } - else if ( P9_COND == sensorID ) - { - setFPGAP9Address( conductivitySensorControl[ sensorID ].writeAddress ); - setFPGAP9Data( conductivitySensorControl[ sensorID ].writeData ); - setFPGAP9WriteEnable(); - } - else if ( P18_COND == sensorID ) - { - setFPGAP18Address( conductivitySensorControl[ sensorID ].writeAddress ); - setFPGAP18Data( conductivitySensorControl[ sensorID ].writeData ); - setFPGAP18WriteEnable(); - } - - state = CONDUCTIVITY_WRITE_COMPLETE; } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID1, sensor ) + } - return state; + return result; } /*********************************************************************//** * @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 + * The getTemperatureSensorReadCount function gets the current read count + * for a given temperature sensor within the conductivity. + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Inputs: lastTemperatureReadCounter + * @details \b Outputs: none + * @param sensor ID of the conductivity sensor. + * @return The current read count for given temperature sensor within the conductivity sensor. *************************************************************************/ -static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( CONDUCTIVITY_SENSORS_T sensorID ) +static U32 getTemperatureSensorReadCount( CONDUCTIVITY_SENSORS_T sensor ) { - CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_COMPLETE; + U32 result = 0; - if ( TRUE == conductivitySensorControl[ sensorID ].writeInProgress ) + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { - conductivitySensorControl[ sensorID ].writeComplete = TRUE; - conductivitySensorControl[ sensorID ].writeEnable = FALSE; - - if ( D17_COND == sensorID ) + result = lastTemperatureReadCounter[ sensor ].data; + if ( OVERRIDE_KEY == lastTemperatureReadCounter[ sensor ].override ) { - clearFPGAD17CondWriteEnable(); + result = lastTemperatureReadCounter[ sensor ].ovData; } - else if ( D27_COND == sensorID ) - { - clearFPGAD27CondWriteEnable(); - } - else if ( D29_COND == sensorID ) - { - clearFPGAD29CondWriteEnable(); - } - else if ( D43_COND == sensorID ) - { - clearFPGAD43CondWriteEnable(); - } - else if ( D74_COND == sensorID ) - { - clearFPGAD74CondWriteEnable(); - } - else if ( P9_COND == sensorID ) - { - clearFPGAP9WriteEnable(); - } - else if ( P18_COND == sensorID ) - { - clearFPGAP18WriteEnable(); - } - - state = CONDUCTIVITY_WRITE_INITIATE; } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID2, sensor ) + } - return state; + return result; } /*********************************************************************//** * @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 + * The getTemperatureSensorErrorCount function gets the current error count + * for a given temperature sensor within the conductivity. + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Inputs: lastTemperatureErrorCounter + * @details \b Outputs: none + * @param sensor ID of the conductivity sensor. + * @return The current error count for given temperature sensor within the conductivity sensor. *************************************************************************/ -void execConductivitySensorRead( void ) +static U32 getTemperatureSensorErrorCount( CONDUCTIVITY_SENSORS_T sensor ) { - CONDUCTIVITY_SENSORS_T sensor; + U32 result = 0; - for ( sensor = FIRST_DD_COND_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { - // Read state machine - switch ( conductivitySensorControl[ sensor ].readExecState ) + result = lastTemperatureErrorCounter[ sensor ].data; + if ( OVERRIDE_KEY == lastTemperatureErrorCounter[ sensor ].override ) { - 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_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_RD_INVALID_EXEC_STATE, conductivitySensorControl[ sensor ].readExecState ) - conductivitySensorControl[ sensor ].readExecState = CONDUCTIVITY_READ_INITIATE; - break; + result = lastTemperatureErrorCounter[ 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 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 + * 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 *************************************************************************/ -static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( CONDUCTIVITY_SENSORS_T sensorID ) +F32 getConductivityValue( CONDUCTIVITY_SENSORS_T sensor ) { - CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_INITIATE; + F32 result = 0.0F; - if ( TRUE == conductivitySensorControl[ sensorID ].readEnable && - FALSE == conductivitySensorControl[ sensorID ].readInProgress ) + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { - // D17 read request - conductivitySensorControl[ sensorID ].readComplete = FALSE; - conductivitySensorControl[ sensorID ].readInProgress = TRUE; - - if ( D17_COND == sensorID ) + result = currentConductivityReadings[ sensor ].data; + if ( OVERRIDE_KEY == currentConductivityReadings[ sensor ].override ) { - setFPGAD17D74Address( conductivitySensorControl[ sensorID ].readAddress ); - setFPGAD17CondReadEnable(); + result = currentConductivityReadings[ sensor ].ovData; } - else if ( D27_COND == sensorID ) - { - setFPGAD27D29Address( conductivitySensorControl[ sensorID ].readAddress ); - setFPGAD27CondReadEnable(); - } - else if ( D29_COND == sensorID ) - { - setFPGAD27D29Address( conductivitySensorControl[ sensorID ].readAddress ); - setFPGAD29CondReadEnable(); - } - else if ( D43_COND == sensorID ) - { - setFPGAD43Address( conductivitySensorControl[ sensorID ].readAddress ); - setFPGAD43CondReadEnable(); - } - else if ( D74_COND == sensorID ) - { - setFPGAD17D74Address( conductivitySensorControl[ sensorID ].readAddress ); - setFPGAD74CondReadEnable(); - } - else if ( P9_COND == sensorID ) - { - setFPGAP9Address( conductivitySensorControl[ sensorID ].readAddress ); - setFPGAP9ReadEnable(); - } - else if ( P18_COND == sensorID ) - { - setFPGAP18Address( conductivitySensorControl[ sensorID ].readAddress ); - setFPGAP18ReadEnable(); - } - - state = CONDUCTIVITY_READ_COMPLETE; } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID, sensor ) + } - return state; + return result; } /*********************************************************************//** * @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 + * 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 *************************************************************************/ -static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( CONDUCTIVITY_SENSORS_T sensorID ) +F32 getConductivityTemperatureValue( CONDUCTIVITY_SENSORS_T sensor ) { - CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_COMPLETE; + F32 result = 0.0F; - if ( TRUE == conductivitySensorControl[ sensorID ].readInProgress ) + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) { - conductivitySensorControl[ sensorID ].readComplete = TRUE; - conductivitySensorControl[ sensorID ].readEnable = FALSE; - - if ( D17_COND == sensorID ) + result = currentTemperatureReadings[ sensor ].data; + if ( OVERRIDE_KEY == currentTemperatureReadings[ sensor ].override ) { - conductivitySensorControl[ sensorID ].readData = getFPGAD17CondData(); - clearFPGAD17CondReadEnable(); + result = currentTemperatureReadings[ sensor ].ovData; } - else if ( D27_COND == sensorID ) - { - conductivitySensorControl[ sensorID ].readData = getFPGAD27CondData(); - clearFPGAD27CondReadEnable(); - } - else if ( D29_COND == sensorID ) - { - conductivitySensorControl[ sensorID ].readData = getFPGAD29CondData(); - clearFPGAD29CondReadEnable(); - } - else if ( D43_COND == sensorID ) - { - conductivitySensorControl[ sensorID ].readData = getFPGAD43CondData(); - clearFPGAD43CondReadEnable(); - } - else if ( D74_COND == sensorID ) - { - conductivitySensorControl[ sensorID ].readData = getFPGAD74CondData(); - clearFPGAD74CondReadEnable(); - } - else if ( P9_COND == sensorID ) - { - conductivitySensorControl[ sensorID ].readData = getFPGAP9Data(); - clearFPGAP9ReadEnable(); - } - else if ( P18_COND == sensorID ) - { - conductivitySensorControl[ sensorID ].readData = getFPGAP18Data(); - clearFPGAP18ReadEnable(); - } - - state = CONDUCTIVITY_READ_INITIATE; } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID1, sensor ) + } - return state; + return result; } @@ -1053,7 +885,7 @@ * ID and override value of the conductivity sensor read counter. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testDDConductivitySensorReadCounterOverride( MESSAGE_T *message ) +BOOL testDDConductivitySensorConductivityReadCounterOverride( MESSAGE_T *message ) { BOOL result = FALSE; TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; @@ -1077,7 +909,7 @@ * ID and override value of the conductivity sensor error counter. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testDDConductivitySensorErrorCounterOverride( MESSAGE_T *message ) +BOOL testDDConductivitySensorConductivityErrorCounterOverride( MESSAGE_T *message ) { BOOL result = FALSE; TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; @@ -1149,7 +981,7 @@ * ID and override value of the conductivity sensor read counter. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testFPConductivitySensorReadCounterOverride( MESSAGE_T *message ) +BOOL testFPConductivitySensorConductivityReadCounterOverride( MESSAGE_T *message ) { BOOL result = FALSE; TEST_OVERRIDE_ARRAY_PAYLOAD_T payload; @@ -1173,7 +1005,7 @@ * ID and override value of the conductivity sensor error counter. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testFPConductivitySensorErrorCounterOverride( MESSAGE_T *message ) +BOOL testFPConductivitySensorConductivityErrorCounterOverride( MESSAGE_T *message ) { BOOL result = FALSE; TEST_OVERRIDE_ARRAY_PAYLOAD_T payload;