Index: firmware/App/Controllers/PresOccl.c =================================================================== diff -u -r4fd6ae152395c8adb23de5085f4c5a0d1c680c78 -rf5d1bb355b444e008cd495c354b1d9f714cd2ef9 --- firmware/App/Controllers/PresOccl.c (.../PresOccl.c) (revision 4fd6ae152395c8adb23de5085f4c5a0d1c680c78) +++ firmware/App/Controllers/PresOccl.c (.../PresOccl.c) (revision f5d1bb355b444e008cd495c354b1d9f714cd2ef9) @@ -7,47 +7,52 @@ * * @file PresOccl.c * -* @author (last) Michael Garthwaite -* @date (last) 07-Feb-2023 +* @author (last) Darren Cox +* @date (last) 24-Aug-2023 * * @author (original) Sean * @date (original) 15-Jan-2020 * ***************************************************************************/ - + #include "PresOccl.h" -#include "AirPump.h" +#include "AirPump.h" #include "AlarmMgmt.h" -#include "BloodFlow.h" +#include "BloodFlow.h" #include "FPGA.h" +#include "ModeTreatment.h" #include "ModeTreatmentParams.h" -#include "NVDataMgmt.h" +#include "NVDataMgmt.h" #include "OperationModes.h" -#include "PersistentAlarm.h" +#include "PersistentAlarm.h" #include "SystemCommMessages.h" -#include "SelfTests.h" +#include "SelfTests.h" #include "TaskGeneral.h" -#include "Temperatures.h" +#include "Temperatures.h" #include "Timers.h" -#include "Valves.h" - -/** - * @addtogroup PressureOcclusion - * @{ - */ - -// ********** 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. +#include "Valves.h" -#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 +/** + * @addtogroup PressureOcclusion + * @{ + */ + +// ********** 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_LIMIT_STABILIZATION_TIME_MS ( 60 * MS_PER_SECOND ) ///< Duration of pressure limit stabilization period (in ms). +#define PRES_LIMIT_SHORT_STABILIZE_TIME_MS ( 5 * MS_PER_SECOND ) ///< Duration of pressure limit short 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 #define ARTERIAL_PRESSURE_V_PER_BIT ( ARTERIAL_PRESSURE_V_BIAS / \ - (F32)ARTERIAL_PRESSURE_CONVERSION_OFFSET ) ///< Volts per bit in 24-bit arterial pressure sensor reading. - -#define VENOUS_PRESSURE_OFFSET ( 1638 ) ///< Offset for 14-bit venous pressure sensor reading. + (F32)ARTERIAL_PRESSURE_CONVERSION_OFFSET ) ///< Volts per bit in 24-bit arterial pressure sensor reading. + +#define VENOUS_PRESSURE_OFFSET ( 1638 ) ///< Offset for 14-bit venous pressure sensor reading. #define VENOUS_PRESSURE_SCALE ( 14745 - VENOUS_PRESSURE_OFFSET ) ///< Scale for venous pressure sensor. #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). @@ -63,48 +68,56 @@ #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_ND_MIN_MMHG ( -250.0F ) ///< Minimum arterial pressure reading (in mmHg) when not dialyzing. +#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_ND_MAX_MMHG ( 300.0F ) ///< Maximum venous pressure reading (in mmHg) when not dialyzing. +#define VENOUS_PRESSURE_LIMIT_MAX_MMHG ( 400.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_PRES_AT_FILL_DELAY_MAX_BLOOD_VOL_ML ( 41.667F ) ///< Venous pressure low exemption delay after air trap fill maximum blood volume (in mL). +/// Venous pressure low exemption period (in task intervals) conversion factor (from Qb in mL/min) following an air trap fill. +static const U32 VENOUS_PRES_AT_FILL_DELAY_FACTOR = (U32)( VENOUS_PRES_AT_FILL_DELAY_MAX_BLOOD_VOL_ML * (F32)SEC_PER_MIN * ( (F32)MS_PER_SECOND / (F32)TASK_GENERAL_INTERVAL ) ); + #define PSI_TO_MMHG ( 51.7149F ) ///< Conversion factor for converting PSI to mmHg. #define VENOUS_PRESSURE_NORMAL_OP 0 ///< Venous pressure status bits indicate normal operation. #define VENOUS_PRESSURE_CMD_MODE 1 ///< Venous pressure status bits indicate sensor in command mode. #define VENOUS_PRESSURE_STALE_DATA 2 ///< Venous pressure status bits indicate data is stale (no new data since last fpga read). #define VENOUS_PRESSURE_DIAG_CONDITION 3 ///< Venous pressure status bits diagnostic condition (alarm). -// The new arterial pressure sensor is the same as the venous pressure sensor #define ARTERIAL_PRESSURE_NORMAL_OP 0 ///< Arterial pressure status bits indicate normal operation. #define ARTERIAL_PRESSURE_CMD_MODE 1 ///< Arterial pressure status bits indicate sensor in command mode. #define ARTERIAL_PRESSURE_STALE_DATA 2 ///< Arterial pressure status bits indicate data is stale (no new data since last fpga read). #define ARTERIAL_PRESSURE_DIAG_CONDITION 3 ///< Arterial pressure status bits diagnostic condition (alarm). #define OCCLUSION_THRESHOLD_OFFSET 5500 ///< Threshold offset. Combined with initial reading after cartridge install, a threshold is derived above which an occlusion is detected. -#define OCCLUSION_CLEAR_THRESHOLD_OFFSET 5500 ///< Threshold offset. Combined with initial reading after cartridge install, a threshold is derived below which an occlusion is cleared. +#define OCCLUSION_CLEAR_THRESHOLD_OFFSET 5000 ///< Threshold offset. Combined with initial reading after cartridge install, a threshold is derived below which an occlusion is cleared. #define CARTRIDGE_LOADED_THRESHOLD 5000 ///< Threshold above which a cartridge is considered loaded. #define MIN_OCCLUSION_COUNTS 2000 ///< Minimum occlusion sensor reading for range check. -#define MAX_OCCLUSION_COUNTS 32766 ///< Maximum occlusion sensor reading for range check. #define OCCLUSION_CARTRIDGE_LOADED_PRESSURE_READING_MAX 24500 ///< Occlusion sensors maximum pressure reading limit when cartridge is considered loaded. -#define EMPTY_SALINE_BAG_THRESHOLD_MMHG -300.0F ///< Threshold below which the saline bag is considered empty (in mmHg). TODO - get real threshold from Systems +#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). static const U32 EMPTY_SALINE_BAG_PERSISTENCE = ( 250 / TASK_GENERAL_INTERVAL ); ///< Time that saline bag looks empty before saying it is empty. #define PRES_ALARM_PERSISTENCE ( 1 * MS_PER_SECOND ) ///< Alarm persistence period for pressure alarms. #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 ) /// Measured arterial pressure is filtered w/ 1 second moving average for inline pressure. #define SIZE_OF_SHORT_ART_ROLLING_AVG ( ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) * 1 ) +/// Measured arterial pressure is filtered w/ 10 second moving average for pressure compensation of flow. +#define SIZE_OF_LONG_VEN_ROLLING_AVG ( ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) * 10 ) /// Measured venous pressure is filtered w/ 1 second moving average for inline pressure and unfiltered for occlusion detection. #define SIZE_OF_SHORT_VEN_ROLLING_AVG ( ( MS_PER_SECOND / TASK_GENERAL_INTERVAL ) * 1 ) @@ -115,39 +128,53 @@ #ifndef _RELEASE_ #define MIN_OCCLUSION_COUNTS_V3 1500 ///< Minimum occlusion count for v3 hardware -#endif -/// Defined states for the pressure and occlusion monitor state machine. -typedef enum PresOccl_States -{ - PRESSURE_WAIT_FOR_POST_STATE = 0, ///< Wait for POST state. - PRESSURE_CONTINUOUS_READ_STATE, ///< Continuous read sensors state. - NUM_OF_PRESSURE_STATES ///< Number of pressure/occlusion monitor states. -} PRESSURE_STATE_T; - -/// Defined states for the pressure and occlusion self-test state machine. -typedef enum PresOccl_Self_Test_States -{ - PRESSURE_SELF_TEST_STATE_START = 0, ///< Self test start state. - PRESSURE_TEST_STATE_IN_PROGRESS, ///< Self test in progress state. - PRESSURE_TEST_STATE_COMPLETE, ///< Self test completed state. - NUM_OF_PRESSURE_SELF_TEST_STATES ///< Number of pressure/occlusion self-test states. -} PRESSURE_SELF_TEST_STATE_T; - -// ********** private data ********** - -static PRESSURE_STATE_T presOcclState; ///< Current state of pressure monitor state machine. -static U32 presOcclDataPublicationTimerCounter = 0; ///< Used to schedule pressure data publication to CAN bus. - +#endif +/// Defined states for the pressure and occlusion monitor state machine. +typedef enum PresOccl_States +{ + PRESSURE_WAIT_FOR_POST_STATE = 0, ///< Wait for POST state. + PRESSURE_CONTINUOUS_READ_STATE, ///< Continuous read sensors state. + NUM_OF_PRESSURE_STATES ///< Number of pressure/occlusion monitor states. +} PRESSURE_STATE_T; + +/// Defined states for the pressure and occlusion self-test state machine. +typedef enum PresOccl_Self_Test_States +{ + PRESSURE_SELF_TEST_STATE_START = 0, ///< Self test start state. + PRESSURE_TEST_STATE_IN_PROGRESS, ///< Self test in progress state. + PRESSURE_TEST_STATE_COMPLETE, ///< Self test completed state. + NUM_OF_PRESSURE_SELF_TEST_STATES ///< Number of pressure/occlusion self-test states. +} PRESSURE_SELF_TEST_STATE_T; + +// ********** private data ********** + +static PRESSURE_STATE_T presOcclState; ///< Current state of pressure monitor state machine. +static U32 presOcclDataPublicationTimerCounter = 0; ///< Used to schedule pressure data publication to CAN bus. +static U32 venLowPresExemptAfterAirTrapFillTimerCtr; ///< Exempt low ven pressure limit alarm for a time following an air trap fill. + /// Interval (in ms) at which to publish pressure/occlusion data to CAN bus. -static OVERRIDE_U32_T presOcclDataPublishInterval = { PRES_OCCL_DATA_PUB_INTERVAL, PRES_OCCL_DATA_PUB_INTERVAL, 0, 0 }; +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_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 PRESSURE_LIMITS_STATES_T currPresLimitsState; ///< Current pressure limits state. +static F32 arterialPressureOffset; ///< Arterial pressure sensor offset (in mmHg). +static F32 venousPressureOffset; ///< Venous pressure sensor offset (in mmHg). +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. +static OVERRIDE_F32_T shortFilteredArterialPressure = { 0.0, 0.0, 0.0, 0 }; ///< Measured arterial pressure after short (1 s) filter. +static F32 longFilteredVenousPressure; ///< Measured venous pressure after long (10 s) filter. +static OVERRIDE_F32_T shortFilteredVenousPressure = { 0.0, 0.0, 0.0, 0 }; ///< Measured venous pressure after short (1 s) filter. +static BOOL useShortStabilizeTime; ///< Flag to use short stabilize time. -static U32 bloodPumpOcclusionAfterCartridgeInstall; ///< Measured blood pump occlusion reading taken after cartridge install. +static U32 bloodPumpOcclusionAfterCartridgeInstall; ///< Measured blood pump occlusion reading taken after cartridge install. static U32 emptySalineBagCtr = 0; ///< Timer counter for empty bag detection. @@ -161,44 +188,52 @@ static F32 artPressureReadingsShortTotal = 0.0; ///< Rolling total - used to calc average. static U32 artPressureReadingsShortCount = 0; ///< Number of samples in flow rolling average buffer. +static F32 venPressureReadingsLong[ SIZE_OF_LONG_VEN_ROLLING_AVG ]; ///< Holds flow samples for long venous pressure rolling average. +static U32 venPressureReadingsLongIdx = 0; ///< Index for next sample in rolling average array. +static F32 venPressureReadingsLongTotal = 0.0; ///< Rolling total - used to calc average. +static U32 venPressureReadingsLongCount = 0; ///< Number of samples in flow rolling average buffer. + static F32 venPressureReadingsShort[ SIZE_OF_SHORT_VEN_ROLLING_AVG ]; ///< Holds flow samples for long arterial pressure rolling average. 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 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. -// ********** private function prototypes ********** +// ********** private function prototypes ********** -static PRESSURE_STATE_T handlePresOcclWaitForPOSTState( void ); +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 checkVenousPressureInRange( void ); +static void checkOcclusions( void ); +static void publishPresOcclData( void ); +static void determineArtVenPressureLimits( void ); static void filterInlinePressureReadings( F32 artPres, F32 venPres ); - -/*********************************************************************//** - * @brief - * The initPresOccl function initializes the PresOccl module. - * @details Inputs: none - * @details Outputs: PresOccl module initialized. - * @return none - *************************************************************************/ -void initPresOccl( void ) -{ + +/*********************************************************************//** + * @brief + * The initPresOccl function initializes the PresOccl module. + * @details Inputs: none + * @details Outputs: PresOccl module initialized. + * @return none + *************************************************************************/ +void initPresOccl( void ) +{ // Initialize persistent pressure alarms - initPersistentAlarm( ALARM_ID_ARTERIAL_PRESSURE_LOW, 0, PRES_ALARM_PERSISTENCE ); - initPersistentAlarm( ALARM_ID_ARTERIAL_PRESSURE_HIGH, 0, PRES_ALARM_PERSISTENCE ); - initPersistentAlarm( ALARM_ID_VENOUS_PRESSURE_LOW, 0, PRES_ALARM_PERSISTENCE ); - initPersistentAlarm( ALARM_ID_VENOUS_PRESSURE_HIGH, 0, PRES_ALARM_PERSISTENCE ); + initPersistentAlarm( ALARM_ID_HD_ARTERIAL_PRESSURE_LOW, 0, PRES_ALARM_PERSISTENCE ); + initPersistentAlarm( ALARM_ID_HD_ARTERIAL_PRESSURE_HIGH, 0, PRES_ALARM_PERSISTENCE ); + initPersistentAlarm( ALARM_ID_HD_VENOUS_PRESSURE_LOW, 0, PRES_ALARM_PERSISTENCE ); + initPersistentAlarm( ALARM_ID_HD_VENOUS_PRESSURE_HIGH, 0, PRES_ALARM_PERSISTENCE ); initPersistentAlarm( ALARM_ID_HD_ARTERIAL_PRESSURE_OUT_OF_RANGE, 0, PRES_ALARM_PERSISTENCE ); initPersistentAlarm( ALARM_ID_HD_VENOUS_PRESSURE_OUT_OF_RANGE, 0, PRES_ALARM_PERSISTENCE ); initPersistentAlarm( ALARM_ID_HD_BP_OCCLUSION_OUT_OF_RANGE, 0, PRES_OCCL_ALARM_PERSISTENCE ); - initPersistentAlarm( ALARM_ID_HD_VENOUS_LINE_OCCLUSION, 0, VEN_OCCL_ALARM_PERSISTENCE ); + initPersistentAlarm( ALARM_ID_HD_VENOUS_LINE_OCCLUSION, 0, PRES_ALARM_PERSISTENCE ); // Initialize the FPGA persistent alarms initFPGAPersistentAlarm( FPGA_PERS_ERROR_OCCLUSION_PRESSURE_SENSOR, ALARM_ID_HD_OCCLUSION_SENSOR_FPGA_FAULT, @@ -208,17 +243,60 @@ 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 ); - 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; -} - + setPressureLimitsToOuterBounds(); + + currPresLimitsState = PRESSURE_LIMITS_STATE_OFF; + pressureLimitsActive = FALSE; + stabilizationStartTimeMs = 0; + stableArterialPressure = 0; + stableVenousPressure = 0; + venLowPresExemptAfterAirTrapFillTimerCtr = 0; + resetArtVenPressureOffsets(); + longFilteredArterialPressure = 0.0F; + shortFilteredArterialPressure.data = 0.0F; + longFilteredVenousPressure = 0.0F; + shortFilteredVenousPressure.data = 0.0F; + presOcclDataPublicationTimerCounter = DATA_PUBLISH_COUNTER_START_COUNT; + presOcclState = PRESSURE_WAIT_FOR_POST_STATE; + presOcclPostState = PRESSURE_SELF_TEST_STATE_START; + bloodPumpOcclusionAfterCartridgeInstall = 0; + useShortStabilizeTime = USE_NORMAL_STABILIZATION_PERIOD; +} + /*********************************************************************//** * @brief + * The resetArtVenPressureOffsets function resets the arterial and venous + * offsets to zero. + * @details Inputs: none + * @details Outputs: arterialPressureOffset, venousPressureOffset + * @return none + *************************************************************************/ +void resetArtVenPressureOffsets( void ) +{ + arterialPressureOffset = 0.0F; + venousPressureOffset = 0.0F; +} + +/*********************************************************************//** + * @brief + * The setArtVenPressureOffsets function sets the arterial and venous + * offsets to current readings. + * @details Inputs: none + * @details Outputs: arterialPressureOffset, venousPressureOffset + * @return none + *************************************************************************/ +void setArtVenPressureOffsets( void ) +{ + arterialPressureOffset = getMeasuredArterialPressure(); + venousPressureOffset = getMeasuredVenousPressure(); + if ( ( fabs( arterialPressureOffset ) > MAX_ART_VEN_OFFSET_MMHG ) || ( fabs( venousPressureOffset ) > MAX_ART_VEN_OFFSET_MMHG ) ) + { + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_PRE_TREATMENT_DRY_PRESSURE_TEST_FAILURE, arterialPressureOffset, venousPressureOffset ); + } +} + +/*********************************************************************//** + * @brief * The isCartridgeLoaded function determines whether a cartridge has been * properly loaded by looking at the BP occlusion pressure sensor. * @details Inputs: BP occlusion pressure @@ -302,37 +380,156 @@ } } -/*********************************************************************//** - * @brief - * The execPresOccl function executes the pressure and occlusion monitor. - * @details Inputs: presOcclState - * @details Outputs: presOcclState - * @return none - *************************************************************************/ -void execPresOccl( void ) -{ - // State machine - switch ( presOcclState ) - { - case PRESSURE_WAIT_FOR_POST_STATE: - presOcclState = handlePresOcclWaitForPOSTState(); - break; - - case PRESSURE_CONTINUOUS_READ_STATE: - presOcclState = handlePresOcclContReadState(); - break; - - default: - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PRES_OCCL_INVALID_STATE, presOcclState ) - break; - } - - // Publish pressure/occlusion data on interval - publishPresOcclData(); +/*********************************************************************//** + * @brief + * The setPressureLimitsToOuterBounds function sets the min/max pressure + * limits for arterial and venous pressure to their outer boundaries. + * @details Inputs: none + * @details Outputs: currentArterialMaxLimit, currentArterialMinLimit, + * currentVenousMaxLimit, currentVenousMinLimit + * @return none + *************************************************************************/ +void setPressureLimitsToOuterBounds( void ) +{ + 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: useShortStabilizeTime + * @details Outputs: stableArterialPressure, stableVenousPressure + * @return none + *************************************************************************/ +void updatePressureLimitWindows( void ) +{ + F32 filtArt; + F32 filtVen; + S32 curArtPres; + S32 curVenPres; + + if ( USE_SHORT_STABILIZATION_PERIOD == useShortStabilizeTime ) + { + filtArt = getFilteredArterialPressure(); + filtVen = getFilteredVenousPressure(); + } + else + { + F32 filtArt = getLongFilteredArterialPressure(); + F32 filtVen = getLongFilteredVenousPressure(); + } + + curArtPres = FLOAT_TO_INT_WITH_ROUND( filtArt ); + 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 signalInitiatePressureStabilization 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. + * Else reset stabilize counter. + * @details Inputs: currPresLimitsState + * @details Outputs: currPresLimitsState, stabilizationStartTimeMs, useShortStabilizeTime + * @param useShort Flag to use short stabilization period. Use defines: + * USE_NORMAL_STABILIZATION_PERIOD, USE_SHORT_STABILIZATION_PERIOD + * @return none + *************************************************************************/ +void signalInitiatePressureStabilization( BOOL useShort ) +{ + useShortStabilizeTime = useShort; + + // User update of blood/dialysate flow rate or UF rate or 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. + * @details Inputs: presOcclState + * @details Outputs: presOcclState + * @return none + *************************************************************************/ +void execPresOccl( void ) +{ + // State machine + switch ( presOcclState ) + { + case PRESSURE_WAIT_FOR_POST_STATE: + presOcclState = handlePresOcclWaitForPOSTState(); + break; + + case PRESSURE_CONTINUOUS_READ_STATE: + presOcclState = handlePresOcclContReadState(); + break; + + default: + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_SOFTWARE_FAULT, SW_FAULT_ID_PRES_OCCL_INVALID_STATE, presOcclState ) + break; + } + + // Publish pressure/occlusion data on interval + publishPresOcclData(); +} + +/*********************************************************************//** + * @brief * The handlePresOcclWaitForPOSTState function handles the wait for POST * state. * @details Inputs: presOcclPostState @@ -349,18 +546,18 @@ } return result; -} - -/*********************************************************************//** - * @brief - * The handlePresOcclContReadState function handles the continuous read state - * of the pressure/occlusion monitor state machine. - * @details Inputs: FPGA pressure/occlusion readings - * @details Outputs: pressure sensor values updated - * @return next state - *************************************************************************/ -static PRESSURE_STATE_T handlePresOcclContReadState( void ) -{ +} + +/*********************************************************************//** + * @brief + * The handlePresOcclContReadState function handles the continuous read state + * of the pressure/occlusion monitor state machine. + * @details Inputs: FPGA pressure/occlusion readings + * @details Outputs: pressure sensor values updated + * @return next state + *************************************************************************/ +static PRESSURE_STATE_T handlePresOcclContReadState( void ) +{ PRESSURE_STATE_T result = PRESSURE_CONTINUOUS_READ_STATE; // Read latest in-line (arterial and venous) pressures @@ -369,18 +566,127 @@ // 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(); + checkVenousPressureInRange(); - // Check for occlusions + // Check for occlusions checkOcclusions(); - return result; -} + 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(); + BOOL bpRampComplete = isBloodPumpRampComplete(); + HD_OP_MODE_T currMode = getCurrentOperationMode(); + TREATMENT_STATE_T currTxState = getTreatmentState(); + U32 stabilizeTime = PRES_LIMIT_STABILIZATION_TIME_MS; + + if ( currMode != MODE_TREA ) + { + currPresLimitsState = PRESSURE_LIMITS_STATE_OFF; + } + + switch ( currPresLimitsState ) + { + case PRESSURE_LIMITS_STATE_OFF: + if ( ( MODE_TREA == currMode ) && ( currTxState != TREATMENT_RECIRC_STATE ) ) + { // 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 == bpRampComplete ) + { + 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(); + useShortStabilizeTime = USE_NORMAL_STABILIZATION_PERIOD; + currPresLimitsState = PRESSURE_LIMITS_STATE_STABILIZATION; + } + else if ( currTxState == TREATMENT_RECIRC_STATE ) + { + currPresLimitsState = PRESSURE_LIMITS_STATE_OFF; + } + break; + + case PRESSURE_LIMITS_STATE_STABILIZATION: + if ( USE_SHORT_STABILIZATION_PERIOD == useShortStabilizeTime ) + { + stabilizeTime = PRES_LIMIT_SHORT_STABILIZE_TIME_MS; + } + else + { + stabilizeTime = PRES_LIMIT_STABILIZATION_TIME_MS; + } + + 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(); + useShortStabilizeTime = USE_NORMAL_STABILIZATION_PERIOD; + 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(); + useShortStabilizeTime = USE_NORMAL_STABILIZATION_PERIOD; + 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; + } +} + +/*********************************************************************//** + * @brief * The convertInlinePressures function reads inline pressure sensor readings * and converts to mmHg. Sensor status/alarm is checked. * @details Inputs: none @@ -402,23 +708,29 @@ U16 artPres = fpgaArtPres & 0x3FFF; U08 artPresStatus = (U08)( fpgaArtPres >> SHIFT_14_BITS ); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_ARTERIAL_PRESSURE_SENSOR, artErrorCtr, artReadCtr ); - //checkFPGAPersistentAlarms( FPGA_PERS_ERROR_VENOUS_PRESSURE_SESNOR, venReadCtr, venReadCtr ); // TODO investigate this with Noe + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_ARTERIAL_PRESSURE_SENSOR, artReadCtr ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_VENOUS_PRESSURE_SESNOR, venReadCtr ); if ( ARTERIAL_PRESSURE_NORMAL_OP == artPresStatus ) { + F32 artPresPSI; + // If the arterial pressure status is normal, convert the counts to pressure in mmHg - arterialPressure.data = ( (F32)( artPres - ARTERIAL_PRESSURE_OFFSET ) * + artPresPSI = ( (F32)( artPres - ARTERIAL_PRESSURE_OFFSET ) * ( ARTERIAL_PRESSURE_MAX_PSI - ARTERIAL_PRESSURE_MIN_PSI ) / (F32)ARTERIAL_PRESSURE_SCALE ) + ARTERIAL_PRESSURE_MIN_PSI; - arterialPressure.data = arterialPressure.data * PSI_TO_MMHG; + artPresPSI = artPresPSI * PSI_TO_MMHG; + arterialPressure.data = artPresPSI - arterialPressureOffset; } if ( VENOUS_PRESSURE_NORMAL_OP == venPresStatus ) { + F32 venPresPSI; + // Convert venous pressure to PSI and then mmHg - F32 venPresPSI = ( (F32)( venPres - VENOUS_PRESSURE_OFFSET ) * ( VENOUS_PRESSURE_MAX_PSI - VENOUS_PRESSURE_MIN_PSI ) / (F32)VENOUS_PRESSURE_SCALE ) + - VENOUS_PRESSURE_MIN_PSI; - venousPressure.data = venPresPSI * PSI_TO_MMHG; + venPresPSI = ( (F32)( venPres - VENOUS_PRESSURE_OFFSET ) * + ( VENOUS_PRESSURE_MAX_PSI - VENOUS_PRESSURE_MIN_PSI ) / (F32)VENOUS_PRESSURE_SCALE ) + VENOUS_PRESSURE_MIN_PSI; + venPresPSI = venPresPSI * PSI_TO_MMHG; + venousPressure.data = venPresPSI - venousPressureOffset; } // Filter inline pressure readings @@ -437,7 +749,7 @@ U08 bpReadCtr = getFPGABloodPumpOcclusionReadCounter(); U08 bpErrorCtr = getFPGABloodPumpOcclusionErrorCounter(); - checkFPGAPersistentAlarms( FPGA_PERS_ERROR_OCCLUSION_PRESSURE_SENSOR, bpErrorCtr, bpReadCtr ); + checkFPGAPersistentAlarms( FPGA_PERS_ERROR_OCCLUSION_PRESSURE_SENSOR, bpReadCtr ); // Record occlusion sensor readings bloodPumpOcclusion.data = (U32)getFPGABloodPumpOcclusion(); @@ -447,7 +759,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 *************************************************************************/ @@ -459,54 +772,35 @@ 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 ) && ( getDialysisState() != DIALYSIS_SALINE_BOLUS_STATE ) ) || - ( ( TREATMENT_STOP_STATE == txState ) && ( TRUE == isBloodPumpRunning() ) ) || - ( TREATMENT_BLOOD_PRIME_STATE == txState ) ) ) + // 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; - // If BP is ramping up, extend range to outer limits as pressure may not yet have reached expected range. - if ( isBloodPumpRampComplete() != TRUE ) - { - artLowLimit = (F32)getS32TreatmentParamLowerRangeLimit( TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ); - artHighLimit = (F32)getS32TreatmentParamUpperRangeLimit( TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ); - } + artPresLow = ( artPres < (F32)currentArterialMinLimit ? TRUE : FALSE ); + artPresHigh = ( artPres > (F32)currentArterialMaxLimit ? TRUE : FALSE ); - // Check arterial pressure is within user set alarm limits - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_ARTERIAL_PRESSURE_LOW, artPres < artLowLimit ) ) + // 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_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_ARTERIAL_PRESSURE_HIGH, artPres > artHighLimit ) ) + if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_ARTERIAL_PRESSURE_HIGH, artPresHigh ) ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_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 - { - // Check arterial pressure is within non-treatment alarm limits - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_ARTERIAL_PRESSURE_LOW, artPres < ARTERIAL_PRESSURE_ND_MIN_MMHG ) ) - { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_ARTERIAL_PRESSURE_LOW, artPres, ARTERIAL_PRESSURE_ND_MIN_MMHG ); - } - } else - { // Reset persistence if alarm is out of scope - isPersistentAlarmTriggered( ALARM_ID_ARTERIAL_PRESSURE_LOW, FALSE ); - isPersistentAlarmTriggered( ALARM_ID_ARTERIAL_PRESSURE_HIGH, FALSE ); + { // Reset persistence if limits inactive + isPersistentAlarmTriggered( ALARM_ID_HD_ARTERIAL_PRESSURE_LOW, FALSE ); + isPersistentAlarmTriggered( ALARM_ID_HD_ARTERIAL_PRESSURE_HIGH, FALSE ); } } } @@ -515,94 +809,90 @@ * @brief * The checkVenousPressureInRange function checks that venous pressure is * within the set alarm limits. Alarm is triggered if not. - * @details Inputs: venousPressure - * @details Outputs: Alarm if out of range + * @details Inputs: venousPressure, pressureLimitsActive, currentVenousMinLimit + * currentVenousMaxLimit, venLowPresExemptAfterAirTrapFillTimerCtr + * @details Outputs: venLowPresExemptAfterAirTrapFillTimerCtr, alarm if out of range * @return none *************************************************************************/ static void checkVenousPressureInRange( void ) { F32 venPres = getFilteredVenousPressure(); + OPN_CLS_STATE_T airTrapValveState = getValveAirTrapStatus(); + // track time since last air trap fill + if ( STATE_OPEN == airTrapValveState ) + { + venLowPresExemptAfterAirTrapFillTimerCtr = 0; + } + else + { + venLowPresExemptAfterAirTrapFillTimerCtr++; + } + #ifndef _RELEASE_ 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 ) && ( getDialysisState() != DIALYSIS_SALINE_BOLUS_STATE ) ) || - ( ( TREATMENT_STOP_STATE == txState ) && ( TRUE == isBloodPumpRunning() ) ) || - ( TREATMENT_BLOOD_PRIME_STATE == txState ) ) ) + // 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; + S32 qB = abs( getTargetBloodFlowRate() ); + U32 qBx = ( 0 == qB ? MIN_SET_BLOOD_FLOW_RATE : (U32)qB ); + // compute exemption period (in general task intervals) for low venous pressure alarms after air trap fills + U32 exemptPeriod = VENOUS_PRES_AT_FILL_DELAY_FACTOR / qBx; - // If BP is ramping up, extend range to outer limits as pressure may not yet have reached expected range. - if ( isBloodPumpRampComplete() != TRUE ) - { - venLowLimit = MIN_VENOUS_PRESSURE_FOR_RAMP_MMHG; - venHighLimit = (F32)getS32TreatmentParamUpperRangeLimit( TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ); - } + venPresLow = ( venPres < (F32)currentVenousMinLimit ? TRUE : FALSE ); + venPresHigh = ( venPres > (F32)currentVenousMaxLimit ? TRUE : FALSE ); - // Cannot monitor for low venous pressure while venting air trap - if ( getValveAirTrapStatus() != STATE_OPEN ) + // Check venous pressure is within alarm limits + if ( ( airTrapValveState != STATE_OPEN ) && ( venLowPresExemptAfterAirTrapFillTimerCtr > exemptPeriod ) ) { - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_VENOUS_PRESSURE_LOW, venPres < venLowLimit ) ) + if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_LOW, venPresLow ) ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_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_VENOUS_PRESSURE_LOW, FALSE ); + isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_LOW, FALSE ); } - - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_VENOUS_PRESSURE_HIGH, venPres > venHighLimit ) ) + if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_HIGH, venPresHigh ) ) { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_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 - { - // Check venous pressure is less than non-treatment alarm limit - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_VENOUS_PRESSURE_HIGH, venPres > VENOUS_PRESSURE_ND_MAX_MMHG ) ) - { - SET_ALARM_WITH_2_F32_DATA( ALARM_ID_VENOUS_PRESSURE_HIGH, venPres, VENOUS_PRESSURE_ND_MAX_MMHG ); - } - isPersistentAlarmTriggered( ALARM_ID_VENOUS_PRESSURE_LOW, FALSE ); - } else - { // Reset persistence if alarm is out of scope - isPersistentAlarmTriggered( ALARM_ID_VENOUS_PRESSURE_LOW, FALSE ); - isPersistentAlarmTriggered( ALARM_ID_VENOUS_PRESSURE_HIGH, FALSE ); + { // Reset persistence if limits inactive + isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_LOW, FALSE ); + isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_PRESSURE_HIGH, FALSE ); } } } -/*********************************************************************//** - * @brief - * The checkPressureLimits function gets the pressure/occlusion data - * publication interval. - * @details Inputs: occlusion pressures for the pumps - * @details Outputs: Alarm if occlusion limit exceeded - * @return none - *************************************************************************/ -static void checkOcclusions( void ) -{ +/*********************************************************************//** + * @brief + * The checkPressureLimits function gets the pressure/occlusion data + * publication interval. + * @details Inputs: occlusion pressures for the pumps + * @details Outputs: Alarm if occlusion limit exceeded + * @return none + *************************************************************************/ +static void checkOcclusions( void ) +{ U32 bpOccl = getMeasuredBloodPumpOcclusion(); - BOOL outOfRange = ( bpOccl < MIN_OCCLUSION_COUNTS || bpOccl > MAX_OCCLUSION_COUNTS ? TRUE : FALSE ); + BOOL outOfRange = ( bpOccl < MIN_OCCLUSION_COUNTS ? TRUE : FALSE ); #ifndef _RELEASE_ if( HW_CONFIG_BETA == getHardwareConfigStatus() ) { - outOfRange = (( bpOccl < MIN_OCCLUSION_COUNTS_V3 || bpOccl > MAX_OCCLUSION_COUNTS ? TRUE : FALSE )); + outOfRange = ( bpOccl < MIN_OCCLUSION_COUNTS_V3 ? TRUE : FALSE ); } #endif @@ -613,7 +903,6 @@ F32 venPres = getMeasuredVenousPressure(); HD_OP_MODE_T hdMode = getCurrentOperationMode(); U32 hdSubMode = getCurrentSubMode(); - BOOL txMode = ( MODE_TREA == hdMode ? TRUE : FALSE ); BOOL ptxMode = ( MODE_PRET == hdMode && hdSubMode > HD_PRE_TREATMENT_CART_INSTALL_STATE ? TRUE : FALSE ); // Range check occlusion sensor (OB) @@ -629,11 +918,11 @@ if ( ( TRUE == isBloodPumpRunning() ) && ( getPreTreatmentSubState() > HD_PRE_TREATMENT_CART_INSTALL_STATE ) && ( getDrySelfTestsState() > DRY_SELF_TESTS_START_STATE ) ) { - // Check for occlusion - if ( bpOccl > ( OCCLUSION_THRESHOLD_OFFSET + bloodPumpOcclusionAfterCartridgeInstall ) ) + // Check for occlusion + if ( bpOccl > ( OCCLUSION_THRESHOLD_OFFSET + bloodPumpOcclusionAfterCartridgeInstall ) ) { - signalBloodPumpHardStop(); // Stop pump immediately - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_OCCLUSION_BLOOD_PUMP, bpOccl, OCCLUSION_THRESHOLD_OFFSET + bloodPumpOcclusionAfterCartridgeInstall ) + signalBloodPumpHardStop(); // Stop pump immediately + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_OCCLUSION_BLOOD_PUMP, bpOccl, OCCLUSION_THRESHOLD_OFFSET + bloodPumpOcclusionAfterCartridgeInstall ) } } } @@ -647,41 +936,51 @@ if ( bpOccl > ( OCCLUSION_THRESHOLD_OFFSET + bloodPumpOcclusionAfterCartridgeInstall ) ) { signalBloodPumpHardStop(); // Stop pump immediately - SET_ALARM_WITH_2_U32_DATA( ALARM_ID_OCCLUSION_BLOOD_PUMP, bpOccl, OCCLUSION_THRESHOLD_OFFSET + bloodPumpOcclusionAfterCartridgeInstall ) + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_HD_OCCLUSION_BLOOD_PUMP, bpOccl, OCCLUSION_THRESHOLD_OFFSET + bloodPumpOcclusionAfterCartridgeInstall ) } } } // Clear alarm regardless of op mode once conditions are met. if ( bpOccl <= ( OCCLUSION_CLEAR_THRESHOLD_OFFSET + bloodPumpOcclusionAfterCartridgeInstall ) ) { - clearAlarmCondition( ALARM_ID_OCCLUSION_BLOOD_PUMP ); + clearAlarmCondition( ALARM_ID_HD_OCCLUSION_BLOOD_PUMP ); } // Check for venous occlusion - if ( ( TRUE == txMode || TRUE == ptxMode ) && - ( venPres > getS32TreatmentParamUpperRangeLimit( TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ) + VENOUS_PRESSURE_OCCL_OFFSET_MMHG ) ) - { - if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_LINE_OCCLUSION, TRUE ) ) +#ifndef _RELEASE_ + if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_VENOUS_PRESSURE_CHECK ) != SW_CONFIG_ENABLE_VALUE ) +#endif + { // only trigger alarm if BP is running + if ( isBloodPumpRunning() != FALSE ) + { // must be in pre-treatment mode to trigger this alarm + if ( ( TRUE == ptxMode ) && ( venPres > VENOUS_PRESSURE_LIMIT_MAX_MMHG + VENOUS_PRESSURE_OCCL_OFFSET_MMHG ) ) + { + if ( TRUE == isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_LINE_OCCLUSION, TRUE ) ) + { + SET_ALARM_WITH_1_F32_DATA( ALARM_ID_HD_VENOUS_LINE_OCCLUSION, venPres ); + } + } + else + { + isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_LINE_OCCLUSION, FALSE ); + } + } + else { - SET_ALARM_WITH_1_F32_DATA( ALARM_ID_HD_VENOUS_LINE_OCCLUSION, venPres ); + isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_LINE_OCCLUSION, FALSE ); } } - else - { - clearAlarmCondition( ALARM_ID_HD_VENOUS_LINE_OCCLUSION ); - isPersistentAlarmTriggered( ALARM_ID_HD_VENOUS_LINE_OCCLUSION, FALSE ); - } - } -} - -/*********************************************************************//** - * @brief - * The getMeasuredArterialPressure function gets the current arterial pressure. - * @details Inputs: arterialPressure - * @details Outputs: none - * @return the current arterial pressure (in mmHg). - *************************************************************************/ + } +} + +/*********************************************************************//** + * @brief + * The getMeasuredArterialPressure function gets the current arterial pressure. + * @details Inputs: arterialPressure + * @details Outputs: none + * @return the current arterial pressure (in mmHg). + *************************************************************************/ F32 getMeasuredArterialPressure( void ) { F32 result = arterialPressure.data; @@ -703,7 +1002,7 @@ *************************************************************************/ F32 getFilteredArterialPressure( void ) { - return shortFilteredArterialPressure; + return getF32OverrideValue( &shortFilteredArterialPressure ); } /*********************************************************************//** @@ -717,14 +1016,14 @@ { return longFilteredArterialPressure; } - -/*********************************************************************//** - * @brief - * The getMeasuredVenousPressure function gets the measured venous pressure. - * @details Inputs: venousPressure - * @details Outputs: none - * @return the current venous pressure (in mmHg). - *************************************************************************/ + +/*********************************************************************//** + * @brief + * The getMeasuredVenousPressure function gets the measured venous pressure. + * @details Inputs: venousPressure + * @details Outputs: none + * @return the current venous pressure (in mmHg). + *************************************************************************/ F32 getMeasuredVenousPressure( void ) { F32 result = venousPressure.data; @@ -746,17 +1045,30 @@ *************************************************************************/ F32 getFilteredVenousPressure( void ) { - return shortFilteredVenousPressure; + return getF32OverrideValue( &shortFilteredVenousPressure ); } - -/*********************************************************************//** - * @brief - * The getMeasuredBloodPumpOcclusion function gets the measured blood pump - * occlusion pressure. - * @details Inputs: bloodPumpOcclusion - * @details Outputs: none - * @return the current blood pump occlusion pressure (in mmHg). - *************************************************************************/ + +/*********************************************************************//** + * @brief + * The getLongFilteredVenousPressure function gets the current long filtered + * venous pressure. + * @details Inputs: longFilteredVenousPressure + * @details Outputs: none + * @return the current long filtered venous pressure (in mmHg). + *************************************************************************/ +F32 getLongFilteredVenousPressure( void ) +{ + return longFilteredVenousPressure; +} + +/*********************************************************************//** + * @brief + * The getMeasuredBloodPumpOcclusion function gets the measured blood pump + * occlusion pressure. + * @details Inputs: bloodPumpOcclusion + * @details Outputs: none + * @return the current blood pump occlusion pressure (in mmHg). + *************************************************************************/ U32 getMeasuredBloodPumpOcclusion( void ) { U32 result = bloodPumpOcclusion.data; @@ -768,7 +1080,7 @@ return result; } - + /*********************************************************************//** * @brief * The filterInlinePressureReadings function adds a new arterial and venous @@ -804,8 +1116,19 @@ artPressureReadingsShortTotal += artPres; artPressureReadingsShortIdx = INC_WRAP( artPressureReadingsShortIdx, 0, SIZE_OF_SHORT_ART_ROLLING_AVG - 1 ); artPressureReadingsShortCount = INC_CAP( artPressureReadingsShortCount, SIZE_OF_SHORT_ART_ROLLING_AVG ); - shortFilteredArterialPressure = artPressureReadingsShortTotal / (F32)artPressureReadingsShortCount; + shortFilteredArterialPressure.data = artPressureReadingsShortTotal / (F32)artPressureReadingsShortCount; + // Long filter for venous pressure. + if ( venPressureReadingsLongCount >= SIZE_OF_LONG_VEN_ROLLING_AVG ) + { + venPressureReadingsLongTotal -= venPressureReadingsLong[ venPressureReadingsLongIdx ]; + } + venPressureReadingsLong[ venPressureReadingsLongIdx ] = venPres; + venPressureReadingsLongTotal += venPres; + venPressureReadingsLongIdx = INC_WRAP( venPressureReadingsLongIdx, 0, SIZE_OF_LONG_VEN_ROLLING_AVG - 1 ); + venPressureReadingsLongCount = INC_CAP( venPressureReadingsLongCount, SIZE_OF_LONG_VEN_ROLLING_AVG ); + longFilteredVenousPressure = venPressureReadingsLongTotal / (F32)venPressureReadingsLongCount; + // Short filter for venous pressure. if ( venPressureReadingsShortCount >= SIZE_OF_SHORT_VEN_ROLLING_AVG ) { @@ -815,49 +1138,56 @@ venPressureReadingsShortTotal += venPres; venPressureReadingsShortIdx = INC_WRAP( venPressureReadingsShortIdx, 0, SIZE_OF_SHORT_VEN_ROLLING_AVG - 1 ); venPressureReadingsShortCount = INC_CAP( artPressureReadingsShortCount, SIZE_OF_SHORT_VEN_ROLLING_AVG ); - shortFilteredVenousPressure = venPressureReadingsShortTotal / (F32)venPressureReadingsShortCount; + shortFilteredVenousPressure.data = venPressureReadingsShortTotal / (F32)venPressureReadingsShortCount; } - -/*********************************************************************//** - * @brief - * The publishPresOcclData function publishes pressure/occlusion data at the - * set interval. - * @details Inputs: latest pressure and occlusion readings - * @details Outputs: Pressure/occlusion data are published to CAN bus. - * @return none - *************************************************************************/ -static void publishPresOcclData( void ) -{ - // Publish pressure/occlusion data on interval - if ( ++presOcclDataPublicationTimerCounter >= getU32OverrideValue( &presOcclDataPublishInterval ) ) + +/*********************************************************************//** + * @brief + * The publishPresOcclData function publishes pressure/occlusion data at the + * set interval. + * @details Inputs: latest pressure and occlusion readings + * @details Outputs: Pressure/occlusion data are published to CAN bus. + * @return none + *************************************************************************/ +static void publishPresOcclData( void ) +{ + // Publish pressure/occlusion data on interval + if ( ++presOcclDataPublicationTimerCounter >= getU32OverrideValue( &presOcclDataPublishInterval ) ) { PRESSURE_OCCLUSION_DATA_T data; - - data.arterialPressure = shortFilteredArterialPressure; - data.venousPressure = shortFilteredVenousPressure; - data.bldPumpOcclusion = getMeasuredBloodPumpOcclusion(); - + + data.arterialPressure = getFilteredArterialPressure(); + data.venousPressure = getFilteredVenousPressure(); + data.bldPumpOcclusion = getMeasuredBloodPumpOcclusion(); + data.presLimitState = currPresLimitsState; + data.artMinLimit = currentArterialMinLimit; + data.artMaxLimit = currentArterialMaxLimit; + data.venMinLimit = currentVenousMinLimit; + data.venMaxLimit = currentVenousMaxLimit; + data.arterialLongFilterPres = longFilteredArterialPressure; + data.venousLongFilterPres = longFilteredVenousPressure; + broadcastData( MSG_ID_PRESSURE_OCCLUSION_DATA, COMM_BUFFER_OUT_CAN_HD_BROADCAST, (U08*)&data, sizeof( PRESSURE_OCCLUSION_DATA_T ) ); - presOcclDataPublicationTimerCounter = 0; - } -} - -/*********************************************************************//** - * @brief - * The execPresOcclTest function executes the PresOccl self-test. - * @details Inputs: none - * @details Outputs: Triggers fault when test case fails - * @return none - *************************************************************************/ -void execPresOcclTest( void ) + presOcclDataPublicationTimerCounter = 0; + } +} + +/*********************************************************************//** + * @brief + * The execPresOcclTest function executes the PresOccl self-test. + * @details Inputs: none + * @details Outputs: Triggers fault when test case fails + * @return none + *************************************************************************/ +void execPresOcclTest( void ) { #ifndef _RELEASE_ if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_PRESSURE_CHECKS ) != SW_CONFIG_ENABLE_VALUE ) #endif - { - U32 const bpPressure = getMeasuredBloodPumpOcclusion(); - F32 const arterialPressure = getFilteredArterialPressure(); - F32 const venousPressure = getFilteredVenousPressure(); + { + U32 bpPressure = getMeasuredBloodPumpOcclusion(); + F32 arterialPressure = getFilteredArterialPressure(); + F32 venousPressure = getFilteredVenousPressure(); if ( bpPressure > CARTRIDGE_LOADED_THRESHOLD ) { @@ -874,7 +1204,7 @@ SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_VENOUS_PRESSURE_SELF_TEST_FAILURE, venousPressure ); } } -} +} /*********************************************************************//** * @brief @@ -891,11 +1221,11 @@ if ( getSoftwareConfigStatus( SW_CONFIG_DISABLE_OCCLUSION_SELF_TEST ) != SW_CONFIG_ENABLE_VALUE ) #endif { - U32 const bpPressure = getMeasuredBloodPumpOcclusion(); + U32 bpPressure = getMeasuredBloodPumpOcclusion(); if ( ( bpPressure < CARTRIDGE_LOADED_THRESHOLD ) || ( bpPressure > OCCLUSION_CARTRIDGE_LOADED_PRESSURE_READING_MAX ) ) { - activateAlarmNoData( ALARM_ID_NO_CARTRIDGE_LOADED ); + SET_ALARM_WITH_1_U32_DATA( ALARM_ID_HD_NO_CARTRIDGE_LOADED, bpPressure ); result = SELF_TEST_STATUS_FAILED; } } @@ -934,194 +1264,228 @@ } return result; -} +} - -/************************************************************************* - * TEST SUPPORT FUNCTIONS - *************************************************************************/ - - -/*********************************************************************//** - * @brief - * The testSetPresOcclDataPublishIntervalOverride function overrides the - * pressure and occlusion data publish interval. - * @details Inputs: none - * @details Outputs: presOcclDataPublishInterval - * @param value override pressure and occlusion data publish interval with (in ms) - * @return TRUE if override successful, FALSE if not - *************************************************************************/ -BOOL testSetPresOcclDataPublishIntervalOverride( U32 value ) -{ - BOOL result = FALSE; - - if ( TRUE == isTestingActivated() ) - { - U32 intvl = value / TASK_GENERAL_INTERVAL; - - result = TRUE; - presOcclDataPublishInterval.ovData = intvl; - presOcclDataPublishInterval.override = OVERRIDE_KEY; - } - - return result; -} - -/*********************************************************************//** - * @brief - * The testResetPresOcclDataPublishIntervalOverride function resets the override - * of the pressure and occlusion data publish interval. - * @details Inputs: none - * @details Outputs: presOcclDataPublishInterval - * @return TRUE if override reset successful, FALSE if not - *************************************************************************/ -BOOL testResetPresOcclDataPublishIntervalOverride( void ) -{ - BOOL result = FALSE; - - if ( TRUE == isTestingActivated() ) - { - result = TRUE; - presOcclDataPublishInterval.override = OVERRIDE_RESET; - presOcclDataPublishInterval.ovData = presOcclDataPublishInterval.ovInitData; - } - - return result; -} - -/*********************************************************************//** - * @brief - * The testSetArterialPressureOverride function overrides the measured arterial - * pressure. - * @details Inputs: none - * @details Outputs: arterialPressure - * @param value override arterial pressure (in mmHg) - * @return TRUE if override successful, FALSE if not - *************************************************************************/ -BOOL testSetArterialPressureOverride( F32 value ) -{ - BOOL result = FALSE; - - if ( TRUE == isTestingActivated() ) - { - result = TRUE; - arterialPressure.ovData = value; - arterialPressure.override = OVERRIDE_KEY; - } - - return result; -} - -/*********************************************************************//** - * @brief - * The testResetArterialPressureOverride function resets the override of the - * arterial pressure. - * @details Inputs: none - * @details Outputs: arterialPressure - * @return TRUE if reset successful, FALSE if not - *************************************************************************/ -BOOL testResetArterialPressureOverride( void ) -{ - BOOL result = FALSE; - - if ( TRUE == isTestingActivated() ) - { - result = TRUE; - arterialPressure.override = OVERRIDE_RESET; - arterialPressure.ovData = arterialPressure.ovInitData; - } - - return result; -} - -/*********************************************************************//** - * @brief - * The testSetVenousPressureOverride function overrides the measured venous - * pressure. - * @details Inputs: none - * @details Outputs: venousPressure - * @param value override measured venous pressure with (in mmHg) - * @return TRUE if override successful, FALSE if not - *************************************************************************/ -BOOL testSetVenousPressureOverride( F32 value ) -{ - BOOL result = FALSE; - - if ( TRUE == isTestingActivated() ) - { - result = TRUE; - venousPressure.ovData = value; - venousPressure.override = OVERRIDE_KEY; - } - - return result; -} - -/*********************************************************************//** - * @brief - * The testResetVenousPressureOverride function resets the override of the - * venous pressure. - * @details Inputs: none - * @details Outputs: venousPressure - * @return TRUE if reset successful, FALSE if not - *************************************************************************/ -BOOL testResetVenousPressureOverride( void ) -{ - BOOL result = FALSE; - - if ( TRUE == isTestingActivated() ) - { - result = TRUE; - venousPressure.override = OVERRIDE_RESET; - venousPressure.ovData = venousPressure.ovInitData; - } - - return result; -} - -/*********************************************************************//** - * @brief - * The testSetBloodPumpOcclusionOverride function overrides the measured - * blood pump occlusion pressure. - * @details Inputs: none - * @details Outputs: bloodPumpOcclusion - * @param value override measured blood pump occlusion pressure with - * @return TRUE if override successful, FALSE if not - *************************************************************************/ -BOOL testSetBloodPumpOcclusionOverride( U32 value ) -{ - BOOL result = FALSE; - - if ( TRUE == isTestingActivated() ) - { - result = TRUE; - bloodPumpOcclusion.ovData = value; - bloodPumpOcclusion.override = OVERRIDE_KEY; - } - - return result; -} - -/*********************************************************************//** - * @brief - * The testResetBloodPumpOcclusionOverride function resets the override of the - * measured blood pump occlusion pressure. - * @details Inputs: none - * @details Outputs: bloodPumpOcclusion - * @return TRUE if reset successful, FALSE if not - *************************************************************************/ -BOOL testResetBloodPumpOcclusionOverride( void ) -{ - BOOL result = FALSE; - - if ( TRUE == isTestingActivated() ) - { - result = TRUE; - bloodPumpOcclusion.override = OVERRIDE_RESET; - bloodPumpOcclusion.ovData = bloodPumpOcclusion.ovInitData; - } - - return result; + +/************************************************************************* + * TEST SUPPORT FUNCTIONS + *************************************************************************/ + + +/*********************************************************************//** + * @brief + * The testSetPresOcclDataPublishIntervalOverride function overrides the + * pressure and occlusion data publish interval. + * @details Inputs: none + * @details Outputs: presOcclDataPublishInterval + * @param value override pressure and occlusion data publish interval with (in ms) + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testSetPresOcclDataPublishIntervalOverride( U32 value ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + U32 intvl = value / TASK_GENERAL_INTERVAL; + + result = TRUE; + presOcclDataPublishInterval.ovData = intvl; + presOcclDataPublishInterval.override = OVERRIDE_KEY; + } + + return result; } -/**@}*/ +/*********************************************************************//** + * @brief + * The testResetPresOcclDataPublishIntervalOverride function resets the override + * of the pressure and occlusion data publish interval. + * @details Inputs: none + * @details Outputs: presOcclDataPublishInterval + * @return TRUE if override reset successful, FALSE if not + *************************************************************************/ +BOOL testResetPresOcclDataPublishIntervalOverride( void ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + presOcclDataPublishInterval.override = OVERRIDE_RESET; + presOcclDataPublishInterval.ovData = presOcclDataPublishInterval.ovInitData; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testSetArterialPressureOverride function overrides the measured arterial + * pressure. + * @details Inputs: none + * @details Outputs: arterialPressure, shortFilteredArterialPressure + * @param value override arterial pressure (in mmHg) + * @param filtered override filtered value or raw value + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testSetArterialPressureOverride( F32 value, BOOL filtered ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + if ( FALSE == filtered ) + { + arterialPressure.ovData = value; + arterialPressure.override = OVERRIDE_KEY; + } + else + { + shortFilteredArterialPressure.ovData = value; + shortFilteredArterialPressure.override = OVERRIDE_KEY; + } + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testResetArterialPressureOverride function resets the override of the + * arterial pressure. + * @details Inputs: none + * @details Outputs: arterialPressure, shortFilteredArterialPressure + * @return TRUE if reset successful, FALSE if not + *************************************************************************/ +BOOL testResetArterialPressureOverride( BOOL filtered ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + if ( FALSE == filtered ) + { + arterialPressure.override = OVERRIDE_RESET; + arterialPressure.ovData = arterialPressure.ovInitData; + } + else + { + shortFilteredArterialPressure.override = OVERRIDE_RESET; + shortFilteredArterialPressure.ovData = shortFilteredArterialPressure.ovInitData; + } + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testSetVenousPressureOverride function overrides the measured venous + * pressure. + * @details Inputs: none + * @details Outputs: venousPressure, shortFilteredVenousPressure + * @param value override measured venous pressure with (in mmHg) + * @param filtered override filtered value or raw value + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testSetVenousPressureOverride( F32 value, BOOL filtered ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + if ( FALSE == filtered ) + { + venousPressure.ovData = value; + venousPressure.override = OVERRIDE_KEY; + } + else + { + shortFilteredVenousPressure.ovData = value; + shortFilteredVenousPressure.override = OVERRIDE_KEY; + } + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testResetVenousPressureOverride function resets the override of the + * venous pressure. + * @details Inputs: none + * @details Outputs: venousPressure, shortFilteredVenousPressure + * @return TRUE if reset successful, FALSE if not + *************************************************************************/ +BOOL testResetVenousPressureOverride( BOOL filtered ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + if ( FALSE == filtered ) + { + venousPressure.override = OVERRIDE_RESET; + venousPressure.ovData = venousPressure.ovInitData; + } + else + { + shortFilteredVenousPressure.override = OVERRIDE_RESET; + shortFilteredVenousPressure.ovData = shortFilteredVenousPressure.ovInitData; + } + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testSetBloodPumpOcclusionOverride function overrides the measured + * blood pump occlusion pressure. + * @details Inputs: none + * @details Outputs: bloodPumpOcclusion + * @param value override measured blood pump occlusion pressure with + * @return TRUE if override successful, FALSE if not + *************************************************************************/ +BOOL testSetBloodPumpOcclusionOverride( U32 value ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + bloodPumpOcclusion.ovData = value; + bloodPumpOcclusion.override = OVERRIDE_KEY; + } + + return result; +} + +/*********************************************************************//** + * @brief + * The testResetBloodPumpOcclusionOverride function resets the override of the + * measured blood pump occlusion pressure. + * @details Inputs: none + * @details Outputs: bloodPumpOcclusion + * @return TRUE if reset successful, FALSE if not + *************************************************************************/ +BOOL testResetBloodPumpOcclusionOverride( void ) +{ + BOOL result = FALSE; + + if ( TRUE == isTestingActivated() ) + { + result = TRUE; + bloodPumpOcclusion.override = OVERRIDE_RESET; + bloodPumpOcclusion.ovData = bloodPumpOcclusion.ovInitData; + } + + return result; +} + +/**@}*/