Index: firmware/App/Controllers/PresOccl.c =================================================================== diff -u -rf4f7e0ee3baef51d91de64d44a0a00ff967f56c0 -r854f6cd4152f99523debe37d3e7691d08141280a --- firmware/App/Controllers/PresOccl.c (.../PresOccl.c) (revision f4f7e0ee3baef51d91de64d44a0a00ff967f56c0) +++ firmware/App/Controllers/PresOccl.c (.../PresOccl.c) (revision 854f6cd4152f99523debe37d3e7691d08141280a) @@ -63,11 +63,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 +145,13 @@ 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 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 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. @@ -208,6 +218,12 @@ 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 ); + stableArterialPressure = 0; + stableVenousPressure = 0; + currentArterialMaxLimit = 0; + currentArterialMinLimit = 0; + currentVenousMaxLimit = 0; + currentVenousMinLimit = 0; longFilteredArterialPressure = 0.0F; shortFilteredArterialPressure = 0.0F; shortFilteredVenousPressure = 0.0F; @@ -488,39 +504,35 @@ ( ( ( TREATMENT_DIALYSIS_STATE == txState ) && ( DIALYSIS_UF_STATE == getDialysisState() ) ) || ( ( TREATMENT_STOP_STATE == txState ) && ( TRUE == isBloodPumpRunning() ) ) ) ) { - 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 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 ); + BOOL artPresLow = ( artPres < ARTERIAL_PRESSURE_LIMIT_MIN_MMHG ? TRUE : FALSE ); + BOOL artPresHigh = ( artPres > ARTERIAL_PRESSURE_LIMIT_MAX_MMHG ? 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 ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_ARTERIAL_PRESSURE_LOW, artPres, ARTERIAL_PRESSURE_LIMIT_MIN_MMHG ); } 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, ARTERIAL_PRESSURE_LIMIT_MAX_MMHG ); } } else @@ -560,19 +572,17 @@ ( ( ( TREATMENT_DIALYSIS_STATE == txState ) && ( DIALYSIS_UF_STATE == getDialysisState() ) && ( TRUE == didTimeout( venPressureLimitDelayStart, VENOUS_PRESSURE_LIMIT_DELAY_MS ) ) ) || ( ( TREATMENT_STOP_STATE == txState ) && ( TRUE == isBloodPumpRunning() ) ) ) ) { - 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 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, currentVenousMinLimit ); } } else @@ -582,27 +592,25 @@ 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, 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 ); + BOOL venPresLow = ( venPres < VENOUS_PRESSURE_LIMIT_MIN_MMHG ? TRUE : FALSE ); + BOOL venPresHigh = ( venPres > VENOUS_PRESSURE_LIMIT_MAX_MMHG ? TRUE : FALSE ); - // Check venous pressure is within max selectable range + // Check venous pressure is below max limit 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, VENOUS_PRESSURE_LIMIT_MAX_MMHG ); } // 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 ); + SET_ALARM_WITH_2_F32_DATA( ALARM_ID_HD_VENOUS_PRESSURE_LOW, venPres, VENOUS_PRESSURE_LIMIT_MIN_MMHG ); } } else @@ -696,7 +704,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 ) ) { Index: firmware/App/Modes/ModeTreatment.c =================================================================== diff -u -r38355442b06187fe5d57deca647b3adf2fa26b89 -r854f6cd4152f99523debe37d3e7691d08141280a --- firmware/App/Modes/ModeTreatment.c (.../ModeTreatment.c) (revision 38355442b06187fe5d57deca647b3adf2fa26b89) +++ firmware/App/Modes/ModeTreatment.c (.../ModeTreatment.c) (revision 854f6cd4152f99523debe37d3e7691d08141280a) @@ -1315,97 +1315,50 @@ BOOL verifyPressureLimitsChange( PRESSURE_LIMIT_CHANGE_REQUEST_T *data ) { BOOL result = TRUE; - CRITICAL_DATAS_T proposedNewArtLowLimit, proposedNewArtHighLimit; - CRITICAL_DATAS_T proposedNewVenLowLimit, proposedNewVenHighLimit; - PRESSURE_LIMIT_CHANGE_RESPONSE_T respRecord = { FALSE, 0, 0, 0, 0, 0 }; + CRITICAL_DATAS_T proposedNewArtLimitWindow; + CRITICAL_DATAS_T proposedNewVenLimitWindow; + PRESSURE_LIMIT_CHANGE_RESPONSE_T respRecord = { FALSE, 0, 0, 0 }; - proposedNewArtLowLimit.sInt = data->artLowLimit; - proposedNewArtHighLimit.sInt = data->artHighLimit; - proposedNewVenLowLimit.sInt = data->venLowLimit; - proposedNewVenHighLimit.sInt = data->venHighLimit; + proposedNewArtLimitWindow.sInt = data->artPresLimitWindowmmHg; + proposedNewVenLimitWindow.sInt = data->venPresLimitWindowmmHg; // Check ranges for changed limits - if ( FALSE == isTreatmentParamInRange( TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT, proposedNewArtLowLimit ) ) + if ( FALSE == isTreatmentParamInRange( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW, proposedNewArtLimitWindow ) ) { respRecord.rejReasonCode = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; result = FALSE; } - if ( FALSE == isTreatmentParamInRange( TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT, proposedNewArtHighLimit ) ) + if ( FALSE == isTreatmentParamInRange( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW, proposedNewVenLimitWindow ) ) { respRecord.rejReasonCode = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; result = FALSE; } - if ( FALSE == isTreatmentParamInRange( TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT, proposedNewVenLowLimit ) ) - { - respRecord.rejReasonCode = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; - result = FALSE; - } - if ( FALSE == isTreatmentParamInRange( TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT, proposedNewVenHighLimit ) ) - { - respRecord.rejReasonCode = REQUEST_REJECT_REASON_PARAM_OUT_OF_RANGE; - result = FALSE; - } - // If ranges ok, check separation between low/high limits - if ( TRUE == result ) - { - S32 arterialPresLimitDelta = data->artHighLimit - data->artLowLimit; - S32 venousPresLimitDelta = data->venHighLimit - data->venLowLimit; - - // Check arterial alarm limits dependency - if ( arterialPresLimitDelta < MIN_PRESSURE_ALARM_LIMIT_DELTA_MMHG ) - { - respRecord.rejReasonCode = REQUEST_REJECT_REASON_ARTERIAL_PRESSURE_LOW_VS_HIGH; - result = FALSE; - } - - // Check venous alarm limits dependency - if ( venousPresLimitDelta < MIN_PRESSURE_ALARM_LIMIT_DELTA_MMHG ) - { - respRecord.rejReasonCode = REQUEST_REJECT_REASON_VENOUS_PRESSURE_LOW_VS_HIGH; - result = FALSE; - } - } - // Set overall result - are changes accepted? respRecord.accepted = result; // If changes accepted, set new pressure limits if ( TRUE == result ) { - S32 const artLowLimit = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ); - S32 const artHighLimit = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ); - S32 const venLowLimit = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ); - S32 const venHighLimit = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ); + S32 artLimitWindow = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ); + S32 venLimitWindow = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ); - setTreatmentParameterS32( TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT, data->artLowLimit ); - setTreatmentParameterS32( TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT, data->artHighLimit ); - setTreatmentParameterS32( TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT, data->venLowLimit ); - setTreatmentParameterS32( TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT, data->venHighLimit ); + setTreatmentParameterS32( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW, data->artPresLimitWindowmmHg ); + setTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW, data->venPresLimitWindowmmHg ); - if ( abs( artLowLimit - data->artLowLimit ) > 0 ) + if ( abs( artLimitWindow - data->artPresLimitWindowmmHg ) > 0 ) { - sendTreatmentLogEventData( ARTERIAL_PRESSURE_LOWER_LIMIT_CHANGE_EVENT, (F32)artLowLimit, (F32)data->artLowLimit ); + sendTreatmentLogEventData( ARTERIAL_PRESSURE_LIMIT_WINDOW_CHANGE_EVENT, (F32)artLimitWindow, (F32)data->artPresLimitWindowmmHg ); } - if ( abs( artHighLimit - data->artHighLimit ) > 0 ) + if ( abs( venLimitWindow - data->venPresLimitWindowmmHg ) > 0 ) { - sendTreatmentLogEventData( ARTERIAL_PRESSURE_UPPER_LIMIT_CHANGE_EVENT, (F32)artHighLimit, (F32)data->artHighLimit ); + sendTreatmentLogEventData( VENOUS_PRESSURE_LIMIT_WINDOW_CHANGE_EVENT, (F32)venLimitWindow, (F32)data->venPresLimitWindowmmHg ); } - if ( abs( venLowLimit - data->venLowLimit ) > 0 ) - { - sendTreatmentLogEventData( VENOUS_PRESSURE_LOWER_LIMIT_CHANGE_EVENT, (F32)venLowLimit, (F32)data->venLowLimit ); - } - if ( abs( venHighLimit - data->venHighLimit ) > 0 ) - { - sendTreatmentLogEventData( VENOUS_PRESSURE_UPPER_LIMIT_CHANGE_EVENT, (F32)venHighLimit, (F32)data->venHighLimit ); - } } // Read back limits for transmit to UI. - respRecord.artLowLimit = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ); - respRecord.artHighLimit = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ); - respRecord.venLowLimit = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ); - respRecord.venHighLimit = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ); + respRecord.artPresLimitWindowmmHg = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ); + respRecord.venPresLimitWindowmmHg = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ); // Send response sendPressureLimitsChangeResponse( &respRecord ); Index: firmware/App/Modes/ModeTreatment.h =================================================================== diff -u -r1d07de4e970f54f2ae1786ef546cf5567df9ba8e -r854f6cd4152f99523debe37d3e7691d08141280a --- firmware/App/Modes/ModeTreatment.h (.../ModeTreatment.h) (revision 1d07de4e970f54f2ae1786ef546cf5567df9ba8e) +++ firmware/App/Modes/ModeTreatment.h (.../ModeTreatment.h) (revision 854f6cd4152f99523debe37d3e7691d08141280a) @@ -67,21 +67,17 @@ /// Payload record structure for the in-line pressure limits change request. typedef struct { - S32 artLowLimit; - S32 artHighLimit; - S32 venLowLimit; - S32 venHighLimit; + S32 artPresLimitWindowmmHg; + S32 venPresLimitWindowmmHg; } PRESSURE_LIMIT_CHANGE_REQUEST_T; /// Payload record structure for the in-line pressure limits change response. typedef struct { BOOL accepted; U32 rejReasonCode; - S32 artLowLimit; - S32 artHighLimit; - S32 venLowLimit; - S32 venHighLimit; + S32 artPresLimitWindowmmHg; + S32 venPresLimitWindowmmHg; } PRESSURE_LIMIT_CHANGE_RESPONSE_T; /// Payload record structure for the treatment log 30 minutes periodic data. Index: firmware/App/Modes/ModeTreatmentParams.c =================================================================== diff -u -r38355442b06187fe5d57deca647b3adf2fa26b89 -r854f6cd4152f99523debe37d3e7691d08141280a --- firmware/App/Modes/ModeTreatmentParams.c (.../ModeTreatmentParams.c) (revision 38355442b06187fe5d57deca647b3adf2fa26b89) +++ firmware/App/Modes/ModeTreatmentParams.c (.../ModeTreatmentParams.c) (revision 854f6cd4152f99523debe37d3e7691d08141280a) @@ -68,10 +68,8 @@ { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=0}, {.uInt=0} }, // TREATMENT_PARAM_HEPARIN_TYPE { CRITICAL_DATA_TYPE_U32, {.uInt=0}, {.uInt=60}, {.uInt=30} }, // TREATMENT_PARAM_BP_MEAS_INTERVAL { CRITICAL_DATA_TYPE_U32, {.uInt=50}, {.uInt=150}, {.uInt=75} }, // TREATMENT_PARAM_RINSEBACK_FLOW_RATE - { CRITICAL_DATA_TYPE_S32, {.sInt=-300}, {.sInt=70}, {.sInt=-300} }, // TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT - { CRITICAL_DATA_TYPE_S32, {.sInt=-270}, {.sInt=100}, {.sInt=100} }, // TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT - { CRITICAL_DATA_TYPE_S32, {.sInt=20}, {.sInt=270}, {.sInt=20} }, // TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT - { CRITICAL_DATA_TYPE_S32, {.sInt=50}, {.sInt=300}, {.sInt=300} }, // TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT + { CRITICAL_DATA_TYPE_S32, {.sInt=100}, {.sInt=200}, {.sInt=100} }, // TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW + { CRITICAL_DATA_TYPE_S32, {.sInt=100}, {.sInt=200}, {.sInt=100} }, // TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW { CRITICAL_DATA_TYPE_F32, {.sFlt=0.0}, {.sFlt=1.0}, {.sFlt=0.0} }, // TREATMENT_PARAM_HEPARIN_DISPENSE_RATE { CRITICAL_DATA_TYPE_F32, {.sFlt=0.0}, {.sFlt=2.0}, {.sFlt=0.0} }, // TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME { CRITICAL_DATA_TYPE_F32, {.sFlt=35.0}, {.sFlt=37.0}, {.sFlt=37.0} }, // TREATMENT_PARAM_DIALYSATE_TEMPERATURE @@ -180,10 +178,8 @@ origTreatmentParams.bloodFlowRate_mL_min = 0; origTreatmentParams.dialysateFlowRate_mL_min = 0; origTreatmentParams.treatmentDuration_min = 0; - origTreatmentParams.arterialPressureLowLimit_mmHg = 0; - origTreatmentParams.arterialPressureHighLimit_mmHg = 0; - origTreatmentParams.venousPressureLowLimit_mmHg = 0; - origTreatmentParams.venousPressureHighLimit_mmHg = 0; + origTreatmentParams.arterialPressureLimitWindow_mmHg = 0; + origTreatmentParams.venousPressureLimitWindow_mmHg = 0; origTreatmentParams.uFVolume_L = 0.0; } @@ -367,10 +363,8 @@ origTreatmentParams.bloodFlowRate_mL_min = getCriticalData( &treatmentParameters[ TREATMENT_PARAM_BLOOD_FLOW ] ).uInt; origTreatmentParams.dialysateFlowRate_mL_min = getCriticalData( &treatmentParameters[ TREATMENT_PARAM_DIALYSATE_FLOW ] ).uInt; origTreatmentParams.treatmentDuration_min = getCriticalData( &treatmentParameters[ TREATMENT_PARAM_TREATMENT_DURATION ] ).uInt; - origTreatmentParams.arterialPressureLowLimit_mmHg = getCriticalData( &treatmentParameters[ TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ] ).sInt; - origTreatmentParams.arterialPressureHighLimit_mmHg = getCriticalData( &treatmentParameters[ TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ] ).sInt; - origTreatmentParams.venousPressureLowLimit_mmHg = getCriticalData( &treatmentParameters[ TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ] ).sInt; - origTreatmentParams.venousPressureHighLimit_mmHg = getCriticalData( &treatmentParameters[ TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ] ).sInt; + origTreatmentParams.arterialPressureLimitWindow_mmHg = getCriticalData( &treatmentParameters[ TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ] ).sInt; + origTreatmentParams.venousPressureLimitWindow_mmHg = getCriticalData( &treatmentParameters[ TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ] ).sInt; // If using Heparin in this treatment, set state to stopped otherwise off if ( ( stagedParams[ TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME ].sFlt > 0.0 ) || ( stagedParams[ TREATMENT_PARAM_HEPARIN_DISPENSE_RATE ].sFlt > 0.0 ) ) @@ -553,10 +547,6 @@ BOOL result = TRUE; U32 dialysateVolume_mL = stagedParams[ TREATMENT_PARAM_DIALYSATE_FLOW ].uInt * \ stagedParams[ TREATMENT_PARAM_TREATMENT_DURATION ].uInt; - S32 arterialPresLimitDelta = stagedParams[ TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ].sInt - \ - stagedParams[ TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ].sInt; - S32 venousPresLimitDelta = stagedParams[ TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ].sInt - \ - stagedParams[ TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ].sInt; F32 heparinVolume_mL = ( stagedParams[ TREATMENT_PARAM_HEPARIN_DISPENSE_RATE ].sFlt * \ ( ( stagedParams[ TREATMENT_PARAM_TREATMENT_DURATION ].uInt - stagedParams[ TREATMENT_PARAM_HEPARIN_PRE_STOP_TIME ].uInt ) / MIN_PER_HOUR ) ) + \ stagedParams[ TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME ].sFlt + SYRINGE_PUMP_PRIME_VOLUME_ML + SYRINGE_PUMP_FILL_VOLUME_OFFSET_ML; @@ -592,22 +582,6 @@ result = FALSE; } - // Check arterial alarm limits dependency - if ( arterialPresLimitDelta < MIN_PRESSURE_ALARM_LIMIT_DELTA_MMHG ) - { - reasons[ TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ] = REQUEST_REJECT_REASON_ARTERIAL_PRESSURE_LOW_VS_HIGH; - reasons[ TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ] = REQUEST_REJECT_REASON_ARTERIAL_PRESSURE_LOW_VS_HIGH; - result = FALSE; - } - - // Check venous alarm limits dependency - if ( venousPresLimitDelta < MIN_PRESSURE_ALARM_LIMIT_DELTA_MMHG ) - { - reasons[ TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ] = REQUEST_REJECT_REASON_VENOUS_PRESSURE_LOW_VS_HIGH; - reasons[ TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ] = REQUEST_REJECT_REASON_VENOUS_PRESSURE_LOW_VS_HIGH; - result = FALSE; - } - return result; } @@ -1024,10 +998,8 @@ current_treatment_params.treatment_parameters.heparinType = getTreatmentParameterU32( TREATMENT_PARAM_HEPARIN_TYPE ); current_treatment_params.treatment_parameters.bloodPressureMeasurementInterval_min = getTreatmentParameterU32( TREATMENT_PARAM_BP_MEAS_INTERVAL ); current_treatment_params.treatment_parameters.rinsebackFlowRate_mL_min = getTreatmentParameterU32( TREATMENT_PARAM_RINSEBACK_FLOW_RATE ); - current_treatment_params.treatment_parameters.arterialPressureLowLimit_mmHg = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRESSURE_LOW_LIMIT ); - current_treatment_params.treatment_parameters.arterialPressureHighLimit_mmHg = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRESSURE_HIGH_LIMIT ); - current_treatment_params.treatment_parameters.venousPressureLowLimit_mmHg = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRESSURE_LOW_LIMIT ); - current_treatment_params.treatment_parameters.venousPressureHighLimit_mmHg = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRESSURE_HIGH_LIMIT ); + current_treatment_params.treatment_parameters.arterialPressureLimitWindow_mmHg = getTreatmentParameterS32( TREATMENT_PARAM_ART_PRES_LIMIT_WINDOW ); + current_treatment_params.treatment_parameters.venousPressureLimitWindow_mmHg = getTreatmentParameterS32( TREATMENT_PARAM_VEN_PRES_LIMIT_WINDOW ); current_treatment_params.treatment_parameters.heparinDispenseRate_mL_hr = getTreatmentParameterF32( TREATMENT_PARAM_HEPARIN_DISPENSE_RATE ); current_treatment_params.treatment_parameters.heparinBolusVolume_mL = getTreatmentParameterF32( TREATMENT_PARAM_HEPARIN_BOLUS_VOLUME ); current_treatment_params.treatment_parameters.dialysateTemperature_degC = getTreatmentParameterF32( TREATMENT_PARAM_DIALYSATE_TEMPERATURE ); @@ -1047,14 +1019,12 @@ current_treatment_params.treatment_parameters.heparinType = 0; current_treatment_params.treatment_parameters.bloodPressureMeasurementInterval_min = 0; current_treatment_params.treatment_parameters.rinsebackFlowRate_mL_min = 0; - current_treatment_params.treatment_parameters.arterialPressureLowLimit_mmHg = 0; - current_treatment_params.treatment_parameters.arterialPressureHighLimit_mmHg = 0; - current_treatment_params.treatment_parameters.venousPressureLowLimit_mmHg = 0; - current_treatment_params.treatment_parameters.venousPressureHighLimit_mmHg = 0; - current_treatment_params.treatment_parameters.heparinDispenseRate_mL_hr = 0; - current_treatment_params.treatment_parameters.heparinBolusVolume_mL = 0; - current_treatment_params.treatment_parameters.dialysateTemperature_degC = 0; - current_treatment_params.uFVolume_L = 0; + current_treatment_params.treatment_parameters.arterialPressureLimitWindow_mmHg = 0; + current_treatment_params.treatment_parameters.venousPressureLimitWindow_mmHg = 0; + current_treatment_params.treatment_parameters.heparinDispenseRate_mL_hr = 0.0F; + current_treatment_params.treatment_parameters.heparinBolusVolume_mL = 0.0F; + current_treatment_params.treatment_parameters.dialysateTemperature_degC = 0.0F; + current_treatment_params.uFVolume_L = 0.0F; } sendTestCurrentTreatmentParametersResponse(current_treatment_params); } Index: firmware/App/Modes/ModeTreatmentParams.h =================================================================== diff -u -r25ede6f944eb53b68c8073404663c99d3ce158b0 -r854f6cd4152f99523debe37d3e7691d08141280a --- firmware/App/Modes/ModeTreatmentParams.h (.../ModeTreatmentParams.h) (revision 25ede6f944eb53b68c8073404663c99d3ce158b0) +++ firmware/App/Modes/ModeTreatmentParams.h (.../ModeTreatmentParams.h) (revision 854f6cd4152f99523debe37d3e7691d08141280a) @@ -51,10 +51,8 @@ U32 heparinType; ///< User set heparin type option U32 bloodPressureMeasurementInterval_min; ///< User set blood pressure measurement interval (in min) U32 rinsebackFlowRate_mL_min; ///< User set rinseback flow rate (in mL/min) - S32 arterialPressureLowLimit_mmHg; ///< User set lower alarm limit for arterial pressure (in mmHg) - S32 arterialPressureHighLimit_mmHg; ///< User set upper alarm limit for arterial pressure (in mmHg) - S32 venousPressureLowLimit_mmHg; ///< User set lower alarm limit for venous pressure (in mmHg) - S32 venousPressureHighLimit_mmHg; ///< User set upper alarm limit for venous pressure (in mmHg) + S32 arterialPressureLimitWindow_mmHg; ///< User set alarm limit window for arterial pressure (in mmHg) + S32 venousPressureLimitWindow_mmHg; ///< User set alarm limit window for venous pressure (in mmHg) F32 heparinDispenseRate_mL_hr; ///< User set heparin dispense rate (in mL/hr) F32 heparinBolusVolume_mL; ///< User set heparin bolus volume (in mL) F32 dialysateTemperature_degC; ///< User set dialysate temperature (in deg C) @@ -66,10 +64,8 @@ U32 bloodFlowRate_mL_min; ///< Original blood flow rate (in mL/min) set by user before treatment start U32 dialysateFlowRate_mL_min; ///< Original dialysate flow rate (in mL/min) set by user before treatment start U32 treatmentDuration_min; ///< Original treatment duration (in min) set by user before treatment start - S32 arterialPressureLowLimit_mmHg; ///< Original lower alarm limit for arterial pressure (in mmHg) set by user before treatment start - S32 arterialPressureHighLimit_mmHg; ///< Original upper alarm limit for arterial pressure (in mmHg) set by user before treatment start - S32 venousPressureLowLimit_mmHg; ///< Original lower alarm limit for venous pressure (in mmHg) set by user before treatment start - S32 venousPressureHighLimit_mmHg; ///< Original upper alarm limit for venous pressure (in mmHg) set by user before treatment start + S32 arterialPressureLimitWindow_mmHg; ///< Original alarm limit window for arterial pressure (in mmHg) set by user before treatment start + S32 venousPressureLimitWindow_mmHg; ///< Original alarm limit window for venous pressure (in mmHg) set by user before treatment start F32 uFVolume_L; ///< Original ultrafiltration volume (in L) set by user before treatment start } ADJ_TREATMENT_PARAMS_T;