Index: firmware/App/Controllers/PresOccl.c =================================================================== diff -u -rf4f7e0ee3baef51d91de64d44a0a00ff967f56c0 -rf9b9bf3f04d5ec74b9f1604cb1eb9729de001705 --- firmware/App/Controllers/PresOccl.c (.../PresOccl.c) (revision f4f7e0ee3baef51d91de64d44a0a00ff967f56c0) +++ firmware/App/Controllers/PresOccl.c (.../PresOccl.c) (revision f9b9bf3f04d5ec74b9f1604cb1eb9729de001705) @@ -20,6 +20,7 @@ #include "AlarmMgmt.h" #include "BloodFlow.h" #include "FPGA.h" +#include "ModeTreatment.h" #include "ModeTreatmentParams.h" #include "NVDataMgmt.h" #include "OperationModes.h" @@ -39,8 +40,11 @@ // ********** private definitions ********** /// Default publication interval for pressure and occlusion data. -#define PRES_OCCL_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_OCCL_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_TIME_MS ( SEC_PER_MIN * MS_PER_SECOND ) ///< Duration of pressure limit stabilization period (in ms). +#define PRES_LIMIT_RESTABILIZE_TIME_MS ( 30 * SEC_PER_MIN * MS_PER_SECOND ) ///< Duration of pressure limit re-stabilize period (in ms). + #define ARTERIAL_PRESSURE_CONVERSION_OFFSET 0x800000 ///< Arterial pressure conversion coefficient. #define ARTERIAL_PRESSURE_V_BIAS ( 3.0F ) ///< Bias voltage for arterial pressure sensor. #define ARTERIAL_PRESSURE_SENSITIVITY ( 0.000005F ) ///< Sensitivity for arterial pressure sensor is 5 uV / mmHg @@ -63,11 +67,15 @@ #define ARTERIAL_PRESSURE_SELF_TEST_MAX ( 100.0F ) ///< Maximum self-test value for arterial pressure sensor reading (in mmHg). #define ARTERIAL_PRESSURE_MAX_MMHG ( 2000.0F ) ///< Maximum arterial pressure reading (in mmHg) for range check. #define ARTERIAL_PRESSURE_MIN_MMHG ( -1500.0F ) ///< Minimum arterial pressure reading (in mmHg) for range check. +#define ARTERIAL_PRESSURE_LIMIT_MAX_MMHG ( 100.0F ) ///< Maximum arterial pressure limit (in mmHg). +#define ARTERIAL_PRESSURE_LIMIT_MIN_MMHG ( -300.0F ) ///< Minimum arterial pressure limit (in mmHg). #define VENOUS_PRESSURE_SELF_TEST_MIN ( -100.0F ) ///< Minimum self-test value for venous pressure sensor reading (in mmHg). #define VENOUS_PRESSURE_SELF_TEST_MAX ( 100.0F ) ///< Maximum self-test value for venous pressure sensor reading (in mmHg). #define VENOUS_PRESSURE_MAX_MMHG ( 2000.0F ) ///< Maximum venous pressure reading (in mmHg) for range check. #define VENOUS_PRESSURE_MIN_MMHG ( -1500.0F ) ///< Minimum venous pressure reading (in mmHg) for range check. +#define VENOUS_PRESSURE_LIMIT_MAX_MMHG ( 300.0F ) ///< Maximum venous pressure limit (in mmHg). +#define VENOUS_PRESSURE_LIMIT_MIN_MMHG ( 20.0F ) ///< Minimum venous pressure limit (in mmHg). #define VENOUS_PRESSURE_OCCL_OFFSET_MMHG ( 50.0F ) ///< Venous pressure occlusion threshold offset from max alarm limit (in mmHg). #define VENOUS_PRESSURE_LIMIT_DELAY_MS ( SEC_PER_MIN * MS_PER_SECOND ) ///< Venous pressure limit delay period following dialysis start/resume (use wider limits during this period). @@ -141,7 +149,16 @@ static OVERRIDE_U32_T presOcclDataPublishInterval = { PRES_OCCL_DATA_PUB_INTERVAL, PRES_OCCL_DATA_PUB_INTERVAL, 0, 0 }; static OVERRIDE_F32_T arterialPressure = {0.0, 0.0, 0.0, 0 }; ///< Measured arterial pressure. static OVERRIDE_F32_T venousPressure = {0.0, 0.0, 0.0, 0 }; ///< Measured venous pressure. -static OVERRIDE_U32_T bloodPumpOcclusion = {0, 0, 0, 0 }; ///< Measured blood pump occlusion pressure. +static OVERRIDE_U32_T bloodPumpOcclusion = {0, 0, 0, 0 }; ///< Measured blood pump occlusion pressure. +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 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 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 F32 shortFilteredArterialPressure; ///< Measured arterial pressure after short (1 s) filter. static F32 shortFilteredVenousPressure; ///< Measured venous pressure after short (1 s) filter. @@ -164,7 +181,6 @@ static U32 venPressureReadingsShortIdx = 0; ///< Index for next sample in rolling average array. static F32 venPressureReadingsShortTotal = 0.0; ///< Rolling total - used to calc average. static U32 venPressureReadingsShortCount = 0; ///< Number of samples in flow rolling average buffer. -static U32 venPressureLimitDelayStart; ///< Time stamp for last time dialysis started/resumed. static PRESSURE_SELF_TEST_STATE_T presOcclPostState; ///< Pressure self test post state. static HD_PRESSURE_SENSORS_CAL_RECORD_T pressureSensorsCalRecord; ///< Pressure sensors calibration record. static HD_OCCLUSION_SENSORS_CAL_RECORD_T occlusionSensorsCalRecord; ///< Occlusion sensors calibration record. @@ -173,12 +189,14 @@ static PRESSURE_STATE_T handlePresOcclWaitForPOSTState( void ); static PRESSURE_STATE_T handlePresOcclContReadState( void ); +static void execPressureLimits( void ); static void convertInlinePressures( void ); static void convertOcclusionPressures( void ); static void checkArterialPressureInRange( void ); static void checkVenousPressureInRange( void ); static void checkOcclusions( void ); static void publishPresOcclData( void ); +static void determineArtVenPressureLimits( void ); static void filterInlinePressureReadings( F32 artPres, F32 venPres ); /*********************************************************************//** @@ -208,14 +226,20 @@ initFPGAPersistentAlarm( FPGA_PERS_ERROR_VENOUS_PRESSURE_SESNOR, ALARM_ID_HD_VENOUS_SENSOR_FPGA_FAULT, PRES_SENSORS_FPGA_ERROR_TIMEOUT_MS, PRES_SENSORS_FPGA_ERROR_TIMEOUT_MS ); + setPressureLimitsToOuterBounds(); + + currPresLimitsState = PRESSURE_LIMITS_STATE_OFF; + pressureLimitsActive = FALSE; + stabilizationStartTimeMs = 0; + stableArterialPressure = 0; + stableVenousPressure = 0; longFilteredArterialPressure = 0.0F; shortFilteredArterialPressure = 0.0F; shortFilteredVenousPressure = 0.0F; presOcclDataPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; presOcclState = PRESSURE_WAIT_FOR_POST_STATE; presOcclPostState = PRESSURE_SELF_TEST_STATE_START; bloodPumpOcclusionAfterCartridgeInstall = 0; - venPressureLimitDelayStart = 0; } /*********************************************************************//** @@ -305,18 +329,105 @@ /*********************************************************************//** * @brief - * The signalStartDialysisStartOrResume function signals that dialysis has - * just been started or resumed which begins a brief time window where - * venous pressure limits are relaxed while treatment reaches stability. + * The setPressureLimitsToOuterBounds function sets the min/max pressure + * limits for arterial and venous pressure to their outer boundaries. * @details Inputs: none - * @details Outputs: venPressureLimitDelayStart + * @details Outputs: currentArterialMaxLimit, currentArterialMinLimit, + * currentVenousMaxLimit, currentVenousMinLimit * @return none *************************************************************************/ -void signalStartDialysisStartOrResume( void ) +void setPressureLimitsToOuterBounds( void ) { - venPressureLimitDelayStart = getMSTimerCount(); + currentArterialMaxLimit = (S32)ARTERIAL_PRESSURE_LIMIT_MAX_MMHG; + currentArterialMinLimit = (S32)ARTERIAL_PRESSURE_LIMIT_MIN_MMHG; + currentVenousMaxLimit = (S32)VENOUS_PRESSURE_LIMIT_MAX_MMHG; + currentVenousMinLimit = (S32)VENOUS_PRESSURE_LIMIT_MIN_MMHG; } +/*********************************************************************//** + * @brief + * The updatePressureLimitWindows function updates the pressure limit + * stable pressure levels when windows set/changed by user. + * If treatment in progress, windowed limits around new stable pressures + * will be in effect immediately (next monitor pass). If treatment paused, + * resume will start a new stabilization period ending in another set of + * stable pressures before windowed limits recalculated. + * @details Inputs: none + * @details Outputs: stableArterialPressure, stableVenousPressure + * @return none + *************************************************************************/ +void updatePressureLimitWindows( void ) +{ + F32 filtArt = getFilteredArterialPressure(); + F32 filtVen = getFilteredVenousPressure(); + S32 curArtPres = FLOAT_TO_INT_WITH_ROUND( filtArt ); + S32 curVenPres = FLOAT_TO_INT_WITH_ROUND( filtVen ); + + stableArterialPressure = curArtPres; + stableVenousPressure = curVenPres; + + // want to broadcast new limits right away so UI can update tx screen + presOcclDataPublicationTimerCounter = getU32OverrideValue( &presOcclDataPublishInterval ); +} + +/*********************************************************************//** + * @brief + * The signalUserRateChange function signals that user has changed the blood + * and/or dialysate flow rate. If pressure limits state was stable, a rate change + * will kick us back to stabilization state. + * @details Inputs: none + * @details Outputs: currPresLimitsState, stabilizationStartTimeMs + * @return none + *************************************************************************/ +void signalUserRateChange( void ) +{ + // User update of blood flow rate initiates/resets a stabilization period (if we were in stabilization or stable state) + if ( PRESSURE_LIMITS_STATE_STABILIZATION == currPresLimitsState ) + { + stabilizationStartTimeMs = getMSTimerCount(); + } + else if ( PRESSURE_LIMITS_STATE_STABLE == currPresLimitsState ) + { + currPresLimitsState = PRESSURE_LIMITS_STATE_STABILIZATION; + stabilizationStartTimeMs = getMSTimerCount(); + } +} + +/*********************************************************************//** + * @brief + * The determineArtVenPressureLimits function determines current pressure + * limits based on whether we are in stabilization or stable situation. + * @details Inputs: currPresLimitsState + * @details Outputs: currentArterialMaxLimit, currentArterialMinLimit, + * currentVenousMaxLimit, currentVenousMinLimit + * @return none + *************************************************************************/ +static void determineArtVenPressureLimits( void ) +{ + if ( PRESSURE_LIMITS_STATE_STABLE == currPresLimitsState ) + { // apply pressure windows when stable + S32 artOffset = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ) / 2; // Arterial is symmetric + S32 venMinOffset = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_ASYMMETRIC ); // Venous is asymmetric + S32 venMaxOffset = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ) - venMinOffset; + + currentArterialMinLimit = stableArterialPressure - artOffset; + currentArterialMinLimit = MAX( currentArterialMinLimit, ARTERIAL_PRESSURE_LIMIT_MIN_MMHG ); + currentArterialMaxLimit = stableArterialPressure + artOffset; + currentArterialMaxLimit = MIN( currentArterialMaxLimit, ARTERIAL_PRESSURE_LIMIT_MAX_MMHG ); + currentVenousMinLimit = stableVenousPressure - venMinOffset; + currentVenousMinLimit = MAX( currentVenousMinLimit, VENOUS_PRESSURE_LIMIT_MIN_MMHG ); + currentVenousMaxLimit = stableVenousPressure + venMaxOffset; + currentVenousMaxLimit = MIN( currentVenousMaxLimit, VENOUS_PRESSURE_LIMIT_MAX_MMHG ); + } + else + { // apply outer limits when not stable + setPressureLimitsToOuterBounds(); + } + + // set flag indicating whether pressure limits are active based on current current limits state + pressureLimitsActive = ( currPresLimitsState > PRESSURE_LIMITS_STATE_IDLE ? TRUE : FALSE ); +} + /*********************************************************************//** * @brief * The execPresOccl function executes the pressure and occlusion monitor. @@ -384,6 +495,12 @@ // Read latest occlusion pressures convertOcclusionPressures(); + // 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 checkArterialPressureInRange(); checkVenousPressureInRange(); @@ -392,6 +509,91 @@ checkOcclusions(); return result; +} + +/*********************************************************************//** + * @brief + * The execPressureLimits function executes the pressure limits state machine. + * @details Inputs: currPresLimitsState, stabilizationStartTimeMs + * @details Outputs: currPresLimitsState, stabilizationStartTimeMs + * @return next pressure limits state + *************************************************************************/ +static void execPressureLimits( void ) +{ + BOOL bpRunning = isBloodPumpRunning(); + HD_OP_MODE_T currMode = getCurrentOperationMode(); + TREATMENT_STATE_T currTxState = getTreatmentState(); + + if ( currMode != MODE_TREA ) + { + currPresLimitsState = PRESSURE_LIMITS_STATE_OFF; + } + + switch ( currPresLimitsState ) + { + case PRESSURE_LIMITS_STATE_OFF: + if ( MODE_TREA == currMode ) + { // Tx mode starts in blood prime - want wide limits in that state + currPresLimitsState = PRESSURE_LIMITS_STATE_WIDE; + } + break; + + case PRESSURE_LIMITS_STATE_IDLE: + if ( TRUE == bpRunning ) + { + currPresLimitsState = PRESSURE_LIMITS_STATE_WIDE; + } + break; + + case PRESSURE_LIMITS_STATE_WIDE: + if ( bpRunning != TRUE ) + { + currPresLimitsState = PRESSURE_LIMITS_STATE_IDLE; + } + else if ( ( TREATMENT_DIALYSIS_STATE == currTxState ) || ( TREATMENT_STOP_STATE == currTxState ) ) + { + stabilizationStartTimeMs = getMSTimerCount(); + currPresLimitsState = PRESSURE_LIMITS_STATE_STABILIZATION; + } + break; + + case PRESSURE_LIMITS_STATE_STABILIZATION: + 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, PRES_LIMIT_STABILIZATION_TIME_MS ) ) + { + updatePressureLimitWindows(); + stabilizationStartTimeMs = getMSTimerCount(); + currPresLimitsState = PRESSURE_LIMITS_STATE_STABLE; + } + break; + + case PRESSURE_LIMITS_STATE_STABLE: + 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, PRES_LIMIT_RESTABILIZE_TIME_MS ) ) + { + stabilizationStartTimeMs = getMSTimerCount(); + currPresLimitsState = PRESSURE_LIMITS_STATE_STABILIZATION; + } + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PRES_LIMITS_INVALID_STATE, currPresLimitsState ) + break; + } } /*********************************************************************//** @@ -462,7 +664,8 @@ * @brief * The checkArterialPressureInRange function checks that artieral pressure is * within the set alarm limits. Alarm is triggered if not. - * @details Inputs: arterialPressure + * @details Inputs: arterialPressure, pressureLimitsActive, currentArterialMinLimit, + * currentArterialMaxLimit * @details Outputs: Alarm if out of range * @return none *************************************************************************/ @@ -474,57 +677,33 @@ if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_ARTERIAL_PRESSURE_CHECK ) != SW_CONFIG_ENABLE_VALUE ) #endif { - TREATMENT_STATE_T txState = getTreatmentState(); - // Check arterial pressure is in absolute max range if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_ARTERIAL_PRESSURE_OUT_OF_RANGE, ( artPres > ARTERIAL_PRESSURE_MAX_MMHG || artPres < ARTERIAL_PRESSURE_MIN_MMHG ) ) ) { SET_ALARM_WITH_1_F32_DATA( ALARM_ID_HD_ARTERIAL_PRESSURE_OUT_OF_RANGE, artPres ); } - // Check arterial pressure during treatment mode against either user set limits or fixed max limits depending on treatment state - if ( ( MODE_TREA == getCurrentOperationMode() ) && - ( ( ( TREATMENT_DIALYSIS_STATE == txState ) && ( DIALYSIS_UF_STATE == getDialysisState() ) ) || - ( ( TREATMENT_STOP_STATE == txState ) && ( TRUE == isBloodPumpRunning() ) ) ) ) + // Check arterial pressure when limits active + if ( pressureLimitsActive != FALSE ) { - F32 artLowLimit = (F32)getTreatmentParameterS32( TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ); - F32 artHighLimit = (F32)getTreatmentParameterS32( TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ); BOOL artPresLow, artPresHigh; - artPresLow = ( artPres < artLowLimit ? TRUE : FALSE ); - artPresHigh = ( artPres > artHighLimit ? TRUE : FALSE ); + artPresLow = ( artPres < (F32)currentArterialMinLimit ? TRUE : FALSE ); + artPresHigh = ( artPres > (F32)currentArterialMaxLimit ? TRUE : FALSE ); - // Check arterial pressure is within user set alarm limits + // Check arterial pressure is within alarm limits if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_ARTERIAL_PRESSURE_LOW, artPresLow ) ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_ARTERIAL_PRESSURE_LOW, artPres, artLowLimit ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_ARTERIAL_PRESSURE_LOW, artPres, (F32)currentArterialMinLimit ); } - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_ARTERIAL_PRESSURE_HIGH, artPresHigh ) ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_ARTERIAL_PRESSURE_HIGH, artPres, artHighLimit ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_ARTERIAL_PRESSURE_HIGH, artPres, (F32)currentArterialMaxLimit ); } } - else if ( MODE_TREA == getCurrentOperationMode() ) // All treatment states not covered by the if above - { - F32 artLowLimit = (F32)getS32TreatmentParamLowerRangeLimit( TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ); - F32 artHighLimit = (F32)getS32TreatmentParamUpperRangeLimit( TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ); - BOOL artPresLow = ( artPres < artLowLimit ? TRUE : FALSE ); - BOOL artPresHigh = ( artPres > artHighLimit ? TRUE : FALSE ); - - // Check arterial pressure is within max selectable range - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_ARTERIAL_PRESSURE_LOW, artPresLow ) ) - { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_ARTERIAL_PRESSURE_LOW, artPres, artLowLimit ); - } - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_ARTERIAL_PRESSURE_HIGH, artPresHigh ) ) - { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_ARTERIAL_PRESSURE_HIGH, artPres, artHighLimit ); - } - } else - { // Reset persistence if alarm is out of scope + { // Reset persistence if limits inactive isPersistentAlarmTriggered( ALARM_ID_HD_ARTERIAL_PRESSURE_LOW, FALSE ); isPersistentAlarmTriggered( ALARM_ID_HD_ARTERIAL_PRESSURE_HIGH, FALSE ); } @@ -535,7 +714,8 @@ * @brief * The checkVenousPressureInRange function checks that venous pressure is * within the set alarm limits. Alarm is triggered if not. - * @details Inputs: venousPressure + * @details Inputs: venousPressure, pressureLimitsActive, currentVenousMinLimit + * currentVenousMaxLimit * @details Outputs: Alarm if out of range * @return none *************************************************************************/ @@ -547,71 +727,39 @@ if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_VENOUS_PRESSURE_CHECK ) != SW_CONFIG_ENABLE_VALUE ) #endif { - TREATMENT_STATE_T txState = getTreatmentState(); - // Check venous pressure is in absolute max range if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_OUT_OF_RANGE, ( venPres > VENOUS_PRESSURE_MAX_MMHG || venPres < VENOUS_PRESSURE_MIN_MMHG ) ) ) { SET_ALARM_WITH_1_F32_DATA( ALARM_ID_HD_VENOUS_PRESSURE_OUT_OF_RANGE, venPres ); } - // Check venous pressure during treatment mode against either user set limits or fixed max limits depending on treatment state - if ( ( MODE_TREA == getCurrentOperationMode() ) && - ( ( ( TREATMENT_DIALYSIS_STATE == txState ) && ( DIALYSIS_UF_STATE == getDialysisState() ) && ( TRUE == didTimeout( venPressureLimitDelayStart, VENOUS_PRESSURE_LIMIT_DELAY_MS ) ) ) || - ( ( TREATMENT_STOP_STATE == txState ) && ( TRUE == isBloodPumpRunning() ) ) ) ) + // Check venous pressure when limits active + if ( pressureLimitsActive != FALSE ) { - F32 venLowLimit = (F32)getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ); - F32 venHighLimit = (F32)getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ); BOOL venPresLow, venPresHigh; - venPresLow = ( venPres < venLowLimit ? TRUE : FALSE ); - venPresHigh = ( venPres > venHighLimit ? TRUE : FALSE ); + venPresLow = ( venPres < (F32)currentVenousMinLimit ? TRUE : FALSE ); + venPresHigh = ( venPres > (F32)currentVenousMaxLimit ? TRUE : FALSE ); - // Cannot monitor for low venous pressure while venting air trap + // Check arterial pressure is within alarm limits if ( getValveAirTrapStatus() != STATE_OPEN ) { if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_LOW, venPresLow ) ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_VENOUS_PRESSURE_LOW, venPres, venLowLimit ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_VENOUS_PRESSURE_LOW, venPres, (F32)currentVenousMinLimit ); } } else { // clear persistence if air trap valve is open isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_LOW, FALSE ); } - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_HIGH, venPresHigh ) ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_VENOUS_PRESSURE_HIGH, venPres, venHighLimit ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_VENOUS_PRESSURE_HIGH, venPres, (F32)currentVenousMaxLimit ); } } - else if ( MODE_TREA == getCurrentOperationMode() ) // All treatment states not covered by the if statement above - { - F32 venLowLimit = (F32)getS32TreatmentParamLowerRangeLimit( TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ); - F32 venHighLimit = (F32)getS32TreatmentParamUpperRangeLimit( TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ); - BOOL venPresLow = ( venPres < venLowLimit ? TRUE : FALSE ); - BOOL venPresHigh = ( venPres > venHighLimit ? TRUE : FALSE ); - - // Check venous pressure is within max selectable range - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_HIGH, venPresHigh ) ) - { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_VENOUS_PRESSURE_HIGH, venPres, venHighLimit ); - } - // Cannot monitor for low venous pressure while venting air trap - if ( getValveAirTrapStatus() != STATE_OPEN ) - { - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_LOW, venPresLow ) ) - { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_VENOUS_PRESSURE_LOW, venPres, venLowLimit ); - } - } - else - { // clear persistence if air trap valve is open - isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_LOW, FALSE ); - } - } else - { // Reset persistence if alarm is out of scope + { // Reset persistence if limits inactive isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_LOW, FALSE ); isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_HIGH, FALSE ); } @@ -696,7 +844,7 @@ #endif { if ( ( TRUE == txMode || TRUE == ptxMode ) && - ( venPres > getS32TreatmentParamUpperRangeLimit( TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ) + VENOUS_PRESSURE_OCCL_OFFSET_MMHG ) ) + ( venPres > VENOUS_PRESSURE_LIMIT_MAX_MMHG + VENOUS_PRESSURE_OCCL_OFFSET_MMHG ) ) { if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_LINE_OCCLUSION, TRUE ) ) { @@ -871,8 +1019,12 @@ PRESSURE_OCCLUSION_DATA_T data; data.arterialPressure = shortFilteredArterialPressure; - data.venousPressure = shortFilteredVenousPressure; - data.bldPumpOcclusion = getMeasuredBloodPumpOcclusion(); + data.venousPressure = shortFilteredVenousPressure; + data.bldPumpOcclusion = getMeasuredBloodPumpOcclusion(); + data.artMinLimit = currentArterialMinLimit; + data.artMaxLimit = currentArterialMaxLimit; + data.venMinLimit = currentVenousMinLimit; + data.venMaxLimit = currentVenousMaxLimit; broadcastData( MSG_ID_PRESSURE_OCCLUSION_DATA, COMM_BUFFER_OUT_CAN_HD_BROADCAST, (U08*)&data, sizeof( PRESSURE_OCCLUSION_DATA_T ) ); presOcclDataPublicationTimerCounter = 0;