Version 1.4.6.20 - Head Cleaning from PPC, Dye sequence stubs (special dispensers, WCF, Waste time)

24 files changed, 1087 insertions, 228 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
index c110b0d82..8b7580830 100644
--- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
+++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
@@ -20,7 +20,7 @@ typedef struct
 } TangoVersion_t;
 
 
-TangoVersion_t _gTangoVersion = {1,4,6,19};
+TangoVersion_t _gTangoVersion = {1,4,6,20};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
  char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d
diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c
index b0d17c9bf..5282ab9e0 100644
--- a/Software/Embedded_SW/Embedded/Communication/Container.c
+++ b/Software/Embedded_SW/Embedded/Communication/Container.c
@@ -276,6 +276,12 @@ void receive_callback(char* buffer, size_t length)
          case MESSAGE_TYPE__ResumeCurrentJobRequest:
              ResumeCurrentJobRequestFunc(requestContainer);
              break;
+         case MESSAGE_TYPE__StartHeadCleaningRequest:
+             ThreadCleaningJobFunc(requestContainer);
+             break;
+         case MESSAGE_TYPE__AbortHeadCleaningRequest:
+             ThreadCleaningAbortJobFunc(requestContainer);
+             break;
          case MESSAGE_TYPE__UploadHardwareConfigurationRequest:
              HWConfigurationFunc(requestContainer);
              break;
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c
index 8fb38e4c6..c54567f65 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.c
@@ -7,7 +7,7 @@
 #endif
 
 #include "MessageType.pb-c.h"
-static const ProtobufCEnumValue message_type__enum_values_by_number[241] =
+static const ProtobufCEnumValue message_type__enum_values_by_number[245] =
 {
   { "None", "MESSAGE_TYPE__None", 0 },
   { "ErrorResponse", "MESSAGE_TYPE__ErrorResponse", 1 },
@@ -188,6 +188,10 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[241] =
   { "CurrentJobResponse", "MESSAGE_TYPE__CurrentJobResponse", 3007 },
   { "ResumeCurrentJobRequest", "MESSAGE_TYPE__ResumeCurrentJobRequest", 3008 },
   { "ResumeCurrentJobResponse", "MESSAGE_TYPE__ResumeCurrentJobResponse", 3009 },
+  { "StartHeadCleaningRequest", "MESSAGE_TYPE__StartHeadCleaningRequest", 3010 },
+  { "StartHeadCleaningResponse", "MESSAGE_TYPE__StartHeadCleaningResponse", 3011 },
+  { "AbortHeadCleaningRequest", "MESSAGE_TYPE__AbortHeadCleaningRequest", 3012 },
+  { "AbortHeadCleaningResponse", "MESSAGE_TYPE__AbortHeadCleaningResponse", 3013 },
   { "StartDebugLogRequest", "MESSAGE_TYPE__StartDebugLogRequest", 4000 },
   { "StartDebugLogResponse", "MESSAGE_TYPE__StartDebugLogResponse", 4001 },
   { "StopDebugLogRequest", "MESSAGE_TYPE__StopDebugLogRequest", 4002 },
@@ -252,78 +256,80 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[241] =
   { "StopThreadLoadingResponse", "MESSAGE_TYPE__StopThreadLoadingResponse", 11005 },
 };
 static const ProtobufCIntRange message_type__value_ranges[] = {
-{0, 0},{3, 2},{1000, 104},{2000, 123},{3000, 169},{4000, 179},{5000, 187},{6000, 191},{7000, 197},{8000, 221},{9000, 227},{10000, 231},{11000, 235},{0, 241}
+{0, 0},{3, 2},{1000, 104},{2000, 123},{3000, 169},{4000, 183},{5000, 191},{6000, 195},{7000, 201},{8000, 225},{9000, 231},{10000, 235},{11000, 239},{0, 245}
 };
