Index: sources/drydemo/StateControllerHDFTreatment.cpp
===================================================================
diff -u -rbf271a558491a83b39eb30748784f1b744736dd2 -r4d0fc455e6307639e72db490721c7768a487c014
--- sources/drydemo/StateControllerHDFTreatment.cpp	(.../StateControllerHDFTreatment.cpp)	(revision bf271a558491a83b39eb30748784f1b744736dd2)
+++ sources/drydemo/StateControllerHDFTreatment.cpp	(.../StateControllerHDFTreatment.cpp)	(revision 4d0fc455e6307639e72db490721c7768a487c014)
@@ -3,32 +3,114 @@
 #include "ApplicationController.h"
 #include "types.h"
 
+void StateController::initializeTreatmentHDFVariables()
+{
+    _treatmentHDFVars.hdfCurrentVolumeML          = 0.0;
+    _treatmentHDFVars.hdfManualRateMLPM           = 0.0; // TODO assuming manual rate is 0 for now
+    _treatmentHDFVars.hdfControlState             = TD_HDF_PAUSED;
+    _treatmentHDFVars.hdfMaxFiltrationFraction    = HDF_MAX_FILTRATION_FRACTION;
+    _treatmentHDFVars.hdfCurrentRateMLPM          = 0.5;
+    _treatmentHDFVars.hdfControlTimeCtr           = 0;
+    _treatmentHDFVars.hdfHasMaxVolumeBeenReached  = false;
+    _treatmentHDFVars.hdfIsRequested              = true;
+}
+
+float StateController::handleCheckHDFRate(const float proposedRateMLPM)
+{
+    float hdfMaxRateMLPM = (_treatmentHDFVars.hdfMaxFiltrationFraction * _treatmentParams.bloodFlowRateMLPM) - _treatmentStatus.presUFRateMLPM;
+
+    if (hdfMaxRateMLPM > HDF_MAX_RATE) { hdfMaxRateMLPM = HDF_MAX_RATE; }
+
+    float newRateMLPM = (_treatmentHDFVars.hdfCurrentRateMLPM > proposedRateMLPM ? hdfMaxRateMLPM : _treatmentHDFVars.hdfCurrentRateMLPM);
+    qDebug() << "HDF rate" << hdfMaxRateMLPM << newRateMLPM;
+
+    return newRateMLPM;
+}
+
 void StateController::handleTreatmentHDF()
 {
-    if (_treatmentParams.treatmentModality == TREATMENT_MODALITY_HDF_ONLINE_FLUID) {
-       // _treatmentSubStates.txState = TREATMENT_HDF_STATE;
-    }
+    if (_treatmentParams.treatmentModality != TREATMENT_MODALITY_HDF_ONLINE_FLUID) { return; }
+   // _treatmentSubStates.txState = TREATMENT_HDF_STATE; TODo fix when UI fixed it
+   switch (_treatmentHDFVars.hdfControlState) {
+       case TD_HDF_PAUSED:
+           if (!_treatmentHDFVars.hdfHasMaxVolumeBeenReached && _treatmentHDFVars.hdfIsRequested) {
+               _treatmentHDFVars.hdfControlState     = TD_HDF_RUNNING;
+               _treatmentHDFVars.hdfCurrentRateMLPM  = handleCheckHDFRate(_treatmentHDFVars.hdfCurrentRateMLPM);
+           }
+           break;
+
+       case TD_HDF_RUNNING:
+           if (!_treatmentHDFVars.hdfIsRequested) {
+               _treatmentHDFVars.hdfCurrentRateMLPM = 0.0;
+               _treatmentHDFVars.hdfControlState    = TD_HDF_PAUSED;
+           }
+           else {
+               if (++_treatmentHDFVars.hdfControlTimeCtr % static_cast<quint32>(HDF_CONTROL_INT_CTR) != 0 ) { return; }
+               if (_treatmentHDFVars.hdfManualRateMLPM <= NEARLY_ZERO) {
+                   _treatmentHDFVars.hdfCurrentRateMLPM = handleCheckHDFRate(_treatmentHDFVars.hdfCurrentRateMLPM);
+               }
+
+               _treatmentHDFVars.hdfCurrentVolumeML += (static_cast<float>(HDF_CONTROL_INT_CTR) / static_cast<float>(SECONDS_PER_MINUTE)) * _treatmentHDFVars.hdfCurrentRateMLPM;
+
+               qDebug() << "ALL" << _treatmentHDFVars.hdfControlState <<  _treatmentHDFVars.hdfCurrentVolumeML <<
+                           _treatmentHDFVars.hdfHasMaxVolumeBeenReached << _treatmentHDFVars.hdfIsRequested << HDF_CONTROL_INT_CTR;
+
+               if (_treatmentHDFVars.hdfCurrentVolumeML > _treatmentParams.hdfSubstitutionFluidVolumeL * MILLILITERS_PER_LITER) {
+                   qDebug() << "volume HDF" << _treatmentHDFVars.hdfCurrentVolumeML;
+                   _treatmentHDFVars.hdfHasMaxVolumeBeenReached = true;
+                   _treatmentHDFVars.hdfCurrentRateMLPM         = 0.0;
+                   _treatmentHDFVars.hdfControlState            = TD_HDF_PAUSED;
+               }
+           }
+           break;
+
+       default:
+           // Do nothing
+           break;
+   }
 }
 
 void StateController::handleHemodialfiltrationBroadcastData(const Broadcast_Type BCType)
 {
     static quint32 broadcastCounter = 50;
     if ((++broadcastCounter % NUM_OF_COUNTS_TIMER_BC_EMIT != 0) && (BCType == BC_DELAYED)) { return; }
 
+    quint32 autoSubState = (_treatmentHDFVars.hdfManualRateMLPM > 0.0 ? 0 : 1);
+
     QVariantList msg;
     msg.append(static_cast<quint16>(ID_TD_HEMODIAFILTRATION_DATA));
     msg.append(Can_Id::eChlid_TD_Sync);
-    msg.append(0);
-    msg.append(1);
-    msg.append(1.2);
+    msg.append(_treatmentHDFVars.hdfControlState);
+    msg.append(autoSubState);
+    msg.append(_treatmentHDFVars.hdfManualRateMLPM);
     msg.append(5.2);
 
+    msg.append(_treatmentHDFVars.hdfCurrentRateMLPM);
     msg.append(5.2);
-    msg.append(5.2);
-    msg.append(5.2);
-    msg.append(5.2);
-    msg.append(0);
+    msg.append(_treatmentParams.hdfSubstitutionFluidVolumeL);
+    msg.append(_treatmentHDFVars.hdfCurrentVolumeML / MILLILITERS_PER_LITER);
+    msg.append(static_cast<quint32>(_treatmentHDFVars.hdfIsRequested));
+    //qDebug() << "B" << msg;
     _isBroadcastListReady = false;
     _broadcastMessages.append(msg);
     _isBroadcastListReady = true;
 }
+
+void StateController::handleHDFAdjustmentRequestMessage()
+{
+    if (_treatmentRcvdMessages[ID_UI_HDF_ADJUSTMENT_RQST].isNull()) { return; }
+    QVariantList reason;
+    quint32 acceptReject = REJECT_VALUE;
+
+    _treatmentParams.hdfDilution                 = extractU32DataFromReceivedMessage(ID_UI_HDF_ADJUSTMENT_RQST, 0);
+    _treatmentParams.hdfSubstitutionFluidVolumeL = extractF32DataFromReceivedMessage(ID_UI_HDF_ADJUSTMENT_RQST, 4);
+
+    acceptReject = ACCEPT_VALUE;
+    reason.append(REQUEST_REJECT_REASON_NONE);
+    reason.append(REQUEST_REJECT_REASON_NONE);
+
+    _treatmentRcvdMessages[ID_UI_HDF_ADJUSTMENT_RQST].clear();
+
+    // TODo check the reject reasons
+    handleUIResponseMessage(ID_TD_HDF_ADJUSTMENT_RESP, acceptReject, reason);
+}