Index: sources/drydemo/StateControllerTreatment.cpp
===================================================================
diff -u -rc52253ab5fc73e9b59d9cd99eada3d526d799987 -r38521851fd3271aa9a8965067d15daaba0db4b2e
--- sources/drydemo/StateControllerTreatment.cpp	(.../StateControllerTreatment.cpp)	(revision c52253ab5fc73e9b59d9cd99eada3d526d799987)
+++ sources/drydemo/StateControllerTreatment.cpp	(.../StateControllerTreatment.cpp)	(revision 38521851fd3271aa9a8965067d15daaba0db4b2e)
@@ -38,6 +38,8 @@
     static quint32 pauseCountDownS        = 0;
     static quint32 elapsedTimeSincePauseS = 0;
     static quint32 controlCounter         = 0;
+    // Assume the blood pump is running unless the pause button has been resumed
+    _treatmentStatus.isBloodPumpRunning = true;
 
     if (!resume) {
         // If the user has pressed pause, then do the countdown and broadcast
@@ -46,6 +48,8 @@
         primeTimeoutS           = BLOOD_PRIME_PAUSE_TIMEOUT_S;
         pauseCountDownS         = ( elapsedTimeSincePauseS / MILLISECONDS_PER_SECOND < BLOOD_PRIME_PAUSE_TIMEOUT_S ? BLOOD_PRIME_PAUSE_TIMEOUT_S - elapsedTimeSincePauseS / MILLISECONDS_PER_SECOND : pauseCountDownS );
         handleBloodPrimeBroadcastData(accumBloodVolML, primeTimeoutS, pauseCountDownS, BC_DELAYED);
+        // Blood prime has been paused so the blood pump is not running
+        _treatmentStatus.isBloodPumpRunning = false;
         return;
     }
 
@@ -149,7 +153,7 @@
         // Immediately broadcast the results to be updated
         handleFluidBolusBroadcastData(BC_IMMEDIATELY);
     }
-    qDebug() << "Bolus" << _treatmentStatus.accumFluidBolusDeliveredML << _treatmentStatus.totalFluidBolusDeliveredML;
+    //qDebug() << "Bolus" << _treatmentStatus.accumFluidBolusDeliveredML << _treatmentStatus.totalFluidBolusDeliveredML;
 }
 
 void StateController::handleTreatmentPrescriptionEditRequestMessage()
@@ -181,12 +185,7 @@
     resp.append(0);
 
     GetValue(payload.toByteArray(), index, u32Var);
-    qDebug() << "Old conc" << _treatmentParams.acidConcentrate;
-    if (_treatmentParams.acidConcentrate != u32Var.value) {
-        qDebug() << "New conc" << _treatmentParams.acidConcentrate;
-        triggerAnAlarm(ALARM_ID_TD_REPLACE_ACID_JUG);
-    }
-
+    if (_treatmentParams.acidConcentrate != u32Var.value) { triggerAnAlarm(ALARM_ID_TD_REPLACE_ACID_JUG); }
     _treatmentParams.acidConcentrate = u32Var.value;
     resp.append(0);
 
@@ -448,5 +447,145 @@
     _treatmentRcvdMessages[ID_UI_DURATION_CONFIRM_RQST].clear();
 }
 
