Index: firmware/App/Controllers/Valves.c =================================================================== diff -u -rc7dcb245c2378b1c96eeaa02f120f61dff598b11 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Controllers/Valves.c (.../Valves.c) (revision c7dcb245c2378b1c96eeaa02f120f61dff598b11) +++ firmware/App/Controllers/Valves.c (.../Valves.c) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -31,33 +31,33 @@ // ********** private definitions ********** -#define DEENERGIZED 0 ///< 0 for de-energized valve. -#define ENERGIZED 1 ///< 1 for energized valve. -#define ALL_VALVES_DEENERGIZED 0x0000 ///< 0 in U16 bit field for all valves. +#define DEENERGIZED 0 ///< 0 for de-energized valve. +#define ENERGIZED 1 ///< 1 for energized valve. +#define ALL_VALVES_DEENERGIZED 0x0000 ///< 0 in U16 bit field for all valves. -#define MAX_VALVE_STATE_MISMATCH_TIMER_COUNT (100 / TASK_PRIORITY_INTERVAL ) ///< Maximum time commanded valves state can fail to match read back valve states in a row. +#define MAX_VALVE_STATE_MISMATCH_TIMER_COUNT (100 / TASK_PRIORITY_INTERVAL ) ///< Maximum time commanded valves state can fail to match read back valve states in a row. -#define VALVES_STATE_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval ( ms / task time ) at which valves states are published on CAN bus. -#define DATA_PUBLISH_COUNTER_START_COUNT 50 ///< Data publish counter start count. +#define VALVES_STATE_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval ( ms / task time ) at which valves states are published on CAN bus. +#define DATA_PUBLISH_COUNTER_START_COUNT 50 ///< Data publish counter start count. /// Payload record structure for valve open/close request typedef struct { - U32 valveID; ///< ValveID ( valid range 0 to 28 ) - U32 valveState; ///< Valve state ( Open : 0, closed :1) + U32 valveID; ///< ValveID ( valid range 0 to 28 ) + U32 valveState; ///< Valve state ( Open : 0, closed :1) } VALVE_CMD_PAYLOAD_T; // ********** private data ********** -static U32 valvesStatesPublicationTimerCounter; ///< Timer counter used to schedule valve state publication to CAN bus. -static U16 commandedValvesStates; ///< Initialize commanded valves states bit field. -static U32 valveStateMismatchTimerCounter; ///< Initialize valve state mismatch timer. -static U32 pendingValveStateChanges[ NUM_OF_VALVES ]; ///< Delayed (pending) valve state changes. -static U32 pendingValveStateChangeCountDowns[ NUM_OF_VALVES ]; ///< Delayed (pending) valve state change count down timers (in task intervals). +static U32 valvesStatesPublicationTimerCounter; ///< Timer counter used to schedule valve state publication to CAN bus. +static U16 commandedValvesStates; ///< Initialize commanded valves states bit field. +static U32 valveStateMismatchTimerCounter; ///< Initialize valve state mismatch timer. +static U32 pendingValveStateChanges[ NUM_OF_VALVES ]; ///< Delayed (pending) valve state changes. +static U32 pendingValveStateChangeCountDowns[ NUM_OF_VALVES ]; ///< Delayed (pending) valve state change count down timers (in task intervals). -static OVERRIDE_U32_T valveStates[ NUM_OF_VALVES ]; ///< Currently commanded valves states. -static OVERRIDE_U32_T valveSensedStates[ NUM_OF_VALVES ]; ///< Valve sensed states override. -static OVERRIDE_U32_T valvesStatesPublishInterval = { VALVES_STATE_PUB_INTERVAL, VALVES_STATE_PUB_INTERVAL, 0, 0 }; ///< Interval (in ms/task interval) at which to publish valves state to CAN bus. +static OVERRIDE_U32_T valveStates[ NUM_OF_VALVES ]; ///< Currently commanded valves states. +static OVERRIDE_U32_T valveSensedStates[ NUM_OF_VALVES ]; ///< Valve sensed states override. +static OVERRIDE_U32_T valvesStatesPublishInterval; ///< Interval (in ms/task interval) at which to publish valves state to CAN bus. // ********** private function prototypes ********** @@ -92,9 +92,13 @@ valveSensedStates[ valve ].override = OVERRIDE_RESET; } - // initialize timer counters + // initialize time intervals and timer counters valveStateMismatchTimerCounter = 0; - valvesStatesPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; // reset valves states publication timer + valvesStatesPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; // reset valves states publication timer + valvesStatesPublishInterval.data = VALVES_STATE_PUB_INTERVAL; + valvesStatesPublishInterval.ovData = VALVES_STATE_PUB_INTERVAL; + valvesStatesPublishInterval.ovInitData = 0; + valvesStatesPublishInterval.override = OVERRIDE_RESET; // initially set all valves to de-energized state via FPGA readCommandedValveStates(); @@ -122,8 +126,8 @@ { valveStateMismatchTimerCounter++; // increment valve state mismatch counter by 1 if ( valveStateMismatchTimerCounter > MAX_VALVE_STATE_MISMATCH_TIMER_COUNT ) - { -// activateAlarmNoData( ALARM_ID_RO_VALVE_CONTROL_FAILURE ); + { + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_VALVE_CONTROL_FAILURE, (U32)readValvesStates, (U32)commandedValvesStates ) } } else @@ -181,7 +185,7 @@ * name to its corresponding de-energized (0) or energized (1) valve state. * @details \b Inputs: none * @details \b Outputs: none - * @details \b Alarm : ALARM_ID_RO_SOFTWARE_FAULT when invalid valve state name passed + * @details \b Alarm : ALARM_ID_RO_SOFTWARE_FAULT when invalid valve state name given * @param valveStateName valve state name enumeration to convert to energized/de-energized * @return converted valve state for given valve state name *************************************************************************/ @@ -198,7 +202,7 @@ } else { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME, valveStateName ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME, (U32)valveStateName ) } return vState; @@ -209,7 +213,8 @@ * The setValveState function sets the valve state for given valve. * @details \b Inputs: none * @details \b Outputs: valveStates[], pendingValveStateChanges[], pendingValveStateChangeCountDowns[] - * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT when invalid valve ID passed + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT when invalid valve ID or + * valve state given. * @param valveID ID of valve to set state for * @param valveStateName name of valve state to set given valve to * @return TRUE if new valve state is set for given valve ID, FALSE if not. @@ -230,12 +235,12 @@ } else { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE, valveID ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE1, valveID ) } } else { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID, valveID ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID1, valveID ) } return result; @@ -247,7 +252,8 @@ * after a given delay. * @details \b Inputs: pendingValveStateChangeCountDowns[] * @details \b Outputs: pendingValveStateChangeCountDowns[], pendingValveStateChangeCountDowns[] - * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT when invalid valve ID passed + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT when invalid valve ID or + * valve state given. * @param valveID ID of valve to set state for * @param valveStateName name of valve state to set given valve to * @param delayMs delay duration (in ms) before actuation @@ -273,12 +279,12 @@ } else { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE, valveID ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_STATE2, valveID ) } } else { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID, valveID ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID2, valveID ) } return result; @@ -290,7 +296,7 @@ * given valve. * @details \b Inputs: valveStates[] * @details \b Outputs: none - * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT when invalid valve ID passed. + * @details \b Alarm: ALARM_ID_RO_SOFTWARE_FAULT when invalid valve ID given. * @param valveID ID of valve to get state for * @return the current valve state for given valve in enum *************************************************************************/ @@ -312,7 +318,7 @@ } else { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID, valveID ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID3, valveID ) } return name; @@ -337,7 +343,7 @@ } else { -// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID, valveID ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_VALVES_INVALID_VALVE_ID4, valveID ) } return valveState; @@ -366,7 +372,7 @@ data.valvesSensedState[ valve ] = (U08)getValveStateName( (VALVES_T)valve ); } -// broadcastData( MSG_ID_RO_VALVES_STATES_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( RO_VALVES_DATA_T ) ); + broadcastData( MSG_ID_RO_VALVES_STATES_DATA, COMM_BUFFER_OUT_CAN_RO_BROADCAST, (U08*)&data, sizeof( RO_VALVES_DATA_T ) ); valvesStatesPublicationTimerCounter = 0; } @@ -429,40 +435,4 @@ return result; } -/*********************************************************************//** - * @brief - * The testValveOpenCloseStateOverride function overrides the value of the - * specified valve with a given value. - * @details \b Inputs: tester logged in - * @details \b Outputs: valveStates[] - * @param message set message from Dialin which includes the valve Id to set - * and the state to set the valves to. - * @return TRUE if set request is successful, FALSE if not - *************************************************************************/ -BOOL testValveOpenCloseStateOverride( MESSAGE_T *message ) -{ - BOOL result = FALSE; - - // Verify tester has logged in with TD - if ( TRUE == isTestingActivated() ) - { - // Verify payload length is valid - if ( sizeof( VALVE_CMD_PAYLOAD_T ) == message->hdr.payloadLen ) - { - VALVE_CMD_PAYLOAD_T payload; - - memcpy( &payload, message->payload, sizeof(VALVE_CMD_PAYLOAD_T) ); - - if ( ( (VALVES_T)payload.valveID < NUM_OF_VALVES ) && - ( (VALVE_STATE_NAMES_T)payload.valveState < NUM_OF_VALVE_STATES ) ) - { - setValveState( (VALVES_T)payload.valveID, (VALVE_STATE_NAMES_T)payload.valveState ); - result = TRUE; - } - } - } - - return result; -} - /**@}*/ Index: firmware/App/Controllers/Valves.h =================================================================== diff -u -rc7dcb245c2378b1c96eeaa02f120f61dff598b11 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Controllers/Valves.h (.../Valves.h) (revision c7dcb245c2378b1c96eeaa02f120f61dff598b11) +++ firmware/App/Controllers/Valves.h (.../Valves.h) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -73,7 +73,6 @@ BOOL testValvesStatesPublishIntervalOverride( MESSAGE_T *message ); BOOL testValveStateOverride( MESSAGE_T *message ); BOOL testValveSensedStateOverride( MESSAGE_T *message ); -BOOL testValveOpenCloseStateOverride( MESSAGE_T *message ); /**@}*/ Index: firmware/App/Drivers/ConductivitySensors.c =================================================================== diff -u --- firmware/App/Drivers/ConductivitySensors.c (revision 0) +++ firmware/App/Drivers/ConductivitySensors.c (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -0,0 +1,947 @@ +/************************************************************************** +* +* Copyright (c) 2024-2024 Diality Inc. - All Rights Reserved. +* +* THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN +* WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. +* +* @file ConductivitySensors.c +* +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 +* +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 +* +***************************************************************************/ + +#include // Used for calculating the polynomial calibration equation. +#include // For memcpy + +#include "ConductivitySensors.h" +#include "FpgaRO.h" +#include "MessageSupport.h" +#include "Messaging.h" +#include "OperationModes.h" +#include "PersistentAlarm.h" +#include "Utilities.h" + +/** + * @addtogroup ConductivitySensors + * @{ + */ + +// ********** private definitions ********** + +#define SIEMENS_TO_MICROSIEMENS_CONVERSION 1000000 ///< Siemens to microSiemens conversion factor. +#define COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Conductivity sensors FPGA error timeout in milliseconds. +#define COND_SENSORS_READ_ERR_MAX_CNT 255 ///< Conductivity sensors read and error count max value + +/// Defined states for the conductivity write transaction. +typedef enum Conductvity_write_tx_states +{ + CONDUCTIVITY_WRITE_INITIATE = 0, ///< Conductivity sensor write initiate state. + CONDUCTIVITY_WRITE_COMPLETE, ///< Conductivity sensor write complete state. + NUM_OF_CONDUCTIVITY_WR_STATES ///< Number of conductivity write states. +} CONDUCTIVITY_WRITE_STATE_T; + +/// Defined states for the conductivity read transaction. +typedef enum Conductvity_read_tx_states +{ + CONDUCTIVITY_READ_INITIATE = 0, ///< Conductivity sensor read initiate state. + CONDUCTIVITY_READ_COMPLETE, ///< Conductivity sensor read complete state. + NUM_OF_CONDUCTIVITY_RD_STATES ///< Number of conductivity read states. +} CONDUCTIVITY_READ_STATE_T; + +/// Conductivity Sensor Control group +typedef struct +{ + BOOL resetRequested; ///< Flag indicates a reset command for the given conducitvity sensor. + BOOL initEnable; ///< Flag indicates a enables initialization procedure for the given conductivity sensor. + BOOL writeEnable; ///< Flag indicates a enables write transaction for the given conductivity sensor. + BOOL readEnable; ///< Flag indicates a enables read transaction for the given conductivity sensor. + BOOL writeInProgress; ///< Flag indicates write transaction in progress + BOOL readInProgress; ///< Flag indicates read transaction in progress + BOOL writeComplete; ///< Flag indicates write transaction complete state. + BOOL readComplete; ///< Flag indicates read transaction complete state. + U32 writeData; ///< Data to write for the given conductivity sensor. + U32 readData; ///< Read data from the given conductivity sensor. + CONDUCTIVITY_READ_STATE_T readExecState; ///< Read executive state from the given conductivity sensor. + CONDUCTIVITY_WRITE_STATE_T writeExecState; ///< Write executive state from the given conductivity sensor. + U16 writeAddress; ///< Write address where the data needs to be written. + U16 readAddress; ///< Read address to read the data. +} CONDUCTIVITY_SENSOR_CONTROL_T; + +// ********** private data ********** + +static OVERRIDE_F32_T currentConductivityReadings[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Current conductivity sensor conductivity readings (overrideable). +static OVERRIDE_F32_T currentTemperatureReadings[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Current conductivity sensor temperature readings (overrideable). +static OVERRIDE_U32_T lastConductivityReadCounter[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Last conductivity sensor read count (Overrideable). +static OVERRIDE_U32_T lastConductivityErrorCounter[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Last conductivity sensor error count (Overrideable). + +static CONDUCTIVITY_SENSOR_CONTROL_T conductivitySensorControl[ NUM_OF_CONDUCTIVITY_SENSORS ]; ///< Conductivity sensor Control for reset, init, read and write operations. + +// ********** private function prototypes ********** + +//static void checkConductivitySensors( void ); +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( void ); +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( void ); +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( void ); +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( void ); + +/*********************************************************************//** + * @brief + * The initConductivitySensors function initializes the ConductivitySensors unit. + * @details \b Inputs: none + * @details \b Outputs: ConductivitySensors unit variables initialized + * @return none + *************************************************************************/ +void initConductivitySensors( void ) +{ + U08 i; + + // Initialize override structures for each conductivity sensor + for ( i = 0; i < NUM_OF_CONDUCTIVITY_SENSORS; i++ ) + { + currentConductivityReadings[ i ].data = 0.0F; + currentConductivityReadings[ i ].ovData = 0.0F; + currentConductivityReadings[ i ].ovInitData = 0.0F; + currentConductivityReadings[ i ].override = OVERRIDE_RESET; + + currentTemperatureReadings[ i ].data = 0.0F; + currentTemperatureReadings[ i ].ovData = 0.0F; + currentTemperatureReadings[ i ].ovInitData = 0.0F; + currentTemperatureReadings[ i ].override = OVERRIDE_RESET; + + lastConductivityReadCounter[ i ].data = 0; + lastConductivityReadCounter[ i ].ovData = 0; + lastConductivityReadCounter[ i ].ovInitData = 0; + lastConductivityReadCounter[ i ].override = OVERRIDE_RESET; + + lastConductivityErrorCounter[ i ].data = 0; + lastConductivityErrorCounter[ i ].ovData = 0; + lastConductivityErrorCounter[ i ].ovInitData = 0; + lastConductivityErrorCounter[ i ].override = OVERRIDE_RESET; + + conductivitySensorControl[i].initEnable = FALSE; + conductivitySensorControl[i].readAddress = 0; + conductivitySensorControl[i].readComplete = FALSE; + conductivitySensorControl[i].readData = 0; + conductivitySensorControl[i].readEnable = FALSE; + conductivitySensorControl[i].readInProgress = FALSE; + conductivitySensorControl[i].resetRequested = FALSE; + conductivitySensorControl[i].writeAddress = 0; + conductivitySensorControl[i].writeComplete = 0; + conductivitySensorControl[i].writeData = 0; + conductivitySensorControl[i].readExecState = CONDUCTIVITY_READ_INITIATE; + conductivitySensorControl[i].writeExecState = CONDUCTIVITY_WRITE_INITIATE; + conductivitySensorControl[i].writeEnable = FALSE; + conductivitySensorControl[i].writeInProgress = FALSE; + } + + // Initialize the conductivity sensor FPGA alarms +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD1_COND_SENSOR, ALARM_ID_DD_CD1_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD2_COND_SENSOR, ALARM_ID_DD_CD2_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD3_COND_SENSOR, ALARM_ID_DD_CD3_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_CD4_COND_SENSOR, ALARM_ID_DD_CD4_SENSOR_FPGA_FAULT, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS, COND_SENSORS_FPGA_ERROR_TIMEOUT_MS ); +} + +/*********************************************************************//** + * @brief + * The readConductivitySensors function gets the current conductivity reading + * for all conductivity sensors from the FPGA and also reads the freshness + * and error counters to verify that the conductivity sensors are being read + * by the FPGA without issue. + * @note This function should be called periodically to maintain fresh + * sensor readings for all conductivity sensors. + * @details \b Inputs: FPGA + * @details \b Outputs: currentConductivityReadings[],currentTemperatureReadings[], + * lastConductivityReadCounter[],lastConductivityErrorCounter[]. + * @return none + *************************************************************************/ +void readConductivitySensors( void ) +{ +// // Read raw conductivity +// currentConductivityReadings[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (F32)getFPGACD1(); +// currentConductivityReadings[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (F32)getFPGACD2(); +// currentConductivityReadings[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (F32)getFPGACD3(); +// currentConductivityReadings[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (F32)getFPGACD4(); +// +// // Read temperature associated to conductivity sensor +// currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (F32)getFPGACD1Temp(); +// currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (F32)getFPGACD2Temp(); +// currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (F32)getFPGACD3Temp(); +// currentTemperatureReadings[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (F32)getFPGACD4Temp(); +// +// // Update read and error counters for each conductivity sensor +// lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (U32)getFPGACD1ReadCount(); +// lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (U32)getFPGACD2ReadCount(); +// lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (U32)getFPGACD3ReadCount(); +// lastConductivityReadCounter[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (U32)getFPGACD4ReadCount(); +// +// lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD1_SENSOR ].data = (U32)getFPGACD1ErrorCount(); +// lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD2_SENSOR ].data = (U32)getFPGACD2ErrorCount(); +// lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD3_SENSOR ].data = (U32)getFPGACD3ErrorCount(); +// lastConductivityErrorCounter[ CONDUCTIVITYSENSORS_CD4_SENSOR ].data = (U32)getFPGACD4ErrorCount(); +// +// // Monitor conductivity sensor health +// checkConductivitySensors(); +} + +/*********************************************************************//** + * @brief + * The checkConductivitySensors function checks the read and error counters for + * each conductivity sensor. + * @details \b Alarm: ALARM_ID_DD_CD1_SENSOR_FPGA_FAULT if the + * CD1 conductivity sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_CD2_SENSOR_FPGA_FAULT if the + * CD2 conductivity sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_CD3_SENSOR_FPGA_FAULT if the + * CD3 conductivity sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_CD4_SENSOR_FPGA_FAULT if the + * CD4 conductivity sensor is not able to be read. + * @details \b Inputs: lastConductivityReadCounter, lastConductivityErrorCounter + * @details \b Outputs: none + * @return none + *************************************************************************/ +//static void checkConductivitySensors( void ) +//{ +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD1_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD1_SENSOR) ); +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD2_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD2_SENSOR) ); +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD3_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD3_SENSOR) ); +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_CD4_COND_SENSOR, getConductivitySensorReadCount(CONDUCTIVITYSENSORS_CD4_SENSOR) ); +// +// checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD1_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD1_SENSOR ) ); +// checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD2_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD2_SENSOR ) ); +// checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD3_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD3_SENSOR ) ); +// checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_CD4_COND_SENSOR, getConductivitySensorErrorCount( CONDUCTIVITYSENSORS_CD4_SENSOR ) ); +//} + +/*********************************************************************//** + * @brief + * The getConductivityValue function gets the conductivity + * value for a given conductivity sensor id. + * @details \b Inputs: currentConductivityReadings[] + * @details \b Outputs: none + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensorId conductivity sensor id + * @return conductivity value + *************************************************************************/ +//F32 getConductivityValue( CONDUCTIVITY_SENSORS_T sensor ) +//{ +// F32 result = 0.0F; +// +// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) +// { +// result = currentConductivityReadings[ sensor ].data; +// if ( OVERRIDE_KEY == currentConductivityReadings[ sensor ].override ) +// { +// result = currentConductivityReadings[ sensor ].ovData; +// } +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID, sensor ); +// } +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The getConductivityTemperatureValue function gets the temperature + * value for a given conductivity sensor id. + * @details \b Inputs: currentTemperatureReadings[] + * @details \b Outputs: none + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensorId conductivity sensor id + * @return temperature value + *************************************************************************/ +//F32 getConductivityTemperatureValue( CONDUCTIVITY_SENSORS_T sensor ) +//{ +// F32 result = 0.0F; +// +// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) +// { +// result = currentTemperatureReadings[ sensor ].data; +// if ( OVERRIDE_KEY == currentTemperatureReadings[ sensor ].override ) +// { +// result = currentTemperatureReadings[ sensor ].ovData; +// } +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID1, sensor ); +// } +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The getConductivitySensorReadCount function gets the current conductivity sensor + * read count for a given conductivity sensor. + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Inputs: lastConductivityReadCounter + * @details \b Outputs: none + * @param sensor ID of conductivity sensor to get read count for. + * @return The current conductivity sensor read count of a given conductivity sensor. + *************************************************************************/ +//U32 getConductivitySensorReadCount( CONDUCTIVITY_SENSORS_T sensor ) +//{ +// U32 result = 0; +// +// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) +// { +// result = lastConductivityReadCounter[ sensor ].data; +// if ( OVERRIDE_KEY == lastConductivityReadCounter[ sensor ].override ) +// { +// result = lastConductivityReadCounter[ sensor ].ovData; +// } +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID2, sensor ) +// } +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The getConductivitySensorErrorCount function gets the current conductivity sensor + * error count for a given conductivity sensor. + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Inputs: lastConductivityErrorCounter + * @details \b Outputs: none + * @param sensor ID of conductivity sensor to get error count for. + * @return The current conductivity sensor error count of a given conductivity sensor. + *************************************************************************/ +//U32 getConductivitySensorErrorCount( CONDUCTIVITY_SENSORS_T sensor ) +//{ +// U32 result = 0; +// +// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) +// { +// result = lastConductivityErrorCounter[ sensor ].data; +// if ( OVERRIDE_KEY == lastConductivityErrorCounter[ sensor ].override ) +// { +// result = lastConductivityErrorCounter[ sensor ].ovData; +// } +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID3, sensor ) +// } +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The requestConductivitySensorReset function commands the given + * the conductivity sensor to go for reset. + * @details \b Inputs: none + * @details \b Outputs: conductivitySensorControl + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor conductivity sensor id + * @return none + *************************************************************************/ +//void requestConductivitySensorReset( CONDUCTIVITY_SENSORS_T sensor ) +//{ +// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) +// { +// conductivitySensorControl[ sensor ].resetRequested = TRUE; +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID4, sensor ); +// } +//} + +/*********************************************************************//** + * @brief + * The setConductivitySensorInitEnable function enables the given + * the conductivity sensor (re)initialization procedure. + * @details \b Inputs: none + * @details \b Outputs: conductivitySensorControl + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor conductivity sensor id + * @return none + *************************************************************************/ +//void setConductivitySensorInitEnable( CONDUCTIVITY_SENSORS_T sensor ) +//{ +// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) +// { +// conductivitySensorControl[ sensor ].initEnable = TRUE; +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID5, sensor ); +// } +//} + +/*********************************************************************//** + * @brief + * The conductivitySensorWriteRequest function requests the write transaction + * for the given conductivity sensor. + * @details \b Inputs: none + * @details \b Outputs: conductivitySensorControl + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor conductivity sensor id + * @param writeAddr address to write for the given conductivity sensor. + * @param data data to write in write address of given conductivity sensor. + * @return none + *************************************************************************/ +//void conductivitySensorWriteRequest( CONDUCTIVITY_SENSORS_T sensor, U16 writeAddr, U32 data ) +//{ +// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) +// { +// conductivitySensorControl[ sensor ].writeAddress = writeAddr; +// conductivitySensorControl[ sensor ].writeData = data; +// conductivitySensorControl[ sensor ].writeEnable = TRUE; +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID6, sensor ); +// } +//} + +/*********************************************************************//** + * @brief + * The conductivitySensorReadRequest function requests the read transaction + * for the given conductivity sensor. + * @details \b Inputs: none + * @details \b Outputs: conductivitySensorControl + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @param sensor conductivity sensor id + * @param readAddr for sensor read transaction. + * @return none + *************************************************************************/ +//void conductivitySensorReadRequest( CONDUCTIVITY_SENSORS_T sensor, U16 readAddr ) +//{ +// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) +// { +// conductivitySensorControl[ sensor ].readAddress = readAddr; +// conductivitySensorControl[ sensor ].readEnable = TRUE; +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID7, sensor ); +// } +//} + +/*********************************************************************//** + * @brief + * The conductivitySensorReadData function returns the read data + * for the given conductivity sensor. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: none + * @param sensor conductivity sensor id + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @return read data for the last request + *************************************************************************/ +//U32 conductivitySensorReadData( CONDUCTIVITY_SENSORS_T sensor ) +//{ +// U32 data; +// +// if ( sensor < NUM_OF_CONDUCTIVITY_SENSORS ) +// { +// data = conductivitySensorControl[ sensor ].readData; +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_CONDUCTIVITY_SENSOR_ID8, sensor ); +// } +// +// return data; +//} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsReset function checks the reset requested + * for all conductivity sensors and perform the sensor reset. + * @note This function should be called periodically to handle any + * reset request for all conductivity sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return none + *************************************************************************/ +void handleConductivitySensorsReset( void ) +{ +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].resetRequested ) +// { +// // CD1 reset +// setFPGACD1Reset(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].resetRequested = FALSE; +// } +// else +// { +// // clear CD1 reset +// clearFPGACD1Reset(); +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].resetRequested ) +// { +// // CD2 reset +// setFPGACD2Reset(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].resetRequested = FALSE; +// } +// else +// { +// // clear CD2 reset +// clearFPGACD2Reset(); +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].resetRequested ) +// { +// // CD3 reset +// setFPGACD3Reset(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].resetRequested = FALSE; +// } +// else +// { +// // clear CD3 reset +// clearFPGACD3Reset(); +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].resetRequested ) +// { +// // CD4 reset +// setFPGACD4Reset(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].resetRequested = FALSE; +// } +// else +// { +// // clear CD4 reset +// clearFPGACD4Reset(); +// } +} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsInitProcedure function checks the (re)initialization + * of conducitviy sensors request and may perform the sensor sequencing to + * complete the initialization. + * @note This function should be called periodically to handle any + * Init request for all conductivity sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return none + *************************************************************************/ +//void handleConductivitySensorsInitProcedure( void ) +//{ +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].initEnable ) +// { +// // CD1 initialization +// setFPGACD1InitEnable(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].initEnable = FALSE; +// } +// else +// { +// // clear CD1 Init command +// clearFPGACD1InitEnable(); +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].initEnable ) +// { +// // CD2 initialization +// setFPGACD2InitEnable(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].initEnable = FALSE; +// } +// else +// { +// // clear CD2 Init command +// clearFPGACD2InitEnable(); +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].initEnable ) +// { +// // CD3 initialization +// setFPGACD3InitEnable(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].initEnable = FALSE; +// } +// else +// { +// // clear CD3 Init command +// clearFPGACD3InitEnable(); +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].initEnable ) +// { +// // CD4 initialization +// setFPGACD4InitEnable(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].initEnable = FALSE; +// } +// else +// { +// // clear CD4 Init command +// clearFPGACD4InitEnable(); +// } +//} + +/*********************************************************************//** + * @brief + * The execConductivitySensorWrite function executes the conductivity sensor write + * state machine. + * @details \b Inputs: conductivitySensorWriteState + * @details \b Outputs: conductivitySensorWriteState + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if invalid conductivity sensor write + * state seen + * @return none + *************************************************************************/ +//void execConductivitySensorWrite( void ) +//{ +// CONDUCTIVITY_SENSORS_T sensor; +// +// for ( sensor = CONDUCTIVITYSENSORS_CD1_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) +// { +// // write state machine +// switch ( conductivitySensorControl[sensor].writeExecState ) +// { +// case CONDUCTIVITY_WRITE_INITIATE: +// conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteInitiate(); +// break; +// +// case CONDUCTIVITY_WRITE_COMPLETE: +// conductivitySensorControl[sensor].writeExecState = handleConductivitySensorsWriteComplete(); +// break; +// +// default: +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_WR_INVALID_EXEC_STATE, conductivitySensorControl[sensor].writeExecState ) +// conductivitySensorControl[sensor].writeExecState = CONDUCTIVITY_WRITE_INITIATE; +// break; +// } +// } +//} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsWriteInitiate function initiates the write + * transaction of given conducitviy sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return CONDUCTIVITY_WRITE_STATE_T current state of write transaction + *************************************************************************/ +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteInitiate( void ) +{ + CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_INITIATE; + +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeEnable && +// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress ) +// { +// // CD1 write request +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeComplete = FALSE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress = TRUE; +// setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeAddress ); +// setFPGACD12Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeData ); +// setFPGACD1WriteEnable(); +// state = CONDUCTIVITY_WRITE_COMPLETE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeEnable && +// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress ) +// { +// // CD2 write request +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeComplete = FALSE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress = TRUE; +// setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeAddress ); +// setFPGACD12Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeData ); +// setFPGACD2WriteEnable(); +// state = CONDUCTIVITY_WRITE_COMPLETE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeEnable && +// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress ) +// { +// // CD3 write request +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeComplete = FALSE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress = TRUE; +// setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeAddress ); +// setFPGACD34Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeData ); +// setFPGACD3WriteEnable(); +// state = CONDUCTIVITY_WRITE_COMPLETE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeEnable && +// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress ) +// { +// // CD4 write request +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeComplete = FALSE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress = TRUE; +// setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeAddress ); +// setFPGACD34Data( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeData ); +// setFPGACD4WriteEnable(); +// state = CONDUCTIVITY_WRITE_COMPLETE; +// } + + return state; +} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsWriteComplete function updates the write + * transaction completion of given conducitviy sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return CONDUCTIVITY_WRITE_STATE_T current state of write transaction + *************************************************************************/ +static CONDUCTIVITY_WRITE_STATE_T handleConductivitySensorsWriteComplete( void ) +{ + CONDUCTIVITY_WRITE_STATE_T state = CONDUCTIVITY_WRITE_COMPLETE; + +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeInProgress ) +// { +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeComplete = TRUE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].writeEnable = FALSE; +// clearFPGACD1WriteEnable(); +// state = CONDUCTIVITY_WRITE_INITIATE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeInProgress ) +// { +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeComplete = TRUE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].writeEnable = FALSE; +// clearFPGACD2WriteEnable(); +// state = CONDUCTIVITY_WRITE_INITIATE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeInProgress ) +// { +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeComplete = TRUE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].writeEnable = FALSE; +// clearFPGACD3WriteEnable(); +// state = CONDUCTIVITY_WRITE_INITIATE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeInProgress ) +// { +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeComplete = TRUE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].writeEnable = FALSE; +// clearFPGACD4WriteEnable(); +// state = CONDUCTIVITY_WRITE_INITIATE; +// } + + return state; +} + +/*********************************************************************//** + * @brief + * The execConductivitySensorRead function executes the conductivity sensor read + * state machine. + * @details \b Inputs: conductivitySensorReadState + * @details \b Outputs: conductivitySensorReadState + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if invalid conductivity sensor read + * state seen + * @return none + *************************************************************************/ +void execConductivitySensorRead( void ) +{ + CONDUCTIVITY_SENSORS_T sensor; + + for ( sensor = CONDUCTIVITYSENSORS_CD1_SENSOR; sensor < NUM_OF_CONDUCTIVITY_SENSORS; sensor++ ) + { + // Read state machine + switch ( conductivitySensorControl[sensor].readExecState ) + { + case CONDUCTIVITY_READ_INITIATE: + conductivitySensorControl[sensor].readExecState = handleConductivitySensorsReadInitiate(); + break; + + case CONDUCTIVITY_READ_COMPLETE: + conductivitySensorControl[sensor].readExecState = handleConductivitySensorsReadComplete(); + break; + + default: +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_CONDUCTIVITY_RD_INVALID_EXEC_STATE, conductivitySensorControl[sensor].readExecState ) +// conductivitySensorControl[sensor].readExecState = CONDUCTIVITY_READ_INITIATE; + break; + } + } +} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsReadInitiate function initiates the read + * transaction of given conducitviy sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return CONDUCTIVITY_READ_STATE_T current state of read transaction + *************************************************************************/ +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadInitiate( void ) +{ + CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_INITIATE; + +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readEnable && +// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress ) +// { +// // CD1 read request +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readComplete = FALSE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress = TRUE; +// setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readAddress ); +// setFPGACD1ReadEnable(); +// state = CONDUCTIVITY_READ_COMPLETE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readEnable && +// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress ) +// { +// // CD2 read request +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readComplete = FALSE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress = TRUE; +// setFPGACD12Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readAddress ); +// setFPGACD2ReadEnable(); +// state = CONDUCTIVITY_READ_COMPLETE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readEnable && +// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress ) +// { +// // CD3 read request +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readComplete = FALSE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress = TRUE; +// setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readAddress ); +// setFPGACD3ReadEnable(); +// state = CONDUCTIVITY_READ_COMPLETE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readEnable && +// FALSE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress ) +// { +// // CD4 read request +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readComplete = FALSE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress = TRUE; +// setFPGACD34Address( conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readAddress ); +// setFPGACD4ReadEnable(); +// state = CONDUCTIVITY_READ_COMPLETE; +// } + + return state; +} + +/*********************************************************************//** + * @brief + * The handleConductivitySensorsReadComplete function updates the read + * request completion of given conducitviy sensors. + * @details \b Inputs: conductivitySensorControl + * @details \b Outputs: conductivitySensorControl + * @return CONDUCTIVITY_READ_STATE_T current state of write transaction + *************************************************************************/ +static CONDUCTIVITY_READ_STATE_T handleConductivitySensorsReadComplete( void ) +{ + CONDUCTIVITY_READ_STATE_T state = CONDUCTIVITY_READ_COMPLETE; + +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readInProgress ) +// { +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readData = getFPGACD1Data(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readComplete = TRUE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD1_SENSOR ].readEnable = FALSE; +// clearFPGACD1ReadEnable(); +// state = CONDUCTIVITY_READ_INITIATE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readInProgress ) +// { +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readData = getFPGACD2Data(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readComplete = TRUE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD2_SENSOR ].readEnable = FALSE; +// clearFPGACD2ReadEnable(); +// state = CONDUCTIVITY_READ_INITIATE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readInProgress ) +// { +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readData = getFPGACD3Data(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readComplete = TRUE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD3_SENSOR ].readEnable = FALSE; +// clearFPGACD3ReadEnable(); +// state = CONDUCTIVITY_READ_INITIATE; +// } +// +// if ( TRUE == conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readInProgress ) +// { +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readData = getFPGACD4Data(); +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readComplete = TRUE; +// conductivitySensorControl[ CONDUCTIVITYSENSORS_CD4_SENSOR ].readEnable = FALSE; +// clearFPGACD4ReadEnable(); +// state = CONDUCTIVITY_READ_INITIATE; +// } + + return state; +} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testConductivitySensorReadingsOverride function overrides the value of the + * specified conductivity sensor with a given value. + * @details \b Inputs: none + * @details \b Outputs: currentConductivityReadings[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the conductivity sensor. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testConductivitySensorReadingsOverride( MESSAGE_T *message ) +{ + BOOL result = f32ArrayOverride( message, ¤tConductivityReadings[0], NUM_OF_CONDUCTIVITY_SENSORS - 1 ); + + return result; +} + +/*********************************************************************//** + * @brief + * The testConductivitySensorTemperatureReadingsOverride function overrides + * the value of the specified conductivity sensor temperature with a given value. + * @details \b Inputs: none + * @details \b Outputs: currentPresTempReadings[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the conductivity sensor temperature. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testConductivitySensorTemperatureReadingsOverride( MESSAGE_T *message ) +{ + BOOL result = f32ArrayOverride( message, ¤tTemperatureReadings[0], NUM_OF_CONDUCTIVITY_SENSORS - 1 ); + + return result; +} + +/*********************************************************************//** + * @brief + * The testConductivitySensorReadCounterOverride function overrides + * the value of the specified conductivity sensor read counter with a given value. + * @details \b Inputs: none + * @details \b Outputs: lastConductivityReadCounter[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the conductivity sensor read counter. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testConductivitySensorReadCounterOverride( MESSAGE_T *message ) +{ + BOOL result = u32ArrayOverride( message, &lastConductivityReadCounter[0], NUM_OF_CONDUCTIVITY_SENSORS - 1, 0, COND_SENSORS_READ_ERR_MAX_CNT ); + + return result; +} + +/*********************************************************************//** + * @brief + * The testConductivitySensorErrorCounterOverride function overrides + * the value of the specified conductivity sensor error counter with a given value. + * @details \b Inputs: none + * @details \b Outputs: lastConductivityErrorCounter[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the conductivity sensor error counter. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testConductivitySensorErrorCounterOverride( MESSAGE_T *message ) +{ + BOOL result = u32ArrayOverride( message, &lastConductivityErrorCounter[0], NUM_OF_CONDUCTIVITY_SENSORS - 1, 0, COND_SENSORS_READ_ERR_MAX_CNT ); + + return result; +} + +/**@}*/ Index: firmware/App/Drivers/ConductivitySensors.h =================================================================== diff -u --- firmware/App/Drivers/ConductivitySensors.h (revision 0) +++ firmware/App/Drivers/ConductivitySensors.h (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -0,0 +1,78 @@ +/************************************************************************** +* +* 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) Sean Nash +* @date (last) 09-Nov-2024 +* +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 +* +***************************************************************************/ + +#ifndef __CONDUCTIVITY_SENSORS_H__ +#define __CONDUCTIVITY_SENSORS_H__ + +#include "ROCommon.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 ); +//BOOL testConductivitySensorReadCounterOverride( MESSAGE_T *message ); +//BOOL testConductivitySensorErrorCounterOverride( MESSAGE_T *message ); + +/**@}*/ + +#endif Index: firmware/App/Drivers/PressureSensor.c =================================================================== diff -u --- firmware/App/Drivers/PressureSensor.c (revision 0) +++ firmware/App/Drivers/PressureSensor.c (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -0,0 +1,458 @@ +/************************************************************************** +* +* 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 PressureSensor.c +* +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 +* +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 +* +***************************************************************************/ + +#include "AlarmMgmtRO.h" +#include "FpgaRO.h" +#include "Messaging.h" +#include "PersistentAlarm.h" +#include "PressureSensor.h" +#include "TemperatureSensors.h" + +/** + * @addtogroup PressureSensor + * @{ + */ + +// ********** private definitions ********** + +#define PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Pressure sensors read and error count timeout in milliseconds. +#define ONE_BAR_TO_MILLI_BAR 1000 ///< 1 bar to milli-bar conversion. +#define COUNTS_TO_MILLI_BAR 100 ///< Counts to milli-bar conversion. +#define BAR_TO_MMHG ( 750.062F ) ///< Conversion factor for converting bar to mmHg. +#define PRES_SENSORS_READ_ERR_MAX_CNT 255 ///< Pressure sensor read and error max count value + +/// Barometric sensor conversion coefficients +typedef struct +{ + U16 pressureSensitivity; ///< Barometric sensor pressure sensitivity constant. + U16 pressureOffset; ///< Barometric sensor pressure offset constant. + U16 pressureSensitivityTempCoeff; ///< Barometric sensor pressure sensitivity temperature coefficient. + U16 pressureOffsetTempCoeff; ///< Barometric sensor pressure offset temperature coefficient. +} BARO_SENSOR_CONSTS_T; + +static const U32 TWO_TO_POWER_OF_6 = ( 1 << 6 ); ///< 2^6. +static const U32 TWO_TO_POWER_OF_7 = ( 1 << 7 ); ///< 2^7. +static const U32 TWO_TO_POWER_OF_15 = ( 1 << 15 ); ///< 2^15. +static const U32 TWO_TO_POWER_OF_16 = ( 1 << 16 ); ///< 2^16. +static const U32 TWO_TO_POWER_OF_17 = ( 1 << 17 ); ///< 2^17. +static const U32 TWO_TO_POWER_OF_21 = ( 1 << 21 ); ///< 2^21. + +// ********** private data ********** + +static OVERRIDE_F32_T currentPressureReadings[ NUM_OF_PRESSURE_SENSORS ]; ///< Current pressure sensor pressure readings (overrideable). +static OVERRIDE_F32_T currentPresTempReadings[ NUM_OF_PRESSURE_SENSORS ]; ///< Current pressure sensor temperature readings (overrideable). +static OVERRIDE_U32_T lastPressureReadCounter[ NUM_OF_PRESSURE_SENSORS ]; ///< Last pressure sensor read count (Overrideable). +static OVERRIDE_U32_T lastPressureErrorCounter[ NUM_OF_PRESSURE_SENSORS ]; ///< Last pressure sensor error count (Overrideable). +static BARO_SENSOR_CONSTS_T baroConvConsts; ///< Barometric sensor conversion constants. + +// ********** private function prototypes ********** + +//static void checkPressureSensors( void ); +//static F32 convertBaroPressureReading2mmHg( U32 rawPressure ); +//static F32 calculateBaroPressure( U32 pressure ); + +/*********************************************************************//** + * @brief + * The initPressureSensor function initializes the Pressure Sensor unit. + * @details \b Inputs: none + * @details \b Outputs: Pressure Sensor unit is initialized. + * @return none + *************************************************************************/ +void initPressureSensor( void ) +{ + U32 i; + + // Initialize override structures for each pressure sensor + for ( i = (U32)PRESSURE_SENSOR_FIRST; i < (U32)NUM_OF_PRESSURE_SENSORS; i++ ) + { + currentPressureReadings[ i ].data = 0.0F; + currentPressureReadings[ i ].ovData = 0.0F; + currentPressureReadings[ i ].ovInitData = 0.0F; + currentPressureReadings[ i ].override = OVERRIDE_RESET; + + currentPresTempReadings[ i ].data = 0.0F; + currentPresTempReadings[ i ].ovData = 0.0F; + currentPresTempReadings[ i ].ovInitData = 0.0F; + currentPresTempReadings[ i ].override = OVERRIDE_RESET; + + lastPressureReadCounter[ i ].data = 0; + lastPressureReadCounter[ i ].ovData = 0; + lastPressureReadCounter[ i ].ovInitData = 0; + lastPressureReadCounter[ i ].override = OVERRIDE_RESET; + + lastPressureErrorCounter[ i ].data = 0; + lastPressureErrorCounter[ i ].ovData = 0; + lastPressureErrorCounter[ i ].ovInitData = 0; + lastPressureErrorCounter[ i ].override = OVERRIDE_RESET; + } + + //Initialize baro variable + baroConvConsts.pressureOffset = 0; + baroConvConsts.pressureOffsetTempCoeff = 0; + baroConvConsts.pressureSensitivity = 0; + baroConvConsts.pressureSensitivityTempCoeff = 0; + + // Initialize the FPGA persistent alarms +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_HYDRAULICS_OUTLET_PRESSURE, ALARM_ID_DD_HYD_OUTLET_PRES_TIMEOUT_FAULT, +// PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS, PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS ); +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_BIBAG_PRESSURE, ALARM_ID_DD_BIBAG_PRES_TIMEOUT_FAULT, +// PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS, PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS ); +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_SPENT_DIALYSATE_PRESSURE, ALARM_ID_DD_SPENT_DIALYSATE_PRES_TIMEOUT_FAULT, +// PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS, PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS ); +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_FRESH_DIALYSATE_PRESSURE, ALARM_ID_DD_FRESH_DIALYSATE_PRES_TIMEOUT_FAULT, +// PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS, PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS ); +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_TRANSMEMBRANE_PRESSURE, ALARM_ID_DD_TRANSMEMB_PRES_TIMEOUT_FAULT, +// PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS, PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS ); +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_WATER_INLET_INPUT_PRESSURE, ALARM_ID_DD_WATER_INLET_INPUT_PRES_TIMEOUT_FAULT, +// PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS, PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS ); +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_WATER_INLET_OUTPUT_PRESSURE, ALARM_ID_DD_WATER_INLET_OUTPUT_PRES_TIMEOUT_FAULT, +// PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS, PRES_SENSORS_COUNT_ERROR_TIMEOUT_MS ); +} + +/*********************************************************************//** + * @brief + * The readPressureSensors function gets the current pressure reading + * for a all pressure sensors from the FPGA and also reads the freshness + * and error counters to verify that the pressure sensors are being read + * by the FPGA without issue. + * @note This function should be called periodically to maintain fresh + * sensor readings for all pressure sensors. + * @details \b Inputs: FPGA + * @details \b Outputs: currentPressureReadings[],currentPresTempReadings[], + * lastPressureReadCounter[],lastPressureErrorCounter[]. + * @return none + *************************************************************************/ +void readPressureSensors( void ) +{ +// // Update and convert raw pressures to mmHg +// currentPressureReadings[ PRESSURE_SENSOR_WATER_INLET_INPUT ].data = convertPressureReading2mmHg( getFPGAPRiRawPressure() ); +// currentPressureReadings[ PRESSURE_SENSOR_WATER_INLET_OUTPUT ].data = convertPressureReading2mmHg( getFPGAPRoRawPressure() ); +// currentPressureReadings[ PRESSURE_SENSOR_HYDRAULICS_OUTLET ].data = convertPressureReading2mmHg( getFPGAPnRawPressure() ); +// currentPressureReadings[ PRESSURE_SENSOR_BIBAG ].data = convertPressureReading2mmHg( getFPGAPCbRawPressure() ); +// currentPressureReadings[ PRESSURE_SENSOR_SPENT_DIALYSATE ].data = convertPressureReading2mmHg( getFPGAPDsRawPressure() ); +// currentPressureReadings[ PRESSURE_SENSOR_FRESH_DIALYSATE ].data = convertPressureReading2mmHg( getFPGAPDfRawPressure() ); +// currentPressureReadings[ PRESSURE_SENSOR_TRANSMEMBRANE ].data = convertPressureReading2mmHg( getFPGAPtmRawPressure() ); +// currentPressureReadings[ PRESSURE_SENSOR_BAROMETRIC ].data = convertBaroPressureReading2mmHg( getFPGABaroPressure() ); +// +// // Update and convert raw pressure sensor temperatures to deg C +// currentPresTempReadings[ PRESSURE_SENSOR_WATER_INLET_INPUT ].data = convertPressureTempReading2DegC( getFPGAPRiRawTemperature() ); +// currentPresTempReadings[ PRESSURE_SENSOR_WATER_INLET_OUTPUT ].data = convertPressureTempReading2DegC( getFPGAPRoRawTemperature() ); +// currentPresTempReadings[ PRESSURE_SENSOR_HYDRAULICS_OUTLET ].data = convertPressureTempReading2DegC( getFPGAPnRawTemperature() ); +// currentPresTempReadings[ PRESSURE_SENSOR_BIBAG ].data = convertPressureTempReading2DegC( getFPGAPCbRawTemperature() ); +// currentPresTempReadings[ PRESSURE_SENSOR_SPENT_DIALYSATE ].data = convertPressureTempReading2DegC( getFPGAPDsRawTemperature() ); +// currentPresTempReadings[ PRESSURE_SENSOR_FRESH_DIALYSATE ].data = convertPressureTempReading2DegC( getFPGAPDfRawTemperature() ); +// currentPresTempReadings[ PRESSURE_SENSOR_TRANSMEMBRANE ].data = convertPressureTempReading2DegC( getFPGAPtmRawTemperature() ); +// +// // Update read and error counters for each pressure sensor +// lastPressureReadCounter[ PRESSURE_SENSOR_WATER_INLET_INPUT ].data = (U32)getFPGAPRiReadCount(); +// lastPressureReadCounter[ PRESSURE_SENSOR_WATER_INLET_OUTPUT ].data = (U32)getFPGAPRoReadCount(); +// lastPressureReadCounter[ PRESSURE_SENSOR_HYDRAULICS_OUTLET ].data = (U32)getFPGAPnReadCount(); +// lastPressureReadCounter[ PRESSURE_SENSOR_BIBAG ].data = (U32)getFPGAPCbReadCount(); +// lastPressureReadCounter[ PRESSURE_SENSOR_SPENT_DIALYSATE ].data = (U32)getFPGAPDsReadCount(); +// lastPressureReadCounter[ PRESSURE_SENSOR_FRESH_DIALYSATE ].data = (U32)getFPGAPDfReadCount(); +// lastPressureReadCounter[ PRESSURE_SENSOR_TRANSMEMBRANE ].data = (U32)getFPGAPtmReadCount(); +// +// lastPressureErrorCounter[ PRESSURE_SENSOR_WATER_INLET_INPUT ].data = (U32)getFPGAPRiErrorCount(); +// lastPressureErrorCounter[ PRESSURE_SENSOR_WATER_INLET_OUTPUT ].data = (U32)getFPGAPRoErrorCount(); +// lastPressureErrorCounter[ PRESSURE_SENSOR_HYDRAULICS_OUTLET ].data = (U32)getFPGAPnErrorCount(); +// lastPressureErrorCounter[ PRESSURE_SENSOR_BIBAG ].data = (U32)getFPGAPCbErrorCount(); +// lastPressureErrorCounter[ PRESSURE_SENSOR_SPENT_DIALYSATE ].data = (U32)getFPGAPDsErrorCount(); +// lastPressureErrorCounter[ PRESSURE_SENSOR_FRESH_DIALYSATE ].data = (U32)getFPGAPDfErrorCount(); +// lastPressureErrorCounter[ PRESSURE_SENSOR_TRANSMEMBRANE ].data = (U32)getFPGAPtmErrorCount(); +// +// // Monitor pressure sensor health +// checkPressureSensors(); +} + +/*********************************************************************//** + * @brief + * The convertBaroPressureReading2mmHg function converts the raw pressure counts + * in to mmHg unit. + * @details \b Inputs: FPGA + * @details \b Outputs: baroConvConsts + * @param rawPressure the raw baro sensor reading from FPGA. + * @return the converted baro pressure (in mmHg). + *************************************************************************/ +//static F32 convertBaroPressureReading2mmHg( U32 rawPressure ) +//{ +// F32 baroPressure = 0.0F; +// +// baroConvConsts.pressureSensitivity = getFPGABaroPressureSensitivity(); +// baroConvConsts.pressureSensitivityTempCoeff = getFPGABaroTempCoeffOfPressSensitvity(); +// baroConvConsts.pressureOffset = getFPGABaroPressureOffset(); +// baroConvConsts.pressureOffsetTempCoeff = getFPGABaroTempCoeffOfPressOffset(); +// baroPressure = calculateBaroPressure( rawPressure ); +// +// return baroPressure; +//} + +/*********************************************************************//** + * @brief + * The calculateBaroPressure function performs the required calculations + * to compute the baro pressure readings. + * @details \b Inputs: baroConvConsts + * @details \b Outputs: none + * @param pressure the raw baro sensor reading from FPGA. + * @return converted baro pressure (in mmHg). + *************************************************************************/ +//static F32 calculateBaroPressure( U32 pressure ) +//{ +// S32 tempDiff = getBaroSensorTemperatureDiff(); +// S64 tempOffset = ( baroConvConsts.pressureOffsetTempCoeff * tempDiff ) / TWO_TO_POWER_OF_6; +// S64 presOffset = baroConvConsts.pressureOffset * TWO_TO_POWER_OF_17; +// S64 offset = presOffset + tempOffset; +// S64 tempSensitivity = ( baroConvConsts.pressureSensitivityTempCoeff * tempDiff ) / TWO_TO_POWER_OF_7; +// S64 presSensitivity = baroConvConsts.pressureSensitivity * TWO_TO_POWER_OF_16; +// S64 sensitivity = tempSensitivity + presSensitivity; +// S32 pres = (S32)( ( ( pressure * sensitivity ) / TWO_TO_POWER_OF_21 ) - offset ) / TWO_TO_POWER_OF_15; +// F32 presmmHg = ( (F32)pres / (F32)( COUNTS_TO_MILLI_BAR * ONE_BAR_TO_MILLI_BAR ) ) * BAR_TO_MMHG; +// +// return presmmHg; +//} + +/*********************************************************************//** + * @brief + * The checkPressureSensors function checks the read and error counters for + * each pressure sensor. + * @details \b Alarm: ALARM_ID_DD_HYD_OUTLET_PRES_TIMEOUT_FAULT if the + * hydraulics outlet pressure sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_BIBAG_PRES_TIMEOUT_FAULT if the + * BiBag pressure sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_SPENT_DIALYSATE_PRES_TIMEOUT_FAULT if the + * spent dialysate pressure sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_FRESH_DIALYSATE_PRES_TIMEOUT_FAULT if the + * fresh dialysate pressure sensor is not able to be read. + * @details \b Alarm: ALARM_ID_DD_TRANSMEMB_PRES_TIMEOUT_FAULT if the + * Transmembrane pressure sensor is not able to be read. + * @details \b Inputs: lastPressureReadCounter, lastPressureErrorCounter + * @details \b Outputs: none + * @return none + *************************************************************************/ +//static void checkPressureSensors( void ) +//{ +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_WATER_INLET_INPUT_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_WATER_INLET_INPUT ) ); +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_WATER_INLET_OUTPUT_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_WATER_INLET_OUTPUT ) ); +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_HYDRAULICS_OUTLET_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_HYDRAULICS_OUTLET ) ); +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_BIBAG_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_BIBAG ) ); +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_SPENT_DIALYSATE_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_SPENT_DIALYSATE ) ); +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_FRESH_DIALYSATE_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_FRESH_DIALYSATE ) ); +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_TRANSMEMBRANE_PRESSURE, getPressureSensorReadCount( PRESSURE_SENSOR_TRANSMEMBRANE ) ); +// +// checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_WATER_INLET_INPUT_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_WATER_INLET_INPUT ) ); +// checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_WATER_INLET_OUTPUT_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_WATER_INLET_OUTPUT ) ); +// checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_HYDRAULICS_OUTLET_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_HYDRAULICS_OUTLET ) ); +// checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_BIBAG_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_BIBAG ) ); +// checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_SPENT_DIALYSATE_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_SPENT_DIALYSATE ) ); +// checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_FRESH_DIALYSATE_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_FRESH_DIALYSATE ) ); +// checkFPGAPersistentErrorCountAlarm( FPGA_PERS_ERROR_TRANSMEMBRANE_PRESSURE, getPressureSensorErrorCount( PRESSURE_SENSOR_TRANSMEMBRANE ) ); +//} + +/*********************************************************************//** + * @brief + * The getPressure function gets the current pressure (in mmHg) for a given + * pressure sensor. + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Inputs: currentPressureReadings + * @details \b Outputs: none + * @param sensor ID of pressure sensor to get pressure reading for. + * @return The current pressure (in mmHg) of the given pressure sensor. + *************************************************************************/ +//F32 getPressure( PRESSURE_SENSORS_T sensor ) +//{ +// F32 result = 0.0F; +// +// if ( sensor < NUM_OF_PRESSURE_SENSORS ) +// { +// result = currentPressureReadings[ sensor ].data; +// if ( OVERRIDE_KEY == currentPressureReadings[ sensor ].override ) +// { +// result = currentPressureReadings[ sensor ].ovData; +// } +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR1, sensor ) +// } +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The getPressureSensorTemperature function gets the current pressure sensor + * temperature (in deg C) for a given pressure sensor. + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Inputs: currentPresTempReadings + * @details \b Outputs: none + * @param sensor ID of pressure sensor to get temperature reading for. + * @return The current pressure sensor temperature (in deg C) of the given pressure sensor. + *************************************************************************/ +//F32 getPressureSensorTemperature( PRESSURE_SENSORS_T sensor ) +//{ +// F32 result = 0.0F; +// +// if ( sensor < NUM_OF_PRESSURE_SENSORS ) +// { +// result = currentPresTempReadings[ sensor ].data; +// if ( OVERRIDE_KEY == currentPresTempReadings[ sensor ].override ) +// { +// result = currentPresTempReadings[ sensor ].ovData; +// } +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR2, sensor ) +// } +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The getPressureSensorReadCount function gets the current pressure sensor + * read count for a given pressure sensor. + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Inputs: lastPressureReadCounter + * @details \b Outputs: none + * @param sensor ID of pressure sensor to get read count for. + * @return The current pressure sensor read count of a given pressure sensor. + *************************************************************************/ +//U32 getPressureSensorReadCount( PRESSURE_SENSORS_T sensor ) +//{ +// U32 result = 0; +// +// if ( sensor < NUM_OF_PRESSURE_SENSORS ) +// { +// result = lastPressureReadCounter[ sensor ].data; +// if ( OVERRIDE_KEY == lastPressureReadCounter[ sensor ].override ) +// { +// result = lastPressureReadCounter[ sensor ].ovData; +// } +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR3, sensor ) +// } +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The getPressureSensorErrorCount function gets the current pressure sensor + * error count for a given pressure sensor. + * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if given sensor is invalid. + * @details \b Inputs: lastPressureErrorCounter + * @details \b Outputs: none + * @param sensor ID of pressure sensor to get error count for. + * @return The current pressure sensor error count of a given pressure sensor. + *************************************************************************/ +//U32 getPressureSensorErrorCount( PRESSURE_SENSORS_T sensor ) +//{ +// U32 result = 0; +// +// if ( sensor < NUM_OF_PRESSURE_SENSORS ) +// { +// result = lastPressureErrorCounter[ sensor ].data; +// if ( OVERRIDE_KEY == lastPressureErrorCounter[ sensor ].override ) +// { +// result = lastPressureErrorCounter[ sensor ].ovData; +// } +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR4, sensor ) +// } +// +// return result; +//} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testPressureSensorReadingsOverride function overrides the value of the + * specified pressure sensor with a given value. + * @details \b Inputs: none + * @details \b Outputs: currentPressureReadings[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the pressure sensor. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +//BOOL testPressureSensorReadingsOverride( MESSAGE_T *message ) +//{ +// BOOL result = f32ArrayOverride( message, ¤tPressureReadings[0], NUM_OF_PRESSURE_SENSORS - 1 ); +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The testPressureSensorTemperatureReadingsOverride function overrides the value of the + * specified pressure 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 pressure sensor temperature. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +//BOOL testPressureSensorTemperatureReadingsOverride( MESSAGE_T *message ) +//{ +// BOOL result = f32ArrayOverride( message, ¤tPresTempReadings[0], NUM_OF_PRESSURE_SENSORS - 1 ); +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The testPressureSensorReadCounterOverride function overrides the value of the + * specified pressure sensor read counter with a given value. + * @details \b Inputs: none + * @details \b Outputs: lastPressureReadCounter[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the pressure sensor read counter. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +//BOOL testPressureSensorReadCounterOverride( MESSAGE_T *message ) +//{ +// BOOL result = u32ArrayOverride( message, &lastPressureReadCounter[0], NUM_OF_PRESSURE_SENSORS - 1, 0, PRES_SENSORS_READ_ERR_MAX_CNT ); +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The testPressureSensorErrorCounterOverride function overrides the value of the + * specified pressure sensor error counter with a given value. + * @details \b Inputs: none + * @details \b Outputs: lastPressureErrorCounter[] + * @param message Override message from Dialin which includes an sensor + * ID and override value of the pressure sensor error counter. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +//BOOL testPressureSensorErrorCounterOverride( MESSAGE_T *message ) +//{ +// BOOL result = u32ArrayOverride( message, &lastPressureErrorCounter[0], NUM_OF_PRESSURE_SENSORS - 1, 0, PRES_SENSORS_READ_ERR_MAX_CNT ); +// +// return result; +//} + +/**@}*/ Index: firmware/App/Drivers/PressureSensor.h =================================================================== diff -u --- firmware/App/Drivers/PressureSensor.h (revision 0) +++ firmware/App/Drivers/PressureSensor.h (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -0,0 +1,61 @@ +/************************************************************************** +* +* 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 PressureSensor.h +* +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 +* +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 +* +***************************************************************************/ + +#ifndef __PRESSURE_SENSOR_H__ +#define __PRESSURE_SENSOR_H__ + +#include "ROCommon.h" +#include "PressureCommon.h" + +/** + * @defgroup PressureSensor PressureSensor + * @brief Pressure sensors driver module. Reads the various RO pressure + * sensors raw pressure and temperature value. + * + * @addtogroup PressureSensor + * @{ + */ + +// ********** public definitions ********** + +/// Enumeration of pressure sensors monitored by this module. +typedef enum PressureSensors +{ + PRESSURE_SENSOR_WATER_INLET_INPUT = 0, ///< Water Inlet pressure before regulator (PRi) + PRESSURE_SENSOR_FIRST = PRESSURE_SENSOR_WATER_INLET_INPUT, ///< First pressure to scan + PRESSURE_SENSOR_WATER_INLET_OUTPUT, ///< Water Inlet pressure after regulator (PRo) + PRESSURE_SENSOR_WATER_OUTLET, ///< Hydraulics outlet pressure (PHo/Pn) + NUM_OF_PRESSURE_SENSORS ///< Number of pressure sensors +} PRESSURE_SENSORS_T; + +// ********** public function prototypes ********** + +void initPressureSensor( void ); +void readPressureSensors( void ); +//F32 getPressure( PRESSURE_SENSORS_T sensor ); +//F32 getPressureSensorTemperature( PRESSURE_SENSORS_T sensor ); +//U32 getPressureSensorReadCount( PRESSURE_SENSORS_T sensor ); +//U32 getPressureSensorErrorCount( PRESSURE_SENSORS_T sensor ); +// +//BOOL testPressureSensorReadingsOverride( MESSAGE_T *message ); +//BOOL testPressureSensorTemperatureReadingsOverride( MESSAGE_T *message ); +//BOOL testPressureSensorReadCounterOverride( MESSAGE_T *message ); +//BOOL testPressureSensorErrorCounterOverride( MESSAGE_T *message ); + +/**@}*/ + +#endif Index: firmware/App/Drivers/TemperatureSensors.c =================================================================== diff -u --- firmware/App/Drivers/TemperatureSensors.c (revision 0) +++ firmware/App/Drivers/TemperatureSensors.c (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -0,0 +1,667 @@ +/************************************************************************** +* +* 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 TemperatureSensors.c +* +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 +* +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 +* +***************************************************************************/ + +#include // For temperature calculation +#include // For memset() + +#include "FpgaRO.h" +#include "MessageSupport.h" +#include "Messaging.h" +//#include "NVDataMgmt.h" +#include "OperationModes.h" +#include "PersistentAlarm.h" +#include "TemperatureSensors.h" +#include "Timers.h" +#include "Utilities.h" + +/** + * @addtogroup TemperatureSensors + * @{ + */ + +// ********** private definitions ********** + +#define PRIMARY_HEATER_TEMP_SENSORS_GAIN 8U ///< Primary heater temperature sensors gain. +#define PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE 20000 ///< Primary heater temperature sensors reference resistance. +#define PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE 1000U ///< Primary heater temperature sensors zero degree resistance. +#define PRIMARY_HEATER_TEMP_SENSORS_V3_REF_RESISTANCE 19600 ///< Primary heater temperature sensors V3 reference resistance. + +#define TEMP_SENSORS_ADC_BITS 24U ///< External temperature sensors ADC bits. +#define MAX_NUM_OF_RAW_ADC_SAMPLES 4U ///< Number of ADC reads for moving average calculations. +#define SHIFT_BITS_BY_2 2U ///< Shift bits by 2 to create a 4 for averaging 4 samples. +#define SHIFT_BITS_BY_2_FOR_AVERAGING 2U ///< Shift the ADCs of the temperature sensors by 2 to average them. + +#define CELSIUS_TO_KELVIN_CONVERSION 273.15F ///< Celsius to Kelvin temperature conversion. +#define ADC_BOARD_TEMP_SENSORS_CONVERSION_CONST 272.5F ///< ADC board temperature sensors conversion constant. +#define ADC_BOARD_TEMP_SENSORS_CONST 0x800000 ///< ADC board temperature sensors constant. + +#define TEMP_SENSORS_FPGA_ERROR_TIMEOUT_MS ( 2 * MS_PER_SECOND ) ///< Temperature sensors FPGA error timeout in milliseconds. + +#define TEMP_SENSORS_MIN_ALLOWED_DEGREE_C 0.0F ///< Temperature sensors minimum allowed temperature in C. +#define TEMP_SENSORS_MAX_ALLOWED_DEGREE_C 120.0F ///< Temperature sensors maximum allowed temperature in C. +#define HEATERS_INTERNAL_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C 200.0F ///< Heaters' internal temperature sensors maximum allowed temperature in C. +#define NON_FLUID_PATH_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C 80.0F ///< Non fluid temperature sensors path maximum allowed temperature in C. +#define TEMP_SENSORS_OUT_OF_RANGE_TIME_OUT_MS ( 5 * MS_PER_SECOND ) ///< Temperature sensor out of range persistent period in milliseconds. +#define DATA_PUBLISH_COUNTER_START_COUNT 30 ///< Data publish counter start count. +#define BARO_SENSOR_REFERENCE_TEMP_C 2000 ///< Barometric sensor reference temperature in C. +#define BARO_SENSOR_WAIT_FOR_COEFF_TIME_OUT_MS ( 20 * MS_PER_SECOND ) ///< Barometric sensor wait for coefficients timeout in milliseconds. +#define TEMP_READ_COUNTER_MAX_VALUE 255 ///< FPGA temperature sensor read counter max value. +#define BARO_SENSOR_CRC_MAX_VALUE 65535 ///< Baro sensor coefficients CRC max value + +static const U32 TEMP_EQUATION_RESISTOR_CALC = 1 << ( TEMP_SENSORS_ADC_BITS - 1 ); ///< Temperature sensors resistor calculation (2^(24 - 1)). +static const F32 TEMP_EQUATION_COEFF_A = 3.9083E-3; ///< ADC to temperature conversion coefficient A. +static const F32 TEMP_EQUATION_COEFF_B = -5.775E-7; ///< ADC to temperature conversion coefficient B. +static const U32 TWO_TO_POWER_OF_8 = ( 1 << 8 ); ///< 2^8. +static const U32 TWO_TO_POWER_OF_23 = ( 1 << 23 ); ///< 2^23. + +/// Temperature sensor struct. +typedef struct +{ + F32 gain; ///< ADC gain + F32 refResistance; ///< ADC reference resistance + F32 conversionCoeff; ///< ADC conversion coefficient + F32 zeroDegreeResistance; ///< ADC zero degree resistance + S32 rawADCReads[ MAX_NUM_OF_RAW_ADC_SAMPLES ]; ///< Raw ADC reads array + S32 adcNextIndex; ///< Next ADC read index + S32 adcRunningSum; ///< ADC running sum + OVERRIDE_F32_T temperatureValue; ///< Temperature values with override + F32 maxAllowedTemp; ///< Maximum allowed temperature of the sensor + S32 baroTempSnsrDiff; ///< Barometric sensor temperature difference +} TEMP_SENSOR_T; + +/// Barometric sensor temperature conversion +typedef struct +{ + U16 refTemperature; ///< Barometric sensor reference temperature. + U16 temperatureCoeff; ///< Barometric sensor temperature coefficient. + OVERRIDE_U32_T coeffsCRC; ///< Barometric sensor coefficients CRC. + U32 waitForCoeffStartTimeMS; ///< Barometric sensor wait for coefficients start time in milliseconds. + BOOL hasCRCBeenChecked; ///< Barometric sensor has CRC been checked flag. +} BARO_SENSOR_CONSTS_T; + +/// Barometric sensor - 6 type of coefficients +typedef struct +{ + U16 mfgInfo; ///< Barometric sensor manufacturing info. + U16 pressSensitivity; ///< Barometric sensor pressure sensitivity. + U16 pressOffset; ///< Barometric sensor pressure offset. + U16 tempCoeffOfPressSens; ///< Barometric sensor temperature coefficient of pressure sensor. + U16 tempCoeffPressOffset; ///< Barometric sensor temperature coefficient of pressure offset. + U16 referenceTemp; ///< Barometric sensor reference temperature. + U16 tempCoeffOfTemp; ///< Barometric sensor temperature coefficient of Temperature sensor. + U16 crc; ///< Barometric sensor CRC of the coefficients. +} BARO_SENSORS_COEFFS_T; + +// ********** private data ********** + +static TEMP_SENSOR_T tempSensors [ NUM_OF_TEMPERATURE_SENSORS ]; ///< Temperature sensors' data structure. +static OVERRIDE_U32_T lastTemperatureReadCounter; ///< Temperature sensors read count from FPGA. +static OVERRIDE_U32_T lastBaroTempReadCounter; ///< Barometric sensor read count from FPGA. +static BARO_SENSOR_CONSTS_T baroConvConsts; ///< Barometric sensor conversion constants. + +//static DD_TEMP_SENSORS_CAL_RECORD_T tempSensorCalRecord; ///< Temperature sensors calibration record. + +// ********** private function prototypes ********** + +//static F32 getADC2TempConversion( F32 avgADC, U32 gain, U32 refResistance, U32 zeroDegResistance, F32 adcConversionCoeff ); +//static void processTempSnsrsADCRead( U32 sensorIndex, U32 adc ); +//static void processADCRead( U32 sensorIndex, S32 adc ); +//static void checkBaroSensorCRC( void ); +//static void checkTemperatureSensors( void ); +//static void getCalibrationAppliedTemperatureValue( U32 sesnorIndex, F32* temperature ); + +/*********************************************************************//** + * @brief + * The initTemperatureSensors function initializes the temperature sensors unit. + * @details \b Inputs: none + * @details \b Outputs: unit variables initialized + * @return none + *************************************************************************/ +void initTemperatureSensors( void ) +{ + U08 i; + F32 conversionCoeff = 1.0F / 13584.0F; + + baroConvConsts.coeffsCRC.data = 0; + baroConvConsts.hasCRCBeenChecked = FALSE; + baroConvConsts.waitForCoeffStartTimeMS = 0; + + for ( i = 0; i < NUM_OF_TEMPERATURE_SENSORS; ++i ) + { + memset( &tempSensors[ i ], 0x0, sizeof( TEMP_SENSOR_T ) ); + //benignPolynomialCalRecord( &tempSensorCalRecord.tempSensors[ i ] ); + } + + // Initialize the barometric sensor's temperature conversion constants + memset( &baroConvConsts, 0x0, sizeof( BARO_SENSOR_CONSTS_T ) ); + + // Initialize TH1 (primary heater), TH2(outlet Heat Exchanger), TAUX ( Inlet Heat exchanger), + // TH3 ( Trim Heater) constants. For now, assume same gain across all sensors. + tempSensors[ TEMPSENSORS_INLET_HEAT_EXCHANGER ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; + tempSensors[ TEMPSENSORS_INLET_HEAT_EXCHANGER ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ TEMPSENSORS_INLET_HEAT_EXCHANGER ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ TEMPSENSORS_INLET_HEAT_EXCHANGER ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + + tempSensors[ TEMPSENSORS_OUTLET_HEAT_EXCHANGER ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; + tempSensors[ TEMPSENSORS_OUTLET_HEAT_EXCHANGER ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ TEMPSENSORS_OUTLET_HEAT_EXCHANGER ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ TEMPSENSORS_OUTLET_HEAT_EXCHANGER ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + + tempSensors[ TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; + tempSensors[ TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ].maxAllowedTemp = HEATERS_INTERNAL_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + + tempSensors[ TEMPSENSORS_TRIMMER_HEATER ].gain = PRIMARY_HEATER_TEMP_SENSORS_GAIN; + tempSensors[ TEMPSENSORS_TRIMMER_HEATER ].refResistance = PRIMARY_HEATER_TEMP_SENSORS_REF_RESISTANCE; + tempSensors[ TEMPSENSORS_TRIMMER_HEATER ].zeroDegreeResistance = PRIMARY_HEATER_TEMP_SENSORS_0_DEGREE_RESISTANCE; + tempSensors[ TEMPSENSORS_TRIMMER_HEATER ].maxAllowedTemp = TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + + // Board temperature sensors conversion coefficient + tempSensors[ TEMPSENSORS_BOARD_TEMPERATURE ].conversionCoeff = conversionCoeff; + tempSensors[ TEMPSENSORS_BOARD_TEMPERATURE ].maxAllowedTemp = NON_FLUID_PATH_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + + tempSensors[ TEMPSENSORS_BAROMETRIC_TEMP_SENSOR ].maxAllowedTemp = NON_FLUID_PATH_TEMP_SENSORS_MAX_ALLOWED_DEGREE_C; + + // Persistent alarm for the temperature sensors range check +// initPersistentAlarm( ALARM_ID_DD_TEMPERATURE_SENSOR_OUT_OF_RANGE, TEMP_SENSORS_OUT_OF_RANGE_TIME_OUT_MS, TEMP_SENSORS_OUT_OF_RANGE_TIME_OUT_MS ); + + // Initialize the FPGA persistent alarms +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_RTD_ADC_TEMP_SENSORS, ALARM_ID_DD_RTD_SENSORS_FPGA_FAULT, TEMP_SENSORS_FPGA_ERROR_TIMEOUT_MS, TEMP_SENSORS_FPGA_ERROR_TIMEOUT_MS); +// initFPGAPersistentAlarm( FPGA_PERS_ERROR_BARO_SENSOR, ALARM_ID_DD_BARO_SENSOR_FPGA_FAULT, TEMP_SENSORS_FPGA_ERROR_TIMEOUT_MS, TEMP_SENSORS_FPGA_ERROR_TIMEOUT_MS); +} + +/*********************************************************************//** + * @brief + * The getTemperatureValue function gets the temperature of the requested + * sensor. + * @details \b Inputs: tempSensors + * @details \b Outputs: none + * @details \b Alarms: ALARM_ID_DD_SOFTWARE_FAULT when invalid temperature + * sensor is seen. + * @param sensorIndex which is the temperature sensor index + * @return temperature of the requested sensor + *************************************************************************/ +//F32 getTemperatureValue( U32 sensorIndex ) +//{ +// F32 temperature = 0.0F; +// +// if ( sensorIndex < NUM_OF_TEMPERATURE_SENSORS ) +// { +// temperature = getF32OverrideValue( &tempSensors[ sensorIndex ].temperatureValue ); +// } +// else +// { +// // Wrong sensor was called, raise an alarm +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_TEMPERATURE_SENSOR_SELECTED1, sensorIndex ); +// } +// +// return temperature; +//} + +/*********************************************************************//** + * @brief + * The getBaroSensorTemperatureDiff function returns the barometric pressure + * sensor's temperature difference. + * @details \b Inputs: tempSensors + * @details \b Outputs: none + * @return barometric pressure sensor temperature difference + *************************************************************************/ +//S32 getBaroSensorTemperatureDiff( void ) +//{ +// return tempSensors[ TEMPSENSORS_BAROMETRIC_TEMP_SENSOR ].baroTempSnsrDiff; +//} + +/*********************************************************************//** + * @brief + * The setBaroSensorCoefficientReadStartTime function populates the start + * time of baro sensor coefficient read transaction initiated to FPGA. + * @details \b Inputs: none + * @details \b Outputs: baroConvConsts + * @return none + *************************************************************************/ +//void setBaroSensorCoefficientReadStartTime( void ) +//{ +// baroConvConsts.waitForCoeffStartTimeMS = getMSTimerCount(); +//} + +/*********************************************************************//** + * @brief + * The readTemperatureSensors function reads the temperature sensor + * value from FPGA. + * @details \b Inputs: FPGA + * @details \b Outputs: lastTemperatureReadCounter,lastBaroTempReadCounter + * @return none + *************************************************************************/ +void readTemperatureSensors( void ) +{ +// // Temperature sensor read count from FPGA +// lastTemperatureReadCounter.data = (U32)getFPGARTDReadCount(); +// +// //Read temperature sensors +// processTempSnsrsADCRead( TEMPSENSORS_INLET_HEAT_EXCHANGER, getFPGAInletHeatExchangerTemp() ); +// processTempSnsrsADCRead( TEMPSENSORS_OUTLET_HEAT_EXCHANGER, getFPGAOutletHeatExchangerTemp() ); +// processTempSnsrsADCRead( TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER, getFPGAHydraulicsPrimaryHeaterTemp() ); +// processTempSnsrsADCRead( TEMPSENSORS_TRIMMER_HEATER, getFPGATrimmerHeaterTemp() ); +// +// //TODO: Read Board temperture +// //processTempSnsrsADCRead( TEMPSENSORS_INTERNAL_COND_TEMP_SENSOR, getFPGACondSnsrInternalTemp() ); +// +// //Read Baro temperature sensor +// if ( getCurrentOperationMode() != DD_MODE_INIT ) +// { +// // Make sure the baro sensor coefficients are not corrupted +// checkBaroSensorCRC(); +// +// baroConvConsts.refTemperature = getFPGABaroReferenceTemperature(); +// baroConvConsts.temperatureCoeff = getFPGABaroTempCoeffOfTemperature(); +// lastBaroTempReadCounter.data = (U32)getFPGABaroReadCount(); +// +// processTempSnsrsADCRead( TEMPSENSORS_BAROMETRIC_TEMP_SENSOR, getFPGABaroTemperature() ); +// } +} + +/*********************************************************************//** + * @brief + * The getTemperatureSensorsReadCount function gets the current temperature sensor + * read count for the RTD temperature sensors. + * @details \b Inputs: lastTemperatureReadCounter + * @details \b Outputs: none + * @return The RTD temperature sensor read count. + *************************************************************************/ +//U32 getTemperatureSensorsReadCount( void ) +//{ +// U32 result = lastTemperatureReadCounter.data; +// +// if ( OVERRIDE_KEY == lastTemperatureReadCounter.override ) +// { +// result = lastTemperatureReadCounter.ovData; +// } +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The getBaroTempSensorsReadCount function gets the barometric temperature sensor + * read count. + * @details \b Inputs: lastBaroTempReadCounter + * @details \b Outputs: none + * @return The barometric temperature sensor read count. + *************************************************************************/ +//U32 getBaroTempSensorsReadCount( void ) +//{ +// U32 result = lastBaroTempReadCounter.data; +// +// if ( OVERRIDE_KEY == lastBaroTempReadCounter.override ) +// { +// result = lastBaroTempReadCounter.ovData; +// } +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The checkTemperatureSensors function checks the temperature sensor + * freshness and see if there is any read failures from FPGA. + * @details \b Inputs: Temperature sensors reading from FPGA + * @details \b Outputs: none + * @details \b Alarms: ALARM_ID_DD_RTD_SENSORS_FPGA_FAULT when temperature sensor + * read count not updated periodically + * @details \b Alarms: ALARM_ID_DD_BARO_SENSOR_FPGA_FAULT when baro temperature sensor + * read count not updated periodically + * @return none + *************************************************************************/ +//static void checkTemperatureSensors( void ) +//{ +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_RTD_ADC_TEMP_SENSORS, getTemperatureSensorsReadCount() ); +// checkFPGAPersistentAlarms( FPGA_PERS_ERROR_BARO_SENSOR, getBaroTempSensorsReadCount() ); +//} + +/*********************************************************************//** + * @brief + * The getADC2TempConversion function calculates the temperature from the + * moving average ADC samples. + * @details \b Inputs: tempEquationCoeffA, tempEquationCoeffB + * @details \b Outputs: none + * @param avgADC moving average ADC + * @param gain ADC gain + * @param refResistance ADC reference resistance + * @param zeroDegResistance ADC zero degree resistance + * @param adcConversionCoeff ADC conversion coefficient + * @return calculated temperature + *************************************************************************/ +//static F32 getADC2TempConversion( F32 avgADC, U32 gain, U32 refResistance, U32 zeroDegResistance, F32 adcConversionCoeff ) +//{ +// F32 temperature = 0.0F; +// +// if ( fabs( adcConversionCoeff ) <= NEARLY_ZERO ) +// { +// // R(RTD) = R(ref) * ( adc – 2^(N - 1) ) / ( G * 2^(N - 1) ); +// F32 resistance = ( refResistance * ( avgADC - TEMP_EQUATION_RESISTOR_CALC ) ) / ( gain * TEMP_EQUATION_RESISTOR_CALC ); +// // T = (-A + √( A^2 - 4B * ( 1 - R_T / R_0 ) ) ) / 2B +// F32 secondSqrtPart = 4 * TEMP_EQUATION_COEFF_B * ( 1 - ( resistance / zeroDegResistance ) ); +// temperature = ( -TEMP_EQUATION_COEFF_A + sqrt( pow( TEMP_EQUATION_COEFF_A, 2 ) - secondSqrtPart ) ) / ( 2 * TEMP_EQUATION_COEFF_B ); +// } +// else +// { +// temperature = avgADC * adcConversionCoeff; +// } +// +// return temperature; +//} + +/*********************************************************************//** + * @brief + * The processTemperatureSensorsADCRead function masks the MSB of the ADC + * read from FPGA and converts it to an S32. Then it calls the routine + * that checks if the read ADC is valid or not and if it is, to process + * the ADC value and covert it to temperature. + * @details \b Inputs: none + * @details \b Outputs: none + * @param sensorIndex ID of temperature sensor to process + * @param adc ADC value for the temperature sensor + * @return none + *************************************************************************/ +//static void processTempSnsrsADCRead( U32 sensorIndex, U32 adc ) +//{ +// S32 convertedADC = (S32)( adc & MASK_OFF_U32_MSB ); +// +// // Make sure the error bit is not true before +// processADCRead( sensorIndex, convertedADC ); +//} + +/*********************************************************************//** + * @brief + * The processADCRead function updates the ADC count moving average for a + * given temperature sensor. + * @details \b Inputs: tempSensors + * @details \b Outputs: tempSensors + * @details \b Alarms: ALARM_ID_DD_SOFTWARE_FAULT when invalid temperature + * sensor is seen. + * @param sensorIndex Temperature sensor index + * @param adc adc reading from FPGA + * @return none + *************************************************************************/ +//static void processADCRead( U32 sensorIndex, S32 adc ) +//{ +// F32 temperature; +// F32 avgADCReads; +// U32 index = tempSensors[ sensorIndex ].adcNextIndex; +// S32 indexValue = tempSensors[ sensorIndex ].rawADCReads[ index ]; +// +// // Update the temperature sensors' structure +// tempSensors[ sensorIndex ].rawADCReads[ index ] = adc; +// tempSensors[ sensorIndex ].adcNextIndex = INC_WRAP( index, 0, MAX_NUM_OF_RAW_ADC_SAMPLES - 1 ); +// tempSensors[ sensorIndex ].adcRunningSum = tempSensors[ sensorIndex ].adcRunningSum - indexValue + adc; +// avgADCReads = tempSensors[ sensorIndex ].adcRunningSum >> SHIFT_BITS_BY_2_FOR_AVERAGING; // Calculate the average +// +// // Different sensors have different ADC to temperature conversion methods +// switch( sensorIndex ) +// { +// case TEMPSENSORS_INLET_HEAT_EXCHANGER: +// case TEMPSENSORS_OUTLET_HEAT_EXCHANGER: +// case TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER: +// case TEMPSENSORS_TRIMMER_HEATER: +// temperature = getADC2TempConversion( avgADCReads, (U32)tempSensors [ sensorIndex ].gain, (U32)tempSensors [ sensorIndex ].refResistance, +// (U32)tempSensors [ sensorIndex ].zeroDegreeResistance, tempSensors [ sensorIndex ].conversionCoeff ); +// break; +// +// case TEMPSENSORS_BOARD_TEMPERATURE: +// //TODO : Need details on calculations. +// break; +// +// case TEMPSENSORS_BAROMETRIC_TEMP_SENSOR: +// { +// S32 baroTempSensorsDiff = (S32)avgADCReads - ( baroConvConsts.refTemperature * TWO_TO_POWER_OF_8 ); +// S64 differenceTimesCoefficient = (S64)baroTempSensorsDiff * (S64)baroConvConsts.temperatureCoeff; +// S64 baroSnsrTemperature = BARO_SENSOR_REFERENCE_TEMP_C + ( differenceTimesCoefficient / TWO_TO_POWER_OF_23 ); +// +// temperature = (F32)( baroSnsrTemperature / 100.0F ); +// tempSensors[ sensorIndex ].baroTempSnsrDiff = baroTempSensorsDiff; +// } +// break; +// +// default: +// // Wrong sensor was called, raise an alarm +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_TEMPERATURE_SENSOR_SELECTED2, sensorIndex ); +// // Wrong sensor, return temperature to be -1 +// temperature = -1.0F; +// break; +// } +// +// getCalibrationAppliedTemperatureValue( sensorIndex, &temperature ); +// // Update the temperature +// tempSensors[ sensorIndex ].temperatureValue.data = temperature; +//} + + +/*********************************************************************//** + * @brief + * The monitorTemperatureSensors function monitors the temperature sensors' + * temperature value and raises an alarm if any of them are out of range + * for more than the specified time. + * @details \b Inputs: tempSensors + * @details \b Outputs: tempSensors + * @details \b Alarms: ALARM_ID_DD_TEMPERATURE_SENSOR_OUT_OF_RANGE when the + * measured temperature exceeds the maximum limit temperature. + * @return none + *************************************************************************/ +void monitorTemperatureSenors( void ) +{ +// TEMPERATURE_SENSORS_T sensorId; +// TEMPERATURE_SENSORS_T sensorInAlarm = TEMPSENSORS_FIRST; +// F32 temperature = 0.0F; +// BOOL isTemperatureOutOfRange = FALSE; +// F32 alarmTemperature = 0.0F; +// +// for ( sensorId = TEMPSENSORS_FIRST; sensorId < NUM_OF_TEMPERATURE_SENSORS; sensorId++ ) +// { +// // Get temperature value. +// temperature = getTemperatureValue( sensorId ); +// // Check both temperature and to be in range +// if ( ( ( temperature < TEMP_SENSORS_MIN_ALLOWED_DEGREE_C ) || ( temperature > tempSensors[ sensorId ].maxAllowedTemp ) ) && +// ( getCurrentOperationMode() != DD_MODE_INIT ) ) +// { +// isTemperatureOutOfRange |= TRUE; +// sensorInAlarm = sensorId; +// alarmTemperature = temperature; +// } +// } +// +// checkPersistentAlarm( ALARM_ID_DD_TEMPERATURE_SENSOR_OUT_OF_RANGE, isTemperatureOutOfRange, sensorInAlarm, alarmTemperature ); +// +// //check freshness of temperature read +// checkTemperatureSensors(); +} + +/*********************************************************************//** + * @brief + * The checkBaroSensorCRC function gets all the barometric sensor coefficients + * and calls crc4 function to calculate the CRC of the coefficients and compares + * them to the provided CRC by the manufacturer. + * @details \b Inputs: hasBaroCoeffsBeenChecked + * @details \b Outputs: hasBaroCoeffsBeenChecked + * @details \b Alarms: ALARM_ID_DD_BAROMETRIC_SENSOR_COEFFS_BAD_CRC when baro + * temperature sensor coefficient CRC mismatch or timeout. + * @return none + *************************************************************************/ +//static void checkBaroSensorCRC( void ) +//{ +// U32 baroCRC = (U32)getFPGABaroCoeffsCRC(); +// BOOL hasCRCChanged = ( baroCRC != getU32OverrideValue( &baroConvConsts.coeffsCRC ) ? TRUE : FALSE ); +// +// // Once FPGA is ready get the barometric sensor's temperature conversion constants +// if ( TRUE == hasCRCChanged ) +// { +// U08 calculatedCRC; +// BARO_SENSORS_COEFFS_T baroCoeffs; +// +// baroCoeffs.mfgInfo = getFPGABaroMfgInfo(); +// baroCoeffs.pressSensitivity = getFPGABaroPressureSensitivity(); +// baroCoeffs.pressOffset = getFPGABaroPressureOffset(); +// baroCoeffs.tempCoeffOfPressSens = getFPGABaroTempCoeffOfPressSensitvity(); +// baroCoeffs.tempCoeffPressOffset = getFPGABaroTempCoeffOfPressOffset(); +// baroCoeffs.referenceTemp = getFPGABaroReferenceTemperature(); +// baroCoeffs.tempCoeffOfTemp = getFPGABaroTempCoeffOfTemperature(); +// baroCoeffs.crc = MASK_OFF_LSB & getFPGABaroCoeffsCRC(); +// calculatedCRC = crc4( (U16*)&baroCoeffs, sizeof( baroCoeffs ) ); +// baroConvConsts.coeffsCRC.data = baroCRC; +// baroCRC = (U16)( baroCRC & MASK_OFF_MSB ) & MASK_OFF_NIBBLE_MSB; +// baroConvConsts.hasCRCBeenChecked = TRUE; +// +// if ( calculatedCRC != baroCRC ) +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_BAROMETRIC_SENSOR_COEFFS_BAD_CRC, calculatedCRC, baroCoeffs.crc ); +// } +// } +// else if ( ( TRUE == didTimeout( baroConvConsts.waitForCoeffStartTimeMS, BARO_SENSOR_WAIT_FOR_COEFF_TIME_OUT_MS ) ) && +// ( FALSE == baroConvConsts.hasCRCBeenChecked ) ) +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_BAROMETRIC_SENSOR_COEFFS_BAD_CRC, 0, baroCRC ); +// } +//} + +/*********************************************************************//** + * @brief + * The getCalibrationAppliedTemperatureValue function applies the calibration + * values to the provided temperature value + * @details \b Inputs: tempSensorCalRecord + * @details \b Outputs: none + * @param sensorIndex Temperature sensor index + * @param temperature pointer to the calculated temperature value + * @return none + *************************************************************************/ +//static void getCalibrationAppliedTemperatureValue( U32 sesnorIndex, F32* temperature ) +//{ +// //CAL_DATA_DD_TEMP_SENSORS_T calId; +// F32 tempTemperature = *temperature; +// +// switch( sesnorIndex ) +// { +// case TEMPSENSORS_INLET_HEAT_EXCHANGER: +// //calId = CAL_DATA_INLET_HEAT_EXCHANGER_TEMP; +// break; +// +// case TEMPSENSORS_OUTLET_HEAT_EXCHANGER: +// //calId = CAL_DATA_OUTLET_HEAT_EXCHANGER_TEMP; +// break; +// +// case TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER: +// //calId = CAL_DATA_HYD_PRIMARY_HEATER_TEMP; +// break; +// +// case TEMPSENSORS_TRIMMER_HEATER: +// //calId = CAL_DATA_TRIM_HEATER_TEMP; +// break; +// +// case TEMPSENSORS_BAROMETRIC_TEMP_SENSOR: +// //calId = CAL_DATA_BARMOTERIC_TEMP; +// break; +// +// default: +// // Set the calibration temperature value as num of meaning calibration is not needed for the provided sensor +// //calId = NUM_OF_CAL_DATA_TEMP_SENSORS; +// break; +// } +// +// if ( calId != NUM_OF_CAL_DATA_TEMP_SENSORS ) +// { +// *temperature = pow( tempTemperature, 4 ) * tempSensorCalRecord.tempSensors[ calId ].fourthOrderCoeff + +// pow( tempTemperature, 3 ) * tempSensorCalRecord.tempSensors[ calId ].thirdOrderCoeff + +// pow( tempTemperature, 2 ) * tempSensorCalRecord.tempSensors[ calId ].secondOrderCoeff + +// tempTemperature * tempSensorCalRecord.tempSensors[ calId ].gain + +// tempSensorCalRecord.tempSensors[ calId ].offset; +// } +//} + + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testSetMeasuredTemperatureOverride function sets the override value + * for a specific temperature sensor. + * @details Inputs: tempSensors + * @details Outputs: tempSensors + * @param message Override message from Dialin which includes an ID of + * the sensor to override and the state to override the sensor to. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +//BOOL testMeasuredTemperatureOverride( MESSAGE_T *message ) +//{ +// BOOL result = f32ArrayOverride( message, &tempSensors[0].temperatureValue, NUM_OF_TEMPERATURE_SENSORS - 1 ); +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The testTemperatureReadCounterOverride function sets the override value + * of the temperature read counter. + * @details Inputs: lastTemperatureReadCounter + * @details Outputs: lastTemperatureReadCounter + * @param message Override message from Dialin which includes the read + * counter value to override for the set of temperature sensors. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +//BOOL testTemperatureReadCounterOverride( MESSAGE_T *message ) +//{ +// BOOL result = u32Override( message, &lastTemperatureReadCounter, 0, TEMP_READ_COUNTER_MAX_VALUE ); +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The testBaroTemperatureReadCounterOverride function sets the override value + * of the baro temperature read counter. + * @details Inputs: lastBaroTempReadCounter + * @details Outputs: lastBaroTempReadCounter + * @param message Override message from Dialin which includes the read + * counter value to override for the baro sensor. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +//BOOL testBaroTemperatureReadCounterOverride( MESSAGE_T *message ) +//{ +// BOOL result = u32Override( message, &lastBaroTempReadCounter, 0, TEMP_READ_COUNTER_MAX_VALUE ); +// +// return result; +//} + +/*********************************************************************//** + * @brief + * The testBaroTemperatureReadCounterOverride function sets the override value + * of the baro temperature read counter. + * @details Inputs: lastBaroTempReadCounter + * @details Outputs: lastBaroTempReadCounter + * @param message Override message from Dialin which includes the CRC + * value to override for the baro sensor. + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +//BOOL testBaroTemperatureCRCOverride( MESSAGE_T *message ) +//{ +// BOOL result = u32Override( message, &baroConvConsts.coeffsCRC, 0, BARO_SENSOR_CRC_MAX_VALUE ); +// +// return result; +//} + +/**@}*/ Index: firmware/App/Drivers/TemperatureSensors.h =================================================================== diff -u --- firmware/App/Drivers/TemperatureSensors.h (revision 0) +++ firmware/App/Drivers/TemperatureSensors.h (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -0,0 +1,67 @@ +/************************************************************************** +* +* 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 TemperatureSensors.h +* +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 +* +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 +* +***************************************************************************/ + +#ifndef __TEMPERATURE_SENSORS_H__ +#define __TEMPERATURE_SENSORS_H__ + +#include "ROCommon.h" +//#include "NVDataMgmt.h" + +/** + * @defgroup TemperatureSensors TemperatureSensors + * @brief Temperature Sensors driver module. Reads and processes the temperature sensors. + * 2 wire/ 3 wire RTD : PT1000 temperature sensor interfaced to FPGA ADC. + * + * @addtogroup TemperatureSensors + * @{ + */ + +// ********** public definitions ********** + +/// Enumeration of temperature sensors. +typedef enum SENSORS_NAME +{ + TEMPSENSORS_INLET_HEAT_EXCHANGER = 0, ///< First temp sensor to scan + TEMPSENSORS_FIRST = TEMPSENSORS_INLET_HEAT_EXCHANGER, ///< Heat exchanger Inlet temperature sensor + TEMPSENSORS_OUTLET_HEAT_EXCHANGER, ///< Heat exchanger Outlet temperature sensor + TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER, ///< Hydraulics primary heater temperature sensor + TEMPSENSORS_TRIMMER_HEATER, ///< Trimmer heater temperature sensor + TEMPSENSORS_BAROMETRIC_TEMP_SENSOR, ///< Barometric temperature sensor + TEMPSENSORS_BOARD_TEMPERATURE, ///< DD board temperature sensor ( thermistor ) + NUM_OF_TEMPERATURE_SENSORS ///< Number of temperature sensors +} TEMPERATURE_SENSORS_T; + +// ********** public function prototypes ********** + +void initTemperatureSensors( void ); + +//F32 getTemperatureValue( U32 sensorIndex ); +//S32 getBaroSensorTemperatureDiff( void ); +void readTemperatureSensors( void ); +void monitorTemperatureSenors( void ); +//U32 getTemperatureSensorsReadCount( void ); +//U32 getBaroTempSensorsReadCount( void ); +//void setBaroSensorCoefficientReadStartTime( void ); +// +//BOOL testMeasuredTemperatureOverride( MESSAGE_T *message ); +//BOOL testTemperatureReadCounterOverride( MESSAGE_T *message ); +//BOOL testBaroTemperatureReadCounterOverride( MESSAGE_T *message ); +//BOOL testBaroTemperatureCRCOverride( MESSAGE_T *message ); + +/**@}*/ + +#endif Index: firmware/App/Monitors/Conductivity.c =================================================================== diff -u -rc7dcb245c2378b1c96eeaa02f120f61dff598b11 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Monitors/Conductivity.c (.../Conductivity.c) (revision c7dcb245c2378b1c96eeaa02f120f61dff598b11) +++ firmware/App/Monitors/Conductivity.c (.../Conductivity.c) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -7,13 +7,14 @@ * * @file Conductivity.c * -* @author (last) Vinayakam Mani -* @date (last) 10-Sep-2024 +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 * -* @author (original) Vinayakam Mani -* @date (original) 10-Sep-2024 +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 * ***************************************************************************/ + #include // Used for calculating the polynomial calibration equation. #include // For memcpy @@ -36,25 +37,29 @@ // ********** 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. +static U32 conductivityPublishTimerCounter; ///< Conductivity data publication counter. +static OVERRIDE_U32_T conductivityDataPublishInterval; ///< Conductivity sensors publish time interval override. // ********** private function prototypes ********** -static void publishConductivitySensorsData( void ); +//static void publishConductivitySensorsData( void ); /*********************************************************************//** * @brief - * The initConductivity function initializes the ConductivitySensors module. + * The initConductivity function initializes the Conductivity unit. * @details \b Inputs: none * @details \b Outputs: Conductivity unit variables initialized * @return none *************************************************************************/ void initConductivity( void ) { - conductivityPublishTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; + conductivityPublishTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; + conductivityDataPublishInterval.data = COND_SENSOR_REPORT_PERIOD; + conductivityDataPublishInterval.ovData = COND_SENSOR_REPORT_PERIOD; + conductivityDataPublishInterval.ovInitData = 0; + conductivityDataPublishInterval.override = OVERRIDE_RESET; + initConductivitySensors(); } @@ -74,13 +79,13 @@ //control conductivity sensor // TODO : need more clarity on why and when to execute following control. - handleConductivitySensorsReset(); - handleConductivitySensorsInitProcedure(); - execConductivitySensorWrite(); - execConductivitySensorRead(); - - // publish conductivity sensors - publishConductivitySensorsData(); +// handleConductivitySensorsReset(); +// handleConductivitySensorsInitProcedure(); +// execConductivitySensorWrite(); +// execConductivitySensorRead(); +// +// // publish conductivity sensors +// publishConductivitySensorsData(); } /*********************************************************************//** @@ -89,31 +94,27 @@ * 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. + * @details \b Message \b Sent: MSG_ID_RO_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; +//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.td1 = getConductivityTemperatureValue( CONDUCTIVITYSENSORS_CD1_SENSOR ); +// data.td2 = getConductivityTemperatureValue( CONDUCTIVITYSENSORS_CD2_SENSOR ); +// conductivityPublishTimerCounter = 0; +// +// broadcastData( MSG_ID_RO_CONDUCTIVITY_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( CONDUCTIVITY_DATA_T ) ); +// } +//} - 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 *************************************************************************/ @@ -129,11 +130,11 @@ * that override valves states publish interval with (in ms) * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testConductivitySensorDataPublishIntervalOverride( MESSAGE_T *message ) -{ - BOOL result = u32BroadcastIntervalOverride( message, &conductivityDataPublishInterval, TASK_PRIORITY_INTERVAL ); +//BOOL testConductivitySensorDataPublishIntervalOverride( MESSAGE_T *message ) +//{ +// BOOL result = u32BroadcastIntervalOverride( message, &conductivityDataPublishInterval, TASK_PRIORITY_INTERVAL ); +// +// return result; +//} - return result; -} - /**@}*/ Index: firmware/App/Monitors/Conductivity.h =================================================================== diff -u -rc7dcb245c2378b1c96eeaa02f120f61dff598b11 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Monitors/Conductivity.h (.../Conductivity.h) (revision c7dcb245c2378b1c96eeaa02f120f61dff598b11) +++ firmware/App/Monitors/Conductivity.h (.../Conductivity.h) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -7,26 +7,24 @@ * * @file Conductivity.h * -* @author (last) Vinayakam Mani -* @date (last) 10-Sep-2024 +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 * -* @author (original) Vinayakam Mani -* @date (original) 10-Sep-2024 +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 * ***************************************************************************/ #ifndef __CONDUCTIVITY_H__ #define __CONDUCTIVITY_H__ -#include "DDCommon.h" +#include "ROCommon.h" #include "ConductivitySensors.h" /** * @defgroup Conductivity Conductivity * @brief Conductivity Sensors monitor module. Monitors and filters conductivity sensor readings. * - * - * * @addtogroup Conductivity * @{ */ @@ -36,14 +34,10 @@ /// 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 + F32 CPiConductivity; ///< CPi (P9) conductivity sensor value + F32 CPoConductivity; ///< CPo (P18) conductivity sensor value + F32 CPiTemperature; ///< CPi (P9) temperature value + F32 CPoTemperature; ///< CPo (P18) temperature value } CONDUCTIVITY_DATA_T; // ********** public function prototypes ********** Index: firmware/App/Monitors/Level.c =================================================================== diff -u -rc7dcb245c2378b1c96eeaa02f120f61dff598b11 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Monitors/Level.c (.../Level.c) (revision c7dcb245c2378b1c96eeaa02f120f61dff598b11) +++ firmware/App/Monitors/Level.c (.../Level.c) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -7,15 +7,15 @@ * * @file Level.c * -* @author (last) Vinayakam Mani -* @date (last) 11-Oct-2024 +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 * -* @author (original) Vinayakam Mani -* @date (original) 11-Oct-2024 +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 * ***************************************************************************/ -#include "FpgaDD.h" +#include "FpgaRO.h" #include "Level.h" #include "MessageSupport.h" #include "Messaging.h" @@ -44,8 +44,7 @@ // ********** private data ********** static U32 levelsDataPublicationCounter; ///< Level data publication counter. -static OVERRIDE_U32_T levelsDataPublishInterval = { LEVEL_DATA_PUB_INTERVAL, - LEVEL_DATA_PUB_INTERVAL, 0, 0 }; ///< Interval (in ms) at which to publish Level data to CAN bus. +static OVERRIDE_U32_T levelsDataPublishInterval; ///< Interval (in ms) at which to publish Level data to CAN bus. static LEVEL_STATUS_T levelsStatus[ NUM_OF_LEVELS ]; ///< Level status array. // ********** private function prototypes ********** @@ -54,119 +53,98 @@ /*********************************************************************//** * @brief - * The initLevels function initializes the level module. + * The initLevels function initializes the levels unit. * @details \b Inputs: none * @details \b Outputs: Level unit variables initialized. * @return none *************************************************************************/ void initLevels( void ) { - U32 i; + U32 level; levelsDataPublicationCounter = DATA_PUBLISH_COUNTER_START_COUNT; // Initialize all the Level - for ( i = 0; i < NUM_OF_LEVELS; i++ ) + for ( level = 0; level < NUM_OF_LEVELS; level++ ) { - levelsStatus[ i ].status.data = (U32)STATE_HIGH; - levelsStatus[ i ].status.ovData = (U32)STATE_HIGH; - levelsStatus[ i ].status.ovInitData = (U32)STATE_HIGH; - levelsStatus[ i ].status.override = OVERRIDE_RESET; - levelsStatus[ i ].debounceStartTime = 0; - levelsStatus[ i ].debounceTime = LEVEL_DEBOUNCE_TIME_MS; + levelsStatus[ level ].status.data = (U32)STATE_HIGH; + levelsStatus[ level ].status.ovData = (U32)STATE_HIGH; + levelsStatus[ level ].status.ovInitData = (U32)STATE_HIGH; + levelsStatus[ level ].status.override = OVERRIDE_RESET; + levelsStatus[ level ].debounceStartTime = 0; + levelsStatus[ level ].debounceTime = LEVEL_DEBOUNCE_TIME_MS; } + levelsDataPublishInterval.data = LEVEL_DATA_PUB_INTERVAL; + levelsDataPublishInterval.ovData = LEVEL_DATA_PUB_INTERVAL; + levelsDataPublishInterval.ovInitData = 0; + levelsDataPublishInterval.override = OVERRIDE_RESET; } /*********************************************************************//** * @brief * The execLevels function executes the floater and level sensor states. * @details \b Inputs: level sensor and floater reading from FPGA * @details \b Outputs: levelStatus - * @details \b Alarms: ALARM_ID_DD_SOFTWARE_FAULT when invalid level sensor - * executed. + * @details \b Alarms: ALARM_ID_RO_SOFTWARE_FAULT when invalid level sensor is set. * @return none *************************************************************************/ void execLevels( void ) { - U32 i; + U32 level; U32 currentLevelStatus = 0; - for ( i = 0; i < NUM_OF_LEVELS; i++ ) + for ( level = 0; level < NUM_OF_LEVELS; level++ ) { // Get the current level status - switch ( i ) - { - // Process the status of the Level - case FLOATER_1: - currentLevelStatus = ( getFPGAFloater1Status() != 0 ? STATE_LOW : STATE_MEDIUM ); - break; - - case FLOATER_2: - currentLevelStatus = ( getFPGAFloater2Status() != 0 ? STATE_MEDIUM : STATE_HIGH ); - break; - - case BICARB_LEVEL: - currentLevelStatus = ( getFPGALevelSensor1() != 0 ? STATE_LOW : STATE_HIGH ); - break; - - case SPENT_DIALYSATE_LEVEL: - currentLevelStatus = ( getFPGALevelSensor2() != 0 ? STATE_LOW : STATE_HIGH ); - break; - -#ifndef _VECTORCAST_ - default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_LEVEL_SELECTED, i ); - break; -#endif - } - - // Check if the current level status is not the same as the recorded data - if ( currentLevelStatus != levelsStatus[ i ].status.data ) - { - // If the debounce time is 0, start the timer - if ( 0 == levelsStatus[ i ].debounceStartTime ) - { - levelsStatus[ i ].debounceStartTime = getMSTimerCount(); - } - // If the debounce time has been elapsed, update the level sensor status to the new status - else if ( TRUE == didTimeout( levelsStatus[ i ].debounceStartTime, levelsStatus[ i ].debounceTime ) ) - { - switch ( i ) - { - case FLOATER_1: - SEND_EVENT_WITH_2_U32_DATA( DD_EVENT_FLOATER_1_LEVEL_CHANGE, (U32)levelsStatus[ i ].status.data, (U32)currentLevelStatus ); - break; - - case FLOATER_2: - SEND_EVENT_WITH_2_U32_DATA( DD_EVENT_FLOATER_2_LEVEL_CHANGE, (U32)levelsStatus[ i ].status.data, (U32)currentLevelStatus ); - break; - - case BICARB_LEVEL: - SEND_EVENT_WITH_2_U32_DATA( DD_EVENT_BICARB_LEVEL_CHANGE, (U32)levelsStatus[ i ].status.data, (U32)currentLevelStatus ); - break; - - case SPENT_DIALYSATE_LEVEL: - SEND_EVENT_WITH_2_U32_DATA( DD_EVENT_SPENT_DIALYSATE_LEVEL_CHANGE, (U32)levelsStatus[ i ].status.data, (U32)currentLevelStatus ); - break; - -#ifndef _VECTORCAST_ - default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_LEVEL_SELECTED, i ); - break; -#endif - } - - levelsStatus[ i ].debounceStartTime = 0; - levelsStatus[ i ].status.data = currentLevelStatus; - } - } - else - { - levelsStatus[ i ].debounceStartTime = 0; - } +// switch ( level ) +// { +// // Process the status of the Level +// case FLOATER: +// currentLevelStatus = ( getFPGAFloater1Status() != 0 ? STATE_LOW : STATE_MEDIUM ); +// break; +// +//#ifndef _VECTORCAST_ +// default: +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_RO_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_LEVEL_SELECTED, level ); +// break; +//#endif +// } +// +// // Check if the current level status is not the same as the recorded data +// if ( currentLevelStatus != levelsStatus[ level ].status.data ) +// { +// // If the debounce time is 0, start the timer +// if ( 0 == levelsStatus[ level ].debounceStartTime ) +// { +// levelsStatus[ level ].debounceStartTime = getMSTimerCount(); +// } +// // If the debounce time has been elapsed, update the level sensor status to the new status +// else if ( TRUE == didTimeout( levelsStatus[ level ].debounceStartTime, levelsStatus[ level ].debounceTime ) ) +// { +// switch ( level ) +// { +// case FLOATER: +// SEND_EVENT_WITH_2_U32_DATA( DD_EVENT_FLOATER_1_LEVEL_CHANGE, (U32)levelsStatus[ level ].status.data, (U32)currentLevelStatus ); +// break; +// +//#ifndef _VECTORCAST_ +// default: +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_INVALID_LEVEL_SELECTED, level ); +// break; +//#endif +// } +// +// levelsStatus[ level ].debounceStartTime = 0; +// levelsStatus[ level ].status.data = currentLevelStatus; +// } +// } +// else +// { +// levelsStatus[ level ].debounceStartTime = 0; +// } } - publishLevelsData(); +// publishLevelsData(); } /*********************************************************************//** @@ -179,28 +157,28 @@ * @param levelId which is the sensor that its status is requested * @return level status *************************************************************************/ -LEVEL_STATE_T getLevelStatus( LELVEL_T levelId ) -{ - U32 status = 0; +//LEVEL_STATE_T getLevelStatus( LELVEL_T levelId ) +//{ +// U32 status = 0; +// +// if ( levelId < NUM_OF_LEVELS ) +// { +// // Assume there is no override +// status = levelsStatus[ levelId ].status.data; +// +// if ( OVERRIDE_KEY == levelsStatus[ levelId ].status.override ) +// { +// status = levelsStatus[ levelId ].status.ovData; +// } +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_DD_INVALID_LEVEL_ID, (U32)levelId ) +// } +// +// return (LEVEL_STATE_T)status; +//} - if ( levelId < NUM_OF_LEVELS ) - { - // Assume there is no override - status = levelsStatus[ levelId ].status.data; - - if ( OVERRIDE_KEY == levelsStatus[ levelId ].status.override ) - { - status = levelsStatus[ levelId ].status.ovData; - } - } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_DD_INVALID_LEVEL_ID, (U32)levelId ) - } - - return (LEVEL_STATE_T)status; -} - /*********************************************************************//** * @brief * The publishLevelsData function broadcasts the level data at the @@ -211,24 +189,24 @@ * sensors data. * @return none *************************************************************************/ -static void publishLevelsData( void ) -{ - if ( ++levelsDataPublicationCounter >= getU32OverrideValue( &levelsDataPublishInterval ) ) - { - LEVEL_DATA_T data; +//static void publishLevelsData( void ) +//{ +// if ( ++levelsDataPublicationCounter >= getU32OverrideValue( &levelsDataPublishInterval ) ) +// { +// LEVEL_DATA_T data; +// +// data.floater1Level = (U32)getLevelStatus( FLOATER_1 ); +// data.floater2Level = (U32)getLevelStatus( FLOATER_2 ); +// data.bicarbLevel = (U32)getLevelStatus( BICARB_LEVEL ); +// data.spentDialysateLevel = (U32)getLevelStatus( SPENT_DIALYSATE_LEVEL ); +// +// levelsDataPublicationCounter = 0; +// +// broadcastData( MSG_ID_DD_LEVEL_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( LEVEL_DATA_T ) ); +// } +//} - data.floater1Level = (U32)getLevelStatus( FLOATER_1 ); - data.floater2Level = (U32)getLevelStatus( FLOATER_2 ); - data.bicarbLevel = (U32)getLevelStatus( BICARB_LEVEL ); - data.spentDialysateLevel = (U32)getLevelStatus( SPENT_DIALYSATE_LEVEL ); - levelsDataPublicationCounter = 0; - - broadcastData( MSG_ID_DD_LEVEL_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( LEVEL_DATA_T ) ); - } -} - - /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ @@ -244,13 +222,13 @@ * (in ms) to override the level data broadcast interval to. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testLevelsDataPublishIntervalOverride( MESSAGE_T *message ) -{ - BOOL result = u32BroadcastIntervalOverride( message, &levelsDataPublishInterval, TASK_PRIORITY_INTERVAL ); +//BOOL testLevelsDataPublishIntervalOverride( MESSAGE_T *message ) +//{ +// BOOL result = u32BroadcastIntervalOverride( message, &levelsDataPublishInterval, TASK_PRIORITY_INTERVAL ); +// +// return result; +//} - return result; -} - /*********************************************************************//** * @brief * The testLevelStatusOverride function sets the override status @@ -261,11 +239,11 @@ * the level sensor to override and the state to override the level sensor to. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testLevelStatusOverride( MESSAGE_T *message ) -{ - BOOL result = u32ArrayOverride( message, &levelsStatus[0].status, NUM_OF_LEVELS - 1, 0, NUM_OF_LEVELS_STATES -1 ); +//BOOL testLevelStatusOverride( MESSAGE_T *message ) +//{ +// BOOL result = u32ArrayOverride( message, &levelsStatus[0].status, NUM_OF_LEVELS - 1, 0, NUM_OF_LEVELS_STATES -1 ); +// +// return result; +//} - return result; -} - /**@}*/ Index: firmware/App/Monitors/Level.h =================================================================== diff -u -rc7dcb245c2378b1c96eeaa02f120f61dff598b11 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Monitors/Level.h (.../Level.h) (revision c7dcb245c2378b1c96eeaa02f120f61dff598b11) +++ firmware/App/Monitors/Level.h (.../Level.h) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -7,23 +7,22 @@ * * @file Level.h * -* @author (last) Vinayakam Mani -* @date (last) 11-Oct-2024 +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 * -* @author (original) Vinayakam Mani -* @date (original) 11-Oct-2024 +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 * ***************************************************************************/ #ifndef LEVEL_H_ #define LEVEL_H_ -#include "DDCommon.h" +#include "ROCommon.h" /** * @defgroup Level Level - * @brief Level module monitors the floater levels, Bicarb gas separation level and Spent - * dialsate balance air separation level. + * @brief Level module monitors the floater level for RO sub-system. * Level manufacturer: Custom built modules. * * @addtogroup Level @@ -35,10 +34,7 @@ /// DD floater and level sensor enumeration typedef enum level_names { - FLOATER_1 = 0, ///< floater switch low to medium status - FLOATER_2, ///< floater switch medium to high status - BICARB_LEVEL, ///< bicarb level low or high status - SPENT_DIALYSATE_LEVEL, ///< Spent dialysate air separation chamber level low or high status + FLOATER = 0, ///< floater switch low to medium status NUM_OF_LEVELS ///< Number of levels } LELVEL_T; @@ -55,20 +51,17 @@ typedef struct { U32 floater1Level; ///< Floater 1 level - U32 floater2Level; ///< Floater 2 level - U32 bicarbLevel; ///< Bicarb level - U32 spentDialysateLevel; ///< Spent dialysate level } LEVEL_DATA_T; // ********** public function prototypes ********** void initLevels( void ); void execLevels( void ); -LEVEL_STATE_T getLevelStatus( LELVEL_T levelId ); +//LEVEL_STATE_T getLevelStatus( LELVEL_T levelId ); +// +//BOOL testLevelsDataPublishIntervalOverride( MESSAGE_T *message ); +//BOOL testLevelStatusOverride( MESSAGE_T *message ); -BOOL testLevelsDataPublishIntervalOverride( MESSAGE_T *message ); -BOOL testLevelStatusOverride( MESSAGE_T *message ); - /**@}*/ #endif Index: firmware/App/Monitors/Pressure.c =================================================================== diff -u -rc7dcb245c2378b1c96eeaa02f120f61dff598b11 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Monitors/Pressure.c (.../Pressure.c) (revision c7dcb245c2378b1c96eeaa02f120f61dff598b11) +++ firmware/App/Monitors/Pressure.c (.../Pressure.c) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -7,15 +7,15 @@ * * @file Pressure.c * -* @author (last) Vinayakam Mani -* @date (last) 04-Sep-2024 +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 * -* @author (original) Vinayakam Mani -* @date (original) 04-Sep-2024 +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 * ***************************************************************************/ -#include "AlarmMgmtDD.h" +#include "AlarmMgmtRO.h" #include "Messaging.h" #include "Pressure.h" #include "PersistentAlarm.h" @@ -85,18 +85,17 @@ static FILTER_PRESSURE_TEMPERATURE_READINGS_T filteredPressureTempReadings[NUM_OF_PRESSURE_SENSORS]; ///< Filtered pressure reading for pressure sensors. static PRESSURE_STATE_T pressuresState; ///< current state of pressure monitor state machine. static U32 pressuresDataPublicationTimerCounter; ///< used to schedule pressure data publication to CAN bus. -static OVERRIDE_U32_T pressuresDataPublishInterval = { PRESSURES_DATA_PUB_INTERVAL, - PRESSURES_DATA_PUB_INTERVAL, 0, 0 }; ///< Pressure data publish interval. +static OVERRIDE_U32_T pressuresDataPublishInterval; ///< Pressure data publish interval. // ********** private function prototypes ********** -static void filterPressureSensorReadings( void ); -static void filterPressureSensorTemperatureReadings( void ); +//static void filterPressureSensorReadings( void ); +//static void filterPressureSensorTemperatureReadings( void ); //static F32 getCalibrationAppliedPressure( U08 sensorId, F32 pressure ); -static F32 getConvertedPressure( PRESSURE_SENSORS_T sensor, F32 pressure ); +//static F32 getConvertedPressure( PRESSURE_SENSORS_T sensor, F32 pressure ); static PRESSURE_STATE_T handlePressuresInitState( void ); static PRESSURE_STATE_T handlePressuresContReadState( void ); -static void publishPressuresData( void ); +//static void publishPressuresData( void ); /*********************************************************************//** * @brief @@ -107,35 +106,40 @@ *************************************************************************/ void initPressure( void ) { - U32 i; + U32 pres; pressuresState = PRESSURE_INIT_STATE; pressuresDataPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; initPressureSensor(); // Initialize override structures for each pressure sensor - for ( i = (U32)PRESSURE_SENSOR_FIRST; i < (U32)NUM_OF_PRESSURE_SENSORS; i++ ) + for ( pres = (U32)PRESSURE_SENSOR_FIRST; pres < (U32)NUM_OF_PRESSURE_SENSORS; pres++ ) { - filteredcurrentPressureReadings[ i ].data = 0.0F; - filteredcurrentPressureReadings[ i ].ovData = 0.0F; - filteredcurrentPressureReadings[ i ].ovInitData = 0.0F; - filteredcurrentPressureReadings[ i ].override = OVERRIDE_RESET; + filteredcurrentPressureReadings[ pres ].data = 0.0F; + filteredcurrentPressureReadings[ pres ].ovData = 0.0F; + filteredcurrentPressureReadings[ pres ].ovInitData = 0.0F; + filteredcurrentPressureReadings[ pres ].override = OVERRIDE_RESET; - filteredcurrentPresTempReadings[ i ].data = 0.0F; - filteredcurrentPresTempReadings[ i ].ovData = 0.0F; - filteredcurrentPresTempReadings[ i ].ovInitData = 0.0F; - filteredcurrentPresTempReadings[ i ].override = OVERRIDE_RESET; + filteredcurrentPresTempReadings[ pres ].data = 0.0F; + filteredcurrentPresTempReadings[ pres ].ovData = 0.0F; + filteredcurrentPresTempReadings[ pres ].ovInitData = 0.0F; + filteredcurrentPresTempReadings[ pres ].override = OVERRIDE_RESET; - filteredPressureReadings[i].pressureReadingsCount = 0; - filteredPressureReadings[i].pressureReadingsIdx = 0; - filteredPressureReadings[i].pressureReadingsTotal = 0.0F; + filteredPressureReadings[ pres ].pressureReadingsCount = 0; + filteredPressureReadings[ pres ].pressureReadingsIdx = 0; + filteredPressureReadings[ pres ].pressureReadingsTotal = 0.0F; - filteredPressureTempReadings[i].pressureTempReadingsCount = 0; - filteredPressureTempReadings[i].pressureTempReadingsIdx = 0; - filteredPressureTempReadings[i].pressureTempReadingsTotal = 0.0F; + filteredPressureTempReadings[ pres ].pressureTempReadingsCount = 0; + filteredPressureTempReadings[ pres ].pressureTempReadingsIdx = 0; + filteredPressureTempReadings[ pres ].pressureTempReadingsTotal = 0.0F; } + pressuresDataPublishInterval.data = PRESSURES_DATA_PUB_INTERVAL; + pressuresDataPublishInterval.ovData = PRESSURES_DATA_PUB_INTERVAL; + pressuresDataPublishInterval.ovInitData = 0; + pressuresDataPublishInterval.override = OVERRIDE_RESET; + initPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_LOW_RANGE, INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ); initPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_HIGH_RANGE, INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ); initPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_LOW_RANGE, INLET_WATER_PRES_OUT_OF_RANGE_CLEAR_MS, INLET_WATER_PRES_OUT_OF_RANGE_TIMEOUT_MS ); @@ -152,15 +156,15 @@ * @details \b Outputs: filteredPressureReadings[], filteredPressureTempReadings[] * @return none *************************************************************************/ -static void filterPressureSensors( void ) -{ - //Filter pressure sensor reading - filterPressureSensorReadings(); +//static void filterPressureSensors( void ) +//{ +// //Filter pressure sensor reading +// filterPressureSensorReadings(); +// +// //Filter pressure sensor temperature reading +// filterPressureSensorTemperatureReadings(); +//} - //Filter pressure sensor temperature reading - filterPressureSensorTemperatureReadings(); -} - /*********************************************************************//** * @brief * The getFilteredPressure function gets the filtered current pressure (in mmHg) @@ -171,26 +175,26 @@ * @param sensor ID of pressure sensor to get pressure reading for. * @return The filtered current pressure (in mmHg) of the given pressure sensor. *************************************************************************/ -F32 getFilteredPressure( PRESSURE_SENSORS_T sensor ) -{ - F32 result = 0.0F; +//F32 getFilteredPressure( PRESSURE_SENSORS_T sensor ) +//{ +// F32 result = 0.0F; +// +// if ( sensor < NUM_OF_PRESSURE_SENSORS ) +// { +// result = filteredcurrentPressureReadings[ sensor ].data; +// if ( OVERRIDE_KEY == filteredcurrentPressureReadings[ sensor ].override ) +// { +// result = filteredcurrentPressureReadings[ sensor ].ovData; +// } +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR5, sensor ) +// } +// +// return result; +//} - if ( sensor < NUM_OF_PRESSURE_SENSORS ) - { - result = filteredcurrentPressureReadings[ sensor ].data; - if ( OVERRIDE_KEY == filteredcurrentPressureReadings[ sensor ].override ) - { - result = filteredcurrentPressureReadings[ sensor ].ovData; - } - } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR5, sensor ) - } - - return result; -} - /*********************************************************************//** * @brief * The getFilteredPressureSensorTemperature function gets the filtered current @@ -201,26 +205,26 @@ * @param sensor ID of pressure sensor to get temperature reading for. * @return The filtered current pressure sensor temperature (in deg C) of the given pressure sensor. *************************************************************************/ -F32 getFilteredPressureSensorTemperature( PRESSURE_SENSORS_T sensor ) -{ - F32 result = 0.0F; +//F32 getFilteredPressureSensorTemperature( PRESSURE_SENSORS_T sensor ) +//{ +// F32 result = 0.0F; +// +// if ( sensor < NUM_OF_PRESSURE_SENSORS ) +// { +// result = filteredcurrentPresTempReadings[ sensor ].data; +// if ( OVERRIDE_KEY == filteredcurrentPresTempReadings[ sensor ].override ) +// { +// result = filteredcurrentPresTempReadings[ sensor ].ovData; +// } +// } +// else +// { +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR6, sensor ) +// } +// +// return result; +//} - if ( sensor < NUM_OF_PRESSURE_SENSORS ) - { - result = filteredcurrentPresTempReadings[ sensor ].data; - if ( OVERRIDE_KEY == filteredcurrentPresTempReadings[ sensor ].override ) - { - result = filteredcurrentPresTempReadings[ sensor ].ovData; - } - } - else - { - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR6, sensor ) - } - - return result; -} - /*********************************************************************//** * @brief * The checkInletWaterPressure function checks inlet water pressure value @@ -233,71 +237,71 @@ * the inlet water pressure is greater than the high limit. * @return none *************************************************************************/ -void checkInletWaterPressure( void ) -{ - F32 pressureIn = getFilteredPressure( PRESSURE_SENSOR_WATER_INLET_INPUT ); - F32 PressureOut = getFilteredPressure( PRESSURE_SENSOR_WATER_INLET_OUTPUT ); - - //Check Water Inlet Input pressure range - if ( VALVE_STATE_OPEN == getValveStateName( VWI ) ) - { - BOOL isPressureTooLow; - BOOL isPressureTooHigh; - F32 maxInletWaterPressureWarningLow = MIN_INLET_WATER_PRESSURE_WARNING_LOW_PSIG; - F32 minInletWaterPressureWarningLow = MIN_INLET_PRESSURE_TO_CLEAR_WARINING_PSIG; - - isPressureTooLow = ( pressureIn < maxInletWaterPressureWarningLow ? TRUE : FALSE ); - isPressureTooHigh = ( pressureIn > MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ? TRUE : FALSE ); - - if ( TRUE == isAlarmActive( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_LOW_RANGE ) ) - { - isPressureTooLow = ( pressureIn >= minInletWaterPressureWarningLow ? FALSE : TRUE ); - } - checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_LOW_RANGE, isPressureTooLow, pressureIn, maxInletWaterPressureWarningLow ); - - if ( TRUE == isAlarmActive( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_HIGH_RANGE ) ) - { - isPressureTooHigh = ( pressureIn <= MIN_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ? FALSE : TRUE ); - } - checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_HIGH_RANGE, isPressureTooHigh, pressureIn, MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ); - } - else - { - // VWI is closed - clear all alarms - checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_LOW_RANGE, FALSE, pressureIn, MIN_INLET_WATER_PRESSURE_WARNING_LOW_PSIG ); - checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_HIGH_RANGE, FALSE, pressureIn, MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ); - } - - //Check Water Inlet Output pressure range - if ( VALVE_STATE_OPEN == getValveStateName( VWI ) ) - { - BOOL isPressureTooLow; - BOOL isPressureTooHigh; - F32 maxInletWaterPressureWarningLow = MIN_INLET_WATER_PRES_OUT_WARNING_LOW_PSIG; - F32 minInletWaterPressureWarningLow = MIN_INLET_PRES_OUT_TO_CLEAR_WARINING_PSIG; - - isPressureTooLow = ( PressureOut < maxInletWaterPressureWarningLow ? TRUE : FALSE ); - isPressureTooHigh = ( PressureOut > MAX_INLET_WATER_PRES_OUT_WARNING_HIGH_PSIG ? TRUE : FALSE ); - - if ( TRUE == isAlarmActive( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_LOW_RANGE ) ) - { - isPressureTooLow = ( PressureOut >= minInletWaterPressureWarningLow ? FALSE : TRUE ); - } - checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_LOW_RANGE, isPressureTooLow, PressureOut, maxInletWaterPressureWarningLow ); - - if ( TRUE == isAlarmActive( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_HIGH_RANGE ) ) - { - isPressureTooHigh = ( PressureOut <= MIN_INLET_WATER_PRES_OUT_WARNING_HIGH_PSIG ? FALSE : TRUE ); - } - checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_HIGH_RANGE, isPressureTooHigh, PressureOut, MAX_INLET_WATER_PRES_OUT_WARNING_HIGH_PSIG ); - } - else - { - // VWI is closed - clear all alarms - checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_LOW_RANGE, FALSE, PressureOut, MIN_INLET_WATER_PRES_OUT_WARNING_LOW_PSIG ); - checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_HIGH_RANGE, FALSE, PressureOut, MAX_INLET_WATER_PRES_OUT_WARNING_HIGH_PSIG ); - } -} +//void checkInletWaterPressure( void ) +//{ +// F32 pressureIn = getFilteredPressure( PRESSURE_SENSOR_WATER_INLET_INPUT ); +// F32 PressureOut = getFilteredPressure( PRESSURE_SENSOR_WATER_INLET_OUTPUT ); +// +// //Check Water Inlet Input pressure range +// if ( VALVE_STATE_OPEN == getValveStateName( VWI ) ) +// { +// BOOL isPressureTooLow; +// BOOL isPressureTooHigh; +// F32 maxInletWaterPressureWarningLow = MIN_INLET_WATER_PRESSURE_WARNING_LOW_PSIG; +// F32 minInletWaterPressureWarningLow = MIN_INLET_PRESSURE_TO_CLEAR_WARINING_PSIG; +// +// isPressureTooLow = ( pressureIn < maxInletWaterPressureWarningLow ? TRUE : FALSE ); +// isPressureTooHigh = ( pressureIn > MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ? TRUE : FALSE ); +// +// if ( TRUE == isAlarmActive( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_LOW_RANGE ) ) +// { +// isPressureTooLow = ( pressureIn >= minInletWaterPressureWarningLow ? FALSE : TRUE ); +// } +// checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_LOW_RANGE, isPressureTooLow, pressureIn, maxInletWaterPressureWarningLow ); +// +// if ( TRUE == isAlarmActive( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_HIGH_RANGE ) ) +// { +// isPressureTooHigh = ( pressureIn <= MIN_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ? FALSE : TRUE ); +// } +// checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_HIGH_RANGE, isPressureTooHigh, pressureIn, MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ); +// } +// else +// { +// // VWI is closed - clear all alarms +// checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_LOW_RANGE, FALSE, pressureIn, MIN_INLET_WATER_PRESSURE_WARNING_LOW_PSIG ); +// checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_IN_HIGH_RANGE, FALSE, pressureIn, MAX_INLET_WATER_PRESSURE_WARNING_HIGH_PSIG ); +// } +// +// //Check Water Inlet Output pressure range +// if ( VALVE_STATE_OPEN == getValveStateName( VWI ) ) +// { +// BOOL isPressureTooLow; +// BOOL isPressureTooHigh; +// F32 maxInletWaterPressureWarningLow = MIN_INLET_WATER_PRES_OUT_WARNING_LOW_PSIG; +// F32 minInletWaterPressureWarningLow = MIN_INLET_PRES_OUT_TO_CLEAR_WARINING_PSIG; +// +// isPressureTooLow = ( PressureOut < maxInletWaterPressureWarningLow ? TRUE : FALSE ); +// isPressureTooHigh = ( PressureOut > MAX_INLET_WATER_PRES_OUT_WARNING_HIGH_PSIG ? TRUE : FALSE ); +// +// if ( TRUE == isAlarmActive( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_LOW_RANGE ) ) +// { +// isPressureTooLow = ( PressureOut >= minInletWaterPressureWarningLow ? FALSE : TRUE ); +// } +// checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_LOW_RANGE, isPressureTooLow, PressureOut, maxInletWaterPressureWarningLow ); +// +// if ( TRUE == isAlarmActive( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_HIGH_RANGE ) ) +// { +// isPressureTooHigh = ( PressureOut <= MIN_INLET_WATER_PRES_OUT_WARNING_HIGH_PSIG ? FALSE : TRUE ); +// } +// checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_HIGH_RANGE, isPressureTooHigh, PressureOut, MAX_INLET_WATER_PRES_OUT_WARNING_HIGH_PSIG ); +// } +// else +// { +// // VWI is closed - clear all alarms +// checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_LOW_RANGE, FALSE, PressureOut, MIN_INLET_WATER_PRES_OUT_WARNING_LOW_PSIG ); +// checkPersistentAlarm( ALARM_ID_DD_INLET_WATER_PRESSURE_OUT_HIGH_RANGE, FALSE, PressureOut, MAX_INLET_WATER_PRES_OUT_WARNING_HIGH_PSIG ); +// } +//} /*********************************************************************//** * @brief @@ -322,13 +326,13 @@ break; default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PRESSURE_INVALID_EXEC_STATE, pressuresState ) - pressuresState = PRESSURE_INIT_STATE; +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_PRESSURE_INVALID_EXEC_STATE, pressuresState ) +// pressuresState = PRESSURE_INIT_STATE; break; } // publish pressure/occlusion data on interval - publishPressuresData(); +// publishPressuresData(); } /*********************************************************************//** @@ -339,27 +343,27 @@ * @details \b Outputs: filteredPressureReadings,filteredcurrentPressureReadings * @return none *************************************************************************/ -static void filterPressureSensorReadings( void ) -{ - U32 i; +//static void filterPressureSensorReadings( void ) +//{ +// U32 i; +// +// for ( i = (U32)PRESSURE_SENSOR_FIRST; i < (U32)NUM_OF_PRESSURE_SENSORS; i++ ) +// { +// F32 pressureinmmHG = getPressure( (PRESSURE_SENSORS_T)i ); +// F32 pressure = getConvertedPressure( (PRESSURE_SENSORS_T)i, pressureinmmHG ); +// +// if ( filteredPressureReadings[i].pressureReadingsCount >= SIZE_OF_PRESSURE_ROLLING_AVG ) +// { +// filteredPressureReadings[i].pressureReadingsTotal -= filteredPressureReadings[i].pressureReadings[ filteredPressureReadings[i].pressureReadingsIdx ]; +// } +// filteredPressureReadings[i].pressureReadings[ filteredPressureReadings[i].pressureReadingsIdx ] = pressure; +// filteredPressureReadings[i].pressureReadingsTotal += pressure; +// filteredPressureReadings[i].pressureReadingsIdx = INC_WRAP( filteredPressureReadings[i].pressureReadingsIdx, 0, SIZE_OF_PRESSURE_ROLLING_AVG - 1 ); +// filteredPressureReadings[i].pressureReadingsCount = INC_CAP( filteredPressureReadings[i].pressureReadingsCount, SIZE_OF_PRESSURE_ROLLING_AVG ); +// filteredcurrentPressureReadings[i].data = filteredPressureReadings[i].pressureReadingsTotal / (F32)filteredPressureReadings[i].pressureReadingsCount; +// } +//} - for ( i = (U32)PRESSURE_SENSOR_FIRST; i < (U32)NUM_OF_PRESSURE_SENSORS; i++ ) - { - F32 pressureinmmHG = getPressure( (PRESSURE_SENSORS_T)i ); - F32 pressure = getConvertedPressure( (PRESSURE_SENSORS_T)i, pressureinmmHG ); - - if ( filteredPressureReadings[i].pressureReadingsCount >= SIZE_OF_PRESSURE_ROLLING_AVG ) - { - filteredPressureReadings[i].pressureReadingsTotal -= filteredPressureReadings[i].pressureReadings[ filteredPressureReadings[i].pressureReadingsIdx ]; - } - filteredPressureReadings[i].pressureReadings[ filteredPressureReadings[i].pressureReadingsIdx ] = pressure; - filteredPressureReadings[i].pressureReadingsTotal += pressure; - filteredPressureReadings[i].pressureReadingsIdx = INC_WRAP( filteredPressureReadings[i].pressureReadingsIdx, 0, SIZE_OF_PRESSURE_ROLLING_AVG - 1 ); - filteredPressureReadings[i].pressureReadingsCount = INC_CAP( filteredPressureReadings[i].pressureReadingsCount, SIZE_OF_PRESSURE_ROLLING_AVG ); - filteredcurrentPressureReadings[i].data = filteredPressureReadings[i].pressureReadingsTotal / (F32)filteredPressureReadings[i].pressureReadingsCount; - } -} - /*********************************************************************//** * @brief * The filterPressureSensorTemperatureReadings function filters the pressure sensor @@ -368,26 +372,26 @@ * @details \b Outputs: filteredPressureTempReadings,filteredcurrentPresTempReadings * @return none *************************************************************************/ -static void filterPressureSensorTemperatureReadings( void ) -{ - U32 i; +//static void filterPressureSensorTemperatureReadings( void ) +//{ +// U32 i; +// +// for ( i = (U32)PRESSURE_SENSOR_FIRST; i < (U32)NUM_OF_PRESSURE_SENSORS; i++ ) +// { +// F32 pressureTemperature = getPressureSensorTemperature( (PRESSURE_SENSORS_T)i ); +// +// if ( filteredPressureTempReadings[i].pressureTempReadingsCount >= SIZE_OF_PRESSURETEMP_ROLLING_AVG ) +// { +// filteredPressureTempReadings[i].pressureTempReadingsTotal -= filteredPressureTempReadings[i].pressureTempReadings[ filteredPressureTempReadings[i].pressureTempReadingsIdx ]; +// } +// filteredPressureTempReadings[i].pressureTempReadings[ filteredPressureTempReadings[i].pressureTempReadingsIdx ] = pressureTemperature; +// filteredPressureTempReadings[i].pressureTempReadingsTotal += pressureTemperature; +// filteredPressureTempReadings[i].pressureTempReadingsIdx = INC_WRAP( filteredPressureTempReadings[i].pressureTempReadingsIdx, 0, SIZE_OF_PRESSURETEMP_ROLLING_AVG - 1 ); +// filteredPressureTempReadings[i].pressureTempReadingsCount = INC_CAP( filteredPressureTempReadings[i].pressureTempReadingsCount, SIZE_OF_PRESSURETEMP_ROLLING_AVG ); +// filteredcurrentPresTempReadings[i].data = filteredPressureTempReadings[i].pressureTempReadingsTotal / (F32)filteredPressureTempReadings[i].pressureTempReadingsCount; +// } +//} - for ( i = (U32)PRESSURE_SENSOR_FIRST; i < (U32)NUM_OF_PRESSURE_SENSORS; i++ ) - { - F32 pressureTemperature = getPressureSensorTemperature( (PRESSURE_SENSORS_T)i ); - - if ( filteredPressureTempReadings[i].pressureTempReadingsCount >= SIZE_OF_PRESSURETEMP_ROLLING_AVG ) - { - filteredPressureTempReadings[i].pressureTempReadingsTotal -= filteredPressureTempReadings[i].pressureTempReadings[ filteredPressureTempReadings[i].pressureTempReadingsIdx ]; - } - filteredPressureTempReadings[i].pressureTempReadings[ filteredPressureTempReadings[i].pressureTempReadingsIdx ] = pressureTemperature; - filteredPressureTempReadings[i].pressureTempReadingsTotal += pressureTemperature; - filteredPressureTempReadings[i].pressureTempReadingsIdx = INC_WRAP( filteredPressureTempReadings[i].pressureTempReadingsIdx, 0, SIZE_OF_PRESSURETEMP_ROLLING_AVG - 1 ); - filteredPressureTempReadings[i].pressureTempReadingsCount = INC_CAP( filteredPressureTempReadings[i].pressureTempReadingsCount, SIZE_OF_PRESSURETEMP_ROLLING_AVG ); - filteredcurrentPresTempReadings[i].data = filteredPressureTempReadings[i].pressureTempReadingsTotal / (F32)filteredPressureTempReadings[i].pressureTempReadingsCount; - } -} - /*********************************************************************//** * @brief * The getConvertedPressure function converts the pressure in PSI unit and @@ -398,17 +402,17 @@ * @param pressure pressure (mmHG) to be converted in PSI * @return converted pressure in PSI. *************************************************************************/ -static F32 getConvertedPressure( PRESSURE_SENSORS_T sensor, F32 pressure ) -{ - F32 baroPressurePSI = getPressure( PRESSURE_SENSOR_BAROMETRIC ) * MMHG_TO_PSI_CONVERSION; - F32 pressurePSI = pressure * MMHG_TO_PSI_CONVERSION; +//static F32 getConvertedPressure( PRESSURE_SENSORS_T sensor, F32 pressure ) +//{ +// F32 baroPressurePSI = getPressure( PRESSURE_SENSOR_BAROMETRIC ) * MMHG_TO_PSI_CONVERSION; +// F32 pressurePSI = pressure * MMHG_TO_PSI_CONVERSION; +// +// // calibrated pressure +// //F32 calPressure = getCalibrationAppliedPressure( sensor, pressurePSI ); +// +// return pressurePSI; +//} - // calibrated pressure - //F32 calPressure = getCalibrationAppliedPressure( sensor, pressurePSI ); - - return pressurePSI; -} - /*********************************************************************//** * @brief * The getCalibrationAppliedPressure function applies the calibration values @@ -454,50 +458,42 @@ { PRESSURE_STATE_T result = PRESSURE_CONTINUOUS_READ_STATE; - //Get raw pressure value - readPressureSensors(); - // filter pressure readings - filterPressureSensors(); +// //Get raw pressure value +// readPressureSensors(); +// // filter pressure readings +// filterPressureSensors(); return result; } /*********************************************************************//** * @brief - * The publishPressuresData function publishes DD pressures data at a set interval. + * The publishPressuresData function publishes RO pressures data at a set interval. * @details \b Inputs: pressuresDataPublicationTimerCounter * @details \b Outputs: pressuresDataPublicationTimerCounter - * @details \b Message \b Sent: MSG_ID_DD_PRESSURES_DATA to publish pressure data. + * @details \b Message \b Sent: MSG_ID_RO_PRESSURES_DATA to publish pressure data. * @return none *************************************************************************/ -static void publishPressuresData( void ) -{ - // publish pressure/occlusion data on interval - if ( ++pressuresDataPublicationTimerCounter >= getU32OverrideValue( &pressuresDataPublishInterval ) ) - { - PRESSURE_TEMP_DATA_T data; - - data.filteredWaterInletInputPressure = getFilteredPressure( PRESSURE_SENSOR_WATER_INLET_INPUT ); - data.filteredWaterInletOutputPressure = getFilteredPressure( PRESSURE_SENSOR_WATER_INLET_OUTPUT ); - data.filteredHydraulicsOutletPressure = getFilteredPressure( PRESSURE_SENSOR_HYDRAULICS_OUTLET ); - data.filteredBibagPressure = getFilteredPressure( PRESSURE_SENSOR_BIBAG ); - data.filteredSpentdialysatePressure = getFilteredPressure( PRESSURE_SENSOR_SPENT_DIALYSATE ); - data.filteredFreshdialysatePressure = getFilteredPressure( PRESSURE_SENSOR_FRESH_DIALYSATE ); - data.filteredTransmembranePressure = getFilteredPressure( PRESSURE_SENSOR_TRANSMEMBRANE ); - data.filteredWaterInletInputTemp = getFilteredPressureSensorTemperature( PRESSURE_SENSOR_WATER_INLET_INPUT ); - data.filteredWaterInletOutputTemp = getFilteredPressureSensorTemperature( PRESSURE_SENSOR_WATER_INLET_OUTPUT ); - data.filteredHydraulicsOutletTemp = getFilteredPressureSensorTemperature( PRESSURE_SENSOR_HYDRAULICS_OUTLET ); - data.filteredBibagTemp = getFilteredPressureSensorTemperature( PRESSURE_SENSOR_BIBAG ); - data.filteredSpentdialysateTemp = getFilteredPressureSensorTemperature( PRESSURE_SENSOR_SPENT_DIALYSATE ); - data.filteredFreshdialysateTemp = getFilteredPressureSensorTemperature( PRESSURE_SENSOR_FRESH_DIALYSATE ); - data.filteredTransmembraneTemp = getFilteredPressureSensorTemperature( PRESSURE_SENSOR_TRANSMEMBRANE ); - pressuresDataPublicationTimerCounter = 0; +//static void publishPressuresData( void ) +//{ +// // publish pressure/occlusion data on interval +// if ( ++pressuresDataPublicationTimerCounter >= getU32OverrideValue( &pressuresDataPublishInterval ) ) +// { +// PRESSURE_TEMP_DATA_T data; +// +// data.filteredWaterInletInputPressure = getFilteredPressure( PRESSURE_SENSOR_WATER_INLET_INPUT ); +// data.filteredWaterInletOutputPressure = getFilteredPressure( PRESSURE_SENSOR_WATER_INLET_OUTPUT ); +// data.filteredWaterOutletPressure = getFilteredPressure( PRESSURE_SENSOR_WATER_OUTLET ); +// data.filteredWaterInletInputTemp = getFilteredPressureSensorTemperature( PRESSURE_SENSOR_WATER_INLET_INPUT ); +// data.filteredWaterInletOutputTemp = getFilteredPressureSensorTemperature( PRESSURE_SENSOR_WATER_INLET_OUTPUT ); +// data.filteredWaterOutletTemp = getFilteredPressureSensorTemperature( PRESSURE_SENSOR_WATER_OUTLET ); +// pressuresDataPublicationTimerCounter = 0; +// +// broadcastData( MSG_ID_RO_PRESSURES_DATA, COMM_BUFFER_OUT_CAN_RO_BROADCAST, (U08*)&data, sizeof( PRESSURE_TEMP_DATA_T ) ); +// } +//} - broadcastData( MSG_ID_DD_PRESSURES_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( PRESSURE_TEMP_DATA_T ) ); - } -} - /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ @@ -513,13 +509,13 @@ * that override valves states publish interval with (in ms) * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testPressureSensorDataPublishIntervalOverride( MESSAGE_T *message ) -{ - BOOL result = u32BroadcastIntervalOverride( message, &pressuresDataPublishInterval, TASK_PRIORITY_INTERVAL ); +//BOOL testPressureSensorDataPublishIntervalOverride( MESSAGE_T *message ) +//{ +// BOOL result = u32BroadcastIntervalOverride( message, &pressuresDataPublishInterval, TASK_PRIORITY_INTERVAL ); +// +// return result; +//} - return result; -} - /*********************************************************************//** * @brief * The testPressureSensorFilteredReadingsOverride function overrides the @@ -530,13 +526,13 @@ * ID and override value of the pressure sensor. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testPressureSensorFilteredReadingsOverride( MESSAGE_T *message ) -{ - BOOL result = f32ArrayOverride( message, &filteredcurrentPressureReadings[0], NUM_OF_PRESSURE_SENSORS - 1 ); +//BOOL testPressureSensorFilteredReadingsOverride( MESSAGE_T *message ) +//{ +// BOOL result = f32ArrayOverride( message, &filteredcurrentPressureReadings[0], NUM_OF_PRESSURE_SENSORS - 1 ); +// +// return result; +//} - return result; -} - /*********************************************************************//** * @brief * The testPressureSensorFilteredTemperatureReadingsOverride function overrides the @@ -547,11 +543,11 @@ * ID and override value of the pressure sensor temperature. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testPressureSensorFilteredTemperatureReadingsOverride( MESSAGE_T *message ) -{ - BOOL result = f32ArrayOverride( message, &filteredcurrentPresTempReadings[0], NUM_OF_PRESSURE_SENSORS - 1 ); - - return result; -} +//BOOL testPressureSensorFilteredTemperatureReadingsOverride( MESSAGE_T *message ) +//{ +// BOOL result = f32ArrayOverride( message, &filteredcurrentPresTempReadings[0], NUM_OF_PRESSURE_SENSORS - 1 ); +// +// return result; +//} /**@}*/ Index: firmware/App/Monitors/Pressure.h =================================================================== diff -u -rc7dcb245c2378b1c96eeaa02f120f61dff598b11 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Monitors/Pressure.h (.../Pressure.h) (revision c7dcb245c2378b1c96eeaa02f120f61dff598b11) +++ firmware/App/Monitors/Pressure.h (.../Pressure.h) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -7,23 +7,23 @@ * * @file Pressure.h * -* @author (last) Vinayakam Mani -* @date (last) 04-Sep-2024 +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 * -* @author (original) Vinayakam Mani -* @date (original) 04-Sep-2024 +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 * ***************************************************************************/ #ifndef __PRESSURE_H__ #define __PRESSURE_H__ -#include "DDCommon.h" +#include "ROCommon.h" #include "PressureSensor.h" /** * @defgroup Pressure Pressure - * @brief Pressure sensors monitor module. Monitors the various DD pressure + * @brief Pressure sensors monitor unit. Monitors the various RO pressure * sensors. * * @addtogroup Pressure @@ -35,34 +35,26 @@ /// Pressure data struct. typedef struct { - F32 filteredWaterInletInputPressure; ///< Water Inlet Input pressure - F32 filteredWaterInletOutputPressure; ///< Water Inlet Output pressure - F32 filteredHydraulicsOutletPressure; ///< Hydraulics outlet pressure - F32 filteredBibagPressure; ///< Bicarb bag pressure - F32 filteredSpentdialysatePressure; ///< Spent Dialysate pressure - F32 filteredFreshdialysatePressure; ///< Fresh Dialysate pressure - F32 filteredTransmembranePressure; ///< Transmembrane pressure + F32 filteredWaterInletInputPressure; ///< Water Inlet Input pressure (P8 PC2o) + F32 filteredWaterInletOutputPressure; ///< Water Inlet Output pressure (P13 PPo) + F32 filteredWaterOutletPressure; ///< Water Outlet pressure (P17 PMp) F32 filteredWaterInletInputTemp; ///< Water Inlet Input temperature F32 filteredWaterInletOutputTemp; ///< Water Inlet Output temperature - F32 filteredHydraulicsOutletTemp; ///< Hydraulics outlet pressure temperature - F32 filteredBibagTemp; ///< Bicarb bag temperature - F32 filteredSpentdialysateTemp; ///< Spent Dialysate temperature - F32 filteredFreshdialysateTemp; ///< Fresh Dialysate temperature - F32 filteredTransmembraneTemp; ///< Transmembrane temperature + F32 filteredWaterOutletTemp; ///< Water Outlet temperature } PRESSURE_TEMP_DATA_T; // ********** public function prototypes ********** void initPressure( void ); void execPressureSensor( void ); -void checkInletWaterPressure( void ); - -F32 getFilteredPressure( PRESSURE_SENSORS_T sensor ); -F32 getFilteredPressureSensorTemperature( PRESSURE_SENSORS_T sensor ); - -BOOL testPressureSensorDataPublishIntervalOverride( MESSAGE_T *message ); -BOOL testPressureSensorFilteredReadingsOverride( MESSAGE_T *message ); -BOOL testPressureSensorFilteredTemperatureReadingsOverride( MESSAGE_T *message ); +//void checkInletWaterPressure( void ); +// +//F32 getFilteredPressure( PRESSURE_SENSORS_T sensor ); +//F32 getFilteredPressureSensorTemperature( PRESSURE_SENSORS_T sensor ); +// +//BOOL testPressureSensorDataPublishIntervalOverride( MESSAGE_T *message ); +//BOOL testPressureSensorFilteredReadingsOverride( MESSAGE_T *message ); +//BOOL testPressureSensorFilteredTemperatureReadingsOverride( MESSAGE_T *message ); /**@}*/ Index: firmware/App/Monitors/Temperature.c =================================================================== diff -u -rc7dcb245c2378b1c96eeaa02f120f61dff598b11 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Monitors/Temperature.c (.../Temperature.c) (revision c7dcb245c2378b1c96eeaa02f120f61dff598b11) +++ firmware/App/Monitors/Temperature.c (.../Temperature.c) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -7,11 +7,11 @@ * * @file Temperature.c * -* @author (last) Vinayakam Mani -* @date (last) 23-Sep-2024 +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 * -* @author (original) Vinayakam Mani -* @date (original) 23-Sep-2024 +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 * ***************************************************************************/ @@ -48,16 +48,14 @@ static TEMPSENSORS_EXEC_STATES_T tempSensorsExecState; ///< TemperatureSensor exec state. static U32 startTime; ///< star time to read FPGA values. - static U32 dataPublicationTimerCounter; ///< Temperature sensors data publish timer counter. -static OVERRIDE_U32_T tempSensorsPublishInterval = { TEMP_SENSORS_DATA_PUBLISH_INTERVAL, - TEMP_SENSORS_DATA_PUBLISH_INTERVAL, 0, 0 }; ///< Temperature sensors publish time interval override. +static OVERRIDE_U32_T tempSensorsPublishInterval; ///< Temperature sensors publish time interval override. // ********** private function prototypes ********** static TEMPSENSORS_EXEC_STATES_T handleExecStart( void ); static TEMPSENSORS_EXEC_STATES_T handleExecGetADCValues( void ); -static void publishTemperatureSensorsData( void ); +//static void publishTemperatureSensorsData( void ); /*********************************************************************//** * @brief @@ -72,6 +70,11 @@ tempSensorsExecState = TEMPSENSORS_EXEC_STATE_START; dataPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; + tempSensorsPublishInterval.data = TEMP_SENSORS_DATA_PUBLISH_INTERVAL; + tempSensorsPublishInterval.ovData = TEMP_SENSORS_DATA_PUBLISH_INTERVAL; + tempSensorsPublishInterval.ovInitData = 0; + tempSensorsPublishInterval.override = OVERRIDE_RESET; + // Initialize the temperature sensors initTemperatureSensors(); } @@ -84,26 +87,26 @@ * @details \b Outputs: none * @return tempSensorsSelfTestState which is the status of the self test *************************************************************************/ -SELF_TEST_STATUS_T execTemperatureSensorsSelfTest( void ) -{ - SELF_TEST_STATUS_T result = SELF_TEST_STATUS_IN_PROGRESS; +//SELF_TEST_STATUS_T execTemperatureSensorsSelfTest( void ) +//{ +// SELF_TEST_STATUS_T result = SELF_TEST_STATUS_IN_PROGRESS; +// +// //BOOL calStatus = getNVRecord2Driver( GET_CAL_TEMP_SENSORS, (U08*)&tempSensorCalRecord, sizeof( DD_TEMP_SENSORS_CAL_RECORD_T ), +// // NUM_OF_CAL_DATA_TEMP_SENSORS, ALARM_ID_DD_TEMPERATURE_SENSORS_INVALID_CAL_RECORD ); +// BOOL calStatus = TRUE; +// +// if ( TRUE == calStatus ) +// { +// result = SELF_TEST_STATUS_PASSED; +// } +// else +// { +// result = SELF_TEST_STATUS_FAILED; +// } +// +// return result; +//} - //BOOL calStatus = getNVRecord2Driver( GET_CAL_TEMP_SENSORS, (U08*)&tempSensorCalRecord, sizeof( DD_TEMP_SENSORS_CAL_RECORD_T ), - // NUM_OF_CAL_DATA_TEMP_SENSORS, ALARM_ID_DD_TEMPERATURE_SENSORS_INVALID_CAL_RECORD ); - BOOL calStatus = TRUE; - - if ( TRUE == calStatus ) - { - result = SELF_TEST_STATUS_PASSED; - } - else - { - result = SELF_TEST_STATUS_FAILED; - } - - return result; -} - /*********************************************************************//** * @brief * The execTemperatureSensors function executes the temperature sensors' @@ -135,16 +138,16 @@ break; default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_TEMPERATURE_SENSORS_EXEC_INVALID_STATE, tempSensorsExecState ); - tempSensorsExecState = TEMPSENSORS_EXEC_STATE_GET_ADC_VALUES; +// SET_ALARM_WITH_2_U32_DATA( ALARM_ID_DD_SOFTWARE_FAULT, SW_FAULT_ID_TEMPERATURE_SENSORS_EXEC_INVALID_STATE, tempSensorsExecState ); +// tempSensorsExecState = TEMPSENSORS_EXEC_STATE_GET_ADC_VALUES; break; } // Monitor the temperature values monitorTemperatureSenors(); // Publish the data - publishTemperatureSensorsData(); +// publishTemperatureSensorsData(); } /*********************************************************************//** @@ -159,17 +162,17 @@ { TEMPSENSORS_EXEC_STATES_T state = TEMPSENSORS_EXEC_STATE_START; - if ( 0 == startTime ) - { - startTime = getMSTimerCount(); - } - // A delay to let FPGA to boot up - else if ( TRUE == didTimeout( startTime, ADC_FPGA_READ_DELAY ) ) - { - startTime = 0; - setBaroSensorCoefficientReadStartTime(); - state = TEMPSENSORS_EXEC_STATE_GET_ADC_VALUES; - } +// if ( 0 == startTime ) +// { +// startTime = getMSTimerCount(); +// } +// // A delay to let FPGA to boot up +// else if ( TRUE == didTimeout( startTime, ADC_FPGA_READ_DELAY ) ) +// { +// startTime = 0; +// setBaroSensorCoefficientReadStartTime(); +// state = TEMPSENSORS_EXEC_STATE_GET_ADC_VALUES; +// } return state; } @@ -201,25 +204,25 @@ * data in a periodic interval. * @return none *************************************************************************/ -static void publishTemperatureSensorsData( void ) -{ - if ( ++dataPublicationTimerCounter >= getU32OverrideValue( &tempSensorsPublishInterval ) ) - { - TEMPERATURE_SENSORS_DATA_T data; +//static void publishTemperatureSensorsData( void ) +//{ +// if ( ++dataPublicationTimerCounter >= getU32OverrideValue( &tempSensorsPublishInterval ) ) +// { +// TEMPERATURE_SENSORS_DATA_T data; +// +// data.inletHeatExchanger = getTemperatureValue( TEMPSENSORS_INLET_HEAT_EXCHANGER ); +// data.outletHeatExchanger = getTemperatureValue( TEMPSENSORS_OUTLET_HEAT_EXCHANGER ); +// data.hydraulicsPrimaryHeater = getTemperatureValue( TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ); +// data.trimmerHeater = getTemperatureValue( TEMPSENSORS_TRIMMER_HEATER ); +// data.boardTemp = getTemperatureValue( TEMPSENSORS_BOARD_TEMPERATURE ); +// data.baroTempSensor = getTemperatureValue( TEMPSENSORS_BAROMETRIC_TEMP_SENSOR ); +// +// broadcastData( MSG_ID_DD_TEMPERATURE_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( TEMPERATURE_SENSORS_DATA_T ) ); +// dataPublicationTimerCounter = 0; +// } +//} - data.inletHeatExchanger = getTemperatureValue( TEMPSENSORS_INLET_HEAT_EXCHANGER ); - data.outletHeatExchanger = getTemperatureValue( TEMPSENSORS_OUTLET_HEAT_EXCHANGER ); - data.hydraulicsPrimaryHeater = getTemperatureValue( TEMPSENSORS_HYDRAULICS_PRIMARY_HEATER ); - data.trimmerHeater = getTemperatureValue( TEMPSENSORS_TRIMMER_HEATER ); - data.boardTemp = getTemperatureValue( TEMPSENSORS_BOARD_TEMPERATURE ); - data.baroTempSensor = getTemperatureValue( TEMPSENSORS_BAROMETRIC_TEMP_SENSOR ); - broadcastData( MSG_ID_DD_TEMPERATURE_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( TEMPERATURE_SENSORS_DATA_T ) ); - dataPublicationTimerCounter = 0; - } -} - - /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ @@ -235,12 +238,12 @@ * (in ms) to override the temperature sensor data broadcast interval to. * @return TRUE if override successful, FALSE if not *************************************************************************/ -BOOL testTemperatureSensorsDataPublishIntervalOverride( MESSAGE_T *message ) -{ - BOOL result = u32BroadcastIntervalOverride( message, &tempSensorsPublishInterval, TASK_PRIORITY_INTERVAL ); +//BOOL testTemperatureSensorsDataPublishIntervalOverride( MESSAGE_T *message ) +//{ +// BOOL result = u32BroadcastIntervalOverride( message, &tempSensorsPublishInterval, TASK_PRIORITY_INTERVAL ); +// +// return result; +//} - return result; -} - /**@}*/ Index: firmware/App/Monitors/Temperature.h =================================================================== diff -u -rc7dcb245c2378b1c96eeaa02f120f61dff598b11 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Monitors/Temperature.h (.../Temperature.h) (revision c7dcb245c2378b1c96eeaa02f120f61dff598b11) +++ firmware/App/Monitors/Temperature.h (.../Temperature.h) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -7,23 +7,24 @@ * * @file Temperature.h * -* @author (last) Vinayakam Mani -* @date (last) 23-Sep-2024 +* @author (last) Sean Nash +* @date (last) 09-Nov-2024 * -* @author (original) Vinayakam Mani -* @date (original) 23-Sep-2024 +* @author (original) Sean Nash +* @date (original) 09-Nov-2024 * ***************************************************************************/ #ifndef __TEMPERATURE_H__ #define __TEMPERATURE_H__ -#include "DDCommon.h" +#include "ROCommon.h" #include "TemperatureSensors.h" /** * @defgroup Temperature Temperature - * @brief Temperature Monitor unit. Reads and processes the temperature sensors. + * @brief Temperature Monitor unit. monitors the temperature sensors + * for the RO sub-system. * * @addtogroup Temperature * @{ @@ -34,22 +35,22 @@ /// Temperature sensors data structure. typedef struct { - F32 inletHeatExchanger; ///< Inlet heat exchanger temperature sensor - F32 outletHeatExchanger; ///< Outlet heat exchanger temperature sensor - F32 hydraulicsPrimaryHeater; ///< Hydraulics primary heater temperature sensor - F32 trimmerHeater; ///< Trimmer heater temperature sensor - F32 boardTemp; ///< Board temperature sensor - F32 baroTempSensor; ///< Barometric temperature sensor + F32 inletTemp; ///< Inlet temperature sensor (P10 TPi) + F32 outCondTemp; ///< Outlet conductivity sensor (P19 TPo) + F32 inHeaterTemp; ///< Inlet heater temperature sensor (P22 TRO2) + F32 outHeaterTemp; ///< Outlet heater temperature sensor (P23 TRO1) + F32 boardTemp; ///< Board temperature sensor +// F32 baroTempSensor; ///< Barometric temperature sensor } TEMPERATURE_SENSORS_DATA_T; // ********** public function prototypes ********** void initTemperature( void ); -SELF_TEST_STATUS_T execTemperatureSensorsSelfTest( void ); void execTemperatureSensors( void ); +//SELF_TEST_STATUS_T execTemperatureSensorsSelfTest( void ); -BOOL testTemperatureSensorsDataPublishIntervalOverride( MESSAGE_T *message ); +//BOOL testTemperatureSensorsDataPublishIntervalOverride( MESSAGE_T *message ); /**@}*/ Index: firmware/App/Services/AlarmMgmtSWFaults.h =================================================================== diff -u -r129a1c2f4343bc85efdb4767c2dec35e4ba8ce98 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Services/AlarmMgmtSWFaults.h (.../AlarmMgmtSWFaults.h) (revision 129a1c2f4343bc85efdb4767c2dec35e4ba8ce98) +++ firmware/App/Services/AlarmMgmtSWFaults.h (.../AlarmMgmtSWFaults.h) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -15,103 +15,84 @@ { // TODO clean up SW_FAULT_ID_NONE = 0, - SW_FAULT_ID_ALARM_LAMP_INVALID_PATTERN_REQUESTED = 1, - SW_FAULT_ID_ALARM_LAMP_INVALID_SELF_TEST_STATE = 2, - SW_FAULT_ID_MODE_INIT_POST_INVALID_POST_STATE = 3, - SW_FAULT_ID_MODE_STANDBY_INVALID_STATE = 4, - SW_FAULT_ID_OP_MODES_ILLEGAL_MODE_TRANSITION_REQUESTED = 5, - SW_FAULT_ID_OP_MODES_INVALID_MODE_STATE = 6, - SW_FAULT_ID_OP_MODES_INVALID_MODE_REQUESTED = 7, - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_ACTIVATE = 8, // TODO stay - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_CLEAR = 9, // TODO stay - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_ACTIVATE1 = 10, - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_ACTIVATE2 = 11, - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_CLEAR1 = 12, - SW_FAULT_ID_ALARM_MGMT_INVALID_USER_ACTION = 13, - SW_FAULT_ID_INVALID_ALARM_USER_ACTION1 = 14, - SW_FAULT_ID_INVALID_ALARM_USER_ACTION2 = 15, - SW_FAULT_ID_ALARM_MGMT_LAMP_INVALID_ALARM_STATE = 16, - SW_FAULT_ID_ALARM_MGMT_AUDIO_INVALID_ALARM_STATE = 17, - SW_FAULT_ID_ALARM_MGMT_INVALID_FIFO_TO_RESET = 18, - SW_FAULT_ID_HD_INVALID_ALARM_AUDIO_STATE = 19, - SW_FAULT_ID_COMM_BUFFERS_ADD_TOO_MUCH_DATA = 20, - SW_FAULT_ID_COMM_BUFFERS_ADD_INVALID_BUFFER = 21, - SW_FAULT_ID_COMM_BUFFERS_GET_INVALID_BUFFER = 22, - SW_FAULT_ID_COMM_BUFFERS_PEEK_INVALID_BUFFER = 23, - SW_FAULT_ID_COMM_BUFFERS_COUNT_INVALID_BUFFER = 24, - SW_FAULT_ID_INVALID_DD_OPERATING_MODE = 25, - SW_FAULT_ID_DD_INVALID_COMMAND_RESPONSE_ID = 26, - SW_FAULT_ID_FPGA_INVALID_ALARM_AUDIO_PARAM = 27, - SW_FAULT_ID_PHANTOM_INTERRUPT = 28, - SW_FAULT_ID_INVALID_RTI_NOTIFICATION = 29, - SW_FAULT_ID_CAN_PARITY_ERROR = 30, - SW_FAULT_ID_CAN_OFF_ERROR = 31, - SW_FAULT_ID_UNEXPECTED_DMA_INTERRUPT = 32, - SW_FAULT_ID_INTERRUPTS_INVALID_EDGE_DETECTED = 33, - SW_FAULT_ID_MSG_PENDING_ACK_LIST_FULL = 34, - SW_FAULT_ID_MSG_QUEUES_ADD_QUEUE_FULL = 35, - SW_FAULT_ID_MSG_QUEUES_ADD_INVALID_QUEUE = 36, - SW_FAULT_ID_MSG_QUEUES_GET_INVALID_QUEUE = 37, - SW_FAULT_ID_MSG_QUEUES_IS_EMPTY_INVALID_QUEUE = 38, - SW_FAULT_ID_MSG_QUEUES_IS_FULL_INVALID_QUEUE = 39, - SW_FAULT_ID_ILLEGAL_MEM_ACCESS = 40, - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_ACTIVATE3 = 41, - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_CLEAR2 = 42, - SW_FAULT_ID_INVALID_ALARM_ID_REFERENCED1 = 43, - SW_FAULT_ID_INVALID_ALARM_ID_REFERENCED2 = 44, - SW_FAULT_ID_FPGA_INVALID_STATE = 45, - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_GET_PROPS = 46, - SW_FAULT_ID_FPGA_WRITE_CMD_TOO_MUCH_DATA = 47, - SW_FAULT_ID_FPGA_WRITE_RSP_TOO_MUCH_DATA = 48, - SW_FAULT_ID_FPGA_READ_CMD_TOO_MUCH_DATA = 49, - SW_FAULT_ID_FPGA_READ_RSP_TOO_MUCH_DATA = 50, - SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX1 = 51, - SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX2 = 52, - SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX3 = 53, - SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED1 = 54, - SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED2 = 55, - SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED3 = 56, - SW_FAULT_ID_INVALID_CAN_MESSAGE_BOX = 57, - SW_FAULT_ID_SYSTEM_CMMM_CAN_TRANSMIT_REJECTED = 58, - SW_FAULT_ID_SYSTEM_COMM_INVALID_FRAME_SIZE = 59, - SW_FAULT_ID_UTIL_INVALID_WIN_MAX_COUNT = 60, - SW_FAULT_ID_UTIL_INVALID_WIN_COUNT = 61, - SW_FAULT_ID_UTIL_TIME_WINDOWED_COUNT_ERROR = 62, - SW_FAULT_ID_SEMAPHORE_IN_USE_TIMEOUT = 63, - SW_FAULT_ID_WATCHDOG_INVALID_SELF_TEST_STATE = 64, - SW_FAULT_ID_WATCHDOG_INVALID_TASK = 65, - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_FOR_START_TIME = 66, - SW_FAULT_ID_INT_ADC_DATA_OVERRUN = 67, - SW_FAULT_ID_INT_ADC_INVALID_CHANNEL_REQUESTED1 = 68, - SW_FAULT_ID_INT_ADC_INVALID_CHANNEL_REQUESTED2 = 69, - SW_FAULT_ID_SAFETY_SHUTDOWN_INVALID_SELF_TEST_STATE = 70, - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_GET_RANK = 71, - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_CLEAR_COND = 72, - SW_FAULT_ID_INVALID_ALARM_ID_REFERENCED3 = 73, - SW_FAULT_ID_SYSTEM_COMM_INVALID_BUFFER_INDEX1 = 74, - SW_FAULT_ID_SYSTEM_COMM_INVALID_BUFFER_INDEX2 = 75, - SW_FAULT_ID_BUBBLE_DETECTOR_INVALID_SENSOR = 76, - SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR1 = 77, - SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR2 = 78, - SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR3 = 79, - SW_FAULT_ID_PRESSURE_SENSOR_INVALID_SENSOR4 = 80, - SW_FAULT_ID_VOLTAGES_INVALID_STATE = 81, - SW_FAULT_ID_VOLTAGES_INVALID_SIGNAL = 82, - SW_FAULT_ID_BUBBLES_INVALID_STATE = 83, - SW_FAULT_ID_BUBBLES_INVALID_SENSOR_ID1 = 84, - SW_FAULT_ID_BUBBLES_INVALID_SENSOR_ID2 = 85, - SW_FAULT_ID_AIR_PUMP_INVALID_MOTOR_STATE_SELECTED = 86, - SW_FAULT_ID_TD_AIR_PUMP_INVALID_STATE1 = 87, - SW_FAULT_ID_TD_AIR_PUMP_INVALID_STATE2 = 88, - SW_FAULT_ID_TD_INVALID_SWITCH_ID = 89, - SW_FAULT_ID_BUTTONS_INVALID_SELF_TEST_STATE = 90, - SW_FAULT_ID_BUTTONS_STOP_BUTTON_NOT_CONSUMED = 91, - SW_FAULT_ID_PRES_OCCL_INVALID_STATE = 92, - SW_FAULT_ID_PRES_LIMITS_INVALID_STATE = 93, - SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_ID = 94, - SW_FAULT_ID_PI_CTRL_INVALID_SIGNAL = 95, - SW_FAULT_ID_PI_CTRL_INVALID_CONTROLLER = 96, - SW_FAULT_ID_PI_CTRL_INVALID_STEP_LIMIT = 97, + SW_FAULT_ID_MODE_INIT_POST_INVALID_POST_STATE = 1, + SW_FAULT_ID_MODE_STANDBY_INVALID_STATE = 2, + SW_FAULT_ID_OP_MODES_ILLEGAL_MODE_TRANSITION_REQUESTED = 3, + SW_FAULT_ID_OP_MODES_INVALID_MODE_STATE = 4, + SW_FAULT_ID_OP_MODES_INVALID_MODE_REQUESTED = 5, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_ACTIVATE = 6, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_CLEAR = 7, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_ACTIVATE1 = 8, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_ACTIVATE2 = 9, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_CLEAR1 = 10, + SW_FAULT_ID_ALARM_MGMT_INVALID_FIFO_TO_RESET = 11, + SW_FAULT_ID_COMM_BUFFERS_ADD_TOO_MUCH_DATA = 12, + SW_FAULT_ID_COMM_BUFFERS_ADD_INVALID_BUFFER = 13, + SW_FAULT_ID_COMM_BUFFERS_GET_INVALID_BUFFER = 14, + SW_FAULT_ID_COMM_BUFFERS_PEEK_INVALID_BUFFER = 15, + SW_FAULT_ID_COMM_BUFFERS_COUNT_INVALID_BUFFER = 16, + SW_FAULT_ID_INVALID_RO_OPERATING_MODE = 17, + SW_FAULT_ID_PHANTOM_INTERRUPT = 18, + SW_FAULT_ID_INVALID_RTI_NOTIFICATION = 19, + SW_FAULT_ID_CAN_PARITY_ERROR = 20, + SW_FAULT_ID_CAN_OFF_ERROR = 21, + SW_FAULT_ID_UNEXPECTED_DMA_INTERRUPT = 22, + SW_FAULT_ID_MSG_PENDING_ACK_LIST_FULL = 23, + SW_FAULT_ID_MSG_QUEUES_ADD_QUEUE_FULL = 24, + SW_FAULT_ID_MSG_QUEUES_ADD_INVALID_QUEUE = 25, + SW_FAULT_ID_MSG_QUEUES_GET_INVALID_QUEUE = 26, + SW_FAULT_ID_MSG_QUEUES_IS_EMPTY_INVALID_QUEUE = 27, + SW_FAULT_ID_MSG_QUEUES_IS_FULL_INVALID_QUEUE = 28, + SW_FAULT_ID_ILLEGAL_MEM_ACCESS = 29, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_ACTIVATE3 = 30, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_CLEAR2 = 31, + SW_FAULT_ID_INVALID_ALARM_ID_REFERENCED1 = 32, + SW_FAULT_ID_INVALID_ALARM_ID_REFERENCED2 = 33, + SW_FAULT_ID_FPGA_INVALID_STATE = 34, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_GET_PROPS = 35, + SW_FAULT_ID_FPGA_WRITE_CMD_TOO_MUCH_DATA = 36, + SW_FAULT_ID_FPGA_WRITE_RSP_TOO_MUCH_DATA = 37, + SW_FAULT_ID_FPGA_READ_CMD_TOO_MUCH_DATA = 38, + SW_FAULT_ID_FPGA_READ_RSP_TOO_MUCH_DATA = 39, + SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX1 = 40, + SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX2 = 41, + SW_FAULT_ID_PERSISTENT_ALARM_INVALID_INDEX3 = 42, + SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED1 = 43, + SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED2 = 44, + SW_FAULT_ID_INVALID_FPGA_SENSOR_GROUP_SELECTED3 = 45, + SW_FAULT_ID_INVALID_CAN_MESSAGE_BOX = 46, + SW_FAULT_ID_SYSTEM_CMMM_CAN_TRANSMIT_REJECTED = 47, + SW_FAULT_ID_SYSTEM_COMM_INVALID_FRAME_SIZE = 48, + SW_FAULT_ID_UTIL_INVALID_WIN_MAX_COUNT = 49, + SW_FAULT_ID_UTIL_INVALID_WIN_COUNT = 50, + SW_FAULT_ID_UTIL_TIME_WINDOWED_COUNT_ERROR = 51, + SW_FAULT_ID_SEMAPHORE_IN_USE_TIMEOUT = 52, + SW_FAULT_ID_WATCHDOG_INVALID_SELF_TEST_STATE = 53, + SW_FAULT_ID_WATCHDOG_INVALID_TASK = 54, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_FOR_START_TIME = 55, + SW_FAULT_ID_INT_ADC_DATA_OVERRUN = 56, + SW_FAULT_ID_INT_ADC_INVALID_CHANNEL_REQUESTED1 = 57, + SW_FAULT_ID_INT_ADC_INVALID_CHANNEL_REQUESTED2 = 58, + SW_FAULT_ID_SAFETY_SHUTDOWN_INVALID_SELF_TEST_STATE = 59, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_GET_RANK = 60, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_TO_CLEAR_COND = 61, + SW_FAULT_ID_INVALID_ALARM_ID_REFERENCED3 = 62, + SW_FAULT_ID_SYSTEM_COMM_INVALID_BUFFER_INDEX1 = 63, + SW_FAULT_ID_SYSTEM_COMM_INVALID_BUFFER_INDEX2 = 64, + SW_FAULT_ID_VOLTAGES_INVALID_STATE = 65, + SW_FAULT_ID_VOLTAGES_INVALID_SIGNAL = 66, + SW_FAULT_ID_TD_INVALID_SWITCH_ID = 67, + SW_FAULT_ID_ALARM_MGMT_INVALID_ALARM_ID = 68, + SW_FAULT_ID_PI_CTRL_INVALID_SIGNAL = 69, + SW_FAULT_ID_PI_CTRL_INVALID_CONTROLLER = 70, + SW_FAULT_ID_PI_CTRL_INVALID_STEP_LIMIT = 71, + SW_FAULT_ID_VALVES_INVALID_VALVE_STATE_NAME = 72, + SW_FAULT_ID_VALVES_INVALID_VALVE_STATE1 = 73, + SW_FAULT_ID_VALVES_INVALID_VALVE_STATE2 = 74, + SW_FAULT_ID_VALVES_INVALID_VALVE_ID1 = 75, + SW_FAULT_ID_VALVES_INVALID_VALVE_ID2 = 76, + SW_FAULT_ID_VALVES_INVALID_VALVE_ID3 = 77, + SW_FAULT_ID_VALVES_INVALID_VALVE_ID4 = 78, NUM_OF_SW_FAULT_IDS } SW_FAULT_ID_T; Index: firmware/App/Services/Messaging.c =================================================================== diff -u -r8e7d30d231de616b58a765d98495ba34010781c8 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Services/Messaging.c (.../Messaging.c) (revision 8e7d30d231de616b58a765d98495ba34010781c8) +++ firmware/App/Services/Messaging.c (.../Messaging.c) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -7,6 +7,7 @@ #include "PAL.h" #include "SystemCommRO.h" #include "Utilities.h" +#include "Valves.h" /** @@ -48,12 +49,22 @@ /// Message handling function lookup table static const U16 MSG_FUNCTION_HANDLER_LOOKUP[] = { - MSG_ID_TESTER_LOGIN_REQUEST, + MSG_ID_RO_TESTER_LOGIN_REQUEST, + MSG_ID_RO_SOFTWARE_RESET_REQUEST, + MSG_ID_RO_SEND_TEST_CONFIGURATION, + MSG_ID_RO_VALVE_PUBLISH_INTERVAL_OVERRIDE_REQUEST, + MSG_ID_RO_VALVE_CMD_STATE_OVERRIDE_REQUEST, + MSG_ID_RO_VALVE_SENSED_STATE_OVERRIDE_REQUEST }; /// Message handling function table static const MsgFuncPtr MSG_FUNCTION_HANDLERS[] = { - &handleTesterLogInRequest + &handleTesterLogInRequest, + &handleROSoftwareResetRequest, + &handleROTestConfiguration, + &testValvesStatesPublishIntervalOverride, + &testValveStateOverride, + &testValveSensedStateOverride, }; #define NUM_OF_FUNCTION_HANDLERS (sizeof(MSG_FUNCTION_HANDLERS) / sizeof(MsgFuncPtr)) @@ -569,4 +580,22 @@ return result; } +/*********************************************************************//** + * @brief + * The handleROTestConfiguration function handles a request to set an RO test + * configuration flag. + * @details \b Inputs: none + * @details \b Outputs: message handled + * @param message a pointer to the set test configuration message to handle + * @return TRUE if test configuration flag set successfully, FALSE if not. + *************************************************************************/ +BOOL handleROTestConfiguration( MESSAGE_T *message ) +{ + BOOL result = FALSE; + + // TODO - implement. + + return result; +} + /**@}*/ Index: firmware/App/Services/Messaging.h =================================================================== diff -u -r8e7d30d231de616b58a765d98495ba34010781c8 -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Services/Messaging.h (.../Messaging.h) (revision 8e7d30d231de616b58a765d98495ba34010781c8) +++ firmware/App/Services/Messaging.h (.../Messaging.h) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -51,6 +51,7 @@ BOOL handleTesterLogInRequest( MESSAGE_T *message ); BOOL handleROSoftwareResetRequest( MESSAGE_T *message ); +BOOL handleROTestConfiguration( MESSAGE_T *message ); /**@}*/ Index: firmware/App/Tasks/TaskPriority.c =================================================================== diff -u -r533272e6ef2873fcfe7a41338a6c88c7a601605d -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/App/Tasks/TaskPriority.c (.../TaskPriority.c) (revision 533272e6ef2873fcfe7a41338a6c88c7a601605d) +++ firmware/App/Tasks/TaskPriority.c (.../TaskPriority.c) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -1,8 +1,12 @@ +#include "Conductivity.h" #include "FPGA.h" #include "InternalADC.h" +#include "Level.h" +#include "Pressure.h" #include "SystemCommRO.h" #include "TaskPriority.h" +#include "Valves.h" #include "WatchdogMgmt.h" /** @@ -29,12 +33,18 @@ // Monitor internal ADC channels execInternalADC(); - // Monitor air trap level sensors -// execAirTrapMonitor(); + // Monitor conductivity sensors + execConductivity(); - // Monitor blood pump and flow -// execBloodFlowMonitor(); + // Monitor levels + execLevels(); + // Monitor pressure sensors + execPressureSensor(); + + // Control valves + execValves(); + // 2nd pass for FPGA execFPGA( FALSE ); Index: firmware/source/sys_main.c =================================================================== diff -u -r533272e6ef2873fcfe7a41338a6c88c7a601605d -r2205857f59dd884c4af450239381387cfb560c2e --- firmware/source/sys_main.c (.../sys_main.c) (revision 533272e6ef2873fcfe7a41338a6c88c7a601605d) +++ firmware/source/sys_main.c (.../sys_main.c) (revision 2205857f59dd884c4af450239381387cfb560c2e) @@ -63,17 +63,20 @@ #include "AlarmMgmtRO.h" #include "CommBuffers.h" -#include "ROCommon.h" +#include "Conductivity.h" #include "FpgaRO.h" #include "Interrupts.h" +#include "Level.h" #include "MsgQueues.h" #include "OperationModes.h" -//#include "Pressure.h" +#include "Pressure.h" #include "SafetyShutdown.h" #include "SystemCommRO.h" #include "TaskBG.h" +#include "Temperature.h" #include "Timers.h" #include "Utilities.h" +#include "Valves.h" #include "WatchdogMgmt.h" static void initProcessor( void ); @@ -158,6 +161,11 @@ initCommBuffers(); initMsgQueues(); initSystemComm(); + initConductivity(); + initLevels(); + initPressure(); + initTemperature(); + initValves(); initOperationModes(); initTestConfigs(); }