Index: firmware/App/Drivers/ConductivitySensors.c =================================================================== diff -u --- firmware/App/Drivers/ConductivitySensors.c (revision 0) +++ firmware/App/Drivers/ConductivitySensors.c (revision e228885d4b066320c69bbec2553b5e7fc62ec2cb) @@ -0,0 +1,957 @@ +/************************************************************************** +* +* Copyright (c) 2024-2024 Diality Inc. - All Rights Reserved. +* +* THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +* WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +* +* @file ConductivitySensors.c +* +* @author (last) Vinayakam Mani +* @date (last) 10-Sep-2024 +* +* @author (original) Vinayakam Mani +* @date (original) 10-Sep-2024 +* +***************************************************************************/ +#include // Used for calculating the polynomial calibration equation. +#include // For memcpy + +#include "ConductivitySensors.h" +#include "FpgaDD.h" +#include "MessageSupport.h" +#include "Messaging.h" +#include "OperationModes.h" +#include "PersistentAlarm.h" +#include "Utilities.h" + +/** + * @addtogroup ConductivitySensors + * @{ + */ + +// ********** private definitions ********** + +#define SIEMENS_TO_MICROSIEMENS_CONVERSION 1000000 ///< Siemens to microSiemens conversion factor. +#define COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Conductivity sensors FPGA error timeout in milliseconds. + +/// Conductivity Sensor Control group +typedef struct +{ + BOOL resetRequested; ///< Flag indicates a reset command for the given conducitvity sensor. + BOOL initEnable; ///< Flag indicates a enables initialization procedure for the given conductivity sensor. + BOOL writeEnable; ///< Flag indicates a enables write transaction for the given conductivity sensor. + BOOL readEnable; ///< Flag indicates a enables read transaction for the given conductivity sensor. + BOOL writeInProgress; ///< Flag indicates write transaction in progress + BOOL readInProgress; ///< Flag indicates read transaction in progress + BOOL writeComplete; ///< Flag indicates write transaction complete state. + BOOL readComplete; ///< Flag indicates read transaction complete state. + U32 writeData; ///< Data to write for the given conductivity sensor. + U32 readData; ///< Read data from the given conductivity sensor. + U16 writeAddress; ///< Write address where the data needs to be written. + U16 readAddress; ///< Read address to read the data. +} CONDUCTIVITY_SENSOR_CONTROL_T; + +/// Defined states for the conductivity write transaction. +typedef enum Conductvity_write_tx_states +{ + CONDUCTIVITY_WRITE_INITIATE = 0, ///< Conductivity sensor write initiate state. + CONDUCTIVITY_WRITE_COMPLETE, ///< Conductivity sensor write complete state. + NUM_OF_CONDUCTIVITY_WR_STATES ///< Number of conductivity write states. +} CONDUCTIVITY_WRITE_STATE_T; + +/// Defined states for the conductivity read transaction. +typedef enum Conductvity_read_tx_states +{ + CONDUCTIVITY_READ_INITIATE = 0, ///< Conductivity sensor read initiate state. + CONDUCTIVITY_READ_COMPLETE, ///< Conductivity sensor read complete state. + NUM_OF_CONDUCTIVITY_RD_STATES ///< Number of conductivity write states. +} CONDUCTIVITY_READ_STATE_T; + +// ********** private data ********** + +static OVERRIDE_F32_T currentConductivityReadings[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Current conductivity sensor conductivity readings (overrideable). +static OVERRIDE_F32_T currentTemperatureReadings[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Current conductivity sensor temperature readings (overrideable). +static OVERRIDE_U32_T lastConductivityReadCounter[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Last conductivity sensor read count (Overrideable). +static OVERRIDE_U32_T lastConductivityErrorCounter[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Last conductivity sensor error count (Overrideable). + +static CONDUCTIVITY_SENSOR_CONTROL_T conductivitySensorControl[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Conductivity sensor Control +static CONDUCTIVITY_WRITE_STATE_T conductivitySensorWriteState; ///< Conductivity sensor write state machine +static CONDUCTIVITY_READ_STATE_T conductivitySensorReadState; ///< Conductivity sensor read state machine + +// ********** private function prototypes ********** + +static void checkConductivitySensors( void ); +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( void ); +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( void ); +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( void ); +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( void ); + +/*********************************************************************//** + * @brief + * The initConductivitySensors function initializes the ConductivitySensors module. + * @details \b Inputs: none + * @details \b Outputs: ConductivitySensors unit variables initialized + * @return none + *************************************************************************/ +void initConductivitySensors( void ) +{ + U08 i; + + // Initialize override structures for each conductivity sensor + for ( i = 0; i < NUM_OF_CONDUCTIVITY_SENSORS; i++ ) + { + currentConductivityReadings[ i ].data = 0.0F; + currentConductivityReadings[ i ].ovData = 0.0F; + currentConductivityReadings[ i ].ovInitData = 0.0F; + currentConductivityReadings[ i ].override = OVERRIDE_RESET; + + currentTemperatureReadings[ i ].data = 0.0F; + currentTemperatureReadings[ i ].ovData = 0.0F; + currentTemperatureReadings[ i ].ovInitData = 0.0F; + currentTemperatureReadings[ i ].override = OVERRIDE_RESET; + + lastConductivityReadCounter[ i ].data = 0; + lastConductivityReadCounter[ i ].ovData = 0; + lastConductivityReadCounter[ i ].ovInitData = 0; + lastConductivityReadCounter[ i ].override = OVERRIDE_RESET; + + lastConductivityErrorCounter[ i ].data = 0; + lastConductivityErrorCounter[ i ].ovData = 0; + lastConductivityErrorCounter[ i ].ovInitData = 0; + lastConductivityErrorCounter[ i ].override = OVERRIDE_RESET; + + conductivitySensorControl[i].initEnable = FALSE; + conductivitySensorControl[i].readAddress = 0; + conductivitySensorControl[i].readComplete = FALSE; + conductivitySensorControl[i].readData = 0; + conductivitySensorControl[i].readEnable = FALSE; + conductivitySensorControl[i].readInProgress = FALSE; + conductivitySensorControl[i].resetRequested = FALSE; + conductivitySensorControl[i].writeAddress = 0; + conductivitySensorControl[i].writeComplete = 0; + conductivitySensorControl[i].writeData = 0; + conductivitySensorControl[i].writeEnable = FALSE; + conductivitySensorControl[i].writeInProgress = FALSE; + } + + //Initialize the conductivity sensor read and write state + conductivitySensorWriteState = CONDUCTIVITY_WRITE_INITIATE; + conductivitySensorReadState = CONDUCTIVITY_READ_INITIATE; + + // Initialize the conductivity sensor FPGA alarms + initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD1_COND_SENSOR, ALARM_ID_DD_CD1_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); + initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD2_COND_SENSOR, ALARM_ID_DD_CD2_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); + initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD3_COND_SENSOR, ALARM_ID_DD_CD3_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); + initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD4_COND_SENSOR, ALARM_ID_DD_CD4_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); +} + +/*********************************************************************//** + * @brief + * The readConductivitySensors function gets the current conductivity reading + * for all conductivity sensors from the FPGA and also reads the freshness + * and error counters to verify that the conductivity sensors are being read + * by the FPGA without issue. + * @note This function should be called periodically to maintain fresh + * sensor readings for all conductivity sensors. + * @details \b Inputs: FPGA + * @details \b Outputs: currentConductivityReadings[],currentTemperatureReadings[], + * lastConductivityReadCounter[],lastConductivityErrorCounter[]. + * @return none + *************************************************************************/ +void readConductivitySensors( void ) +{ + // Read raw conductivity + currentConductivityReadings[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (F32)getFPGACD1(); + currentConductivityReadings[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (F32)getFPGACD2(); + currentConductivityReadings[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (F32)getFPGACD3(); + currentConductivityReadings[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (F32)getFPGACD4(); + + // Read temperature associated to conductivity sensor + currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (F32)getFPGACD1Temp(); + currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (F32)getFPGACD2Temp(); + currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (F32)getFPGACD3Temp(); + currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (F32)getFPGACD4Temp(); + + // Update read and error counters for each conductivity sensor + lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (U32)getFPGACD1ReadCount(); + lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (U32)getFPGACD2ReadCount(); + lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (U32)getFPGACD3ReadCount(); + lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (U32)getFPGACD4ReadCount(); + + lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (U32)getFPGACD1ErrorCount(); + lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (U32)getFPGACD2ErrorCount(); + lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (U32)getFPGACD3ErrorCount(); + lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (U32)getFPGACD4ErrorCount(); + + // Monitor conductivity sensor health + checkConductivitySensors(); +} + +/*********************************************************************//** + * @brief + * The checkConductivitySensors function checks the read and error counters for + * each conductivity sensor. + * @details \b Alarm: ALARM_ID_DD_CD1_SENSOR_FPGA_FAULT if the + * CD1 conductivity sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_CD2_SENSOR_FPGA_FAULT if the + * CD2 conductivity sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_CD3_SENSOR_FPGA_FAULT if the + * CD3 conductivity sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_CD4_SENSOR_FPGA_FAULT if the + * CD4 conductivity sensor is not able to be read. + * @details \b Inputs: lastConductivityReadCounter, lastConductivityErrorCounter + * @details \b Outputs: none + * @return none + *************************************************************************/ +static void checkConductivitySensors( void ) +{ + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD1_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD1_SENSOR) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD2_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD2_SENSOR) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD3_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD3_SENSOR) ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD4_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD4_SENSOR) ); + + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD1_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD1_SENSOR ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD2_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD2_SENSOR ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD3_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD3_SENSOR ) ); + checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD4_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD4_SENSOR ) ); +} + +/*********************************************************************//** + * @brief + * The getConductivityValue function gets the conductivity + * value for a given conductivity sensor id. + * @details \b Inputs: currentConductivityReadings[] + * @details \b Outputs: none + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensorId conductivity sensor id + * @return conductivity value + *************************************************************************/ +F32 getConductivityValue( CONDUCTIVITY_SENSORS_T sensor ) +{ + F32 result = 0.0F; + + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + result = currentConductivityReadings[ sensor ].data; + if ( OVERRIDE_KEY == currentConductivityReadings[ sensor ].override ) + { + result = currentConductivityReadings[ sensor ].ovData; + } + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID, sensor ); + } + + return result; +} + +/*********************************************************************//** + * @brief + * The getConductivityTemperatureValue function gets the temperature + * value for a given conductivity sensor id. + * @details \b Inputs: currentTemperatureReadings[] + * @details \b Outputs: none + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensorId conductivity sensor id + * @return temperature value + *************************************************************************/ +F32 getConductivityTemperatureValue( CONDUCTIVITY_SENSORS_T sensor ) +{ + F32 result = 0.0F; + + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + result = currentTemperatureReadings[ sensor ].data; + if ( OVERRIDE_KEY == currentTemperatureReadings[ sensor ].override ) + { + result = currentTemperatureReadings[ sensor ].ovData; + } + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID1, sensor ); + } + + return result; +} + +/*********************************************************************//** + * @brief + * The getConductivitySensorReadCount function gets the current conductivity sensor + * read count for a given conductivity sensor. + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Inputs: lastConductivityReadCounter + * @details \b Outputs: none + * @param sensor ID of conductivity sensor to get read count for. + * @return The current conductivity sensor read count of a given conductivity sensor. + *************************************************************************/ +U32 getConductivitySensorReadCount( CONDUCTIVITY_SENSORS_T sensor ) +{ + U32 result = 0; + + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + result = lastConductivityReadCounter[ sensor ].data; + if ( OVERRIDE_KEY == lastConductivityReadCounter[ sensor ].override ) + { + result = lastConductivityReadCounter[ sensor ].ovData; + } + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID2, sensor ) + } + + return result; +} + +/*********************************************************************//** + * @brief + * The getConductivitySensorErrorCount function gets the current conductivity sensor + * error count for a given conductivity sensor. + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Inputs: lastConductivityErrorCounter + * @details \b Outputs: none + * @param sensor ID of conductivity sensor to get error count for. + * @return The current conductivity sensor error count of a given conductivity sensor. + *************************************************************************/ +U32 getConductivitySensorErrorCount( CONDUCTIVITY_SENSORS_T sensor ) +{ + U32 result = 0; + + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + result = lastConductivityErrorCounter[ sensor ].data; + if ( OVERRIDE_KEY == lastConductivityErrorCounter[ sensor ].override ) + { + result = lastConductivityErrorCounter[ sensor ].ovData; + } + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID3, sensor ) + } + + return result; +} + +/*********************************************************************//** + * @brief + * The requestConductivitySensorReset function commands the given + * the conductivity sensor to go for reset. + * @details \b Inputs: none + * @details \b Outputs: conductivitySensorControl + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor conductivity sensor id + * @return none + *************************************************************************/ +void requestConductivitySensorReset( CONDUCTIVITY_SENSORS_T sensor ) +{ + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + conductivitySensorControl[ sensor ].resetRequested = TRUE; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID4, sensor ); + } +} + +/*********************************************************************//** + * @brief + * The setConductivitySensorInitEnable function enables the given + * the conductivity sensor (re)initialization procedure. + * @details \b Inputs: none + * @details \b Outputs: conductivitySensorControl + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor conductivity sensor id + * @return none + *************************************************************************/ +void setConductivitySensorInitEnable( CONDUCTIVITY_SENSORS_T sensor ) +{ + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + conductivitySensorControl[ sensor ].initEnable = TRUE; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID5, sensor ); + } +} + +/*********************************************************************//** + * @brief + * The conductivitySensorWriteRequest function requests the write transaction + * for the given conductivity sensor. + * @details \b Inputs: none + * @details \b Outputs: conductivitySensorControl + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor conductivity sensor id + * @param writeAddr address to write for the given conductivity sensor. + * @param data data to write in write address of given conductivity sensor. + * @return none + *************************************************************************/ +void conductivitySensorWriteRequest( CONDUCTIVITY_SENSORS_T sensor, U16 writeAddr, U32 data ) +{ + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + conductivitySensorControl[ sensor ].writeAddress = writeAddr; + conductivitySensorControl[ sensor ].writeData = data; + conductivitySensorControl[ sensor ].writeEnable = TRUE; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID6, sensor ); + } +} + +/*********************************************************************//** + * @brief + * The conductivitySensorReadRequest function requests the read transaction + * for the given conductivity sensor. + * @details \b Inputs: none + * @details \b Outputs: conductivitySensorControl + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor conductivity sensor id + * @param readAddr for sensor read transaction. + * @return none + *************************************************************************/ +void conductivitySensorReadRequest( CONDUCTIVITY_SENSORS_T sensor, U16 readAddr ) +{ + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + conductivitySensorControl[ sensor ].readAddress = readAddr; + conductivitySensorControl[ sensor ].readEnable = TRUE; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID7, sensor ); + } +} + +/*********************************************************************//** + * @brief + * The conductivitySensorReadData function returns the read data + * for the given conductivity sensor. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: none + * @param sensor conductivity sensor id + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @return read data for the last request + *************************************************************************/ +U32 conductivitySensorReadData( CONDUCTIVITY_SENSORS_T sensor ) +{ + U32 data; + + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + data = conductivitySensorControl[ sensor ].readData; + } + else + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID8, sensor ); + } + + return data; +} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsReset function checks the reset requested + * for all conductivity sensors and perform the sensor reset. + * @note This function should be called periodically to handle any + * reset request for all conductivity sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return none + *************************************************************************/ +void handleConductivitySensorsReset( void ) +{ + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].resetRequested ) + { + // CD1 reset + setFPGACD1Reset(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].resetRequested = FALSE; + } + else + { + // clear CD1 reset + clearFPGACD1Reset(); + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].resetRequested ) + { + // CD2 reset + setFPGACD2Reset(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].resetRequested = FALSE; + } + else + { + // clear CD2 reset + clearFPGACD2Reset(); + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].resetRequested ) + { + // CD3 reset + setFPGACD3Reset(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].resetRequested = FALSE; + } + else + { + // clear CD3 reset + clearFPGACD3Reset(); + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].resetRequested ) + { + // CD4 reset + setFPGACD4Reset(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].resetRequested = FALSE; + } + else + { + // clear CD4 reset + clearFPGACD4Reset(); + } +} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsInitProcedure function checks the (re)initialization + * of conducitviy sensors request and may perform the sensor sequencing to + * complete the initialization. + * @note This function should be called periodically to handle any + * Init request for all conductivity sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return none + *************************************************************************/ +void handleConductivitySensorsInitProcedure( void ) +{ + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].initEnable ) + { + // CD1 initialization + setFPGACD1InitEnable(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].initEnable = FALSE; + } + else + { + // clear CD1 Init command + clearFPGACD1InitEnable(); + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].initEnable ) + { + // CD2 initialization + setFPGACD2InitEnable(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].initEnable = FALSE; + } + else + { + // clear CD2 Init command + clearFPGACD2InitEnable(); + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].initEnable ) + { + // CD3 initialization + setFPGACD3InitEnable(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].initEnable = FALSE; + } + else + { + // clear CD3 Init command + clearFPGACD3InitEnable(); + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].initEnable ) + { + // CD4 initialization + setFPGACD4InitEnable(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].initEnable = FALSE; + } + else + { + // clear CD4 Init command + clearFPGACD4InitEnable(); + } +} + +/*********************************************************************//** + * @brief + * The execConductivitySensorWrite function executes the conductivity sensor write + * state machine. + * @details \b Inputs: conductivitySensorWriteState + * @details \b Outputs: conductivitySensorWriteState + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if invalid conductivity sensor write + * state seen + * @return none + *************************************************************************/ +void execConductivitySensorWrite( void ) +{ + // state machine + switch ( conductivitySensorWriteState ) + { + case CONDUCTIVITY_WRITE_INITIATE: + conductivitySensorWriteState = handleConductivitySensorsWriteInitiate(); + break; + + case CONDUCTIVITY_WRITE_COMPLETE: + conductivitySensorWriteState = handleConductivitySensorsWriteComplete(); + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_WR_INVALID_EXEC_STATE, conductivitySensorWriteState ) + conductivitySensorWriteState = CONDUCTIVITY_WRITE_INITIATE; + break; + } +} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsWriteInitiate function initiates the write + * transaction of given conducitviy sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return CONDUCTIVITY_WRITE_STATE_T current state of write transaction + *************************************************************************/ +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( void ) +{ + CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_INITIATE; + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeEnable && + FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress ) + { + // CD1 write request + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeComplete = FALSE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress = TRUE; + setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeAddress ); + setFPGACD12Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeData ); + setFPGACD1WriteEnable(); + state = CONDUCTIVITY_WRITE_COMPLETE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeEnable && + FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress ) + { + // CD2 write request + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeComplete = FALSE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress = TRUE; + setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeAddress ); + setFPGACD12Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeData ); + setFPGACD2WriteEnable(); + state = CONDUCTIVITY_WRITE_COMPLETE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeEnable && + FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress ) + { + // CD3 write request + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeComplete = FALSE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress = TRUE; + setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeAddress ); + setFPGACD34Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeData ); + setFPGACD3WriteEnable(); + state = CONDUCTIVITY_WRITE_COMPLETE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeEnable && + FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress ) + { + // CD4 write request + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeComplete = FALSE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress = TRUE; + setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeAddress ); + setFPGACD34Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeData ); + setFPGACD4WriteEnable(); + state = CONDUCTIVITY_WRITE_COMPLETE; + } + + return state; +} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsWriteComplete function updates the write + * transaction completion of given conducitviy sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return CONDUCTIVITY_WRITE_STATE_T current state of write transaction + *************************************************************************/ +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( void ) +{ + CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_COMPLETE; + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress ) + { + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeComplete = TRUE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeEnable = FALSE; + clearFPGACD1WriteEnable(); + state = CONDUCTIVITY_WRITE_INITIATE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress ) + { + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeComplete = TRUE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeEnable = FALSE; + clearFPGACD2WriteEnable(); + state = CONDUCTIVITY_WRITE_INITIATE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress ) + { + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeComplete = TRUE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeEnable = FALSE; + clearFPGACD3WriteEnable(); + state = CONDUCTIVITY_WRITE_INITIATE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress ) + { + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeComplete = TRUE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeEnable = FALSE; + clearFPGACD4WriteEnable(); + state = CONDUCTIVITY_WRITE_INITIATE; + } + + return state; +} + +/*********************************************************************//** + * @brief + * The execConductivitySensorRead function executes the conductivity sensor read + * state machine. + * @details \b Inputs: conductivitySensorReadState + * @details \b Outputs: conductivitySensorReadState + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if invalid conductivity sensor read + * state seen + * @return none + *************************************************************************/ +void execConductivitySensorRead( void ) +{ + // state machine + switch ( conductivitySensorReadState ) + { + case CONDUCTIVITY_READ_INITIATE: + conductivitySensorReadState = handleConductivitySensorsReadInitiate(); + break; + + case CONDUCTIVITY_READ_COMPLETE: + conductivitySensorReadState = handleConductivitySensorsReadComplete(); + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_RD_INVALID_EXEC_STATE, conductivitySensorReadState ) + conductivitySensorReadState = CONDUCTIVITY_READ_INITIATE; + break; + } +} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsReadInitiate function initiates the read + * transaction of given conducitviy sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return CONDUCTIVITY_READ_STATE_T current state of read transaction + *************************************************************************/ +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( void ) +{ + CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_INITIATE; + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readEnable && + FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress ) + { + // CD1 read request + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readComplete = FALSE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress = TRUE; + setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readAddress ); + setFPGACD1ReadEnable(); + state = CONDUCTIVITY_READ_COMPLETE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readEnable && + FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress ) + { + // CD2 read request + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readComplete = FALSE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress = TRUE; + setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readAddress ); + setFPGACD2ReadEnable(); + state = CONDUCTIVITY_READ_COMPLETE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readEnable && + FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress ) + { + // CD3 read request + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readComplete = FALSE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress = TRUE; + setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readAddress ); + setFPGACD3ReadEnable(); + state = CONDUCTIVITY_READ_COMPLETE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readEnable && + FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress ) + { + // CD4 read request + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readComplete = FALSE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress = TRUE; + setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readAddress ); + setFPGACD4ReadEnable(); + state = CONDUCTIVITY_READ_COMPLETE; + } + + return state; +} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsReadComplete function updates the read + * request completion of given conducitviy sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return CONDUCTIVITY_READ_STATE_T current state of write transaction + *************************************************************************/ +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( void ) +{ + CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_COMPLETE; + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress ) + { + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readData = getFPGACD1Data(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readComplete = TRUE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readEnable = FALSE; + clearFPGACD1ReadEnable(); + state = CONDUCTIVITY_READ_INITIATE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress ) + { + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readData = getFPGACD2Data(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readComplete = TRUE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readEnable = FALSE; + clearFPGACD2ReadEnable(); + state = CONDUCTIVITY_READ_INITIATE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress ) + { + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readData = getFPGACD3Data(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readComplete = TRUE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readEnable = FALSE; + clearFPGACD3ReadEnable(); + state = CONDUCTIVITY_READ_INITIATE; + } + + if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress ) + { + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readData = getFPGACD4Data(); + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readComplete = TRUE; + conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readEnable = FALSE; + clearFPGACD4ReadEnable(); + state = CONDUCTIVITY_READ_INITIATE; + } + + return state; +} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testConductivitySensorReadingsOverride function overrides the value of the + * specified conductivity sensor with a given value. + * @details \b Inputs: none + * @details \b Outputs: currentConductivityReadings[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the conductivity sensor. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testConductivitySensorReadingsOverride( MESSAGE_T *message ) +{ + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T override; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &override ); + + // Verify tester has logged in with TD and override type is valid + if ( ( TRUE == isTestingActivated() ) && ( ovType != OVERRIDE_INVALID ) && ( ovType < NUM_OF_OVERRIDE_TYPES ) ) + { + U32 sensor = override.index; + + // Verify bubble detector index of override + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + if ( OVERRIDE_OVERRIDE == ovType ) + { + F32 value = override.state.f32; + + currentConductivityReadings[ sensor ].ovData = value; + currentConductivityReadings[ sensor ].override = OVERRIDE_KEY; + result = TRUE; + } + else + { + currentConductivityReadings[ sensor ].override = OVERRIDE_RESET; + currentConductivityReadings[ sensor ].ovData = currentConductivityReadings[ sensor ].ovInitData; + result = TRUE; + } + } + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testConductivitySensorTemperatureReadingsOverride function overrides + * the value of the specified conductivity sensor temperature with a given value. + * @details \b Inputs: none + * @details \b Outputs: currentPresTempReadings[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the conductivity sensor temperature. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testConductivitySensorTemperatureReadingsOverride( MESSAGE_T *message ) +{ + BOOL result = FALSE; + TEST_OVERRIDE_ARRAY_PAYLOAD_T override; + OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &override ); + + // Verify tester has logged in with TD and override type is valid + if ( ( TRUE == isTestingActivated() ) && ( ovType != OVERRIDE_INVALID ) && ( ovType < NUM_OF_OVERRIDE_TYPES ) ) + { + U32 sensor = override.index; + + // Verify bubble detector index of override + if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) + { + if ( OVERRIDE_OVERRIDE == ovType ) + { + F32 value = override.state.f32; + + currentTemperatureReadings[ sensor ].ovData = value; + currentTemperatureReadings[ sensor ].override = OVERRIDE_KEY; + result = TRUE; + } + else + { + currentTemperatureReadings[ sensor ].override = OVERRIDE_RESET; + currentTemperatureReadings[ sensor ].ovData = currentTemperatureReadings[ sensor ].ovInitData; + result = TRUE; + } + } + } + + return result; +} + +/**@}*/ Index: firmware/App/Drivers/ConductivitySensors.h =================================================================== diff -u --- firmware/App/Drivers/ConductivitySensors.h (revision 0) +++ firmware/App/Drivers/ConductivitySensors.h (revision e228885d4b066320c69bbec2553b5e7fc62ec2cb) @@ -0,0 +1,76 @@ +/************************************************************************** +* +* 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.h +* +* @author (last) Vinayakam Mani +* @date (last) 10-Sep-2024 +* +* @author (original) Vinayakam Mani +* @date (original) 10-Sep-2024 +* +***************************************************************************/ + +#ifndef __CONDUCTIVITY_SENSORS_H__ +#define __CONDUCTIVITY_SENSORS_H__ + +#include "DDCommon.h" + +/** + * @defgroup ConductivitySensors ConductivitySensors + * @brief Conductivity Sensors monitor module. Monitors and filters conductivity sensor readings. + * The module uses AD5941 - high precision, low power analog front ends(AFEs) for conductivity measurement + * for CD1,CD2, CD3 and CD4. + * + * Conductivity Sensor Module + * Diality P/N: TBD + * Manufacturer: TBD + * Manufacture P/N: TBD + * + * @addtogroup ConductivitySensors + * @{ + */ + +// ********** public definitions ********** + +/// Enumeration of conductivity sensors. +typedef enum ConductivitySensors +{ + CONDUCTIVITYSENSORS_CD1_SENSOR = 0, ///< Inlet water conductivity sensor + CONDUCTIVITYSENSORS_CD2_SENSOR, ///< Outlet water conductivity sensor + CONDUCTIVITYSENSORS_CD3_SENSOR, ///< Post-acid concentrate conductivity sensor + CONDUCTIVITYSENSORS_CD4_SENSOR, ///< Post-bicarbonate concentrate conductivity sensor + NUM_OF_CONDUCTIVITY_SENSORS ///< Number of conductivity sensors +} CONDUCTIVITY_SENSORS_T; + +// ********** public function prototypes ********** + +void initConductivitySensors( void ); +void readConductivitySensors( void ); + +F32 getConductivityValue( CONDUCTIVITY_SENSORS_T sensor ); +F32 getConductivityTemperatureValue( CONDUCTIVITY_SENSORS_T sensor ); +U32 getConductivitySensorReadCount( CONDUCTIVITY_SENSORS_T sensor ); +U32 getConductivitySensorErrorCount( CONDUCTIVITY_SENSORS_T sensor ); + +void handleConductivitySensorsReset( void ); +void handleConductivitySensorsInitProcedure( void ); +void execConductivitySensorWrite( void ); +void execConductivitySensorRead( void ); + +void requestConductivitySensorReset( CONDUCTIVITY_SENSORS_T sensor ); +void setConductivitySensorInitEnable( CONDUCTIVITY_SENSORS_T sensor ); +void conductivitySensorWriteRequest( CONDUCTIVITY_SENSORS_T sensor, U16 writeAddr, U32 data ); +void conductivitySensorReadRequest( CONDUCTIVITY_SENSORS_T sensor, U16 readAddr ); +U32 conductivitySensorReadData( CONDUCTIVITY_SENSORS_T sensor ); + +BOOL testConductivitySensorReadingsOverride( MESSAGE_T *message ); +BOOL testConductivitySensorTemperatureReadingsOverride( MESSAGE_T *message ); + +/**@}*/ + +#endif Index: firmware/App/Monitors/Conductivity.c =================================================================== diff -u --- firmware/App/Monitors/Conductivity.c (revision 0) +++ firmware/App/Monitors/Conductivity.c (revision e228885d4b066320c69bbec2553b5e7fc62ec2cb) @@ -0,0 +1,157 @@ +/************************************************************************** +* +* 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 Conductivity.c +* +* @author (last) Vinayakam Mani +* @date (last) 10-Sep-2024 +* +* @author (original) Vinayakam Mani +* @date (original) 10-Sep-2024 +* +***************************************************************************/ +#include // Used for calculating the polynomial calibration equation. +#include // For memcpy + +#include "Conductivity.h" +#include "MessageSupport.h" +#include "Messaging.h" +#include "OperationModes.h" +#include "TaskPriority.h" +#include "Utilities.h" + +/** + * @addtogroup Conductivity + * @{ + */ + +// ********** private definitions ********** + +#define COND_SENSOR_REPORT_PERIOD ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Broadcast conductivity values message every second. + +// ********** private data ********** + +static U32 conductivityPublishTimerCounter; +static OVERRIDE_U32_T conductivityDataPublishInterval = { COND_SENSOR_REPORT_PERIOD, + COND_SENSOR_REPORT_PERIOD, 0, 0 }; ///< Conductivity sensors publish time interval override. + +// ********** private function prototypes ********** + +static void publishConductivitySensorsData( void ); + +/*********************************************************************//** + * @brief + * The initConductivity function initializes the ConductivitySensors module. + * @details \b Inputs: none + * @details \b Outputs: Conductivity unit variables initialized + * @return none + *************************************************************************/ +void initConductivity( void ) +{ + initConductivitySensors(); +} + +/*********************************************************************//** + * @brief + * The execConductivitySensors function gets conductivity sensors' latest + * readings from FPGA and advertises them over CAN. + * @details \b Inputs: none + * @details \b Outputs: Conductivity sensor latest reading is updated and + * advertised. + * @return none + *************************************************************************/ +void execConductivity( void ) +{ + //read conductivity sensors raw value + readConductivitySensors(); + + //control conductivity sensor + // TODO : need more clarity on why and when to execute following control. + handleConductivitySensorsReset(); + handleConductivitySensorsInitProcedure(); + execConductivitySensorWrite(); + execConductivitySensorRead(); + + // publish conductivity sensors + publishConductivitySensorsData(); +} + +/*********************************************************************//** + * @brief + * The publishConductivitySensorsData function publishes DD conductivity data + * at a set interval. + * @details \b Inputs: conductivityPublishTimerCounter + * @details \b Outputs: conductivityPublishTimerCounter + * @details \b Message \b Sent: MSG_ID_DD_CONDUCTIVITY_DATA to publish conductivity data. + * @return none + *************************************************************************/ +static void publishConductivitySensorsData( void ) +{ + // publish pressure/occlusion data on interval + if ( ++conductivityPublishTimerCounter >= getU32OverrideValue( &conductivityDataPublishInterval ) ) + { + CONDUCTIVITY_DATA_T data; + + data.cd1 = getConductivityValue( CONDUCTIVITYSENSORS_CD1_SENSOR ); + data.cd2 = getConductivityValue( CONDUCTIVITYSENSORS_CD2_SENSOR ); + data.cd3 = getConductivityValue( CONDUCTIVITYSENSORS_CD3_SENSOR ); + data.cd4 = getConductivityValue( CONDUCTIVITYSENSORS_CD4_SENSOR ); + data.td1 = getConductivityTemperatureValue( CONDUCTIVITYSENSORS_CD1_SENSOR ); + data.td2 = getConductivityTemperatureValue( CONDUCTIVITYSENSORS_CD2_SENSOR ); + data.td3 = getConductivityTemperatureValue( CONDUCTIVITYSENSORS_CD3_SENSOR ); + data.td4 = getConductivityTemperatureValue( CONDUCTIVITYSENSORS_CD4_SENSOR ); + conductivityPublishTimerCounter = 0; + + broadcastData( MSG_ID_DD_CONDUCTIVITY_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( CONDUCTIVITY_DATA_T ) ); + } +} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testConductivitySensorDataPublishIntervalOverride function overrides the + * conductivity sensor data publish interval. + * @details \b Inputs: none + * @details \b Outputs: conductivityDataPublishInterval + * @param message Override message from Dialin which includes the value + * that override valves states publish interval with (in ms) + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testConductivitySensorDataPublishIntervalOverride( MESSAGE_T *message ) +{ + BOOL result = FALSE; + TEST_OVERRIDE_PAYLOAD_T override; + OVERRIDE_TYPE_T ovType = getOverridePayloadFromMessage( message, &override ); + + // Verify tester has logged in with TD and override type is valid + if ( ( TRUE == isTestingActivated() ) && ( ovType != OVERRIDE_INVALID ) && ( ovType < NUM_OF_OVERRIDE_TYPES ) ) + { + if ( OVERRIDE_OVERRIDE == ovType ) + { + U32 intvl = override.state.u32 / TASK_PRIORITY_INTERVAL; + + result = TRUE; + conductivityDataPublishInterval.ovData = intvl; + conductivityDataPublishInterval.override = OVERRIDE_KEY; + } + else + { + result = TRUE; + conductivityDataPublishInterval.override = OVERRIDE_RESET; + conductivityDataPublishInterval.ovData = conductivityDataPublishInterval.ovInitData; + } + } + + return result; +} + +/**@}*/ Index: firmware/App/Monitors/Conductivity.h =================================================================== diff -u --- firmware/App/Monitors/Conductivity.h (revision 0) +++ firmware/App/Monitors/Conductivity.h (revision e228885d4b066320c69bbec2553b5e7fc62ec2cb) @@ -0,0 +1,58 @@ +/************************************************************************** +* +* 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 Conductivity.h +* +* @author (last) Vinayakam Mani +* @date (last) 10-Sep-2024 +* +* @author (original) Vinayakam Mani +* @date (original) 10-Sep-2024 +* +***************************************************************************/ + +#ifndef __CONDUCTIVITY_H__ +#define __CONDUCTIVITY_H__ + +#include "DDCommon.h" +#include "ConductivitySensors.h" + +/** + * @defgroup Conductivity Conductivity + * @brief Conductivity Sensors monitor module. Monitors and filters conductivity sensor readings. + * + * + * + * @addtogroup Conductivity + * @{ + */ + +// ********** public definitions ********** + +/// Conductivity data struct. +typedef struct +{ + F32 cd1; ///< CD1 conductivity sensor value + F32 cd2; ///< CD2 conductivity sensor value + F32 cd3; ///< CD3 conductivity sensor value + F32 cd4; ///< CD4 conductivity sensor value + F32 td1; ///< TD1 temperature value + F32 td2; ///< TD2 temperature value + F32 td3; ///< TD3 temperature value + F32 td4; ///< TD4 temperature value +} CONDUCTIVITY_DATA_T; + +// ********** public function prototypes ********** + +void initConductivity( void ); +void execConductivity( void ); + +BOOL testConductivitySensorDataPublishIntervalOverride( MESSAGE_T *message ); + +/**@}*/ + +#endif Index: firmware/App/Monitors/Pressure.c =================================================================== diff -u -r36138f58fce627fb63e4bcfc4607c24bf541d45a -re228885d4b066320c69bbec2553b5e7fc62ec2cb --- firmware/App/Monitors/Pressure.c (.../Pressure.c) (revision 36138f58fce627fb63e4bcfc4607c24bf541d45a) +++ firmware/App/Monitors/Pressure.c (.../Pressure.c) (revision e228885d4b066320c69bbec2553b5e7fc62ec2cb) @@ -27,10 +27,12 @@ // ********** private definitions ********** -#define PRESSURES_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval (ms/task time) at which the pressures data is published on the CAN bus. -#define DATA_PUBLISH_COUNTER_START_COUNT ( 5 ) ///< Data publish counter start count. -#define SIZE_OF_PRESSURE_ROLLING_AVG ( ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) * 1 ) ///< Filtered pressure w/ 1 second moving average. -#define SIZE_OF_PRESSURETEMP_ROLLING_AVG ( ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) * 1 ) ///< Filtered pressure temprature w/ 1 second moving average. +#define PRESSURES_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval (ms/task time) at which the pressures data is published on the CAN bus. +#define DATA_PUBLISH_COUNTER_START_COUNT ( 5 ) ///< Data publish counter start count. +#define PRESSURE_SAMPLE_FILTER_MS ( 200 ) ///< Filter pressure data for given time +#define PRESSURE_TEMP_SAMPLE_FILTER_MS ( 200 ) ///< Filter temperature data for given time +#define SIZE_OF_PRESSURE_ROLLING_AVG ( PRESSURE_SAMPLE_FILTER_MS / TASK_PRIORITY_INTERVAL ) ///< Filtered pressure moving average. +#define SIZE_OF_PRESSURETEMP_ROLLING_AVG ( PRESSURE_TEMP_SAMPLE_FILTER_MS / TASK_PRIORITY_INTERVAL ) ///< Filtered pressure temprature w/ 1 second moving average. /// Defined states for the pressures monitor state machine. typedef enum PresMonitor_States @@ -348,7 +350,7 @@ /*********************************************************************//** * @brief - * The testPressureSensnorDataPublishIntervalOverride function overrides the + * The testPressureSensorDataPublishIntervalOverride function overrides the * pressure sensor data publish interval. * @details \b Inputs: none * @details \b Outputs: pressuresDataPublishInterval Index: firmware/App/Services/AlarmMgmtSWFaults.h =================================================================== diff -u -r8d390efa9309c8a0f430ba4652528fdbdbb6e2b8 -re228885d4b066320c69bbec2553b5e7fc62ec2cb --- firmware/App/Services/AlarmMgmtSWFaults.h (.../AlarmMgmtSWFaults.h) (revision 8d390efa9309c8a0f430ba4652528fdbdbb6e2b8) +++ firmware/App/Services/AlarmMgmtSWFaults.h (.../AlarmMgmtSWFaults.h) (revision e228885d4b066320c69bbec2553b5e7fc62ec2cb) @@ -106,6 +106,13 @@ SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID1 = 75, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID2 = 76, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID3 = 77, + SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID4 = 78, + SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID5 = 79, + SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID6 = 80, + SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID7 = 81, + SW_FAULT_ID_CONDUCTIVITY_WR_INVALID_EXEC_STATE = 82, + SW_FAULT_ID_CONDUCTIVITY_RD_INVALID_EXEC_STATE = 83, + SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID8 = 84, NUM_OF_SW_FAULT_IDS } SW_FAULT_ID_T; Index: firmware/App/Tasks/TaskPriority.c =================================================================== diff -u -r8d390efa9309c8a0f430ba4652528fdbdbb6e2b8 -re228885d4b066320c69bbec2553b5e7fc62ec2cb --- firmware/App/Tasks/TaskPriority.c (.../TaskPriority.c) (revision 8d390efa9309c8a0f430ba4652528fdbdbb6e2b8) +++ firmware/App/Tasks/TaskPriority.c (.../TaskPriority.c) (revision e228885d4b066320c69bbec2553b5e7fc62ec2cb) @@ -14,14 +14,14 @@ * @date (original) 05-Aug-2024 * ***************************************************************************/ - -#include + #include "gio.h" //#include "ConductivitySensors.h" #include "FPGA.h" //#include "Heaters.h" -#include "InternalADC.h" +#include "InternalADC.h" +#include "Pressure.h" #include "TaskPriority.h" //#include "TemperatureSensors.h" #include "Valves.h"