Index: firmware/App/Monitors/Pressures.c =================================================================== diff -u -r234d4fec2bf5b31dacaa2825eed0d4717c295d44 -r4bbe3247ab23375c2b1472efd44addf3b5c8b456 --- firmware/App/Monitors/Pressures.c (.../Pressures.c) (revision 234d4fec2bf5b31dacaa2825eed0d4717c295d44) +++ firmware/App/Monitors/Pressures.c (.../Pressures.c) (revision 4bbe3247ab23375c2b1472efd44addf3b5c8b456) @@ -1,27 +1,28 @@ /************************************************************************** * -* Copyright (c) 2020-2024 Diality Inc. - All Rights Reserved. +* Copyright (c) 2024-2026 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 Pressure.c +* @file Pressures.c * -* @author (last) Vinayakam Mani -* @date (last) 06-May-2024 +* @author (last) Varshini Nagabooshanam +* @date (last) 04-Feb-2026 * -* @author (original) Sean -* @date (original) 15-Jan-2020 +* @author (original) Sean Nash +* @date (original) 24-Sep-2024 * ***************************************************************************/ #include "AirPump.h" #include "AlarmMgmtTD.h" //#include "BloodFlow.h" +#include "DDInterface.h" #include "FpgaTD.h" #include "Messaging.h" -//#include "ModeTreatment.h" -//#include "ModeTreatmentParams.h" +#include "ModeTreatment.h" +#include "TxParams.h" //#include "NVDataMgmt.h" #include "OperationModes.h" #include "PersistentAlarm.h" @@ -42,14 +43,15 @@ #define PRESSURE_DATA_PUB_INTERVAL ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) ///< Interval (ms/task time) at which the pressure/occlusion data is published on the CAN bus. #define PRES_LIMIT_STABILIZATION_OFF ( 0 ) ///< pressure limit stabilization period off -#define PRES_LIMIT_STABILIZATION_2_TIME_MS ( 60 * MS_PER_SECOND ) ///< Duration of pressure limit second stage stabilization period (in ms) #define PRES_LIMIT_STABILIZATION_TIME_MS ( 60 * MS_PER_SECOND ) ///< Duration of pressure limit stabilization period (in ms). #define PRES_LIMIT_SHORT_STABILIZE_TIME_MS ( 10 * MS_PER_SECOND ) ///< Duration of pressure limit short stabilization period (in ms). #define PRES_LIMIT_RESTABILIZE_TIME_MS ( 15 * SEC_PER_MIN * MS_PER_SECOND ) ///< Duration of pressure limit re-stabilize period (in ms). /// Pressure Limit minimum stabilization time before short stabilization time activation static const U32 PRES_LIMIT_MIN_STABILIZATION_TIME_IN_MS = ( PRES_LIMIT_STABILIZATION_TIME_MS - PRES_LIMIT_SHORT_STABILIZE_TIME_MS ); +#define PSI_TO_MMHG ( 51.715F ) ////< Conversion constant for PSI to mmHg + #define VENOUS_PRESSURE_MIN_PSI ( -30.0F ) ///< Minimum of scale for venous pressure sensor reading (in PSI). #define VENOUS_PRESSURE_MAX_PSI ( 30.0F ) ///< Maximum of scale for venous pressure sensor reading (in PSI). #define MIN_VENOUS_PRESSURE_FOR_RAMP_MMHG ( 0.0F ) ///< Minimum venous pressure during blood pump ramp up (in mmHg). @@ -74,10 +76,16 @@ #define VENOUS_PRESSURE_EXEMPTION_PERIOD ( ( 2 * MS_PER_SECOND ) / \ TASK_GENERAL_INTERVAL ) ///< Venous pressure low exemption period (in task interval) after fill for all blood flow rate +#define TMP_PRESSURE_LIMIT_MAX_MMHG ( 500.0F ) ///< Maximum transmembrane pressure limit (in mmHg) +#define TMP_PRESSURE_LIMIT_MIN_MMHG ( -500.0F ) ///< Minimum transmembrane pressure limit (in mmHg) +#define TMP_PRESSURE_HIGH_ABSOLUTE_MMHG ( 500.0F ) ///< Transmembrane pressure high absolute (in mmHg). +#define TMP_ALARM_PERSISTENCE ( ( 1 * MS_PER_SECOND ) / TASK_GENERAL_INTERVAL ) ///< Alarm persistence period for transmembrane pressure alarms + #define MIN_TIME_BETWEEN_AIR_TRAP_FILL_EXEMPTIONS_MS ( 1200 ) ///< To monitor low Venous pressure in the defined interval in a case where continuous air fill event happens followed by exemption period to stabilize the pressure -#define MIN_TIME_BETWEEN_AIR_TRAP_FILL_EXEMPTIONS_WINDOW ( MIN_TIME_BETWEEN_AIR_TRAP_FILL_EXEMPTIONS_MS / \ - TASK_GENERAL_INTERVAL ) ///< Low Venous pressure monitoring window between air fill events based on the task interval time +///< Low Venous pressure monitoring window between air fill events based on the task interval time +#define MIN_TIME_BETWEEN_AIR_TRAP_FILL_EXEMPTIONS_WINDOW ( MIN_TIME_BETWEEN_AIR_TRAP_FILL_EXEMPTIONS_MS / TASK_GENERAL_INTERVAL ) + #define MAX_ART_VEN_OFFSET_MMHG 15.0F ///< Maximum arterial/venous offset allowed. #define EMPTY_SALINE_BAG_THRESHOLD_MMHG -300.0F ///< Threshold below which the saline bag is considered empty (in mmHg). @@ -87,7 +95,7 @@ #define HIGH_VEN_PRES_ALARM_PERSISTENCE 500 ///< Alarm persistence period for high venous pressure alarm #define PRES_OCCL_ALARM_PERSISTENCE ( 3 * MS_PER_SECOND ) ///< Alarm persistence period for occlusion alarms #define VEN_OCCL_ALARM_PERSISTENCE 100 ///< Alarm persistence period for venous occlusion alarm. -#define AIR_PUMP_TOLERANCE_TIMEOUT_MS (1 * MS_PER_SECOND ) ///< Time to allow increased maximum venous high limit +#define AIR_PUMP_TOLERANCE_TIMEOUT_MS ( 1 * MS_PER_SECOND ) ///< Time to allow increased maximum venous high limit /// Measured arterial pressure is filtered w/ 10 second moving average for pressure compensation of flow. #define SIZE_OF_LONG_ART_ROLLING_AVG ( ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) * 10 ) @@ -100,6 +108,8 @@ #define DATA_PUBLISH_COUNTER_START_COUNT 5 ///< Data publish counter start count. +#define BARO_MOVING_AVG_NUM_OF_SAMPLES 10 ///< Barometric pressure sensor moving average number of samples. + /// Defined states for the pressure monitor state machine. typedef enum Pressure_States { @@ -117,6 +127,15 @@ NUM_OF_PRESSURE_SELF_TEST_STATES ///< Number of pressure/occlusion self-test states. } PRESSURE_SELF_TEST_STATE_T; +/// Barometric pressure sensor moving average structure +typedef struct +{ + F32 baroRunningSumPSI; ///< Baro pressure sensor running sum in psi. + OVERRIDE_F32_T baroAvgPSI; ///< Baro pressure sensor average in psi. + F32 baroSamplesPSI[ BARO_MOVING_AVG_NUM_OF_SAMPLES ]; ///< Baro pressure sensor samples array in psi. + U32 baroSamplesNextIndex; ///< Baro pressure sensor sample next index number. +} BARO_MOVING_AVG_DATA_T; + // ********** private data ********** static PRESSURE_STATE_T pressureState; ///< Current state of pressure monitor state machine. @@ -128,16 +147,20 @@ static PRESSURE_LIMITS_STATES_T currPresLimitsState; ///< Current pressure limits state. static S32 stableArterialPressure; ///< Arterial pressure that limit window is based on (in mmHg). static S32 stableVenousPressure; ///< Venous pressure that limit window is based on (in mmHg). +static S32 stableTmpPressure; ///< TMP pressure that limit window is based on (in mmHg). static S32 currentArterialMaxLimit; ///< Maximum arterial pressure limit (in mmHg). static S32 currentArterialMinLimit; ///< Minimum arterial pressure limit (in mmHg). static S32 currentVenousMaxLimit; ///< Maximum venous pressure limit (in mmHg). static S32 currentVenousMinLimit; ///< Minimum venous pressure limit (in mmHg). +static S32 currentTmpMaxLimit; ///< Maximum TMP pressure limit (in mmHg). +static S32 currentTmpMinLimit; ///< Minimum TMP pressure limit (in mmHg). static BOOL pressureLimitsActive; ///< Flag indicates whether arterial and venous pressure alarm limits are active. static U32 stabilizationStartTimeMs; ///< Timestamp taken when pressure limit stabilization began (ms). -static F32 longFilteredArterialPressure; ///< Measured arterial pressure after long (10 s) filter. -static OVERRIDE_F32_T shortFilteredArterialPressure; ///< Measured arterial pressure after short (1 s) filter. -static F32 longFilteredVenousPressure; ///< Measured venous pressure after long (10 s) filter. -static OVERRIDE_F32_T shortFilteredVenousPressure; ///< Measured venous pressure after short (1 s) filter. +static F32 longFilteredArterialPressure; ///< Measured arterial pressure after long (10 s) filter (in mmHg). +static OVERRIDE_F32_T shortFilteredArterialPressure; ///< Measured arterial pressure after short (1 s) filter (in mmHg). +static F32 longFilteredVenousPressure; ///< Measured venous pressure after long (10 s) filter (in mmHg). +static OVERRIDE_F32_T shortFilteredVenousPressure; ///< Measured venous pressure after short (1 s) filter (in mmHg). +static OVERRIDE_F32_T tmpPressure; ///< Calculated trans-membrane pressure (in mmHg). static STABILIZATION_PERIODS_T pressureStabilizeTime; ///< Pressure stabilization time based on system events such as airpump, treatment param changes etc., static BOOL resetFillExemptPeriod; ///< Flag to reset the exempt period after defined time expire. static BOOL lowVenousPressureExemptCheck; ///< low venous pressure exempt check flag based on the air trap valve status @@ -166,6 +189,7 @@ static U32 venPressureReadingsShortIdx; ///< Index for next sample in rolling average array. static F32 venPressureReadingsShortTotal; ///< Rolling total - used to calc average. static U32 venPressureReadingsShortCount; ///< Number of samples in flow rolling average buffer. +static BARO_MOVING_AVG_DATA_T baroMovingAvg; ///< Barometric sensor moving average. static PRESSURE_SELF_TEST_STATE_T pressurePostState; ///< Pressure self test post state. //static HD_PRESSURE_SENSORS_CAL_RECORD_T pressureSensorsCalRecord; ///< Pressure sensors calibration record. @@ -177,9 +201,11 @@ static void execPressureLimits( void ); static void checkArterialPressureInRange( void ); static void checkVenousPressureInRange( void ); +static void checkTmpPressureInRange( void ); static void publishPressureData( void ); static void determineArtVenPressureLimits( void ); static void filterInlinePressureReadings( F32 artPres, F32 venPres ); +static void filterBaroPressureReadings( F32 baroPresPSI ); /*********************************************************************//** * @brief @@ -200,6 +226,8 @@ initPersistentAlarm( ALARM_ID_TD_VENOUS_PRESSURE_HIGH, 0, HIGH_VEN_PRES_ALARM_PERSISTENCE ); initPersistentAlarm( ALARM_ID_TD_ARTERIAL_PRESSURE_OUT_OF_RANGE, 0, PRES_ALARM_PERSISTENCE ); initPersistentAlarm( ALARM_ID_TD_VENOUS_PRESSURE_OUT_OF_RANGE, 0, PRES_ALARM_PERSISTENCE ); + initPersistentAlarm( ALARM_ID_TD_TMP_PRESSURE_LOW, 0, ( TMP_ALARM_PERSISTENCE * TASK_GENERAL_INTERVAL ) ); + initPersistentAlarm( ALARM_ID_TD_TMP_PRESSURE_HIGH, 0, ( TMP_ALARM_PERSISTENCE * TASK_GENERAL_INTERVAL ) ); setPressureLimitsToOuterBounds(); @@ -210,6 +238,7 @@ stabilizationStartTimeMs = 0; stableArterialPressure = 0; stableVenousPressure = 0; + stableTmpPressure = 0; venLowPresExemptAfterAirTrapFillTimerCtr = 0; prevVenLowPresExemptAfterAirTrapFillTimerCtr = 0; emptySalineBagCtr = 0; @@ -224,6 +253,10 @@ shortFilteredVenousPressure.ovData = 0.0F; shortFilteredVenousPressure.ovInitData = 0.0F; shortFilteredVenousPressure.override = OVERRIDE_RESET; + tmpPressure.data = 0.0F; + tmpPressure.ovData = 0.0F; + tmpPressure.ovInitData = 0.0F; + tmpPressure.override = OVERRIDE_RESET; pressureDataPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; pressureState = PRESSURE_WAIT_FOR_POST_STATE; @@ -252,6 +285,14 @@ venPressureReadingsShortIdx = 0; venPressureReadingsShortTotal = 0.0F; venPressureReadingsShortCount = 0; + + baroMovingAvg.baroAvgPSI.data = 0.0F; + baroMovingAvg.baroAvgPSI.ovData = 0.0F; + baroMovingAvg.baroAvgPSI.ovInitData = 0.0F; + baroMovingAvg.baroAvgPSI.override = OVERRIDE_RESET; + baroMovingAvg.baroRunningSumPSI = 0.0F; + baroMovingAvg.baroSamplesNextIndex = 0; + memset( baroMovingAvg.baroSamplesPSI, 0.0F, BARO_MOVING_AVG_NUM_OF_SAMPLES ); } /*********************************************************************//** @@ -330,7 +371,8 @@ * limits for arterial and venous pressure to their outer boundaries. * @details \b Inputs: none * @details \b Outputs: currentArterialMaxLimit, currentArterialMinLimit, - * currentVenousMaxLimit, currentVenousMinLimit + * currentVenousMaxLimit, currentVenousMinLimit, currentTmpMaxLimit, + * currentTmpMinLimit * @return none *************************************************************************/ void setPressureLimitsToOuterBounds( void ) @@ -339,6 +381,8 @@ currentArterialMinLimit = (S32)ARTERIAL_PRESSURE_LIMIT_MIN_MMHG; currentVenousMaxLimit = (S32)VENOUS_PRESSURE_LIMIT_MAX_MMHG; currentVenousMinLimit = (S32)VENOUS_PRESSURE_LIMIT_MIN_MMHG; + currentTmpMaxLimit = (S32)TMP_PRESSURE_LIMIT_MAX_MMHG; + currentTmpMinLimit = (S32)TMP_PRESSURE_LIMIT_MIN_MMHG; } /*********************************************************************//** @@ -350,15 +394,18 @@ * resume will start a new stabilization period ending in another set of * stable pressures before windowed limits recalculated. * @details \b Inputs: pressureStabilizeTime - * @details \b Outputs: stableArterialPressure, stableVenousPressure + * @details \b Outputs: stableArterialPressure, stableVenousPressure, + * stableTmpPressure * @return none *************************************************************************/ void updatePressureLimitWindows( void ) { F32 filtArt; F32 filtVen; + F32 filtTmp; S32 curArtPres; S32 curVenPres; + S32 curTmpPres; if ( USE_SHORT_STABILIZATION_PERIOD == pressureStabilizeTime ) { @@ -371,10 +418,15 @@ filtVen = getLongFilteredVenousPressure(); } + // Using final TMP value for override. + filtTmp = getTMPPressure(); + curArtPres = FLOAT_TO_INT_WITH_ROUND( filtArt ); curVenPres = FLOAT_TO_INT_WITH_ROUND( filtVen ); + curTmpPres = FLOAT_TO_INT_WITH_ROUND( filtTmp ); stableArterialPressure = curArtPres; stableVenousPressure = curVenPres; + stableTmpPressure = curTmpPres; // want to broadcast new limits right away so UI can update tx screen pressureDataPublicationTimerCounter = getU32OverrideValue( &pressuresDataPublishInterval ); @@ -410,8 +462,7 @@ stabilizationStartTimeMs = getMSTimerCount(); } } - else if ( ( PRESSURE_LIMITS_STATE_STABLE == currPresLimitsState ) || - ( PRESSURE_LIMITS_STATE_STABILIZATION_2 == currPresLimitsState ) ) + else if ( PRESSURE_LIMITS_STATE_STABLE == currPresLimitsState ) { pressureStabilizeTime = stabilizationPeriod; currPresLimitsState = PRESSURE_LIMITS_STATE_STABILIZATION; @@ -430,13 +481,13 @@ *************************************************************************/ static void determineArtVenPressureLimits( void ) { - if ( ( PRESSURE_LIMITS_STATE_STABLE == currPresLimitsState ) || - ( PRESSURE_LIMITS_STATE_STABILIZATION_2 == currPresLimitsState ) ) + if ( PRESSURE_LIMITS_STATE_STABLE == currPresLimitsState ) { // apply pressure windows when stable - S32 artOffset = 120; //getTreatmentParameterS32( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ) / 2; - S32 venMinOffset = 100; //getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC ); - S32 venMaxOffset = 20; //getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ) - venMinOffset; + S32 artOffset = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ) / 2; + S32 venMinOffset = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC ); + S32 venMaxOffset = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ) - venMinOffset; + S32 tmpOffset = getTreatmentParameterS32( TREATMENT_PARAM_TMP_PRES_LIMIT_WINDOW ) / 2; currentArterialMinLimit = stableArterialPressure - artOffset; currentArterialMinLimit = MAX( currentArterialMinLimit, ARTERIAL_PRESSURE_LIMIT_MIN_MMHG ); @@ -446,6 +497,8 @@ currentVenousMinLimit = MAX( currentVenousMinLimit, VENOUS_PRESSURE_LIMIT_MIN_MMHG ); currentVenousMaxLimit = stableVenousPressure + venMaxOffset; currentVenousMaxLimit = MIN( currentVenousMaxLimit, VENOUS_PRESSURE_LIMIT_MAX_MMHG ); + currentTmpMinLimit = MAX( currentTmpMinLimit, TMP_PRESSURE_LIMIT_MIN_MMHG ); + currentTmpMaxLimit = MIN( currentTmpMaxLimit, TMP_PRESSURE_LIMIT_MAX_MMHG ); } else { // apply outer limits when not stable @@ -466,6 +519,9 @@ *************************************************************************/ void execPressure( void ) { + // Update pressure readings + readPressureSensors(); + // State machine switch ( pressureState ) { @@ -498,7 +554,7 @@ { PRESSURE_STATE_T result = PRESSURE_WAIT_FOR_POST_STATE; - if ( PRESSURE_TEST_STATE_COMPLETE == pressurePostState ) +// if ( PRESSURE_TEST_STATE_COMPLETE == pressurePostState ) // TODO - restore later { result = PRESSURE_CONTINUOUS_READ_STATE; } @@ -517,21 +573,29 @@ static PRESSURE_STATE_T handlePressureContReadState( void ) { PRESSURE_STATE_T result = PRESSURE_CONTINUOUS_READ_STATE; - F32 fpgaArtPres = getPressure( PRESSURE_SENSOR_ARTERIAL ) - arterialPressureOffset; - F32 fpgaVenPres = getPressure( PRESSURE_SENSOR_VENOUS ) - venousPressureOffset; + F32 fpgaArtPres = getPressure( H2_PRES ) - arterialPressureOffset; + F32 fpgaVenPres = getPressure( H14_PRES ) - venousPressureOffset; + F32 fpgaBaroPresPSI = getPressure( H23_PRES ); // Filter inline pressure readings filterInlinePressureReadings( fpgaArtPres, fpgaVenPres ); + // Filter the baro pressure + filterBaroPressureReadings( fpgaBaroPresPSI ); + // Get latest dialysate pressure so we can calculate TMP + tmpPressure.data = getFilteredVenousPressure() - ( getDialysatePressure() * PSI_TO_MMHG ); + // Handle pressure limits state machine execPressureLimits(); // Set arterial/venous pressure limits according to current pressure limits state determineArtVenPressureLimits(); // Check in-line pressures are in range +#ifndef TEST_NO_PRESSURE_CHECKS checkArterialPressureInRange(); checkVenousPressureInRange(); +#endif return result; } @@ -578,7 +642,7 @@ { currPresLimitsState = PRESSURE_LIMITS_STATE_IDLE; } - else if ( ( TREATMENT_DIALYSIS_STATE == currTxState ) || ( TREATMENT_STOP_STATE == currTxState ) ) + else if ( ( TREATMENT_DIALYSIS_STATE == currTxState ) || ( TREATMENT_PAUSED_STATE == currTxState ) ) { stabilizationStartTimeMs = getMSTimerCount(); pressureStabilizeTime = USE_NORMAL_STABILIZATION_PERIOD; @@ -606,46 +670,15 @@ { currPresLimitsState = PRESSURE_LIMITS_STATE_IDLE; } - else if ( ( currTxState != TREATMENT_DIALYSIS_STATE ) && ( currTxState != TREATMENT_STOP_STATE ) ) + else if ( ( currTxState != TREATMENT_DIALYSIS_STATE ) && ( currTxState != TREATMENT_PAUSED_STATE ) ) { currPresLimitsState = PRESSURE_LIMITS_STATE_WIDE; } else if ( TRUE == didTimeout( stabilizationStartTimeMs, stabilizeTime ) ) { updatePressureLimitWindows(); stabilizationStartTimeMs = getMSTimerCount(); - currPresLimitsState = PRESSURE_LIMITS_STATE_STABILIZATION_2; - pressureStabilizeTime = USE_NORMAL_STABILIZATION_PERIOD; - } - break; - - case PRESSURE_LIMITS_STATE_STABILIZATION_2: - // zero stabilize time for 15 mins once pressure limits adjust scenario - if ( STABILIZATION_PERIOD_OFF == pressureStabilizeTime ) - { - stabilizeTime = PRES_LIMIT_STABILIZATION_OFF; - } - //60 sec second stage stabilization - else - { - stabilizeTime = PRES_LIMIT_STABILIZATION_2_TIME_MS; - } - - // second stage stabilization helps to re determine the pressure due to UF control change etc., - if ( bpRunning != TRUE ) - { - currPresLimitsState = PRESSURE_LIMITS_STATE_IDLE; - } - else if ( ( currTxState != TREATMENT_DIALYSIS_STATE ) && ( currTxState != TREATMENT_STOP_STATE ) ) - { - currPresLimitsState = PRESSURE_LIMITS_STATE_WIDE; - } - else if ( TRUE == didTimeout( stabilizationStartTimeMs, stabilizeTime ) ) - { - updatePressureLimitWindows(); - stabilizationStartTimeMs = getMSTimerCount(); currPresLimitsState = PRESSURE_LIMITS_STATE_STABLE; - // Reset to normal period as default. pressureStabilizeTime = USE_NORMAL_STABILIZATION_PERIOD; } break; @@ -656,15 +689,15 @@ { currPresLimitsState = PRESSURE_LIMITS_STATE_IDLE; } - else if ( ( currTxState != TREATMENT_DIALYSIS_STATE ) && ( currTxState != TREATMENT_STOP_STATE ) ) + else if ( ( currTxState != TREATMENT_DIALYSIS_STATE ) && ( currTxState != TREATMENT_PAUSED_STATE ) ) { currPresLimitsState = PRESSURE_LIMITS_STATE_WIDE; } else if ( TRUE == didTimeout( stabilizationStartTimeMs, PRES_LIMIT_RESTABILIZE_TIME_MS ) ) { stabilizationStartTimeMs = getMSTimerCount(); pressureStabilizeTime = STABILIZATION_PERIOD_OFF; - currPresLimitsState = PRESSURE_LIMITS_STATE_STABILIZATION_2; + currPresLimitsState = PRESSURE_LIMITS_STATE_STABILIZATION; } break; @@ -744,10 +777,10 @@ static void checkVenousPressureInRange( void ) { F32 venPres = getFilteredVenousPressure(); - OPN_CLS_STATE_T airTrapValveState = STATE_CLOSED; //getValveAirTrapStatus(); + VALVE_3WAY_STATE_T airTrapValveState = VALVE_3WAY_COMMON_TO_CLOSED_STATE; //getValveAirTrapStatus(); // track time since last air trap fill - if ( ( STATE_OPEN == airTrapValveState ) && ( TRUE == resetFillExemptPeriod ) ) + if ( ( VALVE_3WAY_COMMON_TO_OPEN_STATE == airTrapValveState ) && ( TRUE == resetFillExemptPeriod ) ) { venLowPresExemptAfterAirTrapFillTimerCtr = 0; resetFillExemptPeriod = FALSE; @@ -794,11 +827,13 @@ { if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_TD_VENOUS_PRESSURE_LOW, venPresLow ) ) { +#ifndef TEST_UI_ONLY SET_ALARM_WITH_2_F32_DATA( ALARM_ID_TD_VENOUS_PRESSURE_LOW, venPres, (F32)currentVenousMinLimit ); +#endif } } // during reset period, if airTrapValve open, still alarm needs to be raised , hence persistence clearance should happen before or after reset period. - if ( ( airTrapValveState == STATE_OPEN ) && + if ( ( airTrapValveState == VALVE_3WAY_COMMON_TO_OPEN_STATE ) && ( ( venLowPresExemptAfterAirTrapFillTimerCtr < exemptPeriod ) || ( venLowPresExemptAfterAirTrapFillTimerCtr > minimumMonitoringWindow ) ) ) { @@ -824,6 +859,50 @@ /*********************************************************************//** * @brief + * The checkTmpPressureInRange function checks that the calculated TMP + * pressure is within the set alarm limits. + * @details \b Alarm: ALARM_ID_TD_TMP_PRESSURE_LOW if TMP pressure is low. + * @details \b Alarm: ALARM_ID_TD_TMP_PRESSURE_HIGH if TMP pressure is high. + * @details \b Inputs: tmpPressure, pressureLimitsActive, currentTmpMinLimit, currentTmpMaxLimit + * @details \b Outputs: none + * @return none + *************************************************************************/ +static void checkTmpPressureInRange( void ) +{ + F32 tmpPres = getTMPPressure(); + + // TMP alarms are when pressure limits are active. + if ( pressureLimitsActive != FALSE ) + { + BOOL tmpPresLow; + BOOL tmpPresHigh; + F32 tmpHighLimit; + + // High limit is windowed around stabilized TMP, but must also respect absolute floor. + tmpHighLimit = MAX( (F32)currentTmpMaxLimit, TMP_PRESSURE_HIGH_ABSOLUTE_MMHG ); + + tmpPresLow = ( tmpPres < (F32)currentTmpMinLimit ? TRUE : FALSE ); + tmpPresHigh = ( tmpPres > tmpHighLimit ? TRUE : FALSE ); + + if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_TD_TMP_PRESSURE_LOW, tmpPresLow ) ) + { + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_TD_TMP_PRESSURE_LOW, tmpPres, (F32)currentTmpMinLimit ); + } + if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_TD_TMP_PRESSURE_HIGH, tmpPresHigh ) ) + { + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_TD_TMP_PRESSURE_HIGH, tmpPres, tmpHighLimit ); + } + } + else + { + // Reset persistence if limits inactive + isPersistentAlarmTriggered( ALARM_ID_TD_TMP_PRESSURE_LOW, FALSE ); + isPersistentAlarmTriggered( ALARM_ID_TD_TMP_PRESSURE_HIGH, FALSE ); + } +} + +/*********************************************************************//** + * @brief * The signalLowVenousPressureCheck function sets the low venous pressure Exempt check flag to increment the counter. * @details \b Inputs: lowVenousPressureExemptCheck * @details \b Outputs: lowVenousPressureExemptCheck @@ -886,6 +965,30 @@ /*********************************************************************//** * @brief + * The getTMPPressure function gets the calculated trans-membrane pressure. + * @details \b Inputs: tmpPressure + * @details \b Outputs: none + * @return the current calculated TMP (in mmHg). + *************************************************************************/ +F32 getTMPPressure( void ) +{ + return getF32OverrideValue( &tmpPressure ); +} + +/*********************************************************************//** + * @brief + * The getBaroPressurePSI function gets the averaged barometric pressure in psi. + * @details \b Inputs: baroMovingAvg.baroAvgPS + * @details \b Outputs: none + * @return the current average barometric pressure in psi. + *************************************************************************/ +F32 getBaroPressurePSI( void ) +{ + return getF32OverrideValue( &baroMovingAvg.baroAvgPSI ); +} + +/*********************************************************************//** + * @brief * The filterInlinePressureReadings function adds a new arterial and venous * pressure sample to the filters. * @details \b Inputs: none @@ -946,6 +1049,26 @@ /*********************************************************************//** * @brief + * The filterBaroPressureReadings function calculates the barometric pressure + * in psi. + * @details \b Inputs: none + * @details \b Outputs: baroMovingAvg + * @param baroPresPSI newest barometric pressure from FPGA + * @return none + *************************************************************************/ +static void filterBaroPressureReadings( F32 baroPresPSI ) +{ + U32 currentIndex = baroMovingAvg.baroSamplesNextIndex; + F32 prevSampleToRemovePSI = baroMovingAvg.baroSamplesPSI[ currentIndex ]; + + baroMovingAvg.baroSamplesPSI[ currentIndex ] = baroPresPSI; + baroMovingAvg.baroRunningSumPSI = baroMovingAvg.baroRunningSumPSI + baroPresPSI - prevSampleToRemovePSI; + baroMovingAvg.baroSamplesNextIndex = INC_WRAP( currentIndex, 0, BARO_MOVING_AVG_NUM_OF_SAMPLES - 1 ); + baroMovingAvg.baroAvgPSI.data = baroMovingAvg.baroRunningSumPSI / (F32)BARO_MOVING_AVG_NUM_OF_SAMPLES; +} + +/*********************************************************************//** + * @brief * The publishPressureData function publishes pressure data at the set * interval. * @details \b Message \b Sent: MSG_ID_TD_PRESSURE_DATA @@ -963,15 +1086,19 @@ { PRESSURE_DATA_T data; - data.arterialPressure = getFilteredArterialPressure(); - data.venousPressure = getFilteredVenousPressure(); - data.presLimitState = currPresLimitsState; - data.artMinLimit = currentArterialMinLimit; - data.artMaxLimit = currentArterialMaxLimit; - data.venMinLimit = currentVenousMinLimit; - data.venMaxLimit = currentVenousMaxLimit; - data.arterialLongFilterPres = longFilteredArterialPressure; - data.venousLongFilterPres = longFilteredVenousPressure; + data.h2Pressure = getFilteredArterialPressure(); + data.h14Pressure = getFilteredVenousPressure(); + data.presLimitState = currPresLimitsState; + data.h2MinLimit = currentArterialMinLimit; + data.h2MaxLimit = currentArterialMaxLimit; + data.h14MinLimit = currentVenousMinLimit; + data.h14MaxLimit = currentVenousMaxLimit; + data.h2LongFilterPres = longFilteredArterialPressure; + data.h14LongFilterPres = longFilteredVenousPressure; + data.tmpPressure = getTMPPressure(); + data.tmpMinLimit = (F32)currentTmpMinLimit; + data.tmpMaxLimit = (F32)currentTmpMaxLimit; + data.h23Pressure = getBaroPressurePSI(); broadcastData( MSG_ID_TD_PRESSURE_DATA, COMM_BUFFER_OUT_CAN_TD_BROADCAST, (U08*)&data, sizeof( PRESSURE_DATA_T ) ); pressureDataPublicationTimerCounter = 0; @@ -1026,10 +1153,10 @@ BOOL calStatus = TRUE; //FALSE; // Get the pressure sensors and occlusion sensors calibration records -// calStatus |= getNVRecord2Driver( GET_CAL_PRESSURE_SENSORS, (U08*)&pressureSensorsCalRecord, sizeof( HD_PRESSURE_SENSORS_CAL_RECORD_T ), -// NUM_OF_CAL_DATA_HD_PRESSURE_SESNSORS, ALARM_ID_NO_ALARM ); +// calStatus |= getNVRecord2Driver( GET_CAL_PRESSURE_SENSORS, (U08*)&pressureSensorsCalRecord, sizeof( TD_PRESSURE_SENSORS_CAL_RECORD_T ), +// NUM_OF_CAL_DATA_TD_PRESSURE_SESNSORS, ALARM_ID_NO_ALARM ); // -// calStatus |= getNVRecord2Driver( GET_CAL_OCCLUSION_SESNSORS, (U08*)&occlusionSensorsCalRecord, sizeof( HD_OCCLUSION_SENSORS_CAL_RECORD_T ), +// calStatus |= getNVRecord2Driver( GET_CAL_OCCLUSION_SESNSORS, (U08*)&occlusionSensorsCalRecord, sizeof( TD_OCCLUSION_SENSORS_CAL_RECORD_T ), // NUM_OF_CAL_DATA_OCCLUSION_SENSORS, ALARM_ID_NO_ALARM ); pressurePostState = PRESSURE_TEST_STATE_COMPLETE; @@ -1069,4 +1196,37 @@ return result; } +/*********************************************************************//** + * @brief + * The testTMPOverride function overrides the TMP pressure reported by this + * unit. + * @details \b Inputs: none + * @details \b Outputs: tmpPressure + * @param message Override message from Dialin which includes the value to + * override the TMP pressure to. + * @return TRUE if override request is successful, FALSE if not + *************************************************************************/ +BOOL testTMPOverride( MESSAGE_T *message ) +{ + BOOL result = f32Override( message, &tmpPressure ); + + return result; +} + +/*********************************************************************//** + * @brief + * The testBaroPressureOverride function overrides baro sensor pressure. + * @details \b Inputs: none + * @details \b Outputs: baroMovingAvg.baroAvgPSI + * @param message Override message from Dialin which includes the value to + * override the baro pressure to. + * @return TRUE if override request is successful, FALSE if not + *************************************************************************/ +BOOL testBaroPressureOverride( MESSAGE_T * message ) +{ + BOOL result = f32Override( message, &baroMovingAvg.baroAvgPSI ); + + return result; +} + /**@}*/