/************************************************************************** * * 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) Vinayakam Mani * @date (last) 04-Sep-2024 * * @author (original) Vinayakam Mani * @date (original) 04-Sep-2024 * ***************************************************************************/ #include "AlarmMgmtDD.h" #include "FpgaDD.h" #include "Messaging.h" #include "PersistentAlarm.h" #include "PressureCommon.h" #include "PressureSensor.h" #include "TaskPriority.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 PRESSURES_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) ///< Interval (ms/task time) at which the pressures data is published on the CAN bus. #define DATA_PUBLISH_COUNTER_START_COUNT ( 5 ) ///< Data publish counter start count. #define SIZE_OF_PRESSURE_ROLLING_AVG ( ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) * 1 ) ///< Filtered pressure w/ 1 second moving average. #define SIZE_OF_PRESSURETEMP_ROLLING_AVG ( ( MS_PER_SECOND / TASK_PRIORITY_INTERVAL ) * 1 ) ///< Filtered pressure temprature w/ 1 second moving average. /// Defined states for the pressures monitor state machine. typedef enum PresMonitor_States { PRESSURE_INIT_STATE = 0, ///< Initialization state. PRESSURE_CONTINUOUS_READ_STATE, ///< Continuous read sensors state. NUM_OF_PRESSURE_STATES ///< Number of pressure monitor states. } PRESSURE_STATE_T; // ********** 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 OVERRIDE_F32_T filteredcurrentPressureReadings[ NUM_OF_PRESSURE_SENSORS ]; ///< filtered current pressure sensor pressure readings (overrideable). static OVERRIDE_F32_T filteredcurrentPresTempReadings[ NUM_OF_PRESSURE_SENSORS ]; ///< filtered current pressure sensor temperature readings (overrideable). /// Filter pressure reading. typedef struct { F32 pressureReadings[ SIZE_OF_PRESSURE_ROLLING_AVG ]; ///< Holds pressure sample rolling average. U32 pressureReadingsIdx; ///< Index for next sample in rolling average array. F32 pressureReadingsTotal; ///< Rolling total - used to calc average. U32 pressureReadingsCount; ///< Number of samples in rolling average buffer }FILTER_PRESSURE_READINGS_T; /// Filter pressuretemperature reading. typedef struct { F32 pressureTempReadings[ SIZE_OF_PRESSURETEMP_ROLLING_AVG ]; ///< Holds pressure temperature sample rolling average. U32 pressureTempReadingsIdx; ///< Index for next sample in rolling average array. F32 pressureTempReadingsTotal; ///< Rolling total - used to calc average. U32 pressureTempReadingsCount; ///< Number of samples in rolling average buffer }FILTER_PRESSURE_TEMPERATURE_READINGS_T; static FILTER_PRESSURE_READINGS_T filteredPressureReadings[NUM_OF_PRESSURE_SENSORS] = { 0 }; ///< Filtered pressure reading for pressure sensors. static FILTER_PRESSURE_TEMPERATURE_READINGS_T filteredPressureTempReadings[NUM_OF_PRESSURE_SENSORS] = { 0 }; ///< 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. // ********** private function prototypes ********** static void checkPressureSensors( void ); static void readPressureSensors( void ); static void filterPressureSensorReadings( void ); static void filterPressureSensorTemperatureReadings( void ); static PRESSURE_STATE_T handlePressuresInitState( void ); static PRESSURE_STATE_T handlePressuresContReadState( void ); static void publishPressuresData( void ); /*********************************************************************//** * @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; pressuresState = PRESSURE_INIT_STATE; pressuresDataPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; // 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; filteredcurrentPressureReadings[ i ].data = 0.0F; filteredcurrentPressureReadings[ i ].ovData = 0.0F; filteredcurrentPressureReadings[ i ].ovInitData = 0.0F; filteredcurrentPressureReadings[ i ].override = OVERRIDE_RESET; filteredcurrentPresTempReadings[ i ].data = 0.0F; filteredcurrentPresTempReadings[ i ].ovData = 0.0F; filteredcurrentPresTempReadings[ i ].ovInitData = 0.0F; filteredcurrentPresTempReadings[ i ].override = OVERRIDE_RESET; } // 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 ); } /*********************************************************************//** * @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 *************************************************************************/ static void readPressureSensors( void ) { // Update and convert raw pressures to mmHg 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() ); // Update and convert raw pressure sensor temperatures to deg C 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_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_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(); //Filter pressure sensor reading filterPressureSensorReadings(); //Filter pressure sensor temperature reading filterPressureSensorTemperatureReadings(); // Monitor pressure sensor health checkPressureSensors(); } /*********************************************************************//** * @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_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_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 getFilteredPressure function gets the filtered 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: filteredcurrentPressureReadings * @details \b Outputs: none * @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; 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 * 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 filtered current pressure sensor temperature (in deg C) of the given pressure sensor. *************************************************************************/ 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; } /*********************************************************************//** * @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 ) { U08 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 ) { U08 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; } /*********************************************************************//** * @brief * The execPressureSensor function executes the pressure monitor state machine * and publish pressure data. * @details \b Inputs: pressuresState * @details \b Outputs: pressuresState * @details \b Alarm: ALARM_ID_DD_SOFTWARE_FAULT if invalid pressure state seen * @return none *************************************************************************/ void execPressureSensor( void ) { // state machine switch ( pressuresState ) { case PRESSURE_INIT_STATE: pressuresState = handlePressuresInitState(); break; case PRESSURE_CONTINUOUS_READ_STATE: pressuresState = handlePressuresContReadState(); 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; break; } // publish pressure/occlusion data on interval publishPressuresData(); } /*********************************************************************//** * @brief * The filterPressureSensorReadings function filters the pressures for * defined interval to get average pressure reading. * @details \b Inputs: filteredPressureReadings,currentPressureReadings * @details \b Outputs: filteredPressureReadings,filteredcurrentPressureReadings * @return none *************************************************************************/ static void filterPressureSensorReadings( void ) { U32 i; for ( i = (U32)PRESSURE_SENSOR_FIRST; i < (U32)NUM_OF_PRESSURE_SENSORS; i++ ) { F32 pressure = getPressure( (PRESSURE_SENSORS_T)i ); 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 * temperature for defined interval to get average temperature reading. * @details \b Inputs: filteredPressureTempReadings,currentPresTempReadings * @details \b Outputs: filteredPressureTempReadings,filteredcurrentPresTempReadings * @return none *************************************************************************/ 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; } } /*********************************************************************//** * @brief * The handlePressuresInitState function handles the pressures initialize state * of the pressures monitor state machine. * @details \b Inputs: none * @details \b Outputs: none * @return next state *************************************************************************/ static PRESSURE_STATE_T handlePressuresInitState( void ) { return PRESSURE_CONTINUOUS_READ_STATE; } /*********************************************************************//** * @brief * The handlePressuresContReadState function handles the continuous read state * of the pressures monitor state machine. * @details \b Inputs: pressureFilterCounter * @details \b Outputs: pressure sensor values updated * @return next state *************************************************************************/ static PRESSURE_STATE_T handlePressuresContReadState( void ) { PRESSURE_STATE_T result = PRESSURE_CONTINUOUS_READ_STATE; readPressureSensors(); return result; } /*********************************************************************//** * @brief * The publishPressuresData function publishes DD 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. * @return none *************************************************************************/ static void publishPressuresData( void ) { // publish pressure/occlusion data on interval if ( ++pressuresDataPublicationTimerCounter >= getU32OverrideValue( &pressuresDataPublishInterval ) ) { PRESSURE_TEMP_DATA_T data; 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.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; broadcastData( MSG_ID_DD_PRESSURES_DATA, COMM_BUFFER_OUT_CAN_DD_BROADCAST, (U08*)&data, sizeof( PRESSURE_TEMP_DATA_T ) ); } } /************************************************************************* * TEST SUPPORT FUNCTIONS *************************************************************************/ /*********************************************************************//** * @brief * The testPressureSensnorDataPublishIntervalOverride function overrides the * pressure sensor data publish interval. * @details \b Inputs: none * @details \b Outputs: pressuresDataPublishInterval * @param message Override message from Dialin which includes the value * that override valves states publish interval with (in ms) * @return TRUE if override successful, FALSE if not *************************************************************************/ BOOL testPressureSensorDataPublishIntervalOverride( MESSAGE_T *message ) { BOOL result = FALSE; TEST_OVERRIDE_PAYLOAD_T override; OVERRIDE_TYPE_T ovType = getOverridePayloadFromMessage( message, &override ); // Verify tester has logged in with TD and override type is valid if ( ( TRUE == isTestingActivated() ) && ( ovType != OVERRIDE_INVALID ) && ( ovType < NUM_OF_OVERRIDE_TYPES ) ) { if ( OVERRIDE_OVERRIDE == ovType ) { U32 intvl = override.state.u32 / TASK_PRIORITY_INTERVAL; result = TRUE; pressuresDataPublishInterval.ovData = intvl; pressuresDataPublishInterval.override = OVERRIDE_KEY; } else { result = TRUE; pressuresDataPublishInterval.override = OVERRIDE_RESET; pressuresDataPublishInterval.ovData = pressuresDataPublishInterval.ovInitData; } } return result; } /*********************************************************************//** * @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 = FALSE; TEST_OVERRIDE_ARRAY_PAYLOAD_T override; OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &override ); // Verify tester has logged in with TD and override type is valid if ( ( TRUE == isTestingActivated() ) && ( ovType != OVERRIDE_INVALID ) && ( ovType < NUM_OF_OVERRIDE_TYPES ) ) { U32 sensor = override.index; // Verify bubble detector index of override if ( sensor < NUM_OF_PRESSURE_SENSORS ) { if ( OVERRIDE_OVERRIDE == ovType ) { F32 value = override.state.f32; currentPressureReadings[ sensor ].ovData = value; currentPressureReadings[ sensor ].override = OVERRIDE_KEY; result = TRUE; } else { currentPressureReadings[ sensor ].override = OVERRIDE_RESET; currentPressureReadings[ sensor ].ovData = currentPressureReadings[ sensor ].ovInitData; result = TRUE; } } } 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 = FALSE; TEST_OVERRIDE_ARRAY_PAYLOAD_T override; OVERRIDE_TYPE_T ovType = getOverrideArrayPayloadFromMessage( message, &override ); // Verify tester has logged in with TD and override type is valid if ( ( TRUE == isTestingActivated() ) && ( ovType != OVERRIDE_INVALID ) && ( ovType < NUM_OF_OVERRIDE_TYPES ) ) { U32 sensor = override.index; // Verify bubble detector index of override if ( sensor < NUM_OF_PRESSURE_SENSORS ) { if ( OVERRIDE_OVERRIDE == ovType ) { F32 value = override.state.f32; currentPresTempReadings[ sensor ].ovData = value; currentPresTempReadings[ sensor ].override = OVERRIDE_KEY; result = TRUE; } else { currentPresTempReadings[ sensor ].override = OVERRIDE_RESET; currentPresTempReadings[ sensor ].ovData = currentPresTempReadings[ sensor ].ovInitData; result = TRUE; } } } return result; } /**@}*/