-static const ProtobufCEnumValueIndex message_type__enum_values_by_name[241] =
+static const ProtobufCEnumValueIndex message_type__enum_values_by_name[245] =
 {
+  { "AbortHeadCleaningRequest", 181 },
+  { "AbortHeadCleaningResponse", 182 },
   { "AbortJobRequest", 171 },
   { "AbortJobResponse", 172 },
-  { "AbortPowerDownRequest", 233 },
-  { "AbortPowerDownResponse", 234 },
-  { "ActivateVersionRequest", 219 },
-  { "ActivateVersionResponse", 220 },
+  { "AbortPowerDownRequest", 237 },
+  { "AbortPowerDownResponse", 238 },
+  { "ActivateVersionRequest", 223 },
+  { "ActivateVersionResponse", 224 },
   { "CalculateRequest", 2 },
   { "CalculateResponse", 3 },
   { "CartridgeValidationRequest", 167 },
   { "CartridgeValidationResponse", 168 },
   { "ColorProfileRequest", 117 },
   { "ColorProfileResponse", 118 },
-  { "ConnectRequest", 193 },
-  { "ConnectResponse", 194 },
-  { "ContinueThreadLoadingRequest", 237 },
-  { "ContinueThreadLoadingResponse", 238 },
-  { "CreateRequest", 205 },
-  { "CreateResponse", 206 },
+  { "ConnectRequest", 197 },
+  { "ConnectResponse", 198 },
+  { "ContinueThreadLoadingRequest", 241 },
+  { "ContinueThreadLoadingResponse", 242 },
+  { "CreateRequest", 209 },
+  { "CreateResponse", 210 },
   { "CurrentJobRequest", 175 },
   { "CurrentJobResponse", 176 },
-  { "DeleteRequest", 207 },
-  { "DeleteResponse", 208 },
+  { "DeleteRequest", 211 },
+  { "DeleteResponse", 212 },
   { "DirectSynchronizationRequest", 109 },
   { "DirectSynchronizationResponse", 110 },
-  { "DisconnectRequest", 195 },
-  { "DisconnectResponse", 196 },
+  { "DisconnectRequest", 199 },
+  { "DisconnectResponse", 200 },
   { "DispenserAbortHomingRequest", 133 },
   { "DispenserAbortHomingResponse", 134 },
   { "DispenserAbortJoggingRequest", 139 },
   { "DispenserAbortJoggingResponse", 140 },
-  { "DispenserDataRequest", 221 },
-  { "DispenserDataResponse", 222 },
+  { "DispenserDataRequest", 225 },
+  { "DispenserDataResponse", 226 },
   { "DispenserHomingRequest", 135 },
   { "DispenserHomingResponse", 136 },
   { "DispenserJoggingRequest", 137 },
   { "DispenserJoggingResponse", 138 },
   { "ErrorResponse", 1 },
-  { "ExecuteProcessRequest", 201 },
-  { "ExecuteProcessResponse", 202 },
+  { "ExecuteProcessRequest", 205 },
+  { "ExecuteProcessResponse", 206 },
   { "ExternalBridgeLoginRequest", 105 },
   { "ExternalBridgeLoginResponse", 106 },
   { "ExternalBridgeLogoutRequest", 107 },
   { "ExternalBridgeLogoutResponse", 108 },
   { "ExternalBridgeUdpDiscoveryPacket", 104 },
-  { "FileChunkDownloadRequest", 215 },
-  { "FileChunkDownloadResponse", 216 },
-  { "FileChunkUploadRequest", 199 },
-  { "FileChunkUploadResponse", 200 },
-  { "FileDownloadRequest", 213 },
-  { "FileDownloadResponse", 214 },
-  { "FileUploadRequest", 197 },
-  { "FileUploadResponse", 198 },
+  { "FileChunkDownloadRequest", 219 },
+  { "FileChunkDownloadResponse", 220 },
+  { "FileChunkUploadRequest", 203 },
+  { "FileChunkUploadResponse", 204 },
+  { "FileDownloadRequest", 217 },
+  { "FileDownloadResponse", 218 },
+  { "FileUploadRequest", 201 },
+  { "FileUploadResponse", 202 },
   { "GenericRequest", 121 },
   { "GenericResponse", 122 },
-  { "GetFilesRequest", 211 },
-  { "GetFilesResponse", 212 },
-  { "GetStorageInfoRequest", 209 },
-  { "GetStorageInfoResponse", 210 },
+  { "GetFilesRequest", 215 },
+  { "GetFilesResponse", 216 },
+  { "GetStorageInfoRequest", 213 },
+  { "GetStorageInfoResponse", 214 },
   { "JobRequest", 169 },
   { "JobResponse", 170 },
-  { "KeepAliveRequest", 191 },
-  { "KeepAliveResponse", 192 },
-  { "KillProcessRequest", 203 },
-  { "KillProcessResponse", 204 },
-  { "MachineCalibrationDataRequest", 225 },
-  { "MachineCalibrationDataResponse", 226 },
-  { "MidTankDataSetupRequest", 223 },
-  { "MidTankDataSetupResponse", 224 },
+  { "KeepAliveRequest", 195 },
+  { "KeepAliveResponse", 196 },
+  { "KillProcessRequest", 207 },
+  { "KillProcessResponse", 208 },
+  { "MachineCalibrationDataRequest", 229 },
+  { "MachineCalibrationDataResponse", 230 },
+  { "MidTankDataSetupRequest", 227 },
+  { "MidTankDataSetupResponse", 228 },
   { "MotorAbortHomingRequest", 125 },
   { "MotorAbortHomingResponse", 126 },
   { "MotorAbortJoggingRequest", 131 },
@@ -345,46 +351,48 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[241] =
   { "SetBlowerStateResponse", 160 },
   { "SetComponentValueRequest", 147 },
   { "SetComponentValueResponse", 148 },
-  { "SetDebugLogCategoryRequest", 183 },
-  { "SetDebugLogCategoryResponse", 184 },
+  { "SetDebugLogCategoryRequest", 187 },
+  { "SetDebugLogCategoryResponse", 188 },
   { "SetDigitalOutRequest", 141 },
   { "SetDigitalOutResponse", 142 },
   { "SetHeaterStateRequest", 157 },
   { "SetHeaterStateResponse", 158 },
   { "SetValveStateRequest", 161 },
   { "SetValveStateResponse", 162 },
-  { "SetupDebugDisributorsRequest", 185 },
-  { "SetupDebugDisributorsResponse", 186 },
+  { "SetupDebugDisributorsRequest", 189 },
+  { "SetupDebugDisributorsResponse", 190 },
   { "StartApplicationLogsRequest", 113 },
   { "StartApplicationLogsResponse", 114 },
   { "StartCartridgesUpdateRequest", 163 },
   { "StartCartridgesUpdateResponse", 164 },
-  { "StartDebugLogRequest", 179 },
-  { "StartDebugLogResponse", 180 },
+  { "StartDebugLogRequest", 183 },
+  { "StartDebugLogResponse", 184 },
   { "StartDiagnosticsRequest", 123 },
   { "StartDiagnosticsResponse", 124 },
   { "StartEventsNotificationRequest", 153 },
   { "StartEventsNotificationResponse", 154 },
-  { "StartMachineStatusUpdateRequest", 227 },
-  { "StartMachineStatusUpdateResponse", 228 },
-  { "StartPowerDownRequest", 231 },
-  { "StartPowerDownResponse", 232 },
-  { "StartThreadLoadingRequest", 235 },
-  { "StartThreadLoadingResponse", 236 },
+  { "StartHeadCleaningRequest", 179 },
+  { "StartHeadCleaningResponse", 180 },
+  { "StartMachineStatusUpdateRequest", 231 },
+  { "StartMachineStatusUpdateResponse", 232 },
+  { "StartPowerDownRequest", 235 },
+  { "StartPowerDownResponse", 236 },
+  { "StartThreadLoadingRequest", 239 },
+  { "StartThreadLoadingResponse", 240 },
   { "StopApplicationLogsRequest", 115 },
   { "StopApplicationLogsResponse", 116 },
   { "StopCartridgesUpdateRequest", 165 },
   { "StopCartridgesUpdateResponse", 166 },
-  { "StopDebugLogRequest", 181 },
-  { "StopDebugLogResponse", 182 },
+  { "StopDebugLogRequest", 185 },
+  { "StopDebugLogResponse", 186 },
   { "StopDiagnosticsRequest", 151 },
   { "StopDiagnosticsResponse", 152 },
   { "StopEventsNotificationRequest", 155 },
   { "StopEventsNotificationResponse", 156 },
-  { "StopMachineStatusUpdateRequest", 229 },
-  { "StopMachineStatusUpdateResponse", 230 },
-  { "StopThreadLoadingRequest", 239 },
-  { "StopThreadLoadingResponse", 240 },
+  { "StopMachineStatusUpdateRequest", 233 },
+  { "StopMachineStatusUpdateResponse", 234 },
+  { "StopThreadLoadingRequest", 243 },
+  { "StopThreadLoadingResponse", 244 },
   { "StubAbortJobRequest", 100 },
   { "StubAbortJobResponse", 101 },
   { "StubCartridgeReadRequest", 6 },
@@ -483,20 +491,20 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[241] =
   { "StubTivaWriteRegResponse", 79 },
   { "StubValveRequest", 30 },
   { "StubValveResponse", 31 },
-  { "SystemResetRequest", 189 },
-  { "SystemResetResponse", 190 },
+  { "SystemResetRequest", 193 },
+  { "SystemResetResponse", 194 },
   { "ThreadAbortJoggingRequest", 145 },
   { "ThreadAbortJoggingResponse", 146 },
   { "ThreadJoggingRequest", 143 },
   { "ThreadJoggingResponse", 144 },
   { "UpdateStatusRequest", 119 },
   { "UpdateStatusResponse", 120 },
-  { "UploadHardwareConfigurationRequest", 187 },
-  { "UploadHardwareConfigurationResponse", 188 },
+  { "UploadHardwareConfigurationRequest", 191 },
+  { "UploadHardwareConfigurationResponse", 192 },
   { "UploadProcessParametersRequest", 173 },
   { "UploadProcessParametersResponse", 174 },
-  { "ValidateVersionRequest", 217 },
-  { "ValidateVersionResponse", 218 },
+  { "ValidateVersionRequest", 221 },
+  { "ValidateVersionResponse", 222 },
 };
 const ProtobufCEnumDescriptor message_type__descriptor =
 {
@@ -505,9 +513,9 @@ const ProtobufCEnumDescriptor message_type__descriptor =
   "MessageType",
   "MessageType",
   "",
-  241,
+  245,
   message_type__enum_values_by_number,
-  241,
+  245,
   message_type__enum_values_by_name,
   13,
   message_type__value_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h
index 61b17ebef..363aaa17a 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Common/MessageType.pb-c.h
@@ -199,6 +199,10 @@ typedef enum _MessageType {
   MESSAGE_TYPE__CurrentJobResponse = 3007,
   MESSAGE_TYPE__ResumeCurrentJobRequest = 3008,
   MESSAGE_TYPE__ResumeCurrentJobResponse = 3009,
+  MESSAGE_TYPE__StartHeadCleaningRequest = 3010,
+  MESSAGE_TYPE__StartHeadCleaningResponse = 3011,
+  MESSAGE_TYPE__AbortHeadCleaningRequest = 3012,
+  MESSAGE_TYPE__AbortHeadCleaningResponse = 3013,
   MESSAGE_TYPE__StartDebugLogRequest = 4000,
   MESSAGE_TYPE__StartDebugLogResponse = 4001,
   MESSAGE_TYPE__StopDebugLogRequest = 4002,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.c
index 0e060b5aa..d17310835 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.c
@@ -52,7 +52,7 @@ void   configuration_parameters__free_unpacked
   assert(message->base.descriptor == &configuration_parameters__descriptor);
   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 }
-static const ProtobufCFieldDescriptor configuration_parameters__field_descriptors[36] =
+static const ProtobufCFieldDescriptor configuration_parameters__field_descriptors[37] =
 {
   {
     "BreakSensorLimit",
@@ -486,6 +486,18 @@ static const ProtobufCFieldDescriptor configuration_parameters__field_descriptor
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
+  {
+    "FileVersion",
+    37,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_UINT32,
+    offsetof(ConfigurationParameters, has_fileversion),
+    offsetof(ConfigurationParameters, fileversion),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
 };
 static const unsigned configuration_parameters__field_indices_by_name[] = {
   13,   /* field[13] = ACHeatersLowerOperationLimit */
@@ -502,6 +514,7 @@ static const unsigned configuration_parameters__field_indices_by_name[] = {
   9,   /* field[9] = DispenserBuildPressureSpeed */
   11,   /* field[11] = DispenserBuildPressureTimeout */
   18,   /* field[18] = DispenserPresegmentWFCF */
+  36,   /* field[36] = FileVersion */
   20,   /* field[20] = GeneralParameters */
   25,   /* field[25] = IDS_CleaningSpeed */
   27,   /* field[27] = IDS_CleaningStartSprayPreSegmentTime */
@@ -528,7 +541,7 @@ static const unsigned configuration_parameters__field_indices_by_name[] = {
 static const ProtobufCIntRange configuration_parameters__number_ranges[1 + 1] =
 {
   { 1, 0 },
-  { 0, 36 }
+  { 0, 37 }
 };
 const ProtobufCMessageDescriptor configuration_parameters__descriptor =
 {
@@ -538,7 +551,7 @@ const ProtobufCMessageDescriptor configuration_parameters__descriptor =
   "ConfigurationParameters",
   "",
   sizeof(ConfigurationParameters),
-  36,
+  37,
   configuration_parameters__field_descriptors,
   configuration_parameters__field_indices_by_name,
   1,  configuration_parameters__number_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h
index 4901daef5..aca41443a 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/EmbeddedParameters/ConfigurationParameters.pb-c.h
@@ -98,10 +98,12 @@ struct  _ConfigurationParameters
   uint32_t powerofftemperaturelimit;
   protobuf_c_boolean has_ids_presegment_wfcf_timebeforesegment;
   double ids_presegment_wfcf_timebeforesegment;
+  protobuf_c_boolean has_fileversion;
+  uint32_t fileversion;
 };
 #define CONFIGURATION_PARAMETERS__INIT \
  { PROTOBUF_C_MESSAGE_INIT (&configuration_parameters__descriptor) \
-    , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+    , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 
 
 /* ConfigurationParameters methods */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningRequest.pb-c.c
new file mode 100644
index 000000000..d7e18515c
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningRequest.pb-c.c
@@ -0,0 +1,72 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: AbortHeadCleaningRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "AbortHeadCleaningRequest.pb-c.h"
+void   abort_head_cleaning_request__init
+                     (AbortHeadCleaningRequest         *message)
+{
+  static const AbortHeadCleaningRequest init_value = ABORT_HEAD_CLEANING_REQUEST__INIT;
+  *message = init_value;
+}
+size_t abort_head_cleaning_request__get_packed_size
+                     (const AbortHeadCleaningRequest *message)
+{
+  assert(message->base.descriptor == &abort_head_cleaning_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t abort_head_cleaning_request__pack
+                     (const AbortHeadCleaningRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &abort_head_cleaning_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t abort_head_cleaning_request__pack_to_buffer
+                     (const AbortHeadCleaningRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &abort_head_cleaning_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+AbortHeadCleaningRequest *
+       abort_head_cleaning_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (AbortHeadCleaningRequest *)
+     protobuf_c_message_unpack (&abort_head_cleaning_request__descriptor,
+                                allocator, len, data);
+}
+void   abort_head_cleaning_request__free_unpacked
+                     (AbortHeadCleaningRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &abort_head_cleaning_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+#define abort_head_cleaning_request__field_descriptors NULL
+#define abort_head_cleaning_request__field_indices_by_name NULL
+#define abort_head_cleaning_request__number_ranges NULL
+const ProtobufCMessageDescriptor abort_head_cleaning_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "AbortHeadCleaningRequest",
+  "AbortHeadCleaningRequest",
+  "AbortHeadCleaningRequest",
+  "",
+  sizeof(AbortHeadCleaningRequest),
+  0,
+  abort_head_cleaning_request__field_descriptors,
+  abort_head_cleaning_request__field_indices_by_name,
+  0,  abort_head_cleaning_request__number_ranges,
+  (ProtobufCMessageInit) abort_head_cleaning_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningRequest.pb-c.h
new file mode 100644
index 000000000..908207ef2
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningRequest.pb-c.h
@@ -0,0 +1,70 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: AbortHeadCleaningRequest.proto */
+
+#ifndef PROTOBUF_C_AbortHeadCleaningRequest_2eproto__INCLUDED
+#define PROTOBUF_C_AbortHeadCleaningRequest_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _AbortHeadCleaningRequest AbortHeadCleaningRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _AbortHeadCleaningRequest
+{
+  ProtobufCMessage base;
+};
+#define ABORT_HEAD_CLEANING_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&abort_head_cleaning_request__descriptor) \
+     }
+
+
+/* AbortHeadCleaningRequest methods */
+void   abort_head_cleaning_request__init
+                     (AbortHeadCleaningRequest         *message);
+size_t abort_head_cleaning_request__get_packed_size
+                     (const AbortHeadCleaningRequest   *message);
+size_t abort_head_cleaning_request__pack
+                     (const AbortHeadCleaningRequest   *message,
+                      uint8_t             *out);
+size_t abort_head_cleaning_request__pack_to_buffer
+                     (const AbortHeadCleaningRequest   *message,
+                      ProtobufCBuffer     *buffer);
+AbortHeadCleaningRequest *
+       abort_head_cleaning_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   abort_head_cleaning_request__free_unpacked
+                     (AbortHeadCleaningRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*AbortHeadCleaningRequest_Closure)
+                 (const AbortHeadCleaningRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor abort_head_cleaning_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_AbortHeadCleaningRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningResponse.pb-c.c
new file mode 100644
index 000000000..f3d22b512
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningResponse.pb-c.c
@@ -0,0 +1,72 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: AbortHeadCleaningResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "AbortHeadCleaningResponse.pb-c.h"
+void   abort_head_cleaning_response__init
+                     (AbortHeadCleaningResponse         *message)
+{
+  static const AbortHeadCleaningResponse init_value = ABORT_HEAD_CLEANING_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t abort_head_cleaning_response__get_packed_size
+                     (const AbortHeadCleaningResponse *message)
+{
+  assert(message->base.descriptor == &abort_head_cleaning_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t abort_head_cleaning_response__pack
+                     (const AbortHeadCleaningResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &abort_head_cleaning_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t abort_head_cleaning_response__pack_to_buffer
+                     (const AbortHeadCleaningResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &abort_head_cleaning_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+AbortHeadCleaningResponse *
+       abort_head_cleaning_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (AbortHeadCleaningResponse *)
+     protobuf_c_message_unpack (&abort_head_cleaning_response__descriptor,
+                                allocator, len, data);
+}
+void   abort_head_cleaning_response__free_unpacked
+                     (AbortHeadCleaningResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &abort_head_cleaning_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+#define abort_head_cleaning_response__field_descriptors NULL
+#define abort_head_cleaning_response__field_indices_by_name NULL
+#define abort_head_cleaning_response__number_ranges NULL
+const ProtobufCMessageDescriptor abort_head_cleaning_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "AbortHeadCleaningResponse",
+  "AbortHeadCleaningResponse",
+  "AbortHeadCleaningResponse",
+  "",
+  sizeof(AbortHeadCleaningResponse),
+  0,
+  abort_head_cleaning_response__field_descriptors,
+  abort_head_cleaning_response__field_indices_by_name,
+  0,  abort_head_cleaning_response__number_ranges,
+  (ProtobufCMessageInit) abort_head_cleaning_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningResponse.pb-c.h
new file mode 100644
index 000000000..b0b47c420
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/AbortHeadCleaningResponse.pb-c.h
@@ -0,0 +1,70 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: AbortHeadCleaningResponse.proto */
+
+#ifndef PROTOBUF_C_AbortHeadCleaningResponse_2eproto__INCLUDED
+#define PROTOBUF_C_AbortHeadCleaningResponse_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _AbortHeadCleaningResponse AbortHeadCleaningResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _AbortHeadCleaningResponse
+{
+  ProtobufCMessage base;
+};
+#define ABORT_HEAD_CLEANING_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&abort_head_cleaning_response__descriptor) \
+     }
+
+
+/* AbortHeadCleaningResponse methods */
+void   abort_head_cleaning_response__init
+                     (AbortHeadCleaningResponse         *message);
+size_t abort_head_cleaning_response__get_packed_size
+                     (const AbortHeadCleaningResponse   *message);
+size_t abort_head_cleaning_response__pack
+                     (const AbortHeadCleaningResponse   *message,
+                      uint8_t             *out);
+size_t abort_head_cleaning_response__pack_to_buffer
+                     (const AbortHeadCleaningResponse   *message,
+                      ProtobufCBuffer     *buffer);
+AbortHeadCleaningResponse *
+       abort_head_cleaning_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   abort_head_cleaning_response__free_unpacked
+                     (AbortHeadCleaningResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*AbortHeadCleaningResponse_Closure)
+                 (const AbortHeadCleaningResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor abort_head_cleaning_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_AbortHeadCleaningResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningRequest.pb-c.c
new file mode 100644
index 000000000..f29dbcd32
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningRequest.pb-c.c
@@ -0,0 +1,72 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartHeadCleaningRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "StartHeadCleaningRequest.pb-c.h"
+void   start_head_cleaning_request__init
+                     (StartHeadCleaningRequest         *message)
+{
+  static const StartHeadCleaningRequest init_value = START_HEAD_CLEANING_REQUEST__INIT;
+  *message = init_value;
+}
+size_t start_head_cleaning_request__get_packed_size
+                     (const StartHeadCleaningRequest *message)
+{
+  assert(message->base.descriptor == &start_head_cleaning_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t start_head_cleaning_request__pack
+                     (const StartHeadCleaningRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &start_head_cleaning_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t start_head_cleaning_request__pack_to_buffer
+                     (const StartHeadCleaningRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &start_head_cleaning_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+StartHeadCleaningRequest *
+       start_head_cleaning_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (StartHeadCleaningRequest *)
+     protobuf_c_message_unpack (&start_head_cleaning_request__descriptor,
+                                allocator, len, data);
+}
+void   start_head_cleaning_request__free_unpacked
+                     (StartHeadCleaningRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &start_head_cleaning_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+#define start_head_cleaning_request__field_descriptors NULL
+#define start_head_cleaning_request__field_indices_by_name NULL
+#define start_head_cleaning_request__number_ranges NULL
+const ProtobufCMessageDescriptor start_head_cleaning_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "StartHeadCleaningRequest",
+  "StartHeadCleaningRequest",
+  "StartHeadCleaningRequest",
+  "",
+  sizeof(StartHeadCleaningRequest),
+  0,
+  start_head_cleaning_request__field_descriptors,
+  start_head_cleaning_request__field_indices_by_name,
+  0,  start_head_cleaning_request__number_ranges,
+  (ProtobufCMessageInit) start_head_cleaning_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningRequest.pb-c.h
new file mode 100644
index 000000000..591358364
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningRequest.pb-c.h
@@ -0,0 +1,70 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartHeadCleaningRequest.proto */
+
+#ifndef PROTOBUF_C_StartHeadCleaningRequest_2eproto__INCLUDED
+#define PROTOBUF_C_StartHeadCleaningRequest_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _StartHeadCleaningRequest StartHeadCleaningRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _StartHeadCleaningRequest
+{
+  ProtobufCMessage base;
+};
+#define START_HEAD_CLEANING_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&start_head_cleaning_request__descriptor) \
+     }
+
+
+/* StartHeadCleaningRequest methods */
+void   start_head_cleaning_request__init
+                     (StartHeadCleaningRequest         *message);
+size_t start_head_cleaning_request__get_packed_size
+                     (const StartHeadCleaningRequest   *message);
+size_t start_head_cleaning_request__pack
+                     (const StartHeadCleaningRequest   *message,
+                      uint8_t             *out);
+size_t start_head_cleaning_request__pack_to_buffer
+                     (const StartHeadCleaningRequest   *message,
+                      ProtobufCBuffer     *buffer);
+StartHeadCleaningRequest *
+       start_head_cleaning_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   start_head_cleaning_request__free_unpacked
+                     (StartHeadCleaningRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*StartHeadCleaningRequest_Closure)
+                 (const StartHeadCleaningRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor start_head_cleaning_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_StartHeadCleaningRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningResponse.pb-c.c
new file mode 100644
index 000000000..67561cf68
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningResponse.pb-c.c
@@ -0,0 +1,118 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartHeadCleaningResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "StartHeadCleaningResponse.pb-c.h"
+void   start_head_cleaning_response__init
+                     (StartHeadCleaningResponse         *message)
+{
+  static const StartHeadCleaningResponse init_value = START_HEAD_CLEANING_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t start_head_cleaning_response__get_packed_size
+                     (const StartHeadCleaningResponse *message)
+{
+  assert(message->base.descriptor == &start_head_cleaning_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t start_head_cleaning_response__pack
+                     (const StartHeadCleaningResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &start_head_cleaning_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t start_head_cleaning_response__pack_to_buffer
+                     (const StartHeadCleaningResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &start_head_cleaning_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+StartHeadCleaningResponse *
+       start_head_cleaning_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (StartHeadCleaningResponse *)
+     protobuf_c_message_unpack (&start_head_cleaning_response__descriptor,
+                                allocator, len, data);
+}
+void   start_head_cleaning_response__free_unpacked
+                     (StartHeadCleaningResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &start_head_cleaning_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor start_head_cleaning_response__field_descriptors[3] =
+{
+  {
+    "Progress",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(StartHeadCleaningResponse, has_progress),
+    offsetof(StartHeadCleaningResponse, progress),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Total",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(StartHeadCleaningResponse, has_total),
+    offsetof(StartHeadCleaningResponse, total),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "Status",
+    3,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_STRING,
+    0,   /* quantifier_offset */
+    offsetof(StartHeadCleaningResponse, status),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned start_head_cleaning_response__field_indices_by_name[] = {
+  0,   /* field[0] = Progress */
+  2,   /* field[2] = Status */
+  1,   /* field[1] = Total */
+};
+static const ProtobufCIntRange start_head_cleaning_response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 3 }
+};
+const ProtobufCMessageDescriptor start_head_cleaning_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "StartHeadCleaningResponse",
+  "StartHeadCleaningResponse",
+  "StartHeadCleaningResponse",
+  "",
+  sizeof(StartHeadCleaningResponse),
+  3,
+  start_head_cleaning_response__field_descriptors,
+  start_head_cleaning_response__field_indices_by_name,
+  1,  start_head_cleaning_response__number_ranges,
+  (ProtobufCMessageInit) start_head_cleaning_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningResponse.pb-c.h
new file mode 100644
index 000000000..ceca198d4
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/StartHeadCleaningResponse.pb-c.h
@@ -0,0 +1,75 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartHeadCleaningResponse.proto */
+
+#ifndef PROTOBUF_C_StartHeadCleaningResponse_2eproto__INCLUDED
+#define PROTOBUF_C_StartHeadCleaningResponse_2eproto__INCLUDED
+
+#include <protobuf-c/protobuf-c.h>
+
+PROTOBUF_C__BEGIN_DECLS
+
+#if PROTOBUF_C_VERSION_NUMBER < 1003000
+# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
+#elif 1003000 < PROTOBUF_C_MIN_COMPILER_VERSION
+# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
+#endif
+
+
+typedef struct _StartHeadCleaningResponse StartHeadCleaningResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _StartHeadCleaningResponse
+{
+  ProtobufCMessage base;
+  protobuf_c_boolean has_progress;
+  double progress;
+  protobuf_c_boolean has_total;
+  double total;
+  char *status;
+};
+#define START_HEAD_CLEANING_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&start_head_cleaning_response__descriptor) \
+    , 0, 0, 0, 0, NULL }
+
+
+/* StartHeadCleaningResponse methods */
+void   start_head_cleaning_response__init
+                     (StartHeadCleaningResponse         *message);
+size_t start_head_cleaning_response__get_packed_size
+                     (const StartHeadCleaningResponse   *message);
+size_t start_head_cleaning_response__pack
+                     (const StartHeadCleaningResponse   *message,
+                      uint8_t             *out);
+size_t start_head_cleaning_response__pack_to_buffer
+                     (const StartHeadCleaningResponse   *message,
+                      ProtobufCBuffer     *buffer);
+StartHeadCleaningResponse *
+       start_head_cleaning_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   start_head_cleaning_response__free_unpacked
+                     (StartHeadCleaningResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*StartHeadCleaningResponse_Closure)
+                 (const StartHeadCleaningResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor start_head_cleaning_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_StartHeadCleaningResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 0e25f8880..1621f2ecc 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -28,6 +28,7 @@
 //#define VAC_TEST
 
 //#define SPECIAL_DISPENSERS
+extern bool Special_Dispensers;
 //#define Use_Head_Card //for real card only
 //#define Use_WHS_Card //for real card only
 
diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index 551caa544..2a1913b0a 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -357,9 +357,7 @@ int main(void)
 
 
     IDLE_TASK_package_init();
-#ifndef EVALUATION_BOARD
     Start_InitSequence();
-#endif
     PowerIdleInit();
     BIOS_start();
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 1176d3132..98b3704ce 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -54,10 +54,11 @@ void IDS_Dispenser_SetPrepareValues(    uint32_t DispenserBuildPressureSpeed,
 }
 void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout)
 {
-#ifndef SPECIAL_DISPENSERS
-     CloseValveTimeout = CloseTimeout;
-     OpenValveTimeout = OpenTimeout;
-#endif
+    if (Special_Dispensers == false)
+    {
+        CloseValveTimeout = CloseTimeout;
+        OpenValveTimeout = OpenTimeout;
+    }
      Report("IDS_Dispenser_SetTimeOutValues ",__FILE__,__LINE__,OpenValveTimeout,RpWarning,(int)CloseValveTimeout,0);
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index 89892801b..ad1d5b5c4 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -94,6 +94,9 @@ void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, doubl
 void IDS_Dispenser_SetPreSegmentCleaningValues(double ids_cleaningspeed,double ids_cleaningstartspraypresegmenttime ,double ids_cleaningstopbeforesegmenttime,double ids_leftcleaningmotorspeed,double ids_rightcleaningmotorspeed);
 void IDS_Dispenser_SetAutoHoming_Config(AutoHoming_Config_enum Config);
 
+double Get_WFCF(void);
+double Get_WFCF_Time(void);
+
 bool Set_Check_Pressure_Bypass(int);
 
 uint32_t IDS_Dispenser_Close_Valve_And_Stop_Motor(int DispenserId, callback_fptr callback);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 107fd425b..1fe5968e6 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -90,11 +90,14 @@ AutoHoming_Config_enum AutoHoming_Config = AutoHoming_off;
 void IDS_Dispenser_SetAutoHoming_Config(AutoHoming_Config_enum Config)
 {
     Report("IDS_Dispenser_SetAutoHoming_Config ",__FILE__,__LINE__,Config,RpWarning,AutoHoming_Config,0);
-#ifdef SPECIAL_DISPENSERS
-    AutoHoming_Config = AutoHoming_off;
-#else
-    AutoHoming_Config = Config;
-#endif
+    if (Special_Dispensers == false)
+    {
+        AutoHoming_Config = Config;
+    }
+    else
+    {
+        AutoHoming_Config = AutoHoming_off;
+    }
 }
 
 void IDS_Dispenser_SetBackLashValues(double   initialdispenserpressure,   uint32_t initialdispensertimeout,   uint32_t initialdispensertimelag,   uint32_t initialdispenserspeed)
@@ -548,8 +551,9 @@ void IDS_Dispenser_Init(uint8_t DispenserId)
     PrimingActive[DispenserId]= false;
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-#ifdef SPECIAL_DISPENSERS
-    if (ControlIdtoInactiveDispenserId[DispenserId] == 0xFF)
-        ControlIdtoInactiveDispenserId[DispenserId] = AddControlCallback("IDS_Check_Pressure", IDS_Check_Pressure_Callback, eOneMinute,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
-#endif
+    if (Special_Dispensers == true)
+    {
+        if (ControlIdtoInactiveDispenserId[DispenserId] == 0xFF)
+            ControlIdtoInactiveDispenserId[DispenserId] = AddControlCallback("IDS_Check_Pressure", IDS_Check_Pressure_Callback, eOneMinute,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
+    }
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index a34594d56..213774270 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -51,6 +51,8 @@ HardwarePidControlType ThreadDispenserIdToControlId[MAX_SYSTEM_DISPENSERS] = {
 JobUploadStrategy uploadstrategy = JOB_UPLOAD_STRATEGY__Default;
 bool    DispenserReady[MAX_SYSTEM_DISPENSERS] = {true};
 bool IDS_Active = false;
+
+bool Special_Dispensers = false;
 /******************** STRUCTURES AND ENUMs  ********************************************/
 uint32_t IDS_Valve_DistanceToSpoolReady(uint32_t deviceID, uint32_t ReadValue);
 uint32_t IDS_Valve_PresegmentReady(uint32_t deviceID, uint32_t ReadValue);
@@ -82,7 +84,15 @@ int lInterSegmentLength = 0;
  uint32_t WFCF = 80;
  bool EnableCleaning = true;
 bool JobEndSequence = false;
- void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, double  ids_presegment_wfcf_timebeforesegment)
+double Get_WFCF(void)
+{
+    return WFCF;
+}
+double Get_WFCF_Time(void)
+{
+    return InterSegmentStartWFCFDispensers;
+}
+void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, double  ids_presegment_wfcf_timebeforesegment)
  {
      if (ids_presegment_wfcf_timebeforesegment)
          InterSegmentStartWFCFDispensers = ids_presegment_wfcf_timebeforesegment;
@@ -506,13 +516,14 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
      if (pressureReady == false)
      {
-#ifndef SPECIAL_DISPENSERS
-         if (DispenserBuildTimeCounter<(2*eOneSecond))
+         if (Special_Dispensers == false)
          {
-             //REPORT_MSG(DispenserBuildTimeCounter,"waiting 2 seconds for pressure changes");
-             return OK;
+             if (DispenserBuildTimeCounter<(2*eOneSecond))
+             {
+                 //REPORT_MSG(DispenserBuildTimeCounter,"waiting 2 seconds for pressure changes");
+                 return OK;
+             }
          }
-#endif
          for (i = 0; i < MAX_DYE_DISPENSERS; i++)
          {
              //IDS_StopHomeDispenser(i);
@@ -522,33 +533,36 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  if (GetDispenserPressure(i) > DispenserPreparePressure*1.05)
                  {
                      NumofReadyDispensers++;
-#ifdef SPECIAL_DISPENSERS
-                     MotorStop(HW_Motor_Id, Hard_Hiz);
-                     CurrentDispenserSpeed[i] = 0;
+                     if (Special_Dispensers == true)
+                     {
+                         MotorStop(HW_Motor_Id, Hard_Hiz);
+                         CurrentDispenserSpeed[i] = 0;
                      //Report("IDS stopped ready",__FILE__,i,(int)(DispenserPreparePressure*100),RpWarning,(int)NumofReadyDispensers,0);
-#else
-                     tempSpeed = CurrentDispenserSpeed[i];
-                     updatedSpeed = (tempSpeed*0.992>100)?tempSpeed*0.992:100;
-                     MotorSetSpeed(HW_Motor_Id, updatedSpeed);
-                     CurrentDispenserSpeed[i] = updatedSpeed;
-                     //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
-#endif
+                     }
+                     else
+                     {
+                         tempSpeed = CurrentDispenserSpeed[i];
+                         updatedSpeed = (tempSpeed*0.992>100)?tempSpeed*0.992:100;
+                         MotorSetSpeed(HW_Motor_Id, updatedSpeed);
+                         CurrentDispenserSpeed[i] = updatedSpeed;
+                         //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+                     }
                  }
                  else
                  {
-#ifdef SPECIAL_DISPENSERS
-                     tempSpeed = (DispenserPreparePressure-GetDispenserPressure(i))*InitialDispenserSpeed;
-                     if (tempSpeed<300)
-                         tempSpeed = 300;
-#else
-                     tempSpeed = CurrentDispenserSpeed[i];
-#endif
+                     if (Special_Dispensers == true)
+                     {
+                         tempSpeed = (DispenserPreparePressure-GetDispenserPressure(i))*InitialDispenserSpeed;
+                         if (tempSpeed<300)
+                             tempSpeed = 300;
+                     }
+                     else
+                     {
+                         tempSpeed = CurrentDispenserSpeed[i];
+                     }
                      updatedSpeed = (tempSpeed*1.03<InitialDispenserSpeed)?tempSpeed*1.03:InitialDispenserSpeed;
                      MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                      CurrentDispenserSpeed[i] = updatedSpeed;
-#ifdef SPECIAL_DISPENSERS
-                     //Report("IDS accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
-#endif
                  }
              }
          }
@@ -569,7 +583,6 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              Report("pressureReady = true  or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
          }
      }
-//#ifndef SPECIAL_DISPENSERS
      else if (endOfPrepareWCF == false)
      {
          if ((DispenserBuildTimeCounter == PRESSURE_READ_TIME_GAP)&&(FirstBrushStop))
@@ -614,11 +627,14 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                              segmentfirst_speed /= 100;
                              DispenserSegmentReady[DispenserId] = false;
                              //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-#ifdef SPECIAL_DISPENSERS
-                             IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed,NULL);
-#else
-                             MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
-#endif
+                             if (Special_Dispensers == true)
+                             {
+                                 IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed,NULL);
+                             }
+                             else
+                             {
+                                 MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
+                             }
                              CurrentDispenserSpeed[Dispenser_i] = segmentfirst_speed;
 
                              usnprintf(IdMessage, 80,
@@ -660,13 +676,8 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
          }
      }
-/*#endif
-#ifdef SPECIAL_DISPENSERS
-     if (pressureReady == true)
-#else*/
      //start new stage
      if (endOfPrepareWCF == true)
-//#endif
      {
          SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
          DispenserPrepareControlId = 0xFF;
@@ -791,9 +802,10 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
          for (i = 0; i < MAX_DYE_DISPENSERS; i++)
          {
              dispenserspeed = DispenserPrepareSpeed;
-#ifdef SPECIAL_DISPENSERS
-             dispenserspeed = 300;
-#endif
+             if (Special_Dispensers == true)
+             {
+                 dispenserspeed = 300;
+             }
              TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[i];
 
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
@@ -802,11 +814,14 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  {
                      Report("Prepare Speed",__FILE__,HomingActive[i],i,RpWarning,(int)dispenserspeed,0);
                      MotorSetDirection((TimerMotors_t)HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize); //set the dispenser to the
-#ifdef SPECIAL_DISPENSERS
-                     MotorSetSpeed((TimerMotors_t)HW_Motor_Id,dispenserspeed); //set the dispenser to the
-#else
-                     IDS_Dispenser_Start_Motor_and_Open_Valve(i,dispenserspeed, NULL);
-#endif
+                     if (Special_Dispensers == true)
+                     {
+                         MotorSetSpeed((TimerMotors_t)HW_Motor_Id,dispenserspeed); //set the dispenser to the
+                     }
+                     else
+                     {
+                         IDS_Dispenser_Start_Motor_and_Open_Valve(i,dispenserspeed, NULL);
+                     }
                  }
                  /*else
                  {
@@ -943,11 +958,14 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  {
                      if (DispenserUsedInJob[DispenserId] == true)
                      {
-#ifdef SPECIAL_DISPENSERS
-                         IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
-#else
-                         MotorStop(HW_Motor_Id, Hard_Hiz);
-#endif
+                         if (Special_Dispensers == true)
+                         {
+                             IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
+                         }
+                         else
+                         {
+                             MotorStop(HW_Motor_Id, Hard_Hiz);
+                         }
                          CurrentDispenserSpeed[Dispenser_i] = 0;
                          usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
                          Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
@@ -1069,7 +1087,6 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          //cleaning
          return OK;
      }
-//#ifndef SPECIAL_DISPENSERS
      if ((InterSegmentStartWFCFDispensers > 12000)&&(InterSegmentStartWFCFDispensers == (InterSegmentStepsCount+12000)))
      {
 	 	//start prepare 4 seconds before wcf
@@ -1150,7 +1167,6 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          //close waste valve one second before segment - trial
          Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
      }
-//#endif
      return OK;
  }
 uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
@@ -1336,11 +1352,14 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             {
                 if (DispenserUsedInJob[DispenserId] == true)
                 {
-#ifdef SPECIAL_DISPENSERS
-                    IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
-#else
-                    MotorStop(HW_Motor_Id,Soft_Hiz); //26/03/19 test  without valves
-#endif
+                    if (Special_Dispensers == true)
+                    {
+                        IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
+                    }
+                    else
+                    {
+                        MotorStop(HW_Motor_Id,Soft_Hiz); //26/03/19 test  without valves
+                    }
                     CurrentDispenserSpeed[DispenserId] = 0;
                     //MotorSetSpeed(HW_Motor_Id, 5);
                     //CurrentDispenserSpeed[Dispenser_i] = 5;
@@ -1406,11 +1425,14 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                                                          segmentfirst_speed,
                                                          NULL);*/
                 //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-#ifdef SPECIAL_DISPENSERS
-                IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed, NULL);
-#else
-                MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
-#endif
+                if (Special_Dispensers == true)
+                {
+                    IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed, NULL);
+                }
+                else
+                {
+                    MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
+                }
                 CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
                 usnprintf(IdsMessage, 80,
                           "Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d steps %d/%d",
@@ -1429,11 +1451,14 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                 //IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);*/
                 if (DispenserUsedInJob[DispenserId] == true)
                 {
-#ifdef SPECIAL_DISPENSERS
-                    IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
-#else
-                    MotorStop(HW_Motor_Id, Hard_Hiz);
-#endif
+                    if (Special_Dispensers == true)
+                    {
+                        IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
+                    }
+                    else
+                    {
+                        MotorStop(HW_Motor_Id, Hard_Hiz);
+                    }
                     CurrentDispenserSpeed[DispenserId] = 0;
                 }
                 //Report("inActive dispenser stopped", __FILE__, __LINE__, DispenserId, RpWarning,   segmentfirst_speed, 0);
@@ -1615,11 +1640,14 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
              if (DispenserUsedInJob[Dispenser_i]==true)//unconfigured dispenser
              {
                  DispenserDistanceToSpoolReady[Dispenser_i] = false;
-    #ifdef SPECIAL_DISPENSERS
-                 IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
-    #else
-                 MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
-    #endif
+                 if (Special_Dispensers == true)
+                 {
+                     IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
+                 }
+                 else
+                 {
+                     MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
+                 }
                  Control3WayValvesWithCallback ((Valves_t)Dispenser_i, MidTank_Dispenser, IDS_Valve_DistanceToSpoolValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
                  CurrentDispenserSpeed[Dispenser_i] = 0;
                  //IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_DistanceToSpoolValveReady);
@@ -1700,11 +1728,14 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      {
          if (DispenserUsedInJob[Dispenser_i] == true)
          {
-#ifdef SPECIAL_DISPENSERS
-            IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
-#else
-            MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
-#endif
+             if (Special_Dispensers == true)
+             {
+                 IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
+             }
+             else
+             {
+                 MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
+             }
             Control3WayValvesWithCallback (Dispenser_i, MidTank_Dispenser, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
             CurrentDispenserSpeed[Dispenser_i] = 0;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 7a9b66a0b..ed15b74bf 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -685,6 +685,33 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
+    if(request->amount == 0xE3)  //fast refresh for pressure
+    {
+        Report("Set WFCF Value ",__FILE__,__LINE__,request->delay,RpWarning,(int)Get_WFCF_Time(),0);
+        IDS_Dispenser_SetPreSegmentWFCFValues((double) request->delay, Get_WFCF_Time());
+        response.progress = (double)OK;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xE4)  //fast refresh for pressure
+    {
+        Report("Set WFCF build to waste Time Value ",__FILE__,__LINE__,request->delay,RpWarning,(int)Get_WFCF(),0);
+        IDS_Dispenser_SetPreSegmentWFCFValues(Get_WFCF(),(double) request->delay);
+        response.progress = (double)OK;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xE5)  //fast refresh for pressure
+    {
+        if (request->delay<=1)
+        {
+            Report("Set special dispensers ",__FILE__,__LINE__,request->delay,RpWarning,Special_Dispensers,0);
+            Special_Dispensers = request->delay;
+        }
+        response.progress = (double)OK;
+        response.has_progress = true;
+    }
+    else
     if(request->amount == 0xB1)  //fast refresh for pressure
     {
         LOG_ERROR(request->delay,"Set loading arm center");
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
index 10dde5bbe..4b6eb93f3 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
@@ -138,7 +138,7 @@ uint32_t PowerOffHeadClean(void)
     //TBD
     if (AutoHoming_Config >= AutoHoming_PowerOff )
         AutoHoming_Config = AutoHoming_JobEnd_PowerOn_off;
-    if (ThreadCleaningJobFunc(50) == OK)
+    if (ThreadCleaningJob(50) == OK)
     {
         if (PowerOffHeadCleanControlId != 0xFF)
         {
@@ -423,11 +423,11 @@ uint32_t PowerOffTurnOffDryerFan(void)
     int i;
     Control_Dryer_Fan(STOP,75);//use START or STOP,  0 - 100%
     PowerOffMachineState++;
-
-#ifndef SPECIAL_DISPENSERS
-    for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
-        Control3WayValvesWithCallback ((Valves_t)i, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-#endif
+    if (Special_Dispensers == false)
+    {
+        for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
+            Control3WayValvesWithCallback ((Valves_t)i, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+    }
 
     //TBD
     return OK;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
index 52609ab44..35d8c343d 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -37,6 +37,10 @@
 #include "PMR/Printing/CurrentJobResponse.pb-c.h"
 #include "PMR/Printing/ResumeCurrentJobRequest.pb-c.h"
 #include "PMR/Printing/ResumeCurrentJobResponse.pb-c.h"
+#include "PMR/Printing/StartHeadCleaningRequest.pb-c.h"
+#include "PMR/Printing/StartHeadCleaningResponse.pb-c.h"
+#include "PMR/Printing/AbortHeadCleaningRequest.pb-c.h"
+#include "PMR/Printing/AbortHeadCleaningResponse.pb-c.h"
 #include "PMR/Printing/JobUploadStrategy.pb-c.h"
 #include "PMR/Printing/JobStatus.pb-c.h"
 #include "PMR/Printing/AbortJobRequest.pb-c.h"
@@ -418,7 +422,91 @@ uint32_t ThreadJoggingFunc(int speed)
     return status;
 }
 //********************************************************************************************************************
-uint32_t ThreadCleaningJobFunc(int speed)
+uint32_t ThreadCleaningJobFunc(MessageContainer* requestContainer)
+{
+    MessageContainer responseContainer;
+    uint8_t* container_buffer;
+    uint32_t status = OK;
+
+    StartHeadCleaningRequest *request =  start_head_cleaning_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    if (request)
+    {
+        if (JobIsActive() == true)
+        {
+            status = ERROR;
+            LOG_ERROR(JobIsActive(),"Jog JobIsActive");
+        }
+        else
+        {
+            if (dyeingspeed<10)
+                status = ERROR;
+            else
+            {
+                status = ThreadCleaningJob(dyeingspeed);
+                if (status == OK)
+                {
+                    ustrncpy (JobToken, requestContainer->token,36);
+                    previousJobLength = 0.0;
+                }
+            }
+        }
+    }
+
+    StartHeadCleaningResponse response = START_HEAD_CLEANING_RESPONSE__INIT;
+
+    if (status == PASSED)
+    {
+        usnprintf(ErrorMsg, 100, "Cleaning Job Accepted");
+        responseContainer = createContainer(MESSAGE_TYPE__StartHeadCleaningResponse, JobToken, false, &response, &start_head_cleaning_response__pack, &start_head_cleaning_response__get_packed_size);
+        responseContainer.has_continuous = true;
+        responseContainer.continuous = true;
+        container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+    }
+    else
+    {
+        usnprintf(ErrorMsg, 100, "Cleaning Job Failed");
+        responseContainer = createContainer(MESSAGE_TYPE__StartHeadCleaningResponse, JobToken, true, &response, &start_head_cleaning_response__pack, &start_head_cleaning_response__get_packed_size);
+        responseContainer.has_error = true;
+        responseContainer.error = ERROR_CODE__INVALID_PARAMETER;
+        container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+    }
+    response.status = ErrorMsg;
+    response.has_progress = true;
+    response.progress = 0.0;
+    response.has_total = true;
+    response.total = job_length;
+
+    container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+    start_head_cleaning_request__free_unpacked(request,NULL);
+    if (container_buffer)
+    {
+        size_t container_size = message_container__pack(&responseContainer, container_buffer);
+        my_free(responseContainer.data.data);
+        SendChars((char*)container_buffer, container_size);
+        //We keep the job request until it is done
+        //    job_request__free_unpacked(request,NULL);
+    }
+    return status;
+}
+uint32_t ThreadCleaningAbortJobFunc(MessageContainer* requestContainer)
+{
+    MessageContainer responseContainer;
+    uint8_t* container_buffer;
+
+    AbortHeadCleaningResponse response = ABORT_HEAD_CLEANING_RESPONSE__INIT;
+    responseContainer = createContainer(MESSAGE_TYPE__AbortHeadCleaningResponse, requestContainer->token, false, &response, &abort_head_cleaning_response__pack, &abort_head_cleaning_response__get_packed_size);
+    container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    my_free(responseContainer.data.data);
+    SendChars((char*)container_buffer, container_size);
+    JobEndReason = JOB_ABORTED_BY_USER;
+    JobAbortedByUser = true;
+    AbortJob("Job Aborted by user");
+    //We keep the job request until it is done
+    return OK;
+}
+uint32_t ThreadCleaningJob(int speed)
 {
     ProcessParameters ProcessParametersCopy;
     JobEndReasonEnum JobAlarmReason = JOB_OK;
@@ -875,7 +963,52 @@ uint8_t JobStatusBuffer[400];
 ResumeCurrentJobResponse resumeresponse = RESUME_CURRENT_JOB_RESPONSE__INIT;
 JobResponse JobResponseMsg = JOB_RESPONSE__INIT;
 JobStatus jobStatus = JOB_STATUS__INIT;
+void SendCleaningJobProgress(double ProcessedLength, int SegmentId, bool done, char *Message)
+{
+    StartHeadCleaningResponse response = START_HEAD_CLEANING_RESPONSE__INIT;
+    MessageContainer responseContainer;
+    uint8_t* container_buffer;
+
+    double totlen = ProcessedLength;
+    if (ProcessedLength>job_length)
+        totlen = job_length;
+    if (Message)
+    {
+        response.status = Message;
+    }
+    response.has_progress = true;
+    response.progress = totlen;
+    response.has_total = true;
+    response.total = job_length;
+    responseContainer = createContainer(MESSAGE_TYPE__StartHeadCleaningResponse, JobToken, false, &response, &start_head_cleaning_response__pack, &start_head_cleaning_response__get_packed_size);
+    responseContainer.has_continuous = true;
+    responseContainer.continuous = true;
+    container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
 
+    if (done == true)
+    {
+        if(JobEndReason != JOB_OK)
+        {
+            responseContainer.has_error = true;
+            responseContainer.error = JobError_to_ErrorCode[JobEndReason];
+        }
+        if (JobAbortedByUser == true)
+        {
+            JobAbortedByUser = false;
+            responseContainer.has_error = true;
+            responseContainer.error = ERROR_CODE__CONTINUOUS_RESPONSE_ABORTED;
+        }
+    }
+
+    container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+    if (container_buffer)
+    {
+        size_t container_size = message_container__pack(&responseContainer, container_buffer);
+        my_free(responseContainer.data.data);
+        SendChars((char*)container_buffer, container_size);
+    }
+
+}
 void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Message)
 {
     MessageContainer responseContainer;
@@ -899,75 +1032,81 @@ void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Mes
     if (JobToken[0] != 0)
     {
 
-        if (Message)
-        {
-            jobStatus.message = Message;
-        }
-        //previousJobLength =  ProcessedLength;
-        jobStatus.has_progress = true;
-#ifdef FEEDER_LENGTH_CALCULATION
-        totlength = TotalProcessedLength;
-        if (TotalProcessedLength > job_length)
-        {
-            Report("job length bigger than assigned",__FILE__,__LINE__,TotalProcessedLength,RpWarning,job_length,  done);
-            //TotalProcessedLength = job_length;
-            totlength = job_length;
-        }
-#else
-        totlength = PoolerTotalProcessedLength;
-        if (PoolerTotalProcessedLength > job_length)
-        {
-            Report("job length bigger than assigned",__FILE__,__LINE__,PoolerTotalProcessedLength,RpWarning,job_length,  done);
-            //TotalProcessedLength = job_length;
-            totlength = job_length;
-        }
-#endif
-        jobStatus.progress = totlength;
-        jobStatus.has_currentsegmentindex = true;
-        jobStatus.currentsegmentindex = SegmentId;
-
-        if (JobResumed == true)
+        if (CleaningJobActive == true)
         {
-            resumeresponse.status = &jobStatus;
-            //responseContainer = createContainer(MESSAGE_TYPE__ResumeCurrentJobResponse,  JobToken, done, &resumeresponse, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size);
-            responseContainer = createAllocatedContainer(MESSAGE_TYPE__ResumeCurrentJobResponse,  JobToken, done, &resumeresponse, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size,&JobStatusBuffer);
+            SendCleaningJobProgress( ProcessedLength,  SegmentId,  done, Message);
         }
         else
         {
-            JobResponseMsg.status = &jobStatus;
-            //responseContainer = createContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &JobResponseMsg, &job_response__pack, &job_response__get_packed_size);
-            responseContainer = createAllocatedContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &JobResponseMsg, &job_response__pack, &job_response__get_packed_size,&JobStatusBuffer);
-        }
-        responseContainer.has_continuous = true;
-        responseContainer.continuous = true;
+            if (Message)
+            {
+                jobStatus.message = Message;
+            }
+            //previousJobLength =  ProcessedLength;
+            jobStatus.has_progress = true;
+    #ifdef FEEDER_LENGTH_CALCULATION
+            totlength = TotalProcessedLength;
+            if (TotalProcessedLength > job_length)
+            {
+                Report("job length bigger than assigned",__FILE__,__LINE__,TotalProcessedLength,RpWarning,job_length,  done);
+                //TotalProcessedLength = job_length;
+                totlength = job_length;
+            }
+    #else
+            totlength = PoolerTotalProcessedLength;
+            if (PoolerTotalProcessedLength > job_length)
+            {
+                Report("job length bigger than assigned",__FILE__,__LINE__,PoolerTotalProcessedLength,RpWarning,job_length,  done);
+                //TotalProcessedLength = job_length;
+                totlength = job_length;
+            }
+    #endif
+            jobStatus.progress = totlength;
+            jobStatus.has_currentsegmentindex = true;
+            jobStatus.currentsegmentindex = SegmentId;
 
-        if (done == true)
-        {
-            if(JobEndReason != JOB_OK)
+            if (JobResumed == true)
             {
-                responseContainer.has_error = true;
-                responseContainer.error = JobError_to_ErrorCode[JobEndReason];
+                resumeresponse.status = &jobStatus;
+                //responseContainer = createContainer(MESSAGE_TYPE__ResumeCurrentJobResponse,  JobToken, done, &resumeresponse, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size);
+                responseContainer = createAllocatedContainer(MESSAGE_TYPE__ResumeCurrentJobResponse,  JobToken, done, &resumeresponse, &resume_current_job_response__pack, &resume_current_job_response__get_packed_size,&JobStatusBuffer);
             }
-            if (JobAbortedByUser == true)
+            else
             {
-                JobAbortedByUser = false;
-                responseContainer.has_error = true;
-                responseContainer.error = ERROR_CODE__CONTINUOUS_RESPONSE_ABORTED;
+                JobResponseMsg.status = &jobStatus;
+                //responseContainer = createContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &JobResponseMsg, &job_response__pack, &job_response__get_packed_size);
+                responseContainer = createAllocatedContainer(MESSAGE_TYPE__JobResponse, JobToken, done, &JobResponseMsg, &job_response__pack, &job_response__get_packed_size,&JobStatusBuffer);
             }
-        }
-        container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
-        if (container_buffer)
-        {
-            size_t container_size = message_container__pack(&responseContainer, container_buffer);
-            //        if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full
-            if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__JobResponse) == false) //comm tx mailbox full
+            responseContainer.has_continuous = true;
+            responseContainer.continuous = true;
+
+            if (done == true)
+            {
+                if(JobEndReason != JOB_OK)
+                {
+                    responseContainer.has_error = true;
+                    responseContainer.error = JobError_to_ErrorCode[JobEndReason];
+                }
+                if (JobAbortedByUser == true)
+                {
+                    JobAbortedByUser = false;
+                    responseContainer.has_error = true;
+                    responseContainer.error = ERROR_CODE__CONTINUOUS_RESPONSE_ABORTED;
+                }
+            }
+            container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+            if (container_buffer)
             {
-                //AlarmHandlingToken[0] = 0;
-                my_free(container_buffer);
+                size_t container_size = message_container__pack(&responseContainer, container_buffer);
+                //        if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full
+                if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__JobResponse) == false) //comm tx mailbox full
+                {
+                    //AlarmHandlingToken[0] = 0;
+                    my_free(container_buffer);
+                }
             }
         }
     }
-
     if (done == true)
     {
         if (CurrentRequest!= NULL)
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h
index 8fa70a99e..811250bbd 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h
@@ -169,7 +169,10 @@ void ThreadAbortJoggingRequestFunc(MessageContainer* requestContainer);
 
 void ThreadAbortJoggingFunc(void);
 uint32_t ThreadJoggingFunc(int speed);
-uint32_t ThreadCleaningJobFunc(int speed);
+
+uint32_t ThreadCleaningJobFunc(MessageContainer* requestContainer);
+uint32_t ThreadCleaningAbortJobFunc(MessageContainer* requestContainer);
+uint32_t ThreadCleaningJob(int speed);
 
 uint32_t    CurrentJobRequestFunc(MessageContainer* requestContainer);
 uint32_t    ResumeCurrentJobRequestFunc(MessageContainer* requestContainer);