+void StateController::handlePressureLimitState()
+{
+    switch (_pressureVars.presLimitState) {
+        case PRESSURE_LIMITS_STATE_OFF:
+            if ((_treatmentSubStates.txState > TREAT_START_STATE) && (_treatmentSubStates.txState != TREAT_RECIRC_STATE)) {
+                _pressureVars.presLimitState = PRESSURE_LIMITS_STATE_IDLE;
+            }
+            break;
 
+        case PRESSURE_LIMITS_STATE_IDLE:
+            // TODO do we want to show the blood prime ramp?
+            _pressureVars.presLimitState = PRESSURE_LIMITS_STATE_WIDE;
+            break;
 
+        case PRESSURE_LIMITS_STATE_WIDE:
+            if (!_treatmentStatus.isBloodPumpRunning) { _pressureVars.presLimitState = PRESSURE_LIMITS_STATE_IDLE; }
+            else if ((_treatmentSubStates.txState == TREAT_DIALYSIS_STATE) || (_treatmentSubStates.txState == TREAT_PAUSED_STATE)) {
+                _pressureVars.presStabilizationTimerCtr = 0;
+                _pressureVars.presStabilizeTime         = USE_NORMAL_STABILIZATION_PERIOD;
+                _pressureVars.presLimitState            = PRESSURE_LIMITS_STATE_STABILIZATION;
+            }
+            else if (_treatmentSubStates.txState == TREAT_RECIRC_STATE) { _pressureVars.presLimitState = PRESSURE_LIMITS_STATE_OFF; }
+            break;
+
+        case PRESSURE_LIMITS_STATE_STABILIZATION:
+            // Assume the stabilization timeout is normal timeout
+            _pressureVars.presStabilizeTimeoutMS = PRES_LIMIT_STABE_TIME_MS;
+            _pressureVars.presStabilizationTimerCtr++;
+            if (_pressureVars.presLimitState == PRESSURE_LIMITS_STATE_STABILIZATION) {
+                _pressureVars.presStabilizeTimeoutMS = PRES_LIMIT_SHORT_STABE_TIME_MS;
+            }
+
+            if (!_treatmentStatus.isBloodPumpRunning) { _pressureVars.presLimitState = PRESSURE_LIMITS_STATE_IDLE; }
+            else if ((_treatmentSubStates.txState != TREAT_DIALYSIS_STATE) && (_treatmentSubStates.txState != TREAT_PAUSED_STATE)) {
+                _pressureVars.presLimitState = PRESSURE_LIMITS_STATE_WIDE;
+            }
+            else if ((_pressureVars.presStabilizationTimerCtr * QOBJECT_TIMER_TIMEOUT_MS) >= _pressureVars.presStabilizeTimeoutMS) {
+                handleUpdatePressureLimitWindows();
+                _pressureVars.presStabilizationTimerCtr = 0;
+                _pressureVars.presStabilizeTime         = USE_NORMAL_STABILIZATION_PERIOD;
+                _pressureVars.presLimitState            = PRESSURE_LIMITS_STATE_STABLE;
+            }
+            break;
+
+        case PRESSURE_LIMITS_STATE_STABLE:
+            _pressureVars.presStabilizationTimerCtr++;
+            if (!_treatmentStatus.isBloodPumpRunning) { _pressureVars.presLimitState = PRESSURE_LIMITS_STATE_IDLE; }
+            else if ((_treatmentSubStates.txState != TREAT_DIALYSIS_STATE) && (_treatmentSubStates.txState != TREAT_PAUSED_STATE)) {
+                _pressureVars.presLimitState = PRESSURE_LIMITS_STATE_WIDE;
+                qDebug() << "WIDEW" <<  _pressureVars.presLimitState;
+            }
+            else if ((_pressureVars.presStabilizationTimerCtr * QOBJECT_TIMER_TIMEOUT_MS) >= PRES_LIMIT_RESTABILIZE_TIME_MS) {
+                handleUpdatePressureLimitWindows();
+                _pressureVars.presStabilizationTimerCtr = 0;
+                _pressureVars.presStabilizeTime         = STABILIZATION_PERIOD_OFF;
+                _pressureVars.presLimitState            = PRESSURE_LIMITS_STATE_STABILIZATION;
+            }
+            break;
+
+        default:
+            // Do nothing
+            break;
+    }
+
+    qDebug() << "Pres Steat" << _pressureVars.presLimitState << _treatmentStatus.isBloodPumpRunning << _pressureVars.presStabilizeTimeoutMS
+             << _pressureVars.presStabilizationTimerCtr * QOBJECT_TIMER_TIMEOUT_MS << _treatmentSubStates.txState ;
+}
+
+void StateController::handleUpdatePressureLimitWindows()
+{
+    float artMMHG;
+    float venMMHG;
+    float tmpMMHG;
+
+    if (_pressureVars.presStabilizeTime == USE_SHORT_STABILIZATION_PERIOD) {
+        artMMHG = _pressureVars.arterialFilteredMMHG;
+        venMMHG = _pressureVars.venousFilteredMMHG;
+        tmpMMHG = _pressureVars.tmpFilteredMMHG;
+    }
+    else {
+        // TODO need to do the long filtered?
+        artMMHG = _pressureVars.arterialFilteredMMHG;
+        venMMHG = _pressureVars.venousFilteredMMHG;
+        tmpMMHG = _pressureVars.tmpFilteredMMHG;
+    }
+
+    _pressureVars.arterialStableMMHG = (artMMHG < 0.0 ? static_cast<qint32>(artMMHG - 0.5) : static_cast<qint32>(artMMHG + 0.5));
+    _pressureVars.venousStableMMHG   = (venMMHG < 0.0 ? static_cast<qint32>(venMMHG - 0.5) : static_cast<qint32>(venMMHG + 0.5));
+    _pressureVars.tmpStableMMHG      = (tmpMMHG < 0.0 ? static_cast<qint32>(tmpMMHG - 0.5) : static_cast<qint32>(tmpMMHG + 0.5));
+}
+
+void StateController::handleDeterminePressureLimits()
+{
+    if (_pressureVars.presLimitState == PRESSURE_LIMITS_STATE_STABLE) {
+        qint32 artOffsetMMHG    = static_cast<qint32>(ART_PRES_LIMIT_WINDOW_MMHG) / 2;
+        qint32 venMinOffsetMMHG = static_cast<qint32>(VEN_PRES_LIMIT_ASYMM_MMHG);
+        qint32 venMaxOffsetMMHG = static_cast<qint32>(VEN_PRES_LIMIT_WINDOW_MMHG) - venMinOffsetMMHG;
+        qint32 tmpOffsetMMHG    = static_cast<qint32>(TMP_PRES_LIMIT_WINDOW_MMHG) / 2;
+
+        _pressureVars.arterialMinLimitMMHG = _pressureVars.arterialStableMMHG - artOffsetMMHG;
+        _pressureVars.arterialMinLimitMMHG = qMax(_pressureVars.arterialMinLimitMMHG, static_cast<qint32>(MIN_ART_PRES_LIMIT_MMHG));
+
+        _pressureVars.arterialMaxLimitMMHG = _pressureVars.arterialStableMMHG + artOffsetMMHG;
+        _pressureVars.arterialMaxLimitMMHG = qMin(_pressureVars.arterialMaxLimitMMHG, static_cast<qint32>(MAX_ART_PRES_LIMIT_MMHG));
+
+        _pressureVars.venousMinLimitMMHG = _pressureVars.venousStableMMHG - venMinOffsetMMHG;
+        _pressureVars.venousMinLimitMMHG = qMax(_pressureVars.venousMinLimitMMHG, static_cast<qint32>(MIN_VEN_PRES_LIMIT_MMHG));
+
+        _pressureVars.venousMaxLimitMMHG = _pressureVars.venousStableMMHG + venMaxOffsetMMHG;
+        _pressureVars.venousMaxLimitMMHG = qMin(_pressureVars.venousMaxLimitMMHG, static_cast<qint32>(MAX_VEN_PRES_LIMIT_MMHG));
+
+        _pressureVars.tmpMinLimitMMHG = _pressureVars.tmpStableMMHG - tmpOffsetMMHG;
+        _pressureVars.tmpMinLimitMMHG = qMax(_pressureVars.tmpMinLimitMMHG, static_cast<float>(MIN_TMP_PRES_LIMIT_MMHG));
+
+        _pressureVars.tmpMaxLimitMMHG = _pressureVars.tmpStableMMHG + tmpOffsetMMHG;
+        _pressureVars.tmpMaxLimitMMHG = qMin(_pressureVars.tmpMaxLimitMMHG, static_cast<float>(MAX_TMP_PRES_LIMIT_MMHG));
+    }
+    else {
+        _pressureVars.arterialMinLimitMMHG          = MIN_ART_PRES_LIMIT_MMHG;
+        _pressureVars.arterialMaxLimitMMHG          = MAX_ART_PRES_LIMIT_MMHG;
+
+        _pressureVars.venousMinLimitMMHG            = MIN_VEN_PRES_LIMIT_MMHG;
+        _pressureVars.venousMaxLimitMMHG            = MAX_VEN_PRES_LIMIT_MMHG;
+
+        _pressureVars.tmpMinLimitMMHG               = MIN_TMP_PRES_LIMIT_MMHG;
+        _pressureVars.tmpMaxLimitMMHG               = MAX_TMP_PRES_LIMIT_MMHG;
+    }
+}
+
+
+void StateController::handleWidenPressureLimitsMessage()
+{
+    if (! _treatmentRcvdMessages[ID_UI_PRESSURE_LIMIT_WIDEN_RQST].isNull()){
+        _treatmentRcvdMessages[ID_UI_PRESSURE_LIMIT_WIDEN_RQST].clear();
+        // TODo address the increase per request
+        handleUIResponseMessage(ID_TD_PRESSURE_LIMIT_WIDEN_RESP, ACCEPT_VALUE);
+    }
+}
+
+
+
+