merge conflicts

84 files changed, 3202 insertions, 1624 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
index 7871c5e28..b23b4361b 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
@@ -94,32 +94,39 @@ uint32_t    FileUploadRequestFunc(MessageContainer* requestContainer)
             Fresult = FR_DENIED;
         else
         {
-            Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER);
-            Fresult = f_open(UploadFileHandle,request->path,FA_READ | FA_WRITE | FA_OPEN_ALWAYS | FA_CREATE_ALWAYS);
-            if (Fresult == FR_OK)
+            if (Semaphore_pend(FFS_Sem, BIOS_NO_WAIT))
             {
-                FileLength = request->length;
-                FileReceivedLength = 0;
-                REPORT_MSG (FileLength,"file upload request");
-                response.has_maxchunklength = true;
-                response.maxchunklength = MAX_CHUNK_LENGTH;
-                strcpy(FileHandleChar, "1234");
-                response.uploadid = FileHandleChar; //supporting only single file at each time.
-                FileDone = false;
+                CommRxTaskHandle = Task_self();
+                Task_setPri(CommRxTaskHandle, 3);
+               // Report("Task_setPri", __FILE__, __LINE__, 4, RpWarning,   (int)CommRxTaskHandle, 0);
+                Report("FileUploadRequestFunc 2", __FILE__, __LINE__, msec_millisecondCounter, RpWarning,   (int)0, 0);
+                Fresult = f_open(UploadFileHandle,request->path,FA_READ | FA_WRITE | FA_OPEN_ALWAYS | FA_CREATE_ALWAYS);
+                if (Fresult == FR_OK)
+                {
+                    Report("FileUploadRequestFunc 3", __FILE__, __LINE__, msec_millisecondCounter, RpWarning,   (int)0, 0);
+                    FileLength = request->length;
+                    FileReceivedLength = 0;
+                    REPORT_MSG (FileLength,"file upload request");
+                    response.has_maxchunklength = true;
+                    response.maxchunklength = MAX_CHUNK_LENGTH;
+                    strcpy(FileHandleChar, "1234");
+                    response.uploadid = FileHandleChar; //supporting only single file at each time.
+                    FileDone = false;
+                }
+                else
+                {
+                    my_free (UploadFileHandle);
+                    UploadFileHandle = 0;
+                    Semaphore_post(FFS_Sem);
+                }
             }
             else
             {
-                my_free (UploadFileHandle);
-                UploadFileHandle = 0;
-                Semaphore_post(FFS_Sem);
+                Fresult = FR_DENIED;
+                Report("Semaphore_pend failed", __FILE__, __LINE__, 4, RpWarning,   (int)0, 0);
             }
-
         }
     }
-    CommRxTaskHandle = Task_self();
-    Task_setPri(CommRxTaskHandle, 4);
-   // Report("Task_setPri", __FILE__, __LINE__, 4, RpWarning,   (int)CommRxTaskHandle, 0);
-
 
     responseContainer = createContainer(MESSAGE_TYPE__FileUploadResponse,  requestContainer->token, false, &response, &file_upload_response__pack, &file_upload_response__get_packed_size);
     if (Fresult!= FR_OK)
@@ -169,6 +176,8 @@ uint32_t    FileChunkUploadRequestFunc(MessageContainer* requestContainer)
         else
         {
             FileReceivedLength += WrittenBytes;
+            ReportWithPackageFilter(CommFilter,"Chunk received", __FILE__,WrittenBytes,FileReceivedLength, RpMessage,msec_millisecondCounter, 0);
+
             //REPORT_MSG (FileReceivedLength,"file upload chunk");
             if (FileReceivedLength == FileLength)
             {
@@ -533,6 +542,8 @@ uint32_t    GetStorageInfoRequestFunc(MessageContainer* requestContainer)
 
     return OK;
 }
+//char Datestr[100];
+
 uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
 {
     //uint32_t status = OK;
@@ -549,6 +560,15 @@ uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
     char FullPath[MAX_NUM_OF_FILES][60];
     int i,NumOfFiles = 0;
     FRESULT Fresult = FR_OK;
+    /*
+    time_t t;
+    struct tm *ltm;
+    char *curTime;
+    t = time(NULL);
+    ltm = localtime(&t);
+    curTime = asctime(ltm);
+    Report(curTime, __FILE__, ltm->tm_hour,ltm->tm_min , RpWarning,  ltm->tm_sec, 0);
+     */
 
     Semaphore_pend(FFS_Sem, BIOS_WAIT_FOREVER);
     Fresult |= f_opendir(&dir, g_cCwdBuf);
@@ -600,7 +620,14 @@ uint32_t    GetFilesRequestFunc(MessageContainer* requestContainer)
            Data[i].lastmodifieddate = fno[i]->fdate;
            Data[i].has_lastmodifiedtime = true;
            Data[i].lastmodifiedtime = fno[i]->ftime;
-            //Report(Data[i].name, __FILE__, __LINE__, Data[i].lastmodifieddate, RpWarning,   (int)Data[i].lastmodifiedtime, 0);
+           /*
+           t = (fno[i]->fdate<<16)+fno[i]->ftime;
+           ltm = localtime(&t);
+           curTime = asctime(ltm);
+           usnprintf(&Datestr, 100, "File info %s %s",fno[i]->fname, curTime);
+           Report(Datestr, __FILE__, __LINE__, t, RpWarning,   (int)Data[i].lastmodifiedtime, 0);
+           Task_sleep(50);
+            */
 
            if (i==0)
                usnprintf(&FullPath[i], 50,  "%s", request->path);
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 92ef02008..8bcb8fc29 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,8,0};
+TangoVersion_t _gTangoVersion = {1,4,6,1};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
  char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d
diff --git a/Software/Embedded_SW/Embedded/Common/report/report.h b/Software/Embedded_SW/Embedded/Common/report/report.h
index 69dd15bdb..eb0b64fab 100644
--- a/Software/Embedded_SW/Embedded/Common/report/report.h
+++ b/Software/Embedded_SW/Embedded/Common/report/report.h
@@ -124,6 +124,8 @@ extern uint32_t ReportInitMessage(MessageContainer* requestContainer);
 extern void ReportStopReporting(void);
 extern uint32_t StopReportInitMessage(MessageContainer* requestContainer);
 uint32_t SetDebugLogCategoryFunc(MessageContainer* requestContainer);
+void SetupDebugDisributorsRequestFunc(MessageContainer* requestContainer);
+
 void ReportResetReason(void);
 
 
diff --git a/Software/Embedded_SW/Embedded/Common/report/reportInit.c b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
index 5ae55736d..7417ab033 100644
--- a/Software/Embedded_SW/Embedded/Common/report/reportInit.c
+++ b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
@@ -39,8 +39,13 @@
 #include "PMR/debugging/StopDebugLogResponse.pb-c.h"
 #include "PMR/debugging/SetDebugLogCategoryRequest.pb-c.h"
 #include "PMR/debugging/SetDebugLogCategoryResponse.pb-c.h"
+#include "PMR/debugging/DebugDistributor.pb-c.h"
+#include "PMR/debugging/SetupDebugDisributorsRequest.pb-c.h"
+#include "PMR/debugging/SetupDebugDisributorsResponse.pb-c.h"
 
 #include "modules/General/process.h"
+#include "AlarmHandling/AlarmHandling.h"
+
 #include "Common/SW_Info/SW_Info.h"
 
 PackageHandle ControlFilter;
@@ -125,6 +130,39 @@ int ReportResponseFunc(char *message,       /* The formatted message
 
 }
 char ResetMessage[200];
+void SetupDebugDisributorsRequestFunc(MessageContainer* requestContainer)
+{
+    MessageContainer responseContainer;
+    uint8_t* container_buffer;
+    uint32_t status = 0;
+
+    SetupDebugDisributorsRequest* request = setup_debug_disributors_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    SetupDebugDisributorsResponse response = SETUP_DEBUG_DISRIBUTORS_RESPONSE__INIT;
+
+    responseContainer = createContainer(MESSAGE_TYPE__SetupDebugDisributorsResponse, requestContainer->token, true, &response, &setup_debug_disributors_response__pack, &setup_debug_disributors_response__get_packed_size);
+    container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+
+
+    if (request->has_debugdistributor == true )
+    {
+        status|=ReportSwitchPackageFilter(request->debugdistributor   , request->distributoractive);
+    }
+    else
+    {
+        status = ERROR_CODE__INVALID_PARAMETER;
+        ReportWithPackageFilter(GeneralFilter,"SetupDebugDisributorsRequest error",__FILE__,__LINE__,request->has_debugdistributor,RpWarning,0,  0);
+    }
+    if (status)
+    {
+        responseContainer.has_error = true;
+        responseContainer.error = (ErrorCode)status;
+    }
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    my_free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+    setup_debug_disributors_request__free_unpacked(request,NULL);
+
+}
 
 void ReportResetReason(void)
 {
@@ -167,6 +205,10 @@ void ReportResetReason(void)
         strcat(ResetMessage, ", External");
 
     Report(ResetMessage, __FILE__, __LINE__, RESC, RpWarning, RESC, 0);
+
+    if ((RESC & SYSCTL_CAUSE_WDOG1)||(RESC & SYSCTL_CAUSE_WDOG0)||(RESC & SYSCTL_CAUSE_BOR))
+        AlarmHandlingSetAlarm (EVENT_TYPE__UNINTENDED_RESET,ON);  //handle alarm detection and operation
+
 }
 
 uint32_t ReportInitMessage(MessageContainer* requestContainer)
diff --git a/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c b/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c
index a970aab5a..e9a785727 100644
--- a/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c
+++ b/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c
@@ -41,7 +41,7 @@ SerialBuffer inBuffer[11];
 bool SerialBufferUsed[11] = {false,false,false,false,false,false,false,false,false,false,false};
 uint32_t initArray(size_t initialSize)
 {
-  if (initialSize >= COMM_MAX_BUFFER_SIZE) return 0;
+  if (initialSize >= COMM_MAX_BUFFER_SIZE) return 0xFF;
   if (initialSize > SHORT_BUFFER_SIZE)
   {
       if (SerialBufferUsed[10] == true)
@@ -84,6 +84,7 @@ uint32_t initArray(size_t initialSize)
 
 void insertArray(uint32_t buffer,char element)
 {
+    assert(buffer<11);
     SerialBuffer *a = &inBuffer[buffer];
   // a->used is the number of used entries, because a->array[a->used++] updates a->used only *after* the array has been accessed.
   // Therefore a->used can go up to a->size
diff --git a/Software/Embedded_SW/Embedded/Communication/Connection.c b/Software/Embedded_SW/Embedded/Communication/Connection.c
index d92741e01..18f176e64 100644
--- a/Software/Embedded_SW/Embedded/Communication/Connection.c
+++ b/Software/Embedded_SW/Embedded/Communication/Connection.c
@@ -30,6 +30,7 @@
 #include "Modules/AlarmHandling/AlarmHandling.h"
 #include "Modules/Stubs_Handler/Stub_HW_Version.h"
 
+bool FirstConnection = true;
 char HexToDecimal(char hex)
 {
     int i = hex % 0x10;
@@ -44,10 +45,10 @@ void ConnectionRequest(MessageContainer* requestContainer)
     DeviceInformation DevInfo = DEVICE_INFORMATION__INIT;
     ConnectResponse response =   CONNECT_RESPONSE__INIT;
 
-    if (GeneralHwReady == false)
+    /*if (GeneralHwReady == false)
     {
         return;
-    }
+    }*/
     unsigned char Major = 0;
     unsigned char Year = 0 ;
     unsigned char Month = 0;
@@ -90,6 +91,9 @@ void ConnectionRequest(MessageContainer* requestContainer)
     DevInfo.boardrevision = BoardVersion;
     DevInfo.assemblyversion = AssyVersion;
 
+    response.has_isafterreset = true;
+    response.isafterreset = FirstConnection;
+    FirstConnection = false;
 
 
     responseContainer = createContainer(MESSAGE_TYPE__ConnectResponse, requestContainer->token, true, &response, &connect_response__pack, &connect_response__get_packed_size);
diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c
index 11bdbe0c8..8cc4d883f 100644
--- a/Software/Embedded_SW/Embedded/Communication/Container.c
+++ b/Software/Embedded_SW/Embedded/Communication/Container.c
@@ -134,11 +134,12 @@ void receive_callback(char* buffer, size_t length)
      MessageContainer* requestContainer = message_container__unpack(NULL, length, (uint8_t*)buffer);
      if (requestContainer == NULL)
          return;
-    if (requestContainer->type != MESSAGE_TYPE__KeepAliveRequest) //user action resets the idle counter
+    /*if ((requestContainer->type>= MESSAGE_TYPE__StartDiagnosticsRequest)&&(requestContainer->type != MESSAGE_TYPE__KeepAliveRequest)) //user action resets the idle counter
     {
+         ReportWithPackageFilter(CommFilter,"Message received", __FILE__,__LINE__,requestContainer->type, RpMessage,length, 0);
+    }*/
+    if (requestContainer->type != MESSAGE_TYPE__KeepAliveRequest)
         resetIdleCounter();
-        REPORT_MSG(requestContainer->type,"Message received");
-    }
     KeepAliveOneSecondCounter = 0;
      /*msgId[RxIndex] = requestContainer->type;
      Length[RxIndex] = length;
@@ -257,6 +258,9 @@ void receive_callback(char* buffer, size_t length)
          case MESSAGE_TYPE__SetDebugLogCategoryRequest:
              SetDebugLogCategoryFunc(requestContainer);
              break;
+         case MESSAGE_TYPE__SetupDebugDisributorsRequest:
+             SetupDebugDisributorsRequestFunc(requestContainer);
+             break;
          case MESSAGE_TYPE__JobRequest:
              JobRequestFunc(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 81d8fe973..aae3b8d5e 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[227] =
+static const ProtobufCEnumValue message_type__enum_values_by_number[229] =
 {
   { "None", "MESSAGE_TYPE__None", 0 },
   { "ErrorResponse", "MESSAGE_TYPE__ErrorResponse", 1 },
@@ -192,6 +192,8 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[227] =
   { "StopDebugLogResponse", "MESSAGE_TYPE__StopDebugLogResponse", 4003 },
   { "SetDebugLogCategoryRequest", "MESSAGE_TYPE__SetDebugLogCategoryRequest", 4004 },
   { "SetDebugLogCategoryResponse", "MESSAGE_TYPE__SetDebugLogCategoryResponse", 4005 },
+  { "SetupDebugDisributorsRequest", "MESSAGE_TYPE__SetupDebugDisributorsRequest", 4006 },
+  { "SetupDebugDisributorsResponse", "MESSAGE_TYPE__SetupDebugDisributorsResponse", 4007 },
   { "UploadHardwareConfigurationRequest", "MESSAGE_TYPE__UploadHardwareConfigurationRequest", 5000 },
   { "UploadHardwareConfigurationResponse", "MESSAGE_TYPE__UploadHardwareConfigurationResponse", 5001 },
   { "SystemResetRequest", "MESSAGE_TYPE__SystemResetRequest", 5002 },
@@ -238,72 +240,72 @@ static const ProtobufCEnumValue message_type__enum_values_by_number[227] =
   { "StopMachineStatusUpdateResponse", "MESSAGE_TYPE__StopMachineStatusUpdateResponse", 9003 },
 };
 static const ProtobufCIntRange message_type__value_ranges[] = {
-{0, 0},{3, 2},{1000, 104},{2000, 121},{3000, 167},{4000, 177},{5000, 183},{6000, 187},{7000, 193},{8000, 217},{9000, 223},{0, 227}
+{0, 0},{3, 2},{1000, 104},{2000, 121},{3000, 167},{4000, 177},{5000, 185},{6000, 189},{7000, 195},{8000, 219},{9000, 225},{0, 229}
 };
-static const ProtobufCEnumValueIndex message_type__enum_values_by_name[227] =
+static const ProtobufCEnumValueIndex message_type__enum_values_by_name[229] =
 {
   { "AbortJobRequest", 169 },
   { "AbortJobResponse", 170 },
-  { "ActivateVersionRequest", 215 },
-  { "ActivateVersionResponse", 216 },
+  { "ActivateVersionRequest", 217 },
+  { "ActivateVersionResponse", 218 },
   { "CalculateRequest", 2 },
   { "CalculateResponse", 3 },
   { "CartridgeValidationRequest", 165 },
   { "CartridgeValidationResponse", 166 },
   { "ColorProfileRequest", 117 },
   { "ColorProfileResponse", 118 },
-  { "ConnectRequest", 189 },
-  { "ConnectResponse", 190 },
-  { "CreateRequest", 201 },
-  { "CreateResponse", 202 },
+  { "ConnectRequest", 191 },
+  { "ConnectResponse", 192 },
+  { "CreateRequest", 203 },
+  { "CreateResponse", 204 },
   { "CurrentJobRequest", 173 },
   { "CurrentJobResponse", 174 },
-  { "DeleteRequest", 203 },
-  { "DeleteResponse", 204 },
+  { "DeleteRequest", 205 },
+  { "DeleteResponse", 206 },
   { "DirectSynchronizationRequest", 109 },
   { "DirectSynchronizationResponse", 110 },
-  { "DisconnectRequest", 191 },
-  { "DisconnectResponse", 192 },
+  { "DisconnectRequest", 193 },
+  { "DisconnectResponse", 194 },
   { "DispenserAbortHomingRequest", 131 },
   { "DispenserAbortHomingResponse", 132 },
   { "DispenserAbortJoggingRequest", 137 },
   { "DispenserAbortJoggingResponse", 138 },
-  { "DispenserDataRequest", 217 },
-  { "DispenserDataResponse", 218 },
+  { "DispenserDataRequest", 219 },
+  { "DispenserDataResponse", 220 },
   { "DispenserHomingRequest", 133 },
   { "DispenserHomingResponse", 134 },
   { "DispenserJoggingRequest", 135 },
   { "DispenserJoggingResponse", 136 },
   { "ErrorResponse", 1 },
-  { "ExecuteProcessRequest", 197 },
-  { "ExecuteProcessResponse", 198 },
+  { "ExecuteProcessRequest", 199 },
+  { "ExecuteProcessResponse", 200 },
   { "ExternalBridgeLoginRequest", 105 },
   { "ExternalBridgeLoginResponse", 106 },
   { "ExternalBridgeLogoutRequest", 107 },
   { "ExternalBridgeLogoutResponse", 108 },
   { "ExternalBridgeUdpDiscoveryPacket", 104 },
-  { "FileChunkDownloadRequest", 211 },
-  { "FileChunkDownloadResponse", 212 },
-  { "FileChunkUploadRequest", 195 },
-  { "FileChunkUploadResponse", 196 },
-  { "FileDownloadRequest", 209 },
-  { "FileDownloadResponse", 210 },
-  { "FileUploadRequest", 193 },
-  { "FileUploadResponse", 194 },
-  { "GetFilesRequest", 207 },
-  { "GetFilesResponse", 208 },
-  { "GetStorageInfoRequest", 205 },
-  { "GetStorageInfoResponse", 206 },
+  { "FileChunkDownloadRequest", 213 },
+  { "FileChunkDownloadResponse", 214 },
+  { "FileChunkUploadRequest", 197 },
+  { "FileChunkUploadResponse", 198 },
+  { "FileDownloadRequest", 211 },
+  { "FileDownloadResponse", 212 },
+  { "FileUploadRequest", 195 },
+  { "FileUploadResponse", 196 },
+  { "GetFilesRequest", 209 },
+  { "GetFilesResponse", 210 },
+  { "GetStorageInfoRequest", 207 },
+  { "GetStorageInfoResponse", 208 },
   { "JobRequest", 167 },
   { "JobResponse", 168 },
-  { "KeepAliveRequest", 187 },
-  { "KeepAliveResponse", 188 },
-  { "KillProcessRequest", 199 },
-  { "KillProcessResponse", 200 },
-  { "MachineCalibrationDataRequest", 221 },
-  { "MachineCalibrationDataResponse", 222 },
-  { "MidTankDataSetupRequest", 219 },
-  { "MidTankDataSetupResponse", 220 },
+  { "KeepAliveRequest", 189 },
+  { "KeepAliveResponse", 190 },
+  { "KillProcessRequest", 201 },
+  { "KillProcessResponse", 202 },
+  { "MachineCalibrationDataRequest", 223 },
+  { "MachineCalibrationDataResponse", 224 },
+  { "MidTankDataSetupRequest", 221 },
+  { "MidTankDataSetupResponse", 222 },
   { "MotorAbortHomingRequest", 123 },
   { "MotorAbortHomingResponse", 124 },
   { "MotorAbortJoggingRequest", 129 },
@@ -333,6 +335,8 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[227] =
   { "SetHeaterStateResponse", 156 },
   { "SetValveStateRequest", 159 },
   { "SetValveStateResponse", 160 },
+  { "SetupDebugDisributorsRequest", 183 },
+  { "SetupDebugDisributorsResponse", 184 },
   { "StartApplicationLogsRequest", 113 },
   { "StartApplicationLogsResponse", 114 },
   { "StartCartridgesUpdateRequest", 161 },
@@ -343,8 +347,8 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[227] =
   { "StartDiagnosticsResponse", 122 },
   { "StartEventsNotificationRequest", 151 },
   { "StartEventsNotificationResponse", 152 },
-  { "StartMachineStatusUpdateRequest", 223 },
-  { "StartMachineStatusUpdateResponse", 224 },
+  { "StartMachineStatusUpdateRequest", 225 },
+  { "StartMachineStatusUpdateResponse", 226 },
   { "StopApplicationLogsRequest", 115 },
   { "StopApplicationLogsResponse", 116 },
   { "StopCartridgesUpdateRequest", 163 },
@@ -355,8 +359,8 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[227] =
   { "StopDiagnosticsResponse", 150 },
   { "StopEventsNotificationRequest", 153 },
   { "StopEventsNotificationResponse", 154 },
-  { "StopMachineStatusUpdateRequest", 225 },
-  { "StopMachineStatusUpdateResponse", 226 },
+  { "StopMachineStatusUpdateRequest", 227 },
+  { "StopMachineStatusUpdateResponse", 228 },
   { "StubAbortJobRequest", 100 },
   { "StubAbortJobResponse", 101 },
   { "StubCartridgeReadRequest", 6 },
@@ -455,20 +459,20 @@ static const ProtobufCEnumValueIndex message_type__enum_values_by_name[227] =
   { "StubTivaWriteRegResponse", 79 },
   { "StubValveRequest", 30 },
   { "StubValveResponse", 31 },
-  { "SystemResetRequest", 185 },
-  { "SystemResetResponse", 186 },
+  { "SystemResetRequest", 187 },
+  { "SystemResetResponse", 188 },
   { "ThreadAbortJoggingRequest", 143 },
   { "ThreadAbortJoggingResponse", 144 },
   { "ThreadJoggingRequest", 141 },
   { "ThreadJoggingResponse", 142 },
   { "UpdateStatusRequest", 119 },
   { "UpdateStatusResponse", 120 },
-  { "UploadHardwareConfigurationRequest", 183 },
-  { "UploadHardwareConfigurationResponse", 184 },
+  { "UploadHardwareConfigurationRequest", 185 },
+  { "UploadHardwareConfigurationResponse", 186 },
   { "UploadProcessParametersRequest", 171 },
   { "UploadProcessParametersResponse", 172 },
-  { "ValidateVersionRequest", 213 },
-  { "ValidateVersionResponse", 214 },
+  { "ValidateVersionRequest", 215 },
+  { "ValidateVersionResponse", 216 },
 };
 const ProtobufCEnumDescriptor message_type__descriptor =
 {
@@ -477,9 +481,9 @@ const ProtobufCEnumDescriptor message_type__descriptor =
   "MessageType",
   "MessageType",
   "",
-  227,
+  229,
   message_type__enum_values_by_number,
-  227,
+  229,
   message_type__enum_values_by_name,
   11,
   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 90461900a..7cb8306df 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
@@ -203,6 +203,8 @@ typedef enum _MessageType {
   MESSAGE_TYPE__StopDebugLogResponse = 4003,
   MESSAGE_TYPE__SetDebugLogCategoryRequest = 4004,
   MESSAGE_TYPE__SetDebugLogCategoryResponse = 4005,
+  MESSAGE_TYPE__SetupDebugDisributorsRequest = 4006,
+  MESSAGE_TYPE__SetupDebugDisributorsResponse = 4007,
   MESSAGE_TYPE__UploadHardwareConfigurationRequest = 5000,
   MESSAGE_TYPE__UploadHardwareConfigurationResponse = 5001,
   MESSAGE_TYPE__SystemResetRequest = 5002,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Connection/ConnectResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Connection/ConnectResponse.pb-c.c
index ce449266e..ddc2f318a 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Connection/ConnectResponse.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Connection/ConnectResponse.pb-c.c
@@ -52,7 +52,7 @@ void   connect_response__free_unpacked
   assert(message->base.descriptor == &connect_response__descriptor);
   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 }
-static const ProtobufCFieldDescriptor connect_response__field_descriptors[1] =
+static const ProtobufCFieldDescriptor connect_response__field_descriptors[2] =
 {
   {
     "DeviceInformation",
@@ -66,14 +66,27 @@ static const ProtobufCFieldDescriptor connect_response__field_descriptors[1] =
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
+  {
+    "IsAfterReset",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_BOOL,
+    offsetof(ConnectResponse, has_isafterreset),
+    offsetof(ConnectResponse, isafterreset),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
 };
 static const unsigned connect_response__field_indices_by_name[] = {
   0,   /* field[0] = DeviceInformation */
+  1,   /* field[1] = IsAfterReset */
 };
 static const ProtobufCIntRange connect_response__number_ranges[1 + 1] =
 {
   { 1, 0 },
-  { 0, 1 }
+  { 0, 2 }
 };
 const ProtobufCMessageDescriptor connect_response__descriptor =
 {
@@ -83,7 +96,7 @@ const ProtobufCMessageDescriptor connect_response__descriptor =
   "ConnectResponse",
   "",
   sizeof(ConnectResponse),
-  1,
+  2,
   connect_response__field_descriptors,
   connect_response__field_indices_by_name,
   1,  connect_response__number_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Connection/ConnectResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Connection/ConnectResponse.pb-c.h
index 85a15995c..2bd756a07 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Connection/ConnectResponse.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Connection/ConnectResponse.pb-c.h
@@ -28,10 +28,12 @@ struct  _ConnectResponse
 {
   ProtobufCMessage base;
   DeviceInformation *deviceinformation;
+  protobuf_c_boolean has_isafterreset;
+  protobuf_c_boolean isafterreset;
 };
 #define CONNECT_RESPONSE__INIT \
  { PROTOBUF_C_MESSAGE_INIT (&connect_response__descriptor) \
-    , NULL }
+    , NULL, 0, 0 }
 
 
 /* ConnectResponse methods */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.c
index ebdad2054..e4e1c7ae1 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.c
@@ -52,14 +52,26 @@ void   setup_debug_disributors_request__free_unpacked
   assert(message->base.descriptor == &setup_debug_disributors_request__descriptor);
   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 }
-static const ProtobufCFieldDescriptor setup_debug_disributors_request__field_descriptors[1] =
+static const ProtobufCFieldDescriptor setup_debug_disributors_request__field_descriptors[2] =
 {
   {
-    "DistributorActive",
+    "DebugDistributor",
     1,
-    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(SetupDebugDisributorsRequest, has_debugdistributor),
+    offsetof(SetupDebugDisributorsRequest, debugdistributor),
+    &debug_distributor_type__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "DistributorActive",
+    2,
+    PROTOBUF_C_LABEL_OPTIONAL,
     PROTOBUF_C_TYPE_BOOL,
-    offsetof(SetupDebugDisributorsRequest, n_distributoractive),
+    offsetof(SetupDebugDisributorsRequest, has_distributoractive),
     offsetof(SetupDebugDisributorsRequest, distributoractive),
     NULL,
     NULL,
@@ -68,12 +80,13 @@ static const ProtobufCFieldDescriptor setup_debug_disributors_request__field_des
   },
 };
 static const unsigned setup_debug_disributors_request__field_indices_by_name[] = {
-  0,   /* field[0] = DistributorActive */
+  0,   /* field[0] = DebugDistributor */
+  1,   /* field[1] = DistributorActive */
 };
 static const ProtobufCIntRange setup_debug_disributors_request__number_ranges[1 + 1] =
 {
   { 1, 0 },
-  { 0, 1 }
+  { 0, 2 }
 };
 const ProtobufCMessageDescriptor setup_debug_disributors_request__descriptor =
 {
@@ -83,7 +96,7 @@ const ProtobufCMessageDescriptor setup_debug_disributors_request__descriptor =
   "SetupDebugDisributorsRequest",
   "",
   sizeof(SetupDebugDisributorsRequest),
-  1,
+  2,
   setup_debug_disributors_request__field_descriptors,
   setup_debug_disributors_request__field_indices_by_name,
   1,  setup_debug_disributors_request__number_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.h
index 65a5091ac..053609d76 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Debugging/SetupDebugDisributorsRequest.pb-c.h
@@ -14,6 +14,7 @@ PROTOBUF_C__BEGIN_DECLS
 # 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
 
+#include "DebugDistributorType.pb-c.h"
 
 typedef struct _SetupDebugDisributorsRequest SetupDebugDisributorsRequest;
 
@@ -26,12 +27,14 @@ typedef struct _SetupDebugDisributorsRequest SetupDebugDisributorsRequest;
 struct  _SetupDebugDisributorsRequest
 {
   ProtobufCMessage base;
-  size_t n_distributoractive;
-  protobuf_c_boolean *distributoractive;
+  protobuf_c_boolean has_debugdistributor;
+  DebugDistributorType debugdistributor;
+  protobuf_c_boolean has_distributoractive;
+  protobuf_c_boolean distributoractive;
 };
 #define SETUP_DEBUG_DISRIBUTORS_REQUEST__INIT \
  { PROTOBUF_C_MESSAGE_INIT (&setup_debug_disributors_request__descriptor) \
-    , 0,NULL }
+    , 0, DEBUG_DISTRIBUTOR_TYPE__ControlFilter, 0, 0 }
 
 
 /* SetupDebugDisributorsRequest methods */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.c
index ae8c238a9..fdd62c3e9 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.c
@@ -52,7 +52,7 @@ void   diagnostics_monitors__free_unpacked
   assert(message->base.descriptor == &diagnostics_monitors__descriptor);
   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 }
-static const ProtobufCFieldDescriptor diagnostics_monitors__field_descriptors[66] =
+static const ProtobufCFieldDescriptor diagnostics_monitors__field_descriptors[85] =
 {
   {
     "Dancer1Angle",
@@ -846,6 +846,234 @@ static const ProtobufCFieldDescriptor diagnostics_monitors__field_descriptors[66
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
+  {
+    "HeadZone7HeaterCurrent",
+    67,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone7heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone7heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone7Temperature",
+    68,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone7temperature),
+    offsetof(DiagnosticsMonitors, headzone7temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone8HeaterCurrent",
+    69,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone8heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone8heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone8Temperature",
+    70,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone8temperature),
+    offsetof(DiagnosticsMonitors, headzone8temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone9HeaterCurrent",
+    71,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone9heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone9heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone9Temperature",
+    72,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone9temperature),
+    offsetof(DiagnosticsMonitors, headzone9temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone10HeaterCurrent",
+    73,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone10heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone10heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone10Temperature",
+    74,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone10temperature),
+    offsetof(DiagnosticsMonitors, headzone10temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone11HeaterCurrent",
+    75,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone11heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone11heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone11Temperature",
+    76,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone11temperature),
+    offsetof(DiagnosticsMonitors, headzone11temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone12HeaterCurrent",
+    77,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone12heatercurrent),
+    offsetof(DiagnosticsMonitors, headzone12heatercurrent),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone12Temperature",
+    78,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headzone12temperature),
+    offsetof(DiagnosticsMonitors, headzone12temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadBlowerVoltage1",
+    79,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headblowervoltage1),
+    offsetof(DiagnosticsMonitors, headblowervoltage1),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadBlowerVoltage2",
+    80,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headblowervoltage2),
+    offsetof(DiagnosticsMonitors, headblowervoltage2),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadCoverHeater1Current",
+    81,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headcoverheater1current),
+    offsetof(DiagnosticsMonitors, headcoverheater1current),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadCoverHeater1Temperature",
+    82,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headcoverheater1temperature),
+    offsetof(DiagnosticsMonitors, headcoverheater1temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadCoverHeater2Current",
+    83,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headcoverheater2current),
+    offsetof(DiagnosticsMonitors, headcoverheater2current),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadCoverHeater2Temperature",
+    84,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_headcoverheater2temperature),
+    offsetof(DiagnosticsMonitors, headcoverheater2temperature),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "WHSBlower2Voltage",
+    85,
+    PROTOBUF_C_LABEL_REPEATED,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(DiagnosticsMonitors, n_whsblower2voltage),
+    offsetof(DiagnosticsMonitors, whsblower2voltage),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
 };
 static const unsigned diagnostics_monitors__field_indices_by_name[] = {
   38,   /* field[38] = BlowerVoltage */
@@ -885,6 +1113,18 @@ static const unsigned diagnostics_monitors__field_indices_by_name[] = {
   14,   /* field[14] = FeederTension */
   25,   /* field[25] = FilterDeltaPressure */
   13,   /* field[13] = HeadAirFlow */
+  78,   /* field[78] = HeadBlowerVoltage1 */
+  79,   /* field[79] = HeadBlowerVoltage2 */
+  80,   /* field[80] = HeadCoverHeater1Current */
+  81,   /* field[81] = HeadCoverHeater1Temperature */
+  82,   /* field[82] = HeadCoverHeater2Current */
+  83,   /* field[83] = HeadCoverHeater2Temperature */
+  72,   /* field[72] = HeadZone10HeaterCurrent */
+  73,   /* field[73] = HeadZone10Temperature */
+  74,   /* field[74] = HeadZone11HeaterCurrent */
+  75,   /* field[75] = HeadZone11Temperature */
+  76,   /* field[76] = HeadZone12HeaterCurrent */
+  77,   /* field[77] = HeadZone12Temperature */
   57,   /* field[57] = HeadZone1HeaterCurrent */
   10,   /* field[10] = HeadZone1Temperature */
   58,   /* field[58] = HeadZone2HeaterCurrent */
@@ -896,6 +1136,12 @@ static const unsigned diagnostics_monitors__field_indices_by_name[] = {
   36,   /* field[36] = HeadZone5Temperature */
   61,   /* field[61] = HeadZone5_6HeaterCurrent */
   37,   /* field[37] = HeadZone6Temperature */
+  66,   /* field[66] = HeadZone7HeaterCurrent */
+  67,   /* field[67] = HeadZone7Temperature */
+  68,   /* field[68] = HeadZone8HeaterCurrent */
+  69,   /* field[69] = HeadZone8Temperature */
+  70,   /* field[70] = HeadZone9HeaterCurrent */
+  71,   /* field[71] = HeadZone9Temperature */
   47,   /* field[47] = MidTank1Level */
   48,   /* field[48] = MidTank2Level */
   49,   /* field[49] = MidTank3Level */
@@ -912,13 +1158,14 @@ static const unsigned diagnostics_monitors__field_indices_by_name[] = {
   15,   /* field[15] = PullerTension */
   7,   /* field[7] = ScrewMotor */
   8,   /* field[8] = ThreadSpeed */
+  84,   /* field[84] = WHSBlower2Voltage */
   6,   /* field[6] = WinderMotor */
   20,   /* field[20] = WinderTension */
 };
 static const ProtobufCIntRange diagnostics_monitors__number_ranges[1 + 1] =
 {
   { 1, 0 },
-  { 0, 66 }
+  { 0, 85 }
 };
 const ProtobufCMessageDescriptor diagnostics_monitors__descriptor =
 {
@@ -928,7 +1175,7 @@ const ProtobufCMessageDescriptor diagnostics_monitors__descriptor =
   "DiagnosticsMonitors",
   "",
   sizeof(DiagnosticsMonitors),
-  66,
+  85,
   diagnostics_monitors__field_descriptors,
   diagnostics_monitors__field_indices_by_name,
   1,  diagnostics_monitors__number_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h
index 203c1d92c..38ee1ce97 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/DiagnosticsMonitors.pb-c.h
@@ -159,10 +159,48 @@ struct  _DiagnosticsMonitors
   DoubleArray **midtanksinklevel;
   size_t n_overalltemperature;
   double *overalltemperature;
+  size_t n_headzone7heatercurrent;
+  double *headzone7heatercurrent;
+  size_t n_headzone7temperature;
+  double *headzone7temperature;
+  size_t n_headzone8heatercurrent;
+  double *headzone8heatercurrent;
+  size_t n_headzone8temperature;
+  double *headzone8temperature;
+  size_t n_headzone9heatercurrent;
+  double *headzone9heatercurrent;
+  size_t n_headzone9temperature;
+  double *headzone9temperature;
+  size_t n_headzone10heatercurrent;
+  double *headzone10heatercurrent;
+  size_t n_headzone10temperature;
+  double *headzone10temperature;
+  size_t n_headzone11heatercurrent;
+  double *headzone11heatercurrent;
+  size_t n_headzone11temperature;
+  double *headzone11temperature;
+  size_t n_headzone12heatercurrent;
+  double *headzone12heatercurrent;
+  size_t n_headzone12temperature;
+  double *headzone12temperature;
+  size_t n_headblowervoltage1;
+  double *headblowervoltage1;
+  size_t n_headblowervoltage2;
+  double *headblowervoltage2;
+  size_t n_headcoverheater1current;
+  double *headcoverheater1current;
+  size_t n_headcoverheater1temperature;
+  double *headcoverheater1temperature;
+  size_t n_headcoverheater2current;
+  double *headcoverheater2current;
+  size_t n_headcoverheater2temperature;
+  double *headcoverheater2temperature;
+  size_t n_whsblower2voltage;
+  double *whsblower2voltage;
 };
 #define DIAGNOSTICS_MONITORS__INIT \
  { PROTOBUF_C_MESSAGE_INIT (&diagnostics_monitors__descriptor) \
-    , 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL }
+    , 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL }
 
 
 /* DiagnosticsMonitors methods */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c
index 11ae78d92..dbd0f88e0 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.c
@@ -7,7 +7,7 @@
 #endif
 
 #include "EventType.pb-c.h"
-static const ProtobufCEnumValue event_type__enum_values_by_number[289] =
+static const ProtobufCEnumValue event_type__enum_values_by_number[294] =
 {
   { "None", "EVENT_TYPE__None", 0 },
   { "REQUEST_SENT", "EVENT_TYPE__REQUEST_SENT", 1000 },
@@ -41,6 +41,10 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[289] =
   { "MACHINE_STATE_HW_CONFIG_FAILED", "EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED", 2014 },
   { "MACHINE_STATE_INITIAL_BLOWER_FAILED", "EVENT_TYPE__MACHINE_STATE_INITIAL_BLOWER_FAILED", 2015 },
   { "UNSPECIFIED", "EVENT_TYPE__UNSPECIFIED", 2016 },
+  { "MACHINE_INTERNAL_OVERTEMPERATURE_2", "EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2", 2017 },
+  { "ELECTRICAL_CABINET_OVERTEMPERATURE", "EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE", 2018 },
+  { "FPGA_WATCHDOG_ACTIVATED", "EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED", 2019 },
+  { "UNINTENDED_RESET", "EVENT_TYPE__UNINTENDED_RESET", 2020 },
   { "THREAD_BREAK", "EVENT_TYPE__THREAD_BREAK", 3000 },
   { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 3001 },
   { "WINDER_CONE_DOES_NOT_EXIST", "EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST", 3002 },
@@ -92,6 +96,7 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[289] =
   { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 3048 },
   { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", "EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 3049 },
   { "MACHINE_STATE_NO_THREAD_DETECTED", "EVENT_TYPE__MACHINE_STATE_NO_THREAD_DETECTED", 3050 },
+  { "THREAD_LOADING_ERROR", "EVENT_TYPE__THREAD_LOADING_ERROR", 3051 },
   { "DRYER_MOTOR_OVERCURRENT", "EVENT_TYPE__DRYER_MOTOR_OVERCURRENT", 4000 },
   { "DRYER_MOTOR_OVERTEMPERATURE", "EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE", 4001 },
   { "DRYER_MOTOR_STALL", "EVENT_TYPE__DRYER_MOTOR_STALL", 4002 },
@@ -300,299 +305,304 @@ static const ProtobufCEnumValue event_type__enum_values_by_number[289] =
   { "WASTE_CARTRIDGE_RFID_TIMEOUT", "EVENT_TYPE__WASTE_CARTRIDGE_RFID_TIMEOUT", 10005 },
 };
 static const ProtobufCIntRange event_type__value_ranges[] = {
-{0, 0},{1000, 1},{2000, 15},{3000, 32},{4000, 83},{5000, 105},{6000, 148},{7000, 154},{8000, 242},{9000, 274},{10000, 283},{0, 289}
+{0, 0},{1000, 1},{2000, 15},{3000, 36},{4000, 88},{5000, 110},{6000, 153},{7000, 159},{8000, 247},{9000, 279},{10000, 288},{0, 294}
 };
-static const ProtobufCEnumValueIndex event_type__enum_values_by_name[289] =
+static const ProtobufCEnumValueIndex event_type__enum_values_by_name[294] =
 {
-  { "AIR_FILTER_CLOGGED", 275 },
-  { "AIR_FILTER_NOT_INSTALLED", 274 },
-  { "ALL_WASTE_CARTRIDGES_FULL", 286 },
+  { "AIR_FILTER_CLOGGED", 280 },
+  { "AIR_FILTER_NOT_INSTALLED", 279 },
+  { "ALL_WASTE_CARTRIDGES_FULL", 291 },
   { "APPLICATION_EXCEPTION", 4 },
   { "APPLICATION_INFORMATION", 5 },
   { "APPLICATION_STARTED", 6 },
   { "APPLICATION_TERMINATED", 7 },
   { "CARTRIDGES_COVER_OPEN", 21 },
-  { "CHILLER_DRY_CONTACT", 280 },
-  { "DISPENSER_1_EMPTY", 170 },
-  { "DISPENSER_1_HIGH_PRESSURE", 234 },
-  { "DISPENSER_1_LOWER_HARD_LIMIT", 226 },
-  { "DISPENSER_1_MOTOR_OVERCURRENT", 186 },
-  { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 194 },
-  { "DISPENSER_1_MOTOR_STALL", 202 },
-  { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 210 },
-  { "DISPENSER_1_OVERPRESSURE", 154 },
-  { "DISPENSER_1_REFILL_FAILURE", 178 },
-  { "DISPENSER_1_UNDERPRESSURE", 162 },
-  { "DISPENSER_1_UPPER_HARD_LIMIT", 218 },
-  { "DISPENSER_2_EMPTY", 171 },
-  { "DISPENSER_2_HIGH_PRESSURE", 235 },
-  { "DISPENSER_2_LOWER_HARD_LIMIT", 227 },
-  { "DISPENSER_2_MOTOR_OVERCURRENT", 187 },
-  { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 195 },
-  { "DISPENSER_2_MOTOR_STALL", 203 },
-  { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 211 },
-  { "DISPENSER_2_OVERPRESSURE", 155 },
-  { "DISPENSER_2_REFILL_FAILURE", 179 },
-  { "DISPENSER_2_UNDERPRESSURE", 163 },
-  { "DISPENSER_2_UPPER_HARD_LIMIT", 219 },
-  { "DISPENSER_3_EMPTY", 172 },
-  { "DISPENSER_3_HIGH_PRESSURE", 236 },
-  { "DISPENSER_3_LOWER_HARD_LIMIT", 228 },
-  { "DISPENSER_3_MOTOR_OVERCURRENT", 188 },
-  { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 196 },
-  { "DISPENSER_3_MOTOR_STALL", 204 },
-  { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 212 },
-  { "DISPENSER_3_OVERPRESSURE", 156 },
-  { "DISPENSER_3_REFILL_FAILURE", 180 },
-  { "DISPENSER_3_UNDERPRESSURE", 164 },
-  { "DISPENSER_3_UPPER_HARD_LIMIT", 220 },
-  { "DISPENSER_4_EMPTY", 173 },
-  { "DISPENSER_4_HIGH_PRESSURE", 237 },
-  { "DISPENSER_4_LOWER_HARD_LIMIT", 229 },
-  { "DISPENSER_4_MOTOR_OVERCURRENT", 189 },
-  { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 197 },
-  { "DISPENSER_4_MOTOR_STALL", 205 },
-  { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 213 },
-  { "DISPENSER_4_OVERPRESSURE", 157 },
-  { "DISPENSER_4_REFILL_FAILURE", 181 },
-  { "DISPENSER_4_UNDERPRESSURE", 165 },
-  { "DISPENSER_4_UPPER_HARD_LIMIT", 221 },
-  { "DISPENSER_5_EMPTY", 174 },
-  { "DISPENSER_5_HIGH_PRESSURE", 238 },
-  { "DISPENSER_5_LOWER_HARD_LIMIT", 230 },
-  { "DISPENSER_5_MOTOR_OVERCURRENT", 190 },
-  { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 198 },
-  { "DISPENSER_5_MOTOR_STALL", 206 },
-  { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 214 },
-  { "DISPENSER_5_OVERPRESSURE", 158 },
-  { "DISPENSER_5_REFILL_FAILURE", 182 },
-  { "DISPENSER_5_UNDERPRESSURE", 166 },
-  { "DISPENSER_5_UPPER_HARD_LIMIT", 222 },
-  { "DISPENSER_6_EMPTY", 175 },
-  { "DISPENSER_6_HIGH_PRESSURE", 239 },
-  { "DISPENSER_6_LOWER_HARD_LIMIT", 231 },
-  { "DISPENSER_6_MOTOR_OVERCURRENT", 191 },
-  { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 199 },
-  { "DISPENSER_6_MOTOR_STALL", 207 },
-  { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 215 },
-  { "DISPENSER_6_OVERPRESSURE", 159 },
-  { "DISPENSER_6_REFILL_FAILURE", 183 },
-  { "DISPENSER_6_UNDERPRESSURE", 167 },
-  { "DISPENSER_6_UPPER_HARD_LIMIT", 223 },
-  { "DISPENSER_7_EMPTY", 176 },
-  { "DISPENSER_7_HIGH_PRESSURE", 240 },
-  { "DISPENSER_7_LOWER_HARD_LIMIT", 232 },
-  { "DISPENSER_7_MOTOR_OVERCURRENT", 192 },
-  { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 200 },
-  { "DISPENSER_7_MOTOR_STALL", 208 },
-  { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 216 },
-  { "DISPENSER_7_OVERPRESSURE", 160 },
-  { "DISPENSER_7_REFILL_FAILURE", 184 },
-  { "DISPENSER_7_UNDERPRESSURE", 168 },
-  { "DISPENSER_7_UPPER_HARD_LIMIT", 224 },
-  { "DISPENSER_8_EMPTY", 177 },
-  { "DISPENSER_8_HIGH_PRESSURE", 241 },
-  { "DISPENSER_8_LOWER_HARD_LIMIT", 233 },
-  { "DISPENSER_8_MOTOR_OVERCURRENT", 193 },
-  { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 201 },
-  { "DISPENSER_8_MOTOR_STALL", 209 },
-  { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 217 },
-  { "DISPENSER_8_OVERPRESSURE", 161 },
-  { "DISPENSER_8_REFILL_FAILURE", 185 },
-  { "DISPENSER_8_UNDERPRESSURE", 169 },
-  { "DISPENSER_8_UPPER_HARD_LIMIT", 225 },
-  { "DRYER_DOOR_OPEN", 87 },
-  { "DRYER_FAN_RPM_TOO_LOW", 98 },
-  { "DRYER_FAN_STOPPED", 99 },
-  { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 96 },
-  { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 94 },
-  { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 97 },
-  { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 95 },
-  { "DRYER_LID_MOTOR_OVERCURRENT", 100 },
-  { "DRYER_LID_MOTOR_OVERTEMPERATURE", 101 },
-  { "DRYER_LID_MOTOR_STALL", 102 },
-  { "DRYER_LID_MOTOR_UNDERVOLTAGE", 103 },
-  { "DRYER_MOTOR_OVERCURRENT", 83 },
-  { "DRYER_MOTOR_OVERTEMPERATURE", 84 },
-  { "DRYER_MOTOR_STALL", 85 },
-  { "DRYER_MOTOR_UNDERVOLTAGE", 86 },
-  { "DRYER_THERMAL_CUTOFF", 93 },
-  { "DRYER_ZONE_1_OVERTEMPERATURE", 88 },
-  { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 90 },
-  { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 91 },
-  { "DRYER_ZONE_2_OVERTEMPERATURE", 89 },
-  { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 104 },
-  { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 92 },
-  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 144 },
-  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 145 },
-  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 146 },
-  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 147 },
-  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 140 },
-  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 141 },
-  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 142 },
-  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 143 },
-  { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 135 },
-  { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 136 },
-  { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 137 },
-  { "DYEING_HEAD_COVER_MOTOR_STALL", 138 },
-  { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 139 },
-  { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 134 },
-  { "DYEING_HEAD_THERMAL_CUTOFF", 133 },
-  { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 128 },
-  { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 123 },
-  { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 105 },
-  { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 111 },
-  { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 117 },
-  { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 129 },
-  { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 124 },
-  { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 106 },
-  { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 112 },
-  { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 118 },
-  { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 130 },
-  { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 125 },
-  { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 107 },
-  { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 113 },
-  { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 119 },
-  { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 131 },
-  { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 126 },
-  { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 108 },
-  { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 114 },
-  { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 120 },
-  { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 132 },
-  { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 127 },
-  { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 109 },
-  { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 115 },
-  { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 121 },
-  { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 110 },
-  { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 116 },
-  { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 122 },
+  { "CHILLER_DRY_CONTACT", 285 },
+  { "DISPENSER_1_EMPTY", 175 },
+  { "DISPENSER_1_HIGH_PRESSURE", 239 },
+  { "DISPENSER_1_LOWER_HARD_LIMIT", 231 },
+  { "DISPENSER_1_MOTOR_OVERCURRENT", 191 },
+  { "DISPENSER_1_MOTOR_OVERTEMPERATURE", 199 },
+  { "DISPENSER_1_MOTOR_STALL", 207 },
+  { "DISPENSER_1_MOTOR_UNDERVOLTAGE", 215 },
+  { "DISPENSER_1_OVERPRESSURE", 159 },
+  { "DISPENSER_1_REFILL_FAILURE", 183 },
+  { "DISPENSER_1_UNDERPRESSURE", 167 },
+  { "DISPENSER_1_UPPER_HARD_LIMIT", 223 },
+  { "DISPENSER_2_EMPTY", 176 },
+  { "DISPENSER_2_HIGH_PRESSURE", 240 },
+  { "DISPENSER_2_LOWER_HARD_LIMIT", 232 },
+  { "DISPENSER_2_MOTOR_OVERCURRENT", 192 },
+  { "DISPENSER_2_MOTOR_OVERTEMPERATURE", 200 },
+  { "DISPENSER_2_MOTOR_STALL", 208 },
+  { "DISPENSER_2_MOTOR_UNDERVOLTAGE", 216 },
+  { "DISPENSER_2_OVERPRESSURE", 160 },
+  { "DISPENSER_2_REFILL_FAILURE", 184 },
+  { "DISPENSER_2_UNDERPRESSURE", 168 },
+  { "DISPENSER_2_UPPER_HARD_LIMIT", 224 },
+  { "DISPENSER_3_EMPTY", 177 },
+  { "DISPENSER_3_HIGH_PRESSURE", 241 },
+  { "DISPENSER_3_LOWER_HARD_LIMIT", 233 },
+  { "DISPENSER_3_MOTOR_OVERCURRENT", 193 },
+  { "DISPENSER_3_MOTOR_OVERTEMPERATURE", 201 },
+  { "DISPENSER_3_MOTOR_STALL", 209 },
+  { "DISPENSER_3_MOTOR_UNDERVOLTAGE", 217 },
+  { "DISPENSER_3_OVERPRESSURE", 161 },
+  { "DISPENSER_3_REFILL_FAILURE", 185 },
+  { "DISPENSER_3_UNDERPRESSURE", 169 },
+  { "DISPENSER_3_UPPER_HARD_LIMIT", 225 },
+  { "DISPENSER_4_EMPTY", 178 },
+  { "DISPENSER_4_HIGH_PRESSURE", 242 },
+  { "DISPENSER_4_LOWER_HARD_LIMIT", 234 },
+  { "DISPENSER_4_MOTOR_OVERCURRENT", 194 },
+  { "DISPENSER_4_MOTOR_OVERTEMPERATURE", 202 },
+  { "DISPENSER_4_MOTOR_STALL", 210 },
+  { "DISPENSER_4_MOTOR_UNDERVOLTAGE", 218 },
+  { "DISPENSER_4_OVERPRESSURE", 162 },
+  { "DISPENSER_4_REFILL_FAILURE", 186 },
+  { "DISPENSER_4_UNDERPRESSURE", 170 },
+  { "DISPENSER_4_UPPER_HARD_LIMIT", 226 },
+  { "DISPENSER_5_EMPTY", 179 },
+  { "DISPENSER_5_HIGH_PRESSURE", 243 },
+  { "DISPENSER_5_LOWER_HARD_LIMIT", 235 },
+  { "DISPENSER_5_MOTOR_OVERCURRENT", 195 },
+  { "DISPENSER_5_MOTOR_OVERTEMPERATURE", 203 },
+  { "DISPENSER_5_MOTOR_STALL", 211 },
+  { "DISPENSER_5_MOTOR_UNDERVOLTAGE", 219 },
+  { "DISPENSER_5_OVERPRESSURE", 163 },
+  { "DISPENSER_5_REFILL_FAILURE", 187 },
+  { "DISPENSER_5_UNDERPRESSURE", 171 },
+  { "DISPENSER_5_UPPER_HARD_LIMIT", 227 },
+  { "DISPENSER_6_EMPTY", 180 },
+  { "DISPENSER_6_HIGH_PRESSURE", 244 },
+  { "DISPENSER_6_LOWER_HARD_LIMIT", 236 },
+  { "DISPENSER_6_MOTOR_OVERCURRENT", 196 },
+  { "DISPENSER_6_MOTOR_OVERTEMPERATURE", 204 },
+  { "DISPENSER_6_MOTOR_STALL", 212 },
+  { "DISPENSER_6_MOTOR_UNDERVOLTAGE", 220 },
+  { "DISPENSER_6_OVERPRESSURE", 164 },
+  { "DISPENSER_6_REFILL_FAILURE", 188 },
+  { "DISPENSER_6_UNDERPRESSURE", 172 },
+  { "DISPENSER_6_UPPER_HARD_LIMIT", 228 },
+  { "DISPENSER_7_EMPTY", 181 },
+  { "DISPENSER_7_HIGH_PRESSURE", 245 },
+  { "DISPENSER_7_LOWER_HARD_LIMIT", 237 },
+  { "DISPENSER_7_MOTOR_OVERCURRENT", 197 },
+  { "DISPENSER_7_MOTOR_OVERTEMPERATURE", 205 },
+  { "DISPENSER_7_MOTOR_STALL", 213 },
+  { "DISPENSER_7_MOTOR_UNDERVOLTAGE", 221 },
+  { "DISPENSER_7_OVERPRESSURE", 165 },
+  { "DISPENSER_7_REFILL_FAILURE", 189 },
+  { "DISPENSER_7_UNDERPRESSURE", 173 },
+  { "DISPENSER_7_UPPER_HARD_LIMIT", 229 },
+  { "DISPENSER_8_EMPTY", 182 },
+  { "DISPENSER_8_HIGH_PRESSURE", 246 },
+  { "DISPENSER_8_LOWER_HARD_LIMIT", 238 },
+  { "DISPENSER_8_MOTOR_OVERCURRENT", 198 },
+  { "DISPENSER_8_MOTOR_OVERTEMPERATURE", 206 },
+  { "DISPENSER_8_MOTOR_STALL", 214 },
+  { "DISPENSER_8_MOTOR_UNDERVOLTAGE", 222 },
+  { "DISPENSER_8_OVERPRESSURE", 166 },
+  { "DISPENSER_8_REFILL_FAILURE", 190 },
+  { "DISPENSER_8_UNDERPRESSURE", 174 },
+  { "DISPENSER_8_UPPER_HARD_LIMIT", 230 },
+  { "DRYER_DOOR_OPEN", 92 },
+  { "DRYER_FAN_RPM_TOO_LOW", 103 },
+  { "DRYER_FAN_STOPPED", 104 },
+  { "DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK", 101 },
+  { "DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE", 99 },
+  { "DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK", 102 },
+  { "DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE", 100 },
+  { "DRYER_LID_MOTOR_OVERCURRENT", 105 },
+  { "DRYER_LID_MOTOR_OVERTEMPERATURE", 106 },
+  { "DRYER_LID_MOTOR_STALL", 107 },
+  { "DRYER_LID_MOTOR_UNDERVOLTAGE", 108 },
+  { "DRYER_MOTOR_OVERCURRENT", 88 },
+  { "DRYER_MOTOR_OVERTEMPERATURE", 89 },
+  { "DRYER_MOTOR_STALL", 90 },
+  { "DRYER_MOTOR_UNDERVOLTAGE", 91 },
+  { "DRYER_THERMAL_CUTOFF", 98 },
+  { "DRYER_ZONE_1_OVERTEMPERATURE", 93 },
+  { "DRYER_ZONE_1_UNDERTEMPERATURE_A", 95 },
+  { "DRYER_ZONE_1_UNDERTEMPERATURE_B", 96 },
+  { "DRYER_ZONE_2_OVERTEMPERATURE", 94 },
+  { "DRYER_ZONE_2_UNDERTEMPERATURE_A", 109 },
+  { "DRYER_ZONE_2_UNDERTEMPERATURE_B", 97 },
+  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT", 149 },
+  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE", 150 },
+  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL", 151 },
+  { "DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE", 152 },
+  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT", 145 },
+  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE", 146 },
+  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL", 147 },
+  { "DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE", 148 },
+  { "DYEING_HEAD_COVER_CLOSE_TIMEOUT", 140 },
+  { "DYEING_HEAD_COVER_MOTOR_OVERCURRENT", 141 },
+  { "DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE", 142 },
+  { "DYEING_HEAD_COVER_MOTOR_STALL", 143 },
+  { "DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE", 144 },
+  { "DYEING_HEAD_COVER_OPEN_TIMEOUT", 139 },
+  { "DYEING_HEAD_THERMAL_CUTOFF", 138 },
+  { "DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK", 133 },
+  { "DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE", 128 },
+  { "DYEING_HEAD_ZONE_1_OVERTEMPERATURE", 110 },
+  { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A", 116 },
+  { "DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B", 122 },
+  { "DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK", 134 },
+  { "DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE", 129 },
+  { "DYEING_HEAD_ZONE_2_OVERTEMPERATURE", 111 },
+  { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A", 117 },
+  { "DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B", 123 },
+  { "DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK", 135 },
+  { "DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE", 130 },
+  { "DYEING_HEAD_ZONE_3_OVERTEMPERATURE", 112 },
+  { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A", 118 },
+  { "DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B", 124 },
+  { "DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK", 136 },
+  { "DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE", 131 },
+  { "DYEING_HEAD_ZONE_4_OVERTEMPERATURE", 113 },
+  { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A", 119 },
+  { "DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B", 125 },
+  { "DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK", 137 },
+  { "DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE", 132 },
+  { "DYEING_HEAD_ZONE_5_OVERTEMPERATURE", 114 },
+  { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A", 120 },
+  { "DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B", 126 },
+  { "DYEING_HEAD_ZONE_6_OVERTEMPERATURE", 115 },
+  { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A", 121 },
+  { "DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B", 127 },
   { "ELECTRICAL_CABINET_FANS_RPM_TOO_LOW", 26 },
   { "ELECTRICAL_CABINET_FANS_STOPPED", 27 },
+  { "ELECTRICAL_CABINET_OVERTEMPERATURE", 33 },
   { "EMERGENCY_PUSH_BUTTON_PRESSED", 16 },
-  { "FEEDER_DANCER_MOTOR_OVERCURRENT", 70 },
-  { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 73 },
-  { "FEEDER_DANCER_MOTOR_STALL", 76 },
-  { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 79 },
-  { "FEEDER_MOTOR_OVERCURRENT", 35 },
-  { "FEEDER_MOTOR_OVERTEMPERATURE", 42 },
-  { "FEEDER_MOTOR_STALL", 49 },
-  { "FEEDER_MOTOR_UNDERVOLTAGE", 56 },
+  { "FEEDER_DANCER_MOTOR_OVERCURRENT", 74 },
+  { "FEEDER_DANCER_MOTOR_OVERTEMPERATURE", 77 },
+  { "FEEDER_DANCER_MOTOR_STALL", 80 },
+  { "FEEDER_DANCER_MOTOR_UNDERVOLTAGE", 83 },
+  { "FEEDER_MOTOR_OVERCURRENT", 39 },
+  { "FEEDER_MOTOR_OVERTEMPERATURE", 46 },
+  { "FEEDER_MOTOR_STALL", 53 },
+  { "FEEDER_MOTOR_UNDERVOLTAGE", 60 },
+  { "FPGA_WATCHDOG_ACTIVATED", 34 },
   { "FRONT_COVER_1_OPEN", 17 },
   { "FRONT_COVER_2_OPEN", 18 },
   { "FRONT_COVER_3_OPEN", 19 },
   { "FRONT_COVER_4_OPEN", 20 },
-  { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 283 },
-  { "INK_CARTRIDGE_RFID_TIMEOUT", 284 },
-  { "INSUFFICIENT_AIR_FLOW", 281 },
+  { "INK_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 288 },
+  { "INK_CARTRIDGE_RFID_TIMEOUT", 289 },
+  { "INSUFFICIENT_AIR_FLOW", 286 },
   { "JOB_ABORTED", 12 },
   { "JOB_COMPLETED", 14 },
   { "JOB_FAILED", 13 },
   { "JOB_STARTED", 11 },
   { "JOB_STATUS", 10 },
-  { "LEFT_LOADER_MOTOR_OVERCURRENT", 38 },
-  { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 45 },
-  { "LEFT_LOADER_MOTOR_STALL", 52 },
-  { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 59 },
-  { "LOADING_ARM_MOTOR_OVERCURRENT", 41 },
-  { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 48 },
-  { "LOADING_ARM_MOTOR_STALL", 55 },
-  { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 62 },
-  { "LTFU_DOWN_TIMEOUT", 64 },
-  { "LTFU_UP_TIMEOUT", 63 },
+  { "LEFT_LOADER_MOTOR_OVERCURRENT", 42 },
+  { "LEFT_LOADER_MOTOR_OVERTEMPERATURE", 49 },
+  { "LEFT_LOADER_MOTOR_STALL", 56 },
+  { "LEFT_LOADER_MOTOR_UNDERVOLTAGE", 63 },
+  { "LOADING_ARM_MOTOR_OVERCURRENT", 45 },
+  { "LOADING_ARM_MOTOR_OVERTEMPERATURE", 52 },
+  { "LOADING_ARM_MOTOR_STALL", 59 },
+  { "LOADING_ARM_MOTOR_UNDERVOLTAGE", 66 },
+  { "LTFU_DOWN_TIMEOUT", 68 },
+  { "LTFU_UP_TIMEOUT", 67 },
   { "MACHINE_FANS_RPM_TOO_LOW", 24 },
   { "MACHINE_FANS_STOPPED", 25 },
   { "MACHINE_INTERNAL_OVERTEMPERATURE", 23 },
+  { "MACHINE_INTERNAL_OVERTEMPERATURE_2", 32 },
   { "MACHINE_STATE_HW_CONFIG_FAILED", 29 },
   { "MACHINE_STATE_INITIAL_BLOWER_FAILED", 30 },
   { "MACHINE_STATE_NO_CFG_FILE", 28 },
-  { "MACHINE_STATE_NO_THREAD_DETECTED", 82 },
-  { "MID_TANK_1_EMPTY", 250 },
-  { "MID_TANK_1_FILL_TIMEOUT", 266 },
-  { "MID_TANK_1_LOW_LEVEL", 242 },
-  { "MID_TANK_1_OVERFLOW", 258 },
-  { "MID_TANK_2_EMPTY", 251 },
-  { "MID_TANK_2_FILL_TIMEOUT", 267 },
-  { "MID_TANK_2_LOW_LEVEL", 243 },
-  { "MID_TANK_2_OVERFLOW", 259 },
-  { "MID_TANK_3_EMPTY", 252 },
-  { "MID_TANK_3_FILL_TIMEOUT", 268 },
-  { "MID_TANK_3_LOW_LEVEL", 244 },
-  { "MID_TANK_3_OVERFLOW", 260 },
-  { "MID_TANK_4_EMPTY", 253 },
-  { "MID_TANK_4_FILL_TIMEOUT", 269 },
-  { "MID_TANK_4_LOW_LEVEL", 245 },
-  { "MID_TANK_4_OVERFLOW", 261 },
-  { "MID_TANK_5_EMPTY", 254 },
-  { "MID_TANK_5_FILL_TIMEOUT", 270 },
-  { "MID_TANK_5_LOW_LEVEL", 246 },
-  { "MID_TANK_5_OVERFLOW", 262 },
-  { "MID_TANK_6_EMPTY", 255 },
-  { "MID_TANK_6_FILL_TIMEOUT", 271 },
-  { "MID_TANK_6_LOW_LEVEL", 247 },
-  { "MID_TANK_6_OVERFLOW", 263 },
-  { "MID_TANK_7_EMPTY", 256 },
-  { "MID_TANK_7_FILL_TIMEOUT", 272 },
-  { "MID_TANK_7_LOW_LEVEL", 248 },
-  { "MID_TANK_7_OVERFLOW", 264 },
-  { "MID_TANK_8_EMPTY", 257 },
-  { "MID_TANK_8_FILL_TIMEOUT", 273 },
-  { "MID_TANK_8_LOW_LEVEL", 249 },
-  { "MID_TANK_8_OVERFLOW", 265 },
-  { "MIXER_CURRENT_LOOP_BREAK", 153 },
-  { "MIXER_CURRENT_OUT_OF_RANGE", 152 },
-  { "MIXER_OVERTEMPERATURE", 148 },
-  { "MIXER_THERMAL_CUTOFF", 151 },
-  { "MIXER_UNDERTEMPERATURE_A", 149 },
-  { "MIXER_UNDERTEMPERATURE_B", 150 },
-  { "NO_AIR_PRESSURE", 277 },
-  { "NO_WASTE_CARTRIDGE_AVAILABLE", 285 },
+  { "MACHINE_STATE_NO_THREAD_DETECTED", 86 },
+  { "MID_TANK_1_EMPTY", 255 },
+  { "MID_TANK_1_FILL_TIMEOUT", 271 },
+  { "MID_TANK_1_LOW_LEVEL", 247 },
+  { "MID_TANK_1_OVERFLOW", 263 },
+  { "MID_TANK_2_EMPTY", 256 },
+  { "MID_TANK_2_FILL_TIMEOUT", 272 },
+  { "MID_TANK_2_LOW_LEVEL", 248 },
+  { "MID_TANK_2_OVERFLOW", 264 },
+  { "MID_TANK_3_EMPTY", 257 },
+  { "MID_TANK_3_FILL_TIMEOUT", 273 },
+  { "MID_TANK_3_LOW_LEVEL", 249 },
+  { "MID_TANK_3_OVERFLOW", 265 },
+  { "MID_TANK_4_EMPTY", 258 },
+  { "MID_TANK_4_FILL_TIMEOUT", 274 },
+  { "MID_TANK_4_LOW_LEVEL", 250 },
+  { "MID_TANK_4_OVERFLOW", 266 },
+  { "MID_TANK_5_EMPTY", 259 },
+  { "MID_TANK_5_FILL_TIMEOUT", 275 },
+  { "MID_TANK_5_LOW_LEVEL", 251 },
+  { "MID_TANK_5_OVERFLOW", 267 },
+  { "MID_TANK_6_EMPTY", 260 },
+  { "MID_TANK_6_FILL_TIMEOUT", 276 },
+  { "MID_TANK_6_LOW_LEVEL", 252 },
+  { "MID_TANK_6_OVERFLOW", 268 },
+  { "MID_TANK_7_EMPTY", 261 },
+  { "MID_TANK_7_FILL_TIMEOUT", 277 },
+  { "MID_TANK_7_LOW_LEVEL", 253 },
+  { "MID_TANK_7_OVERFLOW", 269 },
+  { "MID_TANK_8_EMPTY", 262 },
+  { "MID_TANK_8_FILL_TIMEOUT", 278 },
+  { "MID_TANK_8_LOW_LEVEL", 254 },
+  { "MID_TANK_8_OVERFLOW", 270 },
+  { "MIXER_CURRENT_LOOP_BREAK", 158 },
+  { "MIXER_CURRENT_OUT_OF_RANGE", 157 },
+  { "MIXER_OVERTEMPERATURE", 153 },
+  { "MIXER_THERMAL_CUTOFF", 156 },
+  { "MIXER_UNDERTEMPERATURE_A", 154 },
+  { "MIXER_UNDERTEMPERATURE_B", 155 },
+  { "NO_AIR_PRESSURE", 282 },
+  { "NO_WASTE_CARTRIDGE_AVAILABLE", 290 },
   { "None", 0 },
   { "POWER_UP_BIT_FAILURE", 15 },
-  { "PULLER_DANCER_MOTOR_OVERCURRENT", 69 },
-  { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", 72 },
-  { "PULLER_DANCER_MOTOR_STALL", 75 },
-  { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", 78 },
-  { "PULLER_MOTOR_OVERCURRENT", 37 },
-  { "PULLER_MOTOR_OVERTEMPERATURE", 44 },
-  { "PULLER_MOTOR_STALL", 51 },
-  { "PULLER_MOTOR_UNDERVOLTAGE", 58 },
+  { "PULLER_DANCER_MOTOR_OVERCURRENT", 73 },
+  { "PULLER_DANCER_MOTOR_OVERTEMPERATURE", 76 },
+  { "PULLER_DANCER_MOTOR_STALL", 79 },
+  { "PULLER_DANCER_MOTOR_UNDERVOLTAGE", 82 },
+  { "PULLER_MOTOR_OVERCURRENT", 41 },
+  { "PULLER_MOTOR_OVERTEMPERATURE", 48 },
+  { "PULLER_MOTOR_STALL", 55 },
+  { "PULLER_MOTOR_UNDERVOLTAGE", 62 },
   { "REAR_COVER_OPEN", 22 },
   { "RECORDING_STARTED", 8 },
   { "RECORDING_STOPPED", 9 },
   { "REQUEST_FAILED", 3 },
   { "REQUEST_SENT", 1 },
   { "RESPONSE_RECEIVED", 2 },
-  { "RIGHT_LOADER_MOTOR_OVERCURRENT", 36 },
-  { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 43 },
-  { "RIGHT_LOADER_MOTOR_STALL", 50 },
-  { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 57 },
-  { "RTFU_DOWN_TIMEOUT", 66 },
-  { "RTFU_UP_TIMEOUT", 65 },
-  { "SCREW_MOTOR_LIMIT_TIMEOUT", 67 },
-  { "SCREW_MOTOR_OVERCURRENT", 40 },
-  { "SCREW_MOTOR_OVERTEMPERATURE", 47 },
-  { "SCREW_MOTOR_STALL", 54 },
-  { "SCREW_MOTOR_UNDERVOLTAGE", 61 },
-  { "THREAD_BREAK", 32 },
-  { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 33 },
-  { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 80 },
-  { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 81 },
+  { "RIGHT_LOADER_MOTOR_OVERCURRENT", 40 },
+  { "RIGHT_LOADER_MOTOR_OVERTEMPERATURE", 47 },
+  { "RIGHT_LOADER_MOTOR_STALL", 54 },
+  { "RIGHT_LOADER_MOTOR_UNDERVOLTAGE", 61 },
+  { "RTFU_DOWN_TIMEOUT", 70 },
+  { "RTFU_UP_TIMEOUT", 69 },
+  { "SCREW_MOTOR_LIMIT_TIMEOUT", 71 },
+  { "SCREW_MOTOR_OVERCURRENT", 44 },
+  { "SCREW_MOTOR_OVERTEMPERATURE", 51 },
+  { "SCREW_MOTOR_STALL", 58 },
+  { "SCREW_MOTOR_UNDERVOLTAGE", 65 },
+  { "THREAD_BREAK", 36 },
+  { "THREAD_LOADING_ERROR", 87 },
+  { "THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER", 37 },
+  { "THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER", 84 },
+  { "THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER", 85 },
+  { "UNINTENDED_RESET", 35 },
   { "UNSPECIFIED", 31 },
-  { "VOC_SENSOR_ALARM_SLOPE", 282 },
-  { "VOC_SENSOR_ALARM_TIME", 279 },
-  { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 287 },
-  { "WASTE_CARTRIDGE_RFID_TIMEOUT", 288 },
-  { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 276 },
-  { "WASTE_CONTAINER_OVERFLOW", 278 },
-  { "WINDER_CONE_DOES_NOT_EXIST", 34 },
-  { "WINDER_DANCER_MOTOR_OVERCURRENT", 68 },
-  { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", 71 },
-  { "WINDER_DANCER_MOTOR_STALL", 74 },
-  { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", 77 },
-  { "WINDER_MOTOR_OVERCURRENT", 39 },
-  { "WINDER_MOTOR_OVERTEMPERATURE", 46 },
-  { "WINDER_MOTOR_STALL", 53 },
-  { "WINDER_MOTOR_UNDERVOLTAGE", 60 },
+  { "VOC_SENSOR_ALARM_SLOPE", 287 },
+  { "VOC_SENSOR_ALARM_TIME", 284 },
+  { "WASTE_CARTRIDGE_PRESENCE_SENSOR_TIMEOUT", 292 },
+  { "WASTE_CARTRIDGE_RFID_TIMEOUT", 293 },
+  { "WASTE_CONTAINER_EMPTYING_TIMEOUT", 281 },
+  { "WASTE_CONTAINER_OVERFLOW", 283 },
+  { "WINDER_CONE_DOES_NOT_EXIST", 38 },
+  { "WINDER_DANCER_MOTOR_OVERCURRENT", 72 },
+  { "WINDER_DANCER_MOTOR_OVERTEMPERATURE", 75 },
+  { "WINDER_DANCER_MOTOR_STALL", 78 },
+  { "WINDER_DANCER_MOTOR_UNDERVOLTAGE", 81 },
+  { "WINDER_MOTOR_OVERCURRENT", 43 },
+  { "WINDER_MOTOR_OVERTEMPERATURE", 50 },
+  { "WINDER_MOTOR_STALL", 57 },
+  { "WINDER_MOTOR_UNDERVOLTAGE", 64 },
 };
 const ProtobufCEnumDescriptor event_type__descriptor =
 {
@@ -601,9 +611,9 @@ const ProtobufCEnumDescriptor event_type__descriptor =
   "EventType",
   "EventType",
   "",
-  289,
+  294,
   event_type__enum_values_by_number,
-  289,
+  294,
   event_type__enum_values_by_name,
   11,
   event_type__value_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h
index 3a2ffd071..8bea8b3e9 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/EventType.pb-c.h
@@ -52,6 +52,10 @@ typedef enum _EventType {
   EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED = 2014,
   EVENT_TYPE__MACHINE_STATE_INITIAL_BLOWER_FAILED = 2015,
   EVENT_TYPE__UNSPECIFIED = 2016,
+  EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2 = 2017,
+  EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE = 2018,
+  EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED = 2019,
+  EVENT_TYPE__UNINTENDED_RESET = 2020,
   EVENT_TYPE__THREAD_BREAK = 3000,
   EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER = 3001,
   EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST = 3002,
@@ -103,6 +107,7 @@ typedef enum _EventType {
   EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER = 3048,
   EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER = 3049,
   EVENT_TYPE__MACHINE_STATE_NO_THREAD_DETECTED = 3050,
+  EVENT_TYPE__THREAD_LOADING_ERROR = 3051,
   EVENT_TYPE__DRYER_MOTOR_OVERCURRENT = 4000,
   EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE = 4001,
   EVENT_TYPE__DRYER_MOTOR_STALL = 4002,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.c
index b4715655e..8e7e8f861 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.c
@@ -7,7 +7,7 @@
 #endif
 
 #include "HeaterType.pb-c.h"
-static const ProtobufCEnumValue heater_type__enum_values_by_number[10] =
+static const ProtobufCEnumValue heater_type__enum_values_by_number[18] =
 {
   { "DryerAirHeater", "HEATER_TYPE__DryerAirHeater", 0 },
   { "DryerMainHeater", "HEATER_TYPE__DryerMainHeater", 1 },
@@ -19,21 +19,37 @@ static const ProtobufCEnumValue heater_type__enum_values_by_number[10] =
   { "HeaterZone5", "HEATER_TYPE__HeaterZone5", 7 },
   { "HeaterZone6", "HEATER_TYPE__HeaterZone6", 8 },
   { "MixerHeater", "HEATER_TYPE__MixerHeater", 9 },
+  { "HeaterZone7", "HEATER_TYPE__HeaterZone7", 10 },
+  { "HeaterZone8", "HEATER_TYPE__HeaterZone8", 11 },
+  { "HeaterZone9", "HEATER_TYPE__HeaterZone9", 12 },
+  { "HeaterZone10", "HEATER_TYPE__HeaterZone10", 13 },
+  { "HeaterZone11", "HEATER_TYPE__HeaterZone11", 14 },
+  { "HeaterZone12", "HEATER_TYPE__HeaterZone12", 15 },
+  { "HeadCoverHeater1", "HEATER_TYPE__HeadCoverHeater1", 16 },
+  { "HeadCoverHeater2", "HEATER_TYPE__HeadCoverHeater2", 17 },
 };
 static const ProtobufCIntRange heater_type__value_ranges[] = {
-{0, 0},{0, 10}
+{0, 0},{0, 18}
 };
-static const ProtobufCEnumValueIndex heater_type__enum_values_by_name[10] =
+static const ProtobufCEnumValueIndex heater_type__enum_values_by_name[18] =
 {
   { "DryerAirHeater", 0 },
   { "DryerMainHeater", 1 },
   { "DryerSecondaryHeater", 2 },
+  { "HeadCoverHeater1", 16 },
+  { "HeadCoverHeater2", 17 },
   { "HeaterZone1", 3 },
+  { "HeaterZone10", 13 },
+  { "HeaterZone11", 14 },
+  { "HeaterZone12", 15 },
   { "HeaterZone2", 4 },
   { "HeaterZone3", 5 },
   { "HeaterZone4", 6 },
   { "HeaterZone5", 7 },
   { "HeaterZone6", 8 },
+  { "HeaterZone7", 10 },
+  { "HeaterZone8", 11 },
+  { "HeaterZone9", 12 },
   { "MixerHeater", 9 },
 };
 const ProtobufCEnumDescriptor heater_type__descriptor =
@@ -43,9 +59,9 @@ const ProtobufCEnumDescriptor heater_type__descriptor =
   "HeaterType",
   "HeaterType",
   "",
-  10,
+  18,
   heater_type__enum_values_by_number,
-  10,
+  18,
   heater_type__enum_values_by_name,
   1,
   heater_type__value_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.h
index 3544e688c..cacd3a6cc 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/HeaterType.pb-c.h
@@ -29,7 +29,15 @@ typedef enum _HeaterType {
   HEATER_TYPE__HeaterZone4 = 6,
   HEATER_TYPE__HeaterZone5 = 7,
   HEATER_TYPE__HeaterZone6 = 8,
-  HEATER_TYPE__MixerHeater = 9
+  HEATER_TYPE__MixerHeater = 9,
+  HEATER_TYPE__HeaterZone7 = 10,
+  HEATER_TYPE__HeaterZone8 = 11,
+  HEATER_TYPE__HeaterZone9 = 12,
+  HEATER_TYPE__HeaterZone10 = 13,
+  HEATER_TYPE__HeaterZone11 = 14,
+  HEATER_TYPE__HeaterZone12 = 15,
+  HEATER_TYPE__HeadCoverHeater1 = 16,
+  HEATER_TYPE__HeadCoverHeater2 = 17
     PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(HEATER_TYPE)
 } HeaterType;
 
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.c
new file mode 100644
index 000000000..2809668e3
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.c
@@ -0,0 +1,72 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartThreadLoadingUpdateRequest.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "StartThreadLoadingUpdateRequest.pb-c.h"
+void   start_thread_loading_update_request__init
+                     (StartThreadLoadingUpdateRequest         *message)
+{
+  static const StartThreadLoadingUpdateRequest init_value = START_THREAD_LOADING_UPDATE_REQUEST__INIT;
+  *message = init_value;
+}
+size_t start_thread_loading_update_request__get_packed_size
+                     (const StartThreadLoadingUpdateRequest *message)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_request__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t start_thread_loading_update_request__pack
+                     (const StartThreadLoadingUpdateRequest *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_request__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t start_thread_loading_update_request__pack_to_buffer
+                     (const StartThreadLoadingUpdateRequest *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_request__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+StartThreadLoadingUpdateRequest *
+       start_thread_loading_update_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (StartThreadLoadingUpdateRequest *)
+     protobuf_c_message_unpack (&start_thread_loading_update_request__descriptor,
+                                allocator, len, data);
+}
+void   start_thread_loading_update_request__free_unpacked
+                     (StartThreadLoadingUpdateRequest *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &start_thread_loading_update_request__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+#define start_thread_loading_update_request__field_descriptors NULL
+#define start_thread_loading_update_request__field_indices_by_name NULL
+#define start_thread_loading_update_request__number_ranges NULL
+const ProtobufCMessageDescriptor start_thread_loading_update_request__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "StartThreadLoadingUpdateRequest",
+  "StartThreadLoadingUpdateRequest",
+  "StartThreadLoadingUpdateRequest",
+  "",
+  sizeof(StartThreadLoadingUpdateRequest),
+  0,
+  start_thread_loading_update_request__field_descriptors,
+  start_thread_loading_update_request__field_indices_by_name,
+  0,  start_thread_loading_update_request__number_ranges,
+  (ProtobufCMessageInit) start_thread_loading_update_request__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.h
new file mode 100644
index 000000000..1ba64b8c1
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateRequest.pb-c.h
@@ -0,0 +1,70 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartThreadLoadingUpdateRequest.proto */
+
+#ifndef PROTOBUF_C_StartThreadLoadingUpdateRequest_2eproto__INCLUDED
+#define PROTOBUF_C_StartThreadLoadingUpdateRequest_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 _StartThreadLoadingUpdateRequest StartThreadLoadingUpdateRequest;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _StartThreadLoadingUpdateRequest
+{
+  ProtobufCMessage base;
+};
+#define START_THREAD_LOADING_UPDATE_REQUEST__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&start_thread_loading_update_request__descriptor) \
+     }
+
+
+/* StartThreadLoadingUpdateRequest methods */
+void   start_thread_loading_update_request__init
+                     (StartThreadLoadingUpdateRequest         *message);
+size_t start_thread_loading_update_request__get_packed_size
+                     (const StartThreadLoadingUpdateRequest   *message);
+size_t start_thread_loading_update_request__pack
+                     (const StartThreadLoadingUpdateRequest   *message,
+                      uint8_t             *out);
+size_t start_thread_loading_update_request__pack_to_buffer
+                     (const StartThreadLoadingUpdateRequest   *message,
+                      ProtobufCBuffer     *buffer);
+StartThreadLoadingUpdateRequest *
+       start_thread_loading_update_request__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   start_thread_loading_update_request__free_unpacked
+                     (StartThreadLoadingUpdateRequest *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*StartThreadLoadingUpdateRequest_Closure)
+                 (const StartThreadLoadingUpdateRequest *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor start_thread_loading_update_request__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_StartThreadLoadingUpdateRequest_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.c
new file mode 100644
index 000000000..b7e1c9346
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.c
@@ -0,0 +1,92 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartThreadLoadingUpdateResponse.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "StartThreadLoadingUpdateResponse.pb-c.h"
+void   start_thread_loading_update_response__init
+                     (StartThreadLoadingUpdateResponse         *message)
+{
+  static const StartThreadLoadingUpdateResponse init_value = START_THREAD_LOADING_UPDATE_RESPONSE__INIT;
+  *message = init_value;
+}
+size_t start_thread_loading_update_response__get_packed_size
+                     (const StartThreadLoadingUpdateResponse *message)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_response__descriptor);
+  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
+}
+size_t start_thread_loading_update_response__pack
+                     (const StartThreadLoadingUpdateResponse *message,
+                      uint8_t       *out)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_response__descriptor);
+  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
+}
+size_t start_thread_loading_update_response__pack_to_buffer
+                     (const StartThreadLoadingUpdateResponse *message,
+                      ProtobufCBuffer *buffer)
+{
+  assert(message->base.descriptor == &start_thread_loading_update_response__descriptor);
+  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
+}
+StartThreadLoadingUpdateResponse *
+       start_thread_loading_update_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data)
+{
+  return (StartThreadLoadingUpdateResponse *)
+     protobuf_c_message_unpack (&start_thread_loading_update_response__descriptor,
+                                allocator, len, data);
+}
+void   start_thread_loading_update_response__free_unpacked
+                     (StartThreadLoadingUpdateResponse *message,
+                      ProtobufCAllocator *allocator)
+{
+  if(!message)
+    return;
+  assert(message->base.descriptor == &start_thread_loading_update_response__descriptor);
+  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
+}
+static const ProtobufCFieldDescriptor start_thread_loading_update_response__field_descriptors[1] =
+{
+  {
+    "ThreadLoadingState",
+    1,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_ENUM,
+    offsetof(StartThreadLoadingUpdateResponse, has_threadloadingstate),
+    offsetof(StartThreadLoadingUpdateResponse, threadloadingstate),
+    &thread_loading_state__descriptor,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+};
+static const unsigned start_thread_loading_update_response__field_indices_by_name[] = {
+  0,   /* field[0] = ThreadLoadingState */
+};
+static const ProtobufCIntRange start_thread_loading_update_response__number_ranges[1 + 1] =
+{
+  { 1, 0 },
+  { 0, 1 }
+};
+const ProtobufCMessageDescriptor start_thread_loading_update_response__descriptor =
+{
+  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
+  "StartThreadLoadingUpdateResponse",
+  "StartThreadLoadingUpdateResponse",
+  "StartThreadLoadingUpdateResponse",
+  "",
+  sizeof(StartThreadLoadingUpdateResponse),
+  1,
+  start_thread_loading_update_response__field_descriptors,
+  start_thread_loading_update_response__field_indices_by_name,
+  1,  start_thread_loading_update_response__number_ranges,
+  (ProtobufCMessageInit) start_thread_loading_update_response__init,
+  NULL,NULL,NULL    /* reserved[123] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.h
new file mode 100644
index 000000000..894969b80
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/StartThreadLoadingUpdateResponse.pb-c.h
@@ -0,0 +1,73 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: StartThreadLoadingUpdateResponse.proto */
+
+#ifndef PROTOBUF_C_StartThreadLoadingUpdateResponse_2eproto__INCLUDED
+#define PROTOBUF_C_StartThreadLoadingUpdateResponse_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
+
+#include "ThreadLoadingState.pb-c.h"
+
+typedef struct _StartThreadLoadingUpdateResponse StartThreadLoadingUpdateResponse;
+
+
+/* --- enums --- */
+
+
+/* --- messages --- */
+
+struct  _StartThreadLoadingUpdateResponse
+{
+  ProtobufCMessage base;
+  protobuf_c_boolean has_threadloadingstate;
+  ThreadLoadingState threadloadingstate;
+};
+#define START_THREAD_LOADING_UPDATE_RESPONSE__INIT \
+ { PROTOBUF_C_MESSAGE_INIT (&start_thread_loading_update_response__descriptor) \
+    , 0, THREAD_LOADING_STATE__ThreadLoadInit }
+
+
+/* StartThreadLoadingUpdateResponse methods */
+void   start_thread_loading_update_response__init
+                     (StartThreadLoadingUpdateResponse         *message);
+size_t start_thread_loading_update_response__get_packed_size
+                     (const StartThreadLoadingUpdateResponse   *message);
+size_t start_thread_loading_update_response__pack
+                     (const StartThreadLoadingUpdateResponse   *message,
+                      uint8_t             *out);
+size_t start_thread_loading_update_response__pack_to_buffer
+                     (const StartThreadLoadingUpdateResponse   *message,
+                      ProtobufCBuffer     *buffer);
+StartThreadLoadingUpdateResponse *
+       start_thread_loading_update_response__unpack
+                     (ProtobufCAllocator  *allocator,
+                      size_t               len,
+                      const uint8_t       *data);
+void   start_thread_loading_update_response__free_unpacked
+                     (StartThreadLoadingUpdateResponse *message,
+                      ProtobufCAllocator *allocator);
+/* --- per-message closures --- */
+
+typedef void (*StartThreadLoadingUpdateResponse_Closure)
+                 (const StartThreadLoadingUpdateResponse *message,
+                  void *closure_data);
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCMessageDescriptor start_thread_loading_update_response__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_StartThreadLoadingUpdateResponse_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.c
new file mode 100644
index 000000000..c193bd981
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.c
@@ -0,0 +1,63 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: ThreadLoadingState.proto */
+
+/* Do not generate deprecated warnings for self */
+#ifndef PROTOBUF_C__NO_DEPRECATED
+#define PROTOBUF_C__NO_DEPRECATED
+#endif
+
+#include "ThreadLoadingState.pb-c.h"
+static const ProtobufCEnumValue thread_loading_state__enum_values_by_number[15] =
+{
+  { "ThreadLoadInit", "THREAD_LOADING_STATE__ThreadLoadInit", 0 },
+  { "ThreadLoadReduceHeat", "THREAD_LOADING_STATE__ThreadLoadReduceHeat", 1 },
+  { "ThreadLoadSetLoadArmToStartPosition", "THREAD_LOADING_STATE__ThreadLoadSetLoadArmToStartPosition", 2 },
+  { "ThreadLoadOpenCovers", "THREAD_LOADING_STATE__ThreadLoadOpenCovers", 3 },
+  { "ThreadLoadLiftDancers", "THREAD_LOADING_STATE__ThreadLoadLiftDancers", 4 },
+  { "ThreadLoadLiftRockers", "THREAD_LOADING_STATE__ThreadLoadLiftRockers", 5 },
+  { "ThreadLoadInitialTension", "THREAD_LOADING_STATE__ThreadLoadInitialTension", 6 },
+  { "ThreadLoadCloseRockers", "THREAD_LOADING_STATE__ThreadLoadCloseRockers", 7 },
+  { "ThreadLoadCloseDancers", "THREAD_LOADING_STATE__ThreadLoadCloseDancers", 8 },
+  { "ThreadLoadCloseLids", "THREAD_LOADING_STATE__ThreadLoadCloseLids", 9 },
+  { "ThreadLoadJogFeederToMiddlePoint", "THREAD_LOADING_STATE__ThreadLoadJogFeederToMiddlePoint", 10 },
+  { "ThreadLoadDryerLoading", "THREAD_LOADING_STATE__ThreadLoadDryerLoading", 11 },
+  { "ThreadLoadResumeHeating", "THREAD_LOADING_STATE__ThreadLoadResumeHeating", 12 },
+  { "ThreadLoadJogThread", "THREAD_LOADING_STATE__ThreadLoadJogThread", 13 },
+  { "ThreadLoadEnd", "THREAD_LOADING_STATE__ThreadLoadEnd", 14 },
+};
+static const ProtobufCIntRange thread_loading_state__value_ranges[] = {
+{0, 0},{0, 15}
+};
+static const ProtobufCEnumValueIndex thread_loading_state__enum_values_by_name[15] =
+{
+  { "ThreadLoadCloseDancers", 8 },
+  { "ThreadLoadCloseLids", 9 },
+  { "ThreadLoadCloseRockers", 7 },
+  { "ThreadLoadDryerLoading", 11 },
+  { "ThreadLoadEnd", 14 },
+  { "ThreadLoadInit", 0 },
+  { "ThreadLoadInitialTension", 6 },
+  { "ThreadLoadJogFeederToMiddlePoint", 10 },
+  { "ThreadLoadJogThread", 13 },
+  { "ThreadLoadLiftDancers", 4 },
+  { "ThreadLoadLiftRockers", 5 },
+  { "ThreadLoadOpenCovers", 3 },
+  { "ThreadLoadReduceHeat", 1 },
+  { "ThreadLoadResumeHeating", 12 },
+  { "ThreadLoadSetLoadArmToStartPosition", 2 },
+};
+const ProtobufCEnumDescriptor thread_loading_state__descriptor =
+{
+  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
+  "ThreadLoadingState",
+  "ThreadLoadingState",
+  "ThreadLoadingState",
+  "",
+  15,
+  thread_loading_state__enum_values_by_number,
+  15,
+  thread_loading_state__enum_values_by_name,
+  1,
+  thread_loading_state__value_ranges,
+  NULL,NULL,NULL,NULL   /* reserved[1234] */
+};
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.h
new file mode 100644
index 000000000..d9ae6b614
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Diagnostics/ThreadLoadingState.pb-c.h
@@ -0,0 +1,56 @@
+/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
+/* Generated from: ThreadLoadingState.proto */
+
+#ifndef PROTOBUF_C_ThreadLoadingState_2eproto__INCLUDED
+#define PROTOBUF_C_ThreadLoadingState_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
+
+
+
+
+/* --- enums --- */
+
+typedef enum _ThreadLoadingState {
+  THREAD_LOADING_STATE__ThreadLoadInit = 0,
+  THREAD_LOADING_STATE__ThreadLoadReduceHeat = 1,
+  THREAD_LOADING_STATE__ThreadLoadSetLoadArmToStartPosition = 2,
+  THREAD_LOADING_STATE__ThreadLoadOpenCovers = 3,
+  THREAD_LOADING_STATE__ThreadLoadLiftDancers = 4,
+  THREAD_LOADING_STATE__ThreadLoadLiftRockers = 5,
+  THREAD_LOADING_STATE__ThreadLoadInitialTension = 6,
+  THREAD_LOADING_STATE__ThreadLoadCloseRockers = 7,
+  THREAD_LOADING_STATE__ThreadLoadCloseDancers = 8,
+  THREAD_LOADING_STATE__ThreadLoadCloseLids = 9,
+  THREAD_LOADING_STATE__ThreadLoadJogFeederToMiddlePoint = 10,
+  THREAD_LOADING_STATE__ThreadLoadDryerLoading = 11,
+  THREAD_LOADING_STATE__ThreadLoadResumeHeating = 12,
+  THREAD_LOADING_STATE__ThreadLoadJogThread = 13,
+  THREAD_LOADING_STATE__ThreadLoadEnd = 14
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(THREAD_LOADING_STATE)
+} ThreadLoadingState;
+
+/* --- messages --- */
+
+/* --- per-message closures --- */
+
+
+/* --- services --- */
+
+
+/* --- descriptors --- */
+
+extern const ProtobufCEnumDescriptor    thread_loading_state__descriptor;
+
+PROTOBUF_C__END_DECLS
+
+
+#endif  /* PROTOBUF_C_ThreadLoadingState_2eproto__INCLUDED */
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.c
index 785821681..5c50b430e 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.c
@@ -7,16 +7,22 @@
 #endif
 
 #include "HardwareBlowerType.pb-c.h"
-static const ProtobufCEnumValue hardware_blower_type__enum_values_by_number[1] =
+static const ProtobufCEnumValue hardware_blower_type__enum_values_by_number[4] =
 {
   { "DefaultBlower", "HARDWARE_BLOWER_TYPE__DefaultBlower", 0 },
+  { "HeadBlower1", "HARDWARE_BLOWER_TYPE__HeadBlower1", 1 },
+  { "HeadBlower2", "HARDWARE_BLOWER_TYPE__HeadBlower2", 2 },
+  { "WHSBlower2", "HARDWARE_BLOWER_TYPE__WHSBlower2", 3 },
 };
 static const ProtobufCIntRange hardware_blower_type__value_ranges[] = {
-{0, 0},{0, 1}
+{0, 0},{0, 4}
 };
-static const ProtobufCEnumValueIndex hardware_blower_type__enum_values_by_name[1] =
+static const ProtobufCEnumValueIndex hardware_blower_type__enum_values_by_name[4] =
 {
   { "DefaultBlower", 0 },
+  { "HeadBlower1", 1 },
+  { "HeadBlower2", 2 },
+  { "WHSBlower2", 3 },
 };
 const ProtobufCEnumDescriptor hardware_blower_type__descriptor =
 {
@@ -25,9 +31,9 @@ const ProtobufCEnumDescriptor hardware_blower_type__descriptor =
   "HardwareBlowerType",
   "HardwareBlowerType",
   "",
-  1,
+  4,
   hardware_blower_type__enum_values_by_number,
-  1,
+  4,
   hardware_blower_type__enum_values_by_name,
   1,
   hardware_blower_type__value_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.h
index 5be545162..b530430ff 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwareBlowerType.pb-c.h
@@ -20,7 +20,10 @@ PROTOBUF_C__BEGIN_DECLS
 /* --- enums --- */
 
 typedef enum _HardwareBlowerType {
-  HARDWARE_BLOWER_TYPE__DefaultBlower = 0
+  HARDWARE_BLOWER_TYPE__DefaultBlower = 0,
+  HARDWARE_BLOWER_TYPE__HeadBlower1 = 1,
+  HARDWARE_BLOWER_TYPE__HeadBlower2 = 2,
+  HARDWARE_BLOWER_TYPE__WHSBlower2 = 3
     PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(HARDWARE_BLOWER_TYPE)
 } HardwareBlowerType;
 
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.c
index 3d172a588..e23a43487 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.c
@@ -7,7 +7,7 @@
 #endif
 
 #include "HardwarePidControlType.pb-c.h"
-static const ProtobufCEnumValue hardware_pid_control_type__enum_values_by_number[23] =
+static const ProtobufCEnumValue hardware_pid_control_type__enum_values_by_number[33] =
 {
   { "DryerAirTemperature", "HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature", 0 },
   { "DryerHeaterMain", "HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain", 1 },
@@ -32,11 +32,21 @@ static const ProtobufCEnumValue hardware_pid_control_type__enum_values_by_number
   { "Dispenser6", "HARDWARE_PID_CONTROL_TYPE__Dispenser6", 20 },
   { "Dispenser7", "HARDWARE_PID_CONTROL_TYPE__Dispenser7", 21 },
   { "Dispenser8", "HARDWARE_PID_CONTROL_TYPE__Dispenser8", 22 },
+  { "HeadHeaterZ7", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7", 23 },
+  { "HeadHeaterZ8", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8", 24 },
+  { "HeadHeaterZ9", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9", 25 },
+  { "HeadHeaterZ10", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10", 26 },
+  { "HeadHeaterZ11", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11", 27 },
+  { "HeadHeaterZ12", "HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12", 28 },
+  { "HeadCoverHeater1", "HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1", 29 },
+  { "HeadCoverHeater2", "HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2", 30 },
+  { "HeadBlower_1", "HARDWARE_PID_CONTROL_TYPE__HeadBlower_1", 31 },
+  { "HeadBlower_2", "HARDWARE_PID_CONTROL_TYPE__HeadBlower_2", 32 },
 };
 static const ProtobufCIntRange hardware_pid_control_type__value_ranges[] = {
-{0, 0},{0, 23}
+{0, 0},{0, 33}
 };
-static const ProtobufCEnumValueIndex hardware_pid_control_type__enum_values_by_name[23] =
+static const ProtobufCEnumValueIndex hardware_pid_control_type__enum_values_by_name[33] =
 {
   { "Dispenser1", 15 },
   { "Dispenser2", 16 },
@@ -49,12 +59,22 @@ static const ProtobufCEnumValueIndex hardware_pid_control_type__enum_values_by_n
   { "DryerAirTemperature", 0 },
   { "DryerHeaterMain", 1 },
   { "DryerHeaterSecondary", 2 },
+  { "HeadBlower_1", 31 },
+  { "HeadBlower_2", 32 },
+  { "HeadCoverHeater1", 29 },
+  { "HeadCoverHeater2", 30 },
   { "HeadHeaterZ1", 3 },
+  { "HeadHeaterZ10", 26 },
+  { "HeadHeaterZ11", 27 },
+  { "HeadHeaterZ12", 28 },
   { "HeadHeaterZ2", 4 },
   { "HeadHeaterZ3", 5 },
   { "HeadHeaterZ4", 6 },
   { "HeadHeaterZ5", 7 },
   { "HeadHeaterZ6", 8 },
+  { "HeadHeaterZ7", 23 },
+  { "HeadHeaterZ8", 24 },
+  { "HeadHeaterZ9", 25 },
   { "MixerHeater", 9 },
   { "MotorDryer", 11 },
   { "MotorFeeder", 12 },
@@ -69,9 +89,9 @@ const ProtobufCEnumDescriptor hardware_pid_control_type__descriptor =
   "HardwarePidControlType",
   "HardwarePidControlType",
   "",
-  23,
+  33,
   hardware_pid_control_type__enum_values_by_number,
-  23,
+  33,
   hardware_pid_control_type__enum_values_by_name,
   1,
   hardware_pid_control_type__value_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.h
index 83d8fe072..dd0fd770b 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Hardware/HardwarePidControlType.pb-c.h
@@ -42,7 +42,17 @@ typedef enum _HardwarePidControlType {
   HARDWARE_PID_CONTROL_TYPE__Dispenser5 = 19,
   HARDWARE_PID_CONTROL_TYPE__Dispenser6 = 20,
   HARDWARE_PID_CONTROL_TYPE__Dispenser7 = 21,
-  HARDWARE_PID_CONTROL_TYPE__Dispenser8 = 22
+  HARDWARE_PID_CONTROL_TYPE__Dispenser8 = 22,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7 = 23,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8 = 24,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9 = 25,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10 = 26,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11 = 27,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12 = 28,
+  HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1 = 29,
+  HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2 = 30,
+  HARDWARE_PID_CONTROL_TYPE__HeadBlower_1 = 31,
+  HARDWARE_PID_CONTROL_TYPE__HeadBlower_2 = 32
     PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(HARDWARE_PID_CONTROL_TYPE)
 } HardwarePidControlType;
 
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index ef72e4114..0fd48c037 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -9,13 +9,11 @@
 
 //#define EVALUATION_BOARD // to use the LCD only when using the evaluation board
 //#define USE_USB
-//#define DEMO_TEMPERATURE 1
 #define Stub_Mode 1
 #define USE_HIGH_SPEED_GPIO // to use AHB GPIO (A..J) ports A-J APB or AHB, ports K-Q on AHB only
 //#define WithTempSensorFiltrer (to use the function Filter_Temparature_Measurement)
 //#define DEBUG_TEST_FUNCTIONS
 #define  HIZ_TIMEOUT 1000
-//#define DEMO_TEMPERATURE
 //#define TEST_LONGER_PID_THREAD
 //#define HUNDRED_MICROSECONDS_DANCER_READ
 #define NO_INITIAL_HEATING
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
index 38330e8d9..2e7281fad 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
@@ -508,29 +508,63 @@ uint32_t DeActivateCoolerPump() //WHS  - Pump the waste accumulated in cooler to
         F1_Moto_Driver_SW1 = F1_Mot_Dr_SW1.ushort;
         return OK;
 }
+uint32_t MagnetControlId = 0xFF;
+uint32_t MagnetCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+{
+#ifdef Use_Head_Card
+    HeadCard_HeadMagnet_Disable();
+    if (SafeRemoveControlCallback(MagnetControlId, MagnetCallBackFunction )==OK)
+        MagnetControlId = 0xFF;
+    else
+        Report("Remove control callback failed",__FILE__,__LINE__,(int)MagnetControlId,RpWarning,(int)MagnetCallBackFunction,0);
+    Report("MagnetCallBackFunction",__FILE__,__LINE__,(int)MagnetControlId,RpWarning,(int)MagnetCallBackFunction,0);
+#else
+    MotorStop(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,Hard_Hiz );
+#endif
+    return OK;
+}
 
 uint32_t ActivateHeadMagnet()
 {
     Report("ActivateHeadMagnet - Close the lid magnet",__FILE__,__LINE__,(int)HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,RpWarning,(int)DH_LID_OPEN,0);
     //Task_sleep(500);
+#ifdef Use_Head_Card
+    HeadCard_ActivateHeadMagnet();
+
+#else
     F2_CTRL_Reg.ushort &= ~SPARE_SSR13_CTRL;
     F2_CTRL = F2_CTRL_Reg.ushort;
     if (isMotorConfigured(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM))
     {
-        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM, DH_LID_CLOSE, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM], NULL,1000);
+        MotorGoTo(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,DH_LID_CLOSE );
+
+        //MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM, DH_LID_CLOSE, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM], NULL,1000);
     }
+#endif
+    MagnetControlId = AddControlCallback(NULL, MagnetCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
     return OK;
 }
-
+/*
+uint32_t HeadCard_ActivateHeadMagnet();
+uint32_t HeadCard_DeActivateHeadMagnet();
+uint32_t HeadCard_HeadMagnet_Disable();
+*/
 uint32_t DeActivateHeadMagnet()
 {
+
+#ifdef Use_Head_Card
+    HeadCard_DeActivateHeadMagnet();
+    MagnetControlId = AddControlCallback(NULL, MagnetCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
+#else
     Report("DeActivateHeadMagnet - open the lid magnet",__FILE__,__LINE__,(int)HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,RpWarning,(int)DH_LID_CLOSE,0);
     if (isMotorConfigured(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM))
     {
-        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM, DH_LID_OPEN, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM], NULL,1000);
+        MotorGoTo(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,DH_LID_OPEN );
+        //MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RLOADARM, DH_LID_OPEN, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RLOADARM], NULL,1000);
     }
     F2_CTRL_Reg.ushort |= SPARE_SSR13_CTRL;
     F2_CTRL = F2_CTRL_Reg.ushort;
+#endif
     Task_sleep(500);
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c
index 259fc65f0..03ee0a3ce 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_SPI_Comm.c
@@ -438,6 +438,7 @@ void FPGA_SetMotorsInit()
         MotorDriverRequest[i].Stop = Hard_Hiz;
         FPGA_SetMotStop((HardwareMotorType)i);
     }
+    FPGA_WD_Occurred = false;
 
     //LOW logic level resets the logic and puts the device into Standby mode.
     F1_Moto_Driver_NSTBYRST1 = 0;
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
index 89b9be968..3479aff9b 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
@@ -19,15 +19,14 @@
 #include "driverlib/sysctl.h"
 
 #include <drivers/FPGA/FPGA_Comm.h>
+#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
 #include <DataDef.h>
 
 #include <Modules/Stubs_Handler/User_Leds.h>
 #include "PMR/Hardware/HardwarePIDControl.pb-c.h"
+#include "PMR/Diagnostics/HeaterType.pb-c.h"
 
 #define MAX_HEATERS_NUM  HARDWARE_PID_CONTROL_TYPE__MixerHeater+1
-#ifdef DEMO_TEMPERATURE
-bool HeaterTestActive[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0};
-#endif
 
 typedef struct
 {
@@ -56,13 +55,63 @@ static GPIOIntPortMap portMap[MAX_HEATERS_NUM] =
     {MIXCHIP_SSR4_CTRL,  false},  // HARDWARE_PID_CONTROL_TYPE__MixerHeater
 
 };
+HeaterType HeaterPidtoHeaterId[HARDWARE_PID_CONTROL_TYPE__HeadBlower_2+1]=
+{ HEATER_TYPE__DryerAirHeater,HEATER_TYPE__DryerMainHeater,HEATER_TYPE__DryerSecondaryHeater,
+  HEATER_TYPE__HeaterZone1,HEATER_TYPE__HeaterZone2,  HEATER_TYPE__HeaterZone3,HEATER_TYPE__HeaterZone4,HEATER_TYPE__HeaterZone5,HEATER_TYPE__HeaterZone6,HEATER_TYPE__MixerHeater,
+  0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,/*motors and dispensers*/
+  HEATER_TYPE__HeaterZone7, HEATER_TYPE__HeaterZone8, HEATER_TYPE__HeaterZone9, HEATER_TYPE__HeaterZone10, HEATER_TYPE__HeaterZone11, HEATER_TYPE__HeaterZone12,
+  HEATER_TYPE__HeadCoverHeater1,HEATER_TYPE__HeadCoverHeater2,0xFF,0xFF};
+HardwarePidControlType HeaterIdtoHeaterpid[HEATER_TYPE_MAX_HEATERS ]=
+{ HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6,HARDWARE_PID_CONTROL_TYPE__MixerHeater,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9,
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12};
+HeaterType HeaterTypetoHeadHeater[HEATER_TYPE_MAX_HEATERS] = {HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,HEADCARD_HIT_ZN1,HEADCARD_HIT_ZN2,HEADCARD_HIT_ZN3,HEADCARD_HIT_ZN4,HEADCARD_HIT_ZN5,HEADCARD_HIT_ZN6,
+    HEADCARD_HIT_MIXER,HEADCARD_HIT_ZN8,HEADCARD_HIT_ZN9,HEADCARD_HIT_ZN10,HEADCARD_HIT_ZN11,HEADCARD_HIT_ZN12,HEADCARD_UPPER_HIT_IN1,HEADCARD_UPPER_HIT_OUT1};
+HEADCARD_HEATERS_ENUM HeadHeatertoHeaterType[HEADCARD_HIT_MIXER+1] = {HEATER_TYPE__HeaterZone1,HEATER_TYPE__HeaterZone2,HEATER_TYPE__HeaterZone3,HEATER_TYPE__HeaterZone4,HEATER_TYPE__HeaterZone5,HEATER_TYPE__HeaterZone6,
+    HEATER_TYPE__HeaterZone7,HEATER_TYPE__HeaterZone8,HEATER_TYPE__HeaterZone9,HEATER_TYPE__HeaterZone10,HEATER_TYPE__HeaterZone11,HEATER_TYPE__HeaterZone12,
+    HEATER_TYPE__HeadCoverHeater1,HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,
+    HEATER_TYPE__HeadCoverHeater2,HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,
+    HEATER_TYPE__MixerHeater};
+
+bool isHeater(HardwarePidControlType HeaterId)
+{
+    switch (HeaterId)
+    {
+      case HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature:
+      case HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain:
+      case HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6:
+      case HARDWARE_PID_CONTROL_TYPE__MixerHeater:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11:
+      case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12:
+        return true;
+    default:
+        return false;
+    }
+}
 
 uint32_t ActivateHeater (int HeaterId)
 {
-    assert(HeaterId < MAX_HEATERS_NUM);
-#ifdef DEMO_TEMPERATURE
-    if (HeaterTestActive[HeaterId])
-        return OK;
+    assert(isHeater(HeaterIdtoHeaterpid[HeaterId]));
+#ifdef Use_Head_Card
+    if (HeaterId>HEATER_TYPE__DryerSecondaryHeater)
+    {
+        HeadCard_Control_Heaters(HeaterIdtoHeaterpid[HeaterId],ON);
+    }
+    else
+    {
+#else
+        if (HeaterId >= HEATER_TYPE__HeaterZone7) return OK;
 #endif
     if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature)
     {
@@ -90,7 +139,7 @@ uint32_t ActivateHeater (int HeaterId)
         F2_CTRL = F2_CTRL_Reg.ushort;
     }
 #endif
-   //---------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------
 //    if(HeaterId < HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1) // Turn On FPGA LED
 //        F3_GPO_01_bus |= (0x01 << HeaterId);
 //    else
@@ -110,7 +159,9 @@ uint32_t ActivateHeater (int HeaterId)
     //---------------------------------------------------------------------------------------
 
     HeaterActive |= 1 << HeaterId;
-
+#ifdef Use_Head_Card
+    }
+#endif
     //---------------------------------------------------------------------------------------
 
     return OK;
@@ -118,10 +169,16 @@ uint32_t ActivateHeater (int HeaterId)
 
 uint32_t DeActivateHeater (int HeaterId)
 {
-    assert(HeaterId < MAX_HEATERS_NUM);
-#ifdef DEMO_TEMPERATURE
-    if (HeaterTestActive[HeaterId])
-        return OK;
+    assert(isHeater(HeaterIdtoHeaterpid[HeaterId]));
+#ifdef Use_Head_Card
+    if (HeaterId>HEATER_TYPE__DryerSecondaryHeater)
+    {
+        HeadCard_Control_Heaters(HeaterIdtoHeaterpid[HeaterId],ON);
+    }
+    else
+    {
+#else
+    if (HeaterId >= HEATER_TYPE__HeaterZone7) return OK;
 #endif
 #ifndef EVALUATION_BOARD
     if(HeaterId == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5)
@@ -160,13 +217,28 @@ uint32_t DeActivateHeater (int HeaterId)
     portMap[HeaterId].Active = false;
 
     HeaterActive &= ~(1 << HeaterId);
+#ifdef Use_Head_Card
+    }
+#endif
 
     return OK;
 }
 bool GetHeaterState (int HeaterId)
 {
-    assert(HeaterId < MAX_HEATERS_NUM);
+    assert(isHeater(HeaterIdtoHeaterpid[HeaterId]));
+#ifdef Use_Head_Card
+    if (HeaterId<=HEATER_TYPE__DryerSecondaryHeater)
+    {
+        return portMap[HeaterId].Active;
+    }
+    else
+    {
+        return(Get_HeadCard_Heater_State(HeaterIdtoHeaterpid[HeaterId]));
+    }
+
+#else
     return portMap[HeaterId].Active;
+#endif
 }
 
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.h b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.h
index 835571200..cf6a2d235 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.h
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.h
@@ -1,18 +1,28 @@
+#ifndef DRIVERS_HEATER_HEATER_H_
+#define DRIVERS_HEATER_HEATER_H_
+
 #define HEATER_ON true
 #define HEATER_OFF false
 
 #include "include.h"
+#include "PMR/Hardware/HardwarePidControlType.pb-c.h"
+#include "PMR/Diagnostics/HeaterType.pb-c.h"
+#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
+
+#define HEATER_TYPE_MAX_HEATERS HEATER_TYPE__HeadCoverHeater2+1
 
+extern HeaterType HeaterPidtoHeaterId[ HARDWARE_PID_CONTROL_TYPE__HeadBlower_2+1];
+extern HardwarePidControlType HeaterIdtoHeaterpid[HEATER_TYPE_MAX_HEATERS];
+extern HeaterType HeaterTypetoHeadHeater[HEATER_TYPE_MAX_HEATERS];
+extern HEADCARD_HEATERS_ENUM HeadHeatertoHeaterType[HEADCARD_HIT_MIXER+1];
 
 uint32_t  ActivateHeater (int HeaterId);
 uint32_t  DeActivateHeater (int HeaterId);
 bool    GetHeaterState (int HeaterId);
 uint32_t HeaterSetTemperatureWithCallback (int HeaterId, uint32_t RequestedTemperature, callback_fptr callback);
 //uint32_t HeaterBalanceLoadControlCBFunction(uint32_t IfIndex, uint32_t readValue);
-
-#ifdef DEMO_TEMPERATURE
-extern bool HeaterTestActive[];
-#endif
+bool isHeater(HardwarePidControlType HeaterId);
+inline HeaterType getHeaterId(HardwarePidControlType HeaterId){ return HeaterPidtoHeaterId[HeaterId];};
 
 extern uint32_t HeaterActive;
-
+#endif
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
index f9f46d8a0..b8d0ab4e3 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
@@ -23,8 +23,6 @@
 uint32_t TemperatureSensorReadFromFPGA_Res(TEMPERATURE_SENSOR_ID_ENUM SensorId);
 //uint32_t TemperatureSendSensorDummyClk(TEMP_SENSE_ANALOG_DYEINGH_TEMP1);
 
-
-
 SENSOR_CONFIG_STAGES_ENUM SensConfigStages[MAX_MAIN_CARD_TEMP_SENS_ID] = {SENSOR_CONFIG_REG0}; // TODO remove buffer if it is the same for all the sensors
 
 uint8_t FPGA_SensorInitConfigReg()
@@ -179,18 +177,20 @@ int TemperatureSensorRead(TEMPERATURE_SENSOR_ID_ENUM SensorId)
     return TempSensorResponse[SensorId].Temperature_C_mult_by_100;
 }
 
+#ifndef Use_Head_Card
 int TemperatureListString(char* str)
 {
     int len;
     len = usnprintf(str, 150, "Prepare H1: %d H2: %d H3: %d H4: %d H5: %d H6: %d D1: %d D2: %d D3: %d M: %d",TempSensorResponse[TEMP_SENSE_ANALOG_DYEINGH_TEMP1].Temperature_C_mult_by_100/100,
                     TempSensorResponse[TEMP_SENSE_ANALOG_DYEINGH_TEMP2].Temperature_C_mult_by_100/100,TempSensorResponse[TEMP_SENSE_ANALOG_DYEINGH_TEMP3].Temperature_C_mult_by_100/100,
                     TempSensorResponse[TEMP_SENSE_ANALOG_DYEINGH_TEMP4].Temperature_C_mult_by_100/100,TempSensorResponse[TEMP_SENSE_ANALOG_DYEINGH_TEMP5].Temperature_C_mult_by_100/100,
-                    TempSensorResponse[TEMP_SENSE_ANALOG_MIXCHIP_TEMP].Temperature_C_mult_by_100/100,TempSensorResponse[TEMP_SENSE_ANALOG_DRYER_TEMP1].Temperature_C_mult_by_100/100,
+                    TempSensorResponse[HEAD6_PT100].Temperature_C_mult_by_100/100,TempSensorResponse[TEMP_SENSE_ANALOG_DRYER_TEMP1].Temperature_C_mult_by_100/100,
                     TempSensorResponse[TEMP_SENSE_ANALOG_DRYER_TEMP2].Temperature_C_mult_by_100/100,TempSensorResponse[TEMP_SENSE_ANALOG_DRYER_TEMP3].Temperature_C_mult_by_100/100
-                    ,TempSensorResponse[TEMP_SENSE_AN_ENCLOSURETEMP3].Temperature_C_mult_by_100/100);
+                    ,TempSensorResponse[MIXER_PT100].Temperature_C_mult_by_100/100);
+    //Prepare H1: 78 H2: 111 H3: 137 H4: 135 H5: 144 H6: 75 D1: 120 D2: 167 D3: 158 M: 129
     return len;
 }
-
+#endif
 
 
 uint32_t Filter_Temparature_Measurement(TEMPERATURE_SENSOR_ID_ENUM SensorId, int32_t Current_Measurement_C, uint32_t NoOfAvrSamples)
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.h b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.h
index d44fa9461..a8ef720ad 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.h
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.h
@@ -166,8 +166,9 @@ uint32_t CalculateTemperatures(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint32_t Dat
 
 int TemperatureSensorRead(TEMPERATURE_SENSOR_ID_ENUM SensorId); // read from buffer
 
+#ifndef Use_Head_Card
 int TemperatureListString(char* str);
-
+#endif
 //The temparature will be at:
 //TempSensorResponse[TEMP_SENSE_ANALOG_DYEINGH_TEMP1].Temperature_C_mult_by_100
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.c
index f290a8ef3..4d7259bd3 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.c
@@ -12,24 +12,18 @@
 
 #include "Drivers/I2C_Communication/WHS_Card/I2C_WHS_Mux.h"
 
-uint8_t Main_Mux_Flag = UNKNOWN;
-
 uint32_t Select_Main_Head_Mux_Channel()
 {
     uint32_t status= OK;
 
     uint8_t Write_Buf[1];
 
-    if(Main_Mux_Flag != HEAD)
-    {
-        Block_Main_WHS_Mux_Channel();
+    //Block_Main_WHS_Mux_Channel();
 
-        Write_Buf[0] = 0x01 << 4;//Channel 4
+    Write_Buf[0] = 0x01 << 4;//Channel 4
 
-        status = I2C_Write(I2C_ID_HEAD_CARD, I2C3_MAIN_MUX_TCA9548A_0xE2, Write_Buf, 1);
+    status = I2C_Write(I2C_ID_HEAD_CARD, I2C3_MAIN_MUX_TCA9548A_0xE2, Write_Buf, 1);
 
-        Main_Mux_Flag = HEAD;
-    }
     return status;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
index 418acc406..c8bfd6f8b 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
@@ -303,15 +303,15 @@ uint32_t HeadCard_Valve_Control(bool Direction)
 {
     uint32_t status = OK;
 
-    Head_I2C_EXP2_0x42.bits.OUTPUT_VALVE_EN  = ENABLE;
-    Head_I2C_EXP2_0x42.bits.OUTPUT_VALVE_DIR = Direction;
+    Head_I2C_EXP2_0x42.bits.OUTPUT_VALVE_EN  = Direction;
+//    Head_I2C_EXP2_0x42.bits.OUTPUT_VALVE_DIR = Direction;
 
     status |= Head_Write_IO_Reg(0x42,LOW);
 
     return status;
 }
 
-uint32_t HeadCard_Valve_Disable()
+/*uint32_t HeadCard_Valve_Disable()
 {
     uint32_t status = OK;
 
@@ -321,7 +321,7 @@ uint32_t HeadCard_Valve_Disable()
 
     return status;
 }
-
+*/
 uint32_t HeadCard_Enable_8_Upper_Heaters(bool Pwr_Cmd)//ON/OFF
 {
     uint32_t status = OK;
@@ -332,11 +332,18 @@ uint32_t HeadCard_Enable_8_Upper_Heaters(bool Pwr_Cmd)//ON/OFF
 
     return status;
 }
-
+bool HeaterMap[HEADCARD_HIT_MIXER+1] = {0};
+bool Get_HeadCard_Heater_State(uint8_t Heater_ID)
+{
+    assert(Heater_ID<=HEADCARD_HIT_MIXER);
+    return HeaterMap[Heater_ID];
+}
 uint32_t HeadCard_Control_Heaters(uint8_t Heater_ID, bool Pwr_Cmd)//ON/OFF
 {
     uint32_t status = OK;
 
+    assert(Heater_ID<=HEADCARD_HIT_MIXER);
+    HeaterMap[Heater_ID] = Pwr_Cmd;
     switch(Heater_ID)
     {
         case HEADCARD_HIT_ZN1:
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h
index 40fc5a6bd..6131dfb79 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h
@@ -162,7 +162,7 @@ extern HEAD_I2C_EXP3_0x44  Head_I2C_EXP3_0x44;
 extern HEAD_I2C_EXP4_0x46  Head_I2C_EXP4_0x46;
 
 #warning move to heaters enum
-enum
+typedef enum
 {
     HEADCARD_HIT_ZN1,
     HEADCARD_HIT_ZN2,
@@ -213,6 +213,17 @@ uint8_t Connect_Mixer_and_12_Heaters_Latch();
 uint32_t HeadCard_Actuators_Control(ACTUATORS Act_ID, bool Active_Low_Pwr, bool Direction);
 uint32_t HeadCard_Actuators_Status(ACTUATORS Act_ID);
 
+uint32_t HeadCard_Valve_Control(bool Direction);
+
+uint32_t HeadCard_ActivateHeadMagnet();
+uint32_t HeadCard_DeActivateHeadMagnet();
+uint32_t HeadCard_HeadMagnet_Disable();
+
+uint32_t HeadCard_Valve_Control(bool Direction);
+
+uint32_t HeadCard_Control_Heaters(uint8_t Heater_ID, bool Pwr_Cmd);
+bool Get_HeadCard_Heater_State(uint8_t Heater_ID);
+
 //------------------------------
 uint8_t Head_Test_IO();
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
index b943a9e1f..4a664a0c5 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
@@ -124,8 +124,8 @@ uint32_t I2C_Read_SensorId(uint32_t I2C_ID, TEMPERATURE_SENSOR_ID_ENUM SensorId,
 
 uint32_t HeadADCPT100_Reset(void)
 {
-    #ifndef EVALUATION_BOARD
     uint32_t status = OK;
+    #ifndef EVALUATION_BOARD
     uint8_t i;
     uint8_t Write_Buf[1];
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
index aa6bfccac..272713389 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
@@ -11,6 +11,7 @@
 #include "inc/hw_memmap.h"
 
 #include "drivers/ADC_Sampling/adc.h"
+#include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
 
 #include "ADC_MUX/ADC_MUX.h"
 #include "modules/ids/ids_ex.h"
@@ -31,8 +32,11 @@ void Trigger_Heater_Current_Read(void)
 {
     I2C_ReadingMessageStruc I2C_ReadingMessage;
     uint8_t Heater_i;
-
+#ifdef Use_Head_Card
+    for (Heater_i = 0;Heater_i < HEAD_NUM_OF_ADC;Heater_i++)
+#else
     for (Heater_i = 0;Heater_i < NUM_OF_CURRENT_HEATERS;Heater_i++)
+#endif
     {
         I2C_ReadingMessage.messageId = Heater_Current_Reading;
         I2C_ReadingMessage.parameter = Heater_i;
@@ -76,8 +80,12 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
             break;
         case Heater_Current_Reading:
             //Report("Read_Heaters_Current",__FILE__,__LINE__,255,RpWarning,0,0);
+#ifdef Use_Head_Card
+            Read_Head_ADC(I2C_ReadingMessage.parameter);
+#else
             Read_Heaters_Current(I2C_ReadingMessage.parameter);
-            break;
+#endif
+        break;
         default:
             break;
         }
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.c
index 8489b08a5..b33d7f0c1 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/PN7150/PN7150.c
@@ -18,6 +18,7 @@ F1_GPO_REG2 Reset_NFC;
 void Reset_NFC_Device(PANEL_BUTTON_OR_CRAT_ID Cart_ID)//reset pin. Set the device in Hard Power Down
 {
     assert (Cart_ID<=CART_3);
+#ifndef EVALUATION_BOARD
 
     switch(Cart_ID)
     {
@@ -35,4 +36,5 @@ void Reset_NFC_Device(PANEL_BUTTON_OR_CRAT_ID Cart_ID)//reset pin. Set the devic
     }
 
     F1_GPO_02_bus = Reset_NFC.ushort;
+#endif
 }
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
index 4a5a48f04..d1a3ee958 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
@@ -90,6 +90,7 @@ uint32_t Motor_ReconfigAllMotors(void)
 {
     TimerMotors_t Motor_i;
     uint32_t status = PASSED;
+    ReportWithPackageFilter(GeneralFilter,"Motor_ReconfigAllMotors",__FILE__,__LINE__,NUM_OF_MOTORS,RpMessage,0,0);
     for (Motor_i = 0; Motor_i < NUM_OF_MOTORS ; Motor_i++)
     {
         if (isMotorConfigured(Motor_i))
@@ -349,6 +350,7 @@ uint32_t MotorStop(TimerMotors_t _motorId, STOP_TYPE_ENUM StopType)
         Stop_Command = StopType;
         Mot_Stop();
     #else
+        //ReportWithPackageFilter(GeneralFilter,"MotorStop",__FILE__,__LINE__,_motorId,RpMessage,StopType,0);
         MotorDriverRequest[_motorId].Stop = StopType;
         FPGA_SetMotStop(_motorId);
     #endif
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
index 3a1d25310..3b8599a5c 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
@@ -29,6 +29,8 @@
 #include "drivers/SSI_Comm/Dancer/Dancer.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
 
+#include "AlarmHandling/AlarmHandling.h"
+
 /////////////////////////
 #include "driverlib/ssi.h"
 
@@ -513,7 +515,7 @@ uint32_t MotorMoveToLimitSwitchCallBackFunction(uint32_t IfIndex, uint32_t Limit
 
        //possibly: start regular control (speed etc)
        //uint32_t ControlId = AddControlCallback(NULL,ControlCBFunction Callback,  eOneMillisecond, (IfTypeMotors*0x100+MotorId), deviceId, Parameter );
-       if (MotorId == HARDWARE_MOTOR_TYPE__MOTO_DH_LID)
+       if ((MotorId == HARDWARE_MOTOR_TYPE__MOTO_DH_LID)&&(LimitSwitch == LIMIT))
        {
            if (CloseMagnet == true)
            {
@@ -521,7 +523,75 @@ uint32_t MotorMoveToLimitSwitchCallBackFunction(uint32_t IfIndex, uint32_t Limit
                Task_sleep(200);
                ActivateHeadMagnet(); // close the lid magnet
                CloseMagnet=false;
-               LOG_ERROR(CloseMagnet,"ActivateHeadMagnet");
+               ReportWithPackageFilter(GeneralFilter,"calling ActivateHeadMagnet",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpMessage,0,0);
+           }
+       }
+       if ((LimitSwitch != LIMIT) &&((MotorTimeout[MotorId]>=MotorTimeLimit[MotorId])&&(MotorTimeLimit[MotorId]>0))) //timeout
+       {
+           switch (MotorId)
+           {
+               case HARDWARE_MOTOR_TYPE__MOTO_RDANCER:
+               case HARDWARE_MOTOR_TYPE__MOTO_RLOADARM:
+               case HARDWARE_MOTOR_TYPE__MOTO_RLOADING:
+                   if(MotorDriverRequest[MotorId].Direction == MotorsCfg[MotorId].directionthreadwize)
+                       AlarmHandlingSetAlarm (EVENT_TYPE__RTFU_DOWN_TIMEOUT,ON);  //handle alarm detection and operation
+                   else
+                       AlarmHandlingSetAlarm (EVENT_TYPE__RTFU_UP_TIMEOUT,ON);  //handle alarm detection and operation
+                   break;
+               case HARDWARE_MOTOR_TYPE__MOTO_LDANCER1:
+               case HARDWARE_MOTOR_TYPE__MOTO_LDANCER2:
+               case HARDWARE_MOTOR_TYPE__MOTO_LPIVOT1:
+               case HARDWARE_MOTOR_TYPE__MOTO_LLOADING:
+                   if(MotorDriverRequest[MotorId].Direction == MotorsCfg[MotorId].directionthreadwize)
+                       AlarmHandlingSetAlarm (EVENT_TYPE__LTFU_DOWN_TIMEOUT,ON);  //handle alarm detection and operation
+                   else
+                       AlarmHandlingSetAlarm (EVENT_TYPE__LTFU_UP_TIMEOUT,ON);  //handle alarm detection and operation
+                   break;
+               case HARDWARE_MOTOR_TYPE__MOTO_SCREW:
+                   AlarmHandlingSetAlarm (EVENT_TYPE__SCREW_MOTOR_LIMIT_TIMEOUT,ON);  //handle alarm detection and operation
+                   break;
+               case HARDWARE_MOTOR_TYPE__MOTO_DH_LID:
+                   if(MotorDriverRequest[MotorId].Direction == MotorsCfg[MotorId].directionthreadwize)
+                       AlarmHandlingSetAlarm (EVENT_TYPE__DYEING_HEAD_COVER_CLOSE_TIMEOUT,ON);  //handle alarm detection and operation
+                   else
+                       AlarmHandlingSetAlarm (EVENT_TYPE__DYEING_HEAD_COVER_OPEN_TIMEOUT,ON);  //handle alarm detection and operation
+                   break;
+               default:
+                   REPORT_MSG(MotorId,"Motor timeout");
+                   break;
+           }
+       }
+       else
+       {
+           if (LimitSwitch == LIMIT)
+           {
+               switch (MotorId)
+               {
+                   case HARDWARE_MOTOR_TYPE__MOTO_RDANCER:
+                   case HARDWARE_MOTOR_TYPE__MOTO_RLOADARM:
+                   case HARDWARE_MOTOR_TYPE__MOTO_RLOADING:
+                       AlarmHandlingSetAlarm (EVENT_TYPE__RTFU_DOWN_TIMEOUT,OFF);  //handle alarm detectiOFF and operatiOFF
+                       AlarmHandlingSetAlarm (EVENT_TYPE__RTFU_UP_TIMEOUT,OFF);  //handle alarm detection and operation
+                       break;
+                   case HARDWARE_MOTOR_TYPE__MOTO_LDANCER1:
+                   case HARDWARE_MOTOR_TYPE__MOTO_LDANCER2:
+                   case HARDWARE_MOTOR_TYPE__MOTO_LPIVOT1:
+                   case HARDWARE_MOTOR_TYPE__MOTO_LLOADING:
+                       AlarmHandlingSetAlarm (EVENT_TYPE__LTFU_DOWN_TIMEOUT,OFF);  //handle alarm detection and operation
+                       AlarmHandlingSetAlarm (EVENT_TYPE__LTFU_UP_TIMEOUT,OFF);  //handle alarm detection and operation
+                       break;
+                   case HARDWARE_MOTOR_TYPE__MOTO_SCREW:
+                       AlarmHandlingSetAlarm (EVENT_TYPE__SCREW_MOTOR_LIMIT_TIMEOUT,OFF);  //handle alarm detection and operation
+                       break;
+                   case HARDWARE_MOTOR_TYPE__MOTO_DH_LID:
+                       AlarmHandlingSetAlarm (EVENT_TYPE__DYEING_HEAD_COVER_CLOSE_TIMEOUT,OFF);  //handle alarm detection and operation
+                       AlarmHandlingSetAlarm (EVENT_TYPE__DYEING_HEAD_COVER_OPEN_TIMEOUT,OFF);  //handle alarm detection and operation
+                       break;
+                   default:
+                       REPORT_MSG(MotorId,"Motor timeout solved");
+                       break;
+               }
+
            }
        }
        //call the module callback
@@ -554,7 +624,7 @@ uint32_t MotorMovetoLimitSwitch (TimerMotors_t MotorId,bool direction, uint32_t
         {
             CloseMagnet = true;
         }
-        LOG_ERROR(CloseMagnet,"DeActivateHeadMagnet");
+        ReportWithPackageFilter(GeneralFilter,"calling DeActivateHeadMagnet",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpMessage,0,0);
     }
     if (MotorId == HARDWARE_MOTOR_TYPE__MOTO_RDANCER)
     {
@@ -711,6 +781,7 @@ uint32_t MotorMovetoDancerPosition (TimerMotors_t MotorId,bool direction, uint32
 
 uint32_t MotorAbortMovetoLimitSwitch (TimerMotors_t MotorId)
 {
+    ReportWithPackageFilter(GeneralFilter,"MotorAbortMovetoLimitSwitch",__FILE__,__LINE__,MotorId,RpMessage,MotorControlId[MotorId],0);
     if (MotorControlId[MotorId] != 0xFF)
     {
         RemoveControlCallback(MotorControlId[MotorId], MotorControlCallback[MotorId] );
diff --git a/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c b/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c
index b7a6fb67e..22a734781 100644
--- a/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c
+++ b/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c
@@ -82,7 +82,7 @@ static unsigned char UsbRxBuffer[COMM_MAX_BUFFER_SIZE];
 
 static unsigned char transmitBuffer[COMM_MAX_BUFFER_SIZE];
 
-int expected_message_size;
+int expected_message_size,keep_expected_message_size;
 int current_message_size;
 static volatile uint32_t g_RxCount;
 //static GateMutex_Handle gateTxSerial;
@@ -617,7 +617,12 @@ uint32_t ControlHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValu
     return(0);
 }
 uint32_t buffId = 0xFF;
+/*#define  MAX_USB_LOG 3
 
+uint32_t ULength[MAX_USB_LOG+1] = {0};
+uint32_t UDataLength[MAX_USB_LOG] = {0};
+byte URxIndex = 0;
+*/
 void handleRx(void)
 {
     uint32_t ui32Read;
@@ -639,9 +644,13 @@ if (expected_message_size == 0)
         } while(size_bar < 4);
 
        expected_message_size = *(int *)size;
+  //     ULength[URxIndex] = expected_message_size;
        buffId = initArray( expected_message_size);
        if (buffId == 0xFF)
+       {
+           keep_expected_message_size = expected_message_size;
            expected_message_size = 0;
+       }
     }
 
     do
@@ -653,11 +662,15 @@ if (expected_message_size == 0)
         {
             insertArray(buffId,ui8Char);
             current_message_size++;
+//            UDataLength[URxIndex] = current_message_size;
         }
 
         if (current_message_size == expected_message_size)
         {
             g_RxCount += current_message_size;
+/*            UDataLength[URxIndex] = current_message_size;
+            if (URxIndex++>= MAX_USB_LOG)
+                URxIndex = 0;*/
             CommunicationTaskMessageReceived(buffId,current_message_size);
             expected_message_size = 0;
             current_message_size = 0;
diff --git a/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c b/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
index bc5cb5096..9f96b4deb 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
@@ -17,6 +17,7 @@
 
 #include "drivers/FPGA/FPGA_Comm.h"
 #include <Drivers/Valves/Valve.h>
+#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
 
 #include "Modules/Control/Control.h"
 
@@ -125,7 +126,11 @@ void Valve_Command(Valves_t Valve_Id) //1 - OPEN, 0 - CLOSE
                 F1_GPO_Reg.bits.F1_VALVE_WASTE_TANK = ValveRequest[Valve_Id].Direction;
             break;
         case VALVE_MIXCHIP_WASTECH:
+#ifdef Use_Head_Card
+            HeadCard_Valve_Control(ValveRequest[Valve_Id].Direction);
+#else
                 F1_GPO_Reg.bits.F1_VALVE_MIXCHIP_WASTECH = ValveRequest[Valve_Id].Direction;
+#endif
             break;
 
         case VALVE_DISPENSER_1:
@@ -372,13 +377,13 @@ uint32_t Control3WayValvesWithCallback (Valves_t _ValveId, bool direction, callb
 
     Valve3WayModuleCallback[_ValveId] = callback;
 
-    busy = FPGA_GetDispenserValveBusyOCD(_ValveId,0);
-    Report("Set valve id, dir, busy",__FILE__,_ValveId,(int)direction,RpWarning,(int)busy,0);
     Valve3WayControlId[_ValveId] = AddControlCallback("Valve3WayControlId", Valve3WayCallBackFunction,  eOneSecond/*eHundredMillisecond*/, FPGA_GetDispenserValveBusyOCD,(IfTypeDisopenser*0x100+_ValveId), _ValveId, 0 );
     if (Valve3WayControlId[_ValveId] == 0xFF)
         Report("Add control callback failed",__FILE__,__LINE__,(int)_ValveId,RpWarning,(int)Valve3WayControlId[_ValveId],0);
     //else
     //    Report("Add control callback",__FILE__,__LINE__,(int)_ValveId,RpWarning,(int)Valve3WayControlId[_ValveId],0);
+    busy = FPGA_GetDispenserValveBusyOCD(_ValveId,0);
+    //Report("Set valve id, dir, busy",__FILE__,_ValveId,(int)direction,RpWarning,(int)busy,0);
 
     EnableDisableDispenserValve(_ValveId, ENABLE);
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/logi-tag/LT_RFID.c b/Software/Embedded_SW/Embedded/Drivers/logi-tag/LT_RFID.c
index 2b340c535..b7683688d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/logi-tag/LT_RFID.c
+++ b/Software/Embedded_SW/Embedded/Drivers/logi-tag/LT_RFID.c
@@ -944,3 +944,218 @@ int incrementCounterAndCompare( uint32_t readerID, NxpNci_RfIntf_t *tagInfo, int
     return 1;
 }
 
+void RFID_Test()
+{
+
+uint8_t i, readerID = 1;
+NxpNci_RfIntf_t tagInfo;
+uint8_t addressBlock = 0xE3; // NTAG216 - User memory blocks: 0x04-0xE1 = 222 blocks = 888 bytes
+uint8_t tagId[]= {0};
+uint8_t Serial[] = {'1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G'};
+uint8_t factoryID[] = { '1', '2', '3'};
+uint16_t fillingSystem = 55;
+uint8_t workOrder[] = { 'W', 'O', '1', '9', '0', '0', '0', '0', '1', '8'};
+uint8_t colorName[] = { 'C', 'O', 'L', 'O', 'R', '-', 'N', 'A', 'M', 'E', '-', '1', '2', '3'};
+uint8_t catagory[] = { '0', '1'};
+uint32_t type = 1234;
+uint32_t cartSize = 1522;
+uint32_t inkVolume = 750;
+uint8_t inkBatch[] = { 'W', 'O', '1', '9', '0', '0', '0', '1', '0', '8' };
+uint8_t inkMfgDate[] = { '1', '9', '/', '0', '7', '/', '1', '9' };
+uint8_t inkEolDate[] = { '1', '9', '/', '0', '7', '/', '2', '0' };
+uint8_t CartFillDate[] = { '1', '8', '/', '0', '8', '/', '1', '9' };
+uint8_t WasteFillDate[] = { 'S', 'T', 'U', 'V', 'W', 'X', 0, 0 };
+uint32_t Misc = 1234;
+uint32_t pluginCounter = 15;
+uint8_t inkFill = 1;
+uint8_t inkUsed = 2;
+uint8_t inkEmpty = 3;
+uint8_t wasteEmpty = 4;
+uint8_t wasteFilling = 5;
+uint8_t wasteFull = 6;
+uint8_t blocked = 7;
+uint8_t fail = 8;
+uint16_t wasteCounter = 14;
+uint8_t MachineIdInl[] = { 'A', '1', 'B', '2', 'C', '3', 'D', '4', 'E', '5', 'F', '6', 'G', '7', 'H', '8' };
+uint8_t MachineIdWst[] = { 'H', '8', 'G', '7', 'F', '6', 'E', '5', 'D', '4', 'C', '3', 'B', '2', 'A', '1' };
+uint8_t reserved[] = { 'A', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 0 };
+uint32_t counter = 12;
+uint8_t tagValid = 1;
+uint8_t uid[7] = {0};
+uint8_t hashValue[16] = {0};
+uint8_t newPACK[] = {0x11, 0x22};
+uint8_t newPwd[] = {0xFF, 0xFF, 0xFF, 0xFF};
+uint8_t startingBlock = 0x04;
+uint8_t pwdAddr = 0xE5;
+uint8_t tagMemory[1024];
+uint16_t succeededWriteSize = 0;
+uint16_t succeededReadSize = 0;
+bool firstTime = true;
+
+uint32_t dummy = 0;
+RFID_RETURN_CODE RFIDRetValue;
+RFID_HardReset(readerID);
+RFID_StartDiscovery(readerID);
+InitFields();
+while(1)
+    {
+        if(RFID_WaitForDiscoveryNotification(readerID, &tagInfo) == SUCCESS){
+            //if(firstTime){
+                //firstTime = false;
+                //RFID_CardModeSend(readerID, &tagInfo, newPwd, pwdAddr, sizeof(newPwd), &succeededWriteSize);
+                //RFID_CardModeReceive(readerID, &tagInfo, tagMemory, addressBlock, sizeof(tagMemory), &succeededReadSize);
+                //if(memcmp(dataToWrite, tagMemory, sizeof(dataToWrite)) == 0)
+                //    greenLedBlink(500);
+                //counter = GetCounter (readerID, &tagInfo);
+                //isTagValid = IsTagValid(readerID, &tagInfo);
+                //UID
+                RFIDRetValue = getUID( readerID, &tagInfo, uid );
+                //password update
+                //if ( setPwdValue( readerID, &tagInfo, newPwd ) == true )
+                //    i = 0;
+
+                ///if ( activatePwd( readerID, &tagInfo, startingBlock ) == true )
+                ///    i = 1;
+                //password authentication
+                if ( checkPwd( newPwd, newPACK ) == true )
+                    i = 0;
+                if ( setPACKValue( readerID, &tagInfo, newPACK ) == true )
+                    i = 1;
+
+                //RFIDRetValue = getPwd( readerID, &tagInfo, pwd );
+                //serial
+                RFIDRetValue = WriteValue( readerID, &tagInfo, Serial, 0, dummy );
+                RFIDRetValue = ReadValue( readerID, &tagInfo, Serial, 0, &dummy );
+                //factory id
+                RFIDRetValue = WriteValue( readerID, &tagInfo, factoryID, 1, dummy );
+                RFIDRetValue = ReadValue( readerID, &tagInfo, factoryID, 1, &dummy );
+                //filling system
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 2, fillingSystem );
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 2, &fillingSystem );
+                //work order
+                RFIDRetValue = WriteValue( readerID, &tagInfo, workOrder, 3, dummy );
+                RFIDRetValue = ReadValue( readerID, &tagInfo, workOrder, 3, &dummy );
+                //color name
+                RFIDRetValue = WriteValue( readerID, &tagInfo, colorName, 4, dummy );
+                RFIDRetValue = ReadValue( readerID, &tagInfo, colorName, 4, &dummy );
+                //category
+                RFIDRetValue = WriteValue( readerID, &tagInfo, catagory, 5, dummy );
+                RFIDRetValue = ReadValue( readerID, &tagInfo, catagory, 5, &dummy );
+                //type
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 6, type );
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 6, &type );
+                //cartSize
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 7, cartSize );
+                cartSize = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 7, &cartSize );
+                //inkVolume
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 8, inkVolume );
+                inkVolume = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 8, &inkVolume );
+                //inkBatch
+                RFIDRetValue = WriteValue( readerID, &tagInfo, inkBatch, 9, dummy );
+                for ( i = 0; i < sizeof(inkBatch); i++ )    inkBatch[i] = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, inkBatch, 9, &dummy );
+                //inkMfgDate
+                RFIDRetValue = WriteValue( readerID, &tagInfo, inkMfgDate, 10, dummy );
+                for ( i = 0; i < sizeof(inkMfgDate); i++ )    inkMfgDate[i] = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, inkMfgDate, 10, &dummy );
+                //inkEolDate
+                RFIDRetValue = WriteValue( readerID, &tagInfo, inkEolDate, 11, dummy );
+                for ( i = 0; i < sizeof(inkEolDate); i++ )    inkEolDate[i] = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, inkEolDate, 11, &dummy );
+                //CartFillDate
+                RFIDRetValue = WriteValue( readerID, &tagInfo, CartFillDate, 12, dummy );
+                for ( i = 0; i < sizeof(CartFillDate); i++ )    CartFillDate[i] = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, CartFillDate, 12, &dummy );
+                //WasteFillDate
+                RFIDRetValue = WriteValue( readerID, &tagInfo, WasteFillDate, 13, dummy );
+                for ( i = 0; i < sizeof(WasteFillDate); i++ )    WasteFillDate[i] = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, WasteFillDate, 13, &dummy );
+                //Misc
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 14, Misc );
+                Misc = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 14, &Misc );
+                //pluginCounter
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 15, pluginCounter );
+                pluginCounter = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 15, &pluginCounter );
+                //inkFill
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 16, inkFill );
+                inkFill = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 16, &inkFill );
+                //inkUsed
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 17, inkUsed );
+                inkUsed = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 17, &inkUsed );
+                //inkEmpty
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 18, inkEmpty );
+                inkEmpty = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 18, &inkEmpty );
+                //wasteEmpty
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 19, wasteEmpty );
+                inkVolume = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 19, &wasteEmpty );
+                //wasteFilling
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 20, wasteFilling );
+                inkVolume = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 20, &wasteFilling );
+                //wasteFull
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 21, wasteFull );
+                wasteFull = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 21, &wasteFull );
+                //blocked
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 22, blocked );
+                inkVolume = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 22, &blocked );
+                //fail
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 23, fail );
+                wasteFull = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 23, &fail );
+                //wasteCounter
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 24, wasteCounter );
+                inkVolume = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 24, &wasteCounter );
+                //MachineIdInl
+                RFIDRetValue = WriteValue( readerID, &tagInfo, MachineIdInl, 25, dummy );
+                for ( i = 0; i < sizeof(MachineIdInl); i++ )    MachineIdInl[i] = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, MachineIdInl, 25, &dummy );
+                //WasteFillDate
+                RFIDRetValue = WriteValue( readerID, &tagInfo, MachineIdWst, 26, dummy );
+                for ( i = 0; i < sizeof(MachineIdWst); i++ )    MachineIdWst[i] = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, MachineIdWst, 26, &dummy );
+                //WasteFillDate
+                RFIDRetValue = WriteValue( readerID, &tagInfo, reserved, 27, dummy );
+                for ( i = 0; i < sizeof(reserved); i++ )    reserved[i] = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, reserved, 27, &dummy );
+                //counter
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 28, counter );
+                counter = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 28, &counter );
+                //tagValid
+                RFIDRetValue = WriteValue( readerID, &tagInfo, tagMemory, 29, tagValid );
+                tagValid = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, tagMemory, 29, &tagValid );
+
+                //hash
+                calcHash( uid, sizeof(uid), hashValue );
+                RFIDRetValue = WriteValue( readerID, &tagInfo, hashValue, 30, dummy );
+                for ( i = 0; i < sizeof(hashValue); i++ )    hashValue[i] = 0;
+                RFIDRetValue = ReadValue( readerID, &tagInfo, hashValue, 30, &dummy );
+                //password
+
+            //}
+            RFID_StopDiscovery(readerID);
+            RFID_StartDiscovery(readerID);
+
+            ACTIVITY_RED_LED_ON;
+            ACTIVITY_GREEN_LED_ON;
+            //greenLedBlink(100);
+        }
+        delayms(100);
+    }
+
+    //----------------------------------------------------------------------------
+
+}
+
diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index 6eb7a2850..f07937db0 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -229,8 +229,10 @@ int main(void)
 
 	PortFunctionInit();
 
-   MCU_E2PromInit();
 
+#ifndef EVALUATION_BOARD
+   MCU_E2PromInit();
+#endif
     #ifdef EVALUATION_BOARD
         Init_EVB();
     #endif
@@ -321,7 +323,9 @@ int main(void)
     Head_IO_Init();
 #endif
 
+#ifndef EVALUATION_BOARD
     Main_EEPROM_Read_Main_Card_SN();
+#endif
 
     // Enable interrupts to the processor.
     //
@@ -329,7 +333,6 @@ int main(void)
 
 
     IDLE_TASK_package_init();
-
     Start_InitSequence();
     PowerIdleInit();
     BIOS_start();
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 6d5dc00b2..93246979b 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -91,7 +91,7 @@ typedef struct AlarmHandlingMessage{
   //  uint32_t Data;
 }AlarmHandlingMessageStruc;
 
-#define MAX_SYSTEM_ALARMS 300+1
+#define MAX_SYSTEM_ALARMS 400+1
 /*typedef enum
 {
     TemperatureAlarm,
@@ -171,265 +171,265 @@ uint32_t * pAlarmItemSize = (uint32_t *)(ALARM_MAP_IN_FLASH);
 uint32_t AlarmItemSize ;
 AlarmHandlingItemStruc  *AlarmItem  = (AlarmHandlingItemStruc *)(ALARM_MAP_IN_FLASH+4);
 AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
-/*	7016	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY},
-/*	7017	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY},
-/*	7018	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY},
-/*	7019	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_4_EMPTY},
-/*	7020	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_5_EMPTY},
-/*	7021	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_6_EMPTY},
-/*	7022	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_7_EMPTY},
-/*	7023	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_8_EMPTY},
+//* 7016    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY},
+//* 7017    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY},
+//* 7018    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY},
+//* 7019    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_4_EMPTY},
+//* 7020    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_5_EMPTY},
+//* 7021    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_6_EMPTY},
+//* 7022    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_7_EMPTY},
+//* 7023    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_8_EMPTY},
 
-/*	7064	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT},
-/*	7065	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_UPPER_HARD_LIMIT},
-/*	7066	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_UPPER_HARD_LIMIT},
-/*	7067	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_UPPER_HARD_LIMIT},
-/*	7068	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_UPPER_HARD_LIMIT},
-/*	7069	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_UPPER_HARD_LIMIT},
-/*	7070	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_UPPER_HARD_LIMIT},
-/*	7071	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_UPPER_HARD_LIMIT},
-/*	7072	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT},
-/*	7073	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_LOWER_HARD_LIMIT},
-/*	7074	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_LOWER_HARD_LIMIT},
-/*	7075	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_LOWER_HARD_LIMIT},
-/*	7076	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_LOWER_HARD_LIMIT},
-/*	7077	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_LOWER_HARD_LIMIT},
-/*	7078	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_LOWER_HARD_LIMIT},
-/*	7079	*/     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_LOWER_HARD_LIMIT},
+//* 7064    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT},
+//* 7065    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_UPPER_HARD_LIMIT},
+//* 7066    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_UPPER_HARD_LIMIT},
+//* 7067    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_UPPER_HARD_LIMIT},
+//* 7068    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_UPPER_HARD_LIMIT},
+//* 7069    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_UPPER_HARD_LIMIT},
+//* 7070    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_UPPER_HARD_LIMIT},
+//* 7071    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_UPPER_HARD_LIMIT},
+//* 7072    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT},
+//* 7073    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_LOWER_HARD_LIMIT},
+//* 7074    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_LOWER_HARD_LIMIT},
+//* 7075    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_LOWER_HARD_LIMIT},
+//* 7076    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_LOWER_HARD_LIMIT},
+//* 7077    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_LOWER_HARD_LIMIT},
+//* 7078    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_LOWER_HARD_LIMIT},
+//* 7079    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_LOWER_HARD_LIMIT},
 
-/*	7080	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,0,0,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_1_HIGH_PRESSURE},
-/*	7081	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,1,1,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_2_HIGH_PRESSURE},
-/*	7082	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,2,2,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_3_HIGH_PRESSURE},
-/*	7083	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,3,3,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE},
-/*	7084	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,4,4,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE},
-/*	7085	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,5,5,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE},
-/*	7086	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,6,6,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE},
-/*	7087	*/     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,7,7,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE},
+//* 7080    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,0,0,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_1_HIGH_PRESSURE},
+//* 7081    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,1,1,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_2_HIGH_PRESSURE},
+//* 7082    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,2,2,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_3_HIGH_PRESSURE},
+//* 7083    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,3,3,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE},
+//* 7084    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,4,4,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE},
+//* 7085    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,5,5,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE},
+//* 7086    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,6,6,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE},
+//* 7087    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,7,7,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE},
 
-/*	7000	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_1_OVERPRESSURE},
-/*	7001	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_2_OVERPRESSURE},
-/*	7002	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_3_OVERPRESSURE},
-/*	7003	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_4_OVERPRESSURE},
-/*	7004	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_5_OVERPRESSURE},
-/*	7005	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_6_OVERPRESSURE},
-/*	7006	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE},
-/*	7007	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE},
+//* 7000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_1_OVERPRESSURE},
+//* 7001    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_2_OVERPRESSURE},
+//* 7002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_3_OVERPRESSURE},
+//* 7003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_4_OVERPRESSURE},
+//* 7004    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_5_OVERPRESSURE},
+//* 7005    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_6_OVERPRESSURE},
+//* 7006    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE},
+//* 7007    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE},
 
-/*	8000	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_1_LOW_LEVEL},
-/*	8001	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_2_LOW_LEVEL},
-/*	8002	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_3_LOW_LEVEL},
-/*	8003	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_4_LOW_LEVEL},
-/*	8004	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_5_LOW_LEVEL},
-/*	8005	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_6_LOW_LEVEL},
-/*	8006	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_7_LOW_LEVEL},
-/*	8007	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_8_LOW_LEVEL},
-/*	8008	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY},
-/*	8009	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY},
-/*	8010	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY},
-/*	8011	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY},
-/*	8012	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY},
-/*	8013	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_EMPTY},
-/*	8014	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_EMPTY},
-/*	8015	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY},
+//* 8000    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_1_LOW_LEVEL},
+//* 8001    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_2_LOW_LEVEL},
+//* 8002    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_3_LOW_LEVEL},
+//* 8003    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_4_LOW_LEVEL},
+//* 8004    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_5_LOW_LEVEL},
+//* 8005    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_6_LOW_LEVEL},
+//* 8006    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_7_LOW_LEVEL},
+//* 8007    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_8_LOW_LEVEL},
+//* 8008    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY},
+//* 8009    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY},
+//* 8010    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY},
+//* 8011    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY},
+//* 8012    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY},
+//* 8013    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_EMPTY},
+//* 8014    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_EMPTY},
+//* 8015    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY},
 
-/*	8016	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_OVERFLOW},
-/*	8017	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_OVERFLOW},
-/*	8018	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_OVERFLOW},
-/*	8019	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_OVERFLOW},
-/*	8020	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_OVERFLOW},
-/*	8021	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_OVERFLOW},
-/*	8022	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_OVERFLOW},
-/*	8023	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_OVERFLOW},
+//* 8016    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_OVERFLOW},
+//* 8017    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_OVERFLOW},
+//* 8018    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_OVERFLOW},
+//* 8019    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_OVERFLOW},
+//* 8020    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_OVERFLOW},
+//* 8021    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_OVERFLOW},
+//* 8022    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_OVERFLOW},
+//* 8023    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_OVERFLOW},
 
 
-/*	4000	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  },
-/*	3003	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT },
-/*	3008	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT  },
-/*	3007	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERCURRENT },
-/*	3005	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERCURRENT },
-/*	7032	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT},
-/*	7033	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT},
-/*	7034	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT},
-/*	7035	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT},
-/*	7036	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT},
-/*	7037	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT},
-/*	7038	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT},
-/*	7039	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT},
-/*	4001	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE},
-/*	3010	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE},
-/*	3015	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE },
-/*	3014	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE},
-/*	3012	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE},
-/*	7040	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE},
-/*	7041	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE},
-/*	7042	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE},
-/*	7043	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE},
-/*	7044	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE},
-/*	7045	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE},
-/*	7046	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE},
-/*	7047	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE},
-/*	4003	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE },
-/*	3024	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE},
-/*	3029	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE },
-/*	3028	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE},
-/*	3026	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE},
-/*	7056	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE},
-/*	7057	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE},
-/*	7058	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE},
-/*	7059	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE},
-/*	7060	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE},
-/*	7061	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE},
-/*	7062	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE},
-/*	7063	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE},
-/*	4002	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_STALL    },
-/*	3017	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_STALL   },
-/*	3022	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_STALL    },
-/*	3021	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_STALL   },
-/*	3019	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_STALL   },
-/*	7048	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_STALL},
-/*	7049	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_STALL},
-/*	7050	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_STALL},
-/*	7051	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_STALL},
-/*	7052	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_STALL},
-/*	7053	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_STALL},
-/*	7054	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_STALL},
-/*	7055	*/     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_STALL},
+//* 4000    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  },
+//* 3003    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT },
+//* 3008    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT  },
+//* 3007    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERCURRENT },
+//* 3005    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERCURRENT },
+//* 7032    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT},
+//* 7033    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT},
+//* 7034    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT},
+//* 7035    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT},
+//* 7036    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT},
+//* 7037    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT},
+//* 7038    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT},
+//* 7039    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT},
+//* 4001    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE},
+//* 3010    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE},
+//* 3015    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE },
+//* 3014    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE},
+//* 3012    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE},
+//* 7040    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE},
+//* 7041    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE},
+//* 7042    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE},
+//* 7043    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE},
+//* 7044    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE},
+//* 7045    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE},
+//* 7046    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE},
+//* 7047    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE},
+//* 4003    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE },
+//* 3024    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE},
+//* 3029    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE },
+//* 3028    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE},
+//* 3026    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE},
+//* 7056    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE},
+//* 7057    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE},
+//* 7058    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE},
+//* 7059    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE},
+//* 7060    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE},
+//* 7061    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE},
+//* 7062    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE},
+//* 7063    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE},
+//* 4002    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_STALL    },
+//* 3017    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_STALL   },
+//* 3022    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_STALL    },
+//* 3021    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_STALL   },
+//* 3019    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_STALL   },
+//* 7048    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_STALL},
+//* 7049    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_STALL},
+//* 7050    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_STALL},
+//* 7051    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_STALL},
+//* 7052    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_STALL},
+//* 7053    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_STALL},
+//* 7054    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_STALL},
+//* 7055    */     {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_STALL},
 
-/*	6000	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE},
-/*	5000	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE},
-/*	5001	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE},
-/*	5002	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE},
-/*	5003	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE},
-/*	5004	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE},
-/*	5005	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE                   },
-/*	4005	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE      },
+//* 6000    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE},
+//* 5000    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE},
+//* 5001    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE},
+//* 5002    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE},
+//* 5003    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE},
+//* 5004    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE},
+//* 5005    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE                   },
+//* 4005    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE      },
 
-/*	2008	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,  0,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
-/*	2017	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,  1,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
+//* 2008    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,  0,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
+//* 2017    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,  1,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
 
-/*	2002	*/  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor1_EC      ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN},
-/*	2003	*/  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor2_PPC     ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_2_OPEN},
-/*	2004	*/  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor3_DH_DRYER,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_3_OPEN},
-/*	2005	*/  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor4_MIDTANKS,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_4_OPEN},
-/*	2007	*/  //  {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor           ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN     },
+//* 2002    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor1_EC      ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN},
+//* 2003    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor2_PPC     ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_2_OPEN},
+//* 2004    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor3_DH_DRYER,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_3_OPEN},
+//* 2005    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor4_MIDTANKS,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_4_OPEN},
+//* 2007    */  //  {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor           ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN     },
 
-/*	2006	*/     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor     ,1,true,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN},
+//* 2006    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor     ,1,true,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN},
 
-/*	6001	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A},
-/*	5006	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A},
-/*	5007	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A},
-/*	5008	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A},
-/*	5009	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A},
-/*	5010	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A},
-/*	5011	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A},
+//* 6001    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A},
+//* 5006    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A},
+//* 5007    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A},
+//* 5008    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A},
+//* 5009    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A},
+//* 5010    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A},
+//* 5011    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A},
 
-/*	4007	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A},
-/*	6002	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B},
-/*	5012	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B},
-/*	5013	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B},
-/*	5014	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B},
-/*	5015	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B},
-/*	5016	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B},
-/*	5017	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B                   },
-/*	4008	*/     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B      },
+//* 4007    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A},
+//* 6002    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B},
+//* 5012    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B},
+//* 5013    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B},
+//* 5014    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B},
+//* 5015    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B},
+//* 5016    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B},
+//* 5017    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B                   },
+//* 4008    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B      },
 
-/*	3004	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT                            },                                           /* 3004 */
-/*	3006	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT                            },                                           /* 3006 */
-/*	3009	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT                            },                                           /* 3009 */
-/*	3036	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_MOTOR_OVERCURRENT /*EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT*/            },   /* 3036 */
-/*	3037	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_MOTOR_OVERCURRENT /*EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT*/            },   /* 3037 */
-/*	3038	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT /*EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT*/            },   /* 3038 */
-/*	4017	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  /*EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT*/                },   /* 4017 */
-/*	5031	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT                    },                                       /* 5031 */
-/*	5035	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT       },                                       /* 5035 */
-/*	5039	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT            },                                       /* 5039 */
+//* 3004    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT                            },                                           //* 3004 */
+//* 3006    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT                            },                                           //* 3006 */
+//* 3009    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT                            },                                           //* 3009 */
+//* 3036    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_MOTOR_OVERCURRENT //*EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT*/            },   //* 3036 */
+//* 3037    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_MOTOR_OVERCURRENT //*EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT*/            },   //* 3037 */
+//* 3038    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT //*EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT*/            },   //* 3038 */
+//* 4017    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  //*EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT*/                },   //* 4017 */
+//* 5031    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT                    },                                       //* 5031 */
+//* 5035    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT       },                                       //* 5035 */
+//* 5039    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT            },                                       //* 5039 */
 
-/*	3011	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE                     },                                           /* 3011 */
-/*	3013	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE                      },                                           /* 3013 */
-/*	3016	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE                      },                                           /* 3016 */
-/*	3039	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE                    },                                           /* 3039 */
-/*	3040	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE                                },                                           /* 3040 */
-/*	3041	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE                   },                                           /* 3041 */
-/*	4018	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE                       },                                           /* 4018 */
-/*	5032	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE          },                                           /* 5032 */
-/*	5036	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE  },                                           /* 5036 */
-/*	5040	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE       },                                           /* 5040 */
+//* 3011    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE                     },                                           //* 3011 */
+//* 3013    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE                      },                                           //* 3013 */
+//* 3016    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE                      },                                           //* 3016 */
+//* 3039    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE                    },                                           //* 3039 */
+//* 3040    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE                                },                                           //* 3040 */
+//* 3041    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE                   },                                           //* 3041 */
+//* 4018    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE                       },                                           //* 4018 */
+//* 5032    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE          },                                           //* 5032 */
+//* 5036    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE  },                                           //* 5036 */
+//* 5040    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE       },                                           //* 5040 */
 
-/*	3018	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                             },                                           /* 3018 */
-/*	3020	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              },                                           /* 3020 */
-/*	3023	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                             },                                           /* 3023 */
-/*	3042	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              },                                           /* 3042 */
-/*	3043	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_STALL                                       },                                           /* 3043 */
-/*	3044	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL                                        },                                           /* 3044 */
-/*	4019	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID        ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_STALL                                  },                                           /* 4019 */
-/*	5033	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID           ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL                         },                                           /* 5033 */
-/*	5037	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL            },                                           /* 5037 */
-/*	5041	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL                 },                                           /* 5041 */
+//* 3018    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                             },                                           //* 3018 */
+//* 3020    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              },                                           //* 3020 */
+//* 3023    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                             },                                           //* 3023 */
+//* 3042    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              },                                           //* 3042 */
+//* 3043    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_STALL                                       },                                           //* 3043 */
+//* 3044    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL                                        },                                           //* 3044 */
+//* 4019    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID        ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_STALL                                  },                                           //* 4019 */
+//* 5033    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID           ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL                         },                                           //* 5033 */
+//* 5037    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL            },                                           //* 5037 */
+//* 5041    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL                 },                                           //* 5041 */
 
-/*	3025	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE                         },                                           /* 3025 */
-/*	3027	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE                          },                                           /* 3027 */
-/*	3030	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE                         },                                           /* 3030 */
-/*	3045	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE                      },                                           /* 3045 */
-/*	3046	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE                                },                                           /* 3046 */
-/*	3047	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE                                    },                                           /* 3047 */
-/*	4020	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE                           },                                           /* 4020 */
-/*	5034	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE                  },                                           /* 5034 */
-/*	5038	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE         },                                           /* 5038 */
-/*	5042	*/     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE             },                                           /* 5042 */
+//* 3025    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE                         },                                           //* 3025 */
+//* 3027    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE                          },                                           //* 3027 */
+//* 3030    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE                         },                                           //* 3030 */
+//* 3045    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE                      },                                           //* 3045 */
+//* 3046    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE                                },                                           //* 3046 */
+//* 3047    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE                                    },                                           //* 3047 */
+//* 4020    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE                           },                                           //* 4020 */
+//* 5034    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE                  },                                           //* 5034 */
+//* 5038    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE         },                                           //* 5038 */
+//* 5042    */     {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE             },                                           //* 5042 */
 
-/*	5018	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 125         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE              },                                           /* 5018 */
-/*	5019	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE          },                                           /* 5019 */
-/*	5020	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE          },                                           /* 5020 */
-/*	5021	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 312         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE          },                                           /* 5021 */
-/*	5022	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 500         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE       },                                           /* 5022 */
-/*	6004	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE                       },                                       /* 6004 */
-/*	4011	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, CURRENT4AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE           },                                           /* 6004 */
-/*	4012	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, CURRENT2AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE           },                                           /* 6004 */
+//* 5018    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 125         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE              },                                           //* 5018 */
+//* 5019    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE          },                                           //* 5019 */
+//* 5020    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE          },                                           //* 5020 */
+//* 5021    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 312         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE          },                                           //* 5021 */
+//* 5022    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 500         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE       },                                           //* 5022 */
+//* 6004    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE                       },                                       //* 6004 */
+//* 4011    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, CURRENT4AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE           },                                           //* 6004 */
+//* 4012    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, CURRENT2AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE           },                                           //* 6004 */
 
-/*	5023	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK              },                                           /* 5018 */
-/*	5024	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK           },                                           /* 5019 */
-/*	5025	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK           },                                           /* 5020 */
-/*	5026	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK           },                                           /* 5021 */
-/*	5027	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK       },                                           /* 5022 */
-/*	6005	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK                       },                                        /* 6004 */
-/*	4013	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK          },                                           /* 6004 */
-/*	4014	*/     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK          },                                           /* 6004 */
-/*	5028	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF},
+//* 5023    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK              },                                           //* 5018 */
+//* 5024    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK           },                                           //* 5019 */
+//* 5025    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK           },                                           //* 5020 */
+//* 5026    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK           },                                           //* 5021 */
+//* 5027    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK       },                                           //* 5022 */
+//* 6005    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK                       },                                        //* 6004 */
+//* 4013    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK          },                                           //* 6004 */
+//* 4014    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK          },                                           //* 6004 */
+//* 5028    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF},
 
-/*	9005	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_TIME},
-/*	9008	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE},
+//* 9005    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_TIME},
+//* 9008    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE},
 
-/*	3000	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK},
-/*	3001	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER},
-/*	3048	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER},
-/*	3049	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER},
-/*	3002	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST},
+//* 3000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK},
+//* 3001    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER},
+//* 3048    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER},
+//* 3049    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER},
+//* 3002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST},
 
-/*	4004	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DRYER_DOOR_OPEN},
-/*	9003	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__NO_AIR_PRESSURE},
-/*	9000	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__AIR_FILTER_NOT_INSTALLED},
-/*	9002	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT},
+//* 4004    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DRYER_DOOR_OPEN},
+//* 9003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__NO_AIR_PRESSURE},
+//* 9000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__AIR_FILTER_NOT_INSTALLED},
+//* 9002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT},
 
-/*	2014	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED},
+//* 2014    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED},
 
-/*	2009	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_MIN_RPM           , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW            }, /*2009*/
-/*	2010	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_STOP              , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__MACHINE_FANS_STOPPED                }, /*2010*/
-/*	2011	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_MIN_RPM, FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW }, /*2011*/
-/*	2012	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_STOP   , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED     }, /*2012*/
-/*	4015	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_MIN_RPM              , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW               }, /*4015*/
-/*	4016	*/     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_STOP                 , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__DRYER_FAN_STOPPED                   }, /*4016*/
+//* 2009    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_MIN_RPM           , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW            }, //*2009*/
+//* 2010    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_STOP              , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__MACHINE_FANS_STOPPED                }, //*2010*/
+//* 2011    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_MIN_RPM, FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW }, //*2011*/
+//* 2012    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_STOP   , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED     }, //*2012*/
+//* 4015    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_MIN_RPM              , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW               }, //*4015*/
+//* 4016    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_STOP                 , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__DRYER_FAN_STOPPED                   }, //*4016*/
 
-/*  8024    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT},
-/*  8025    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_2_FILL_TIMEOUT},
-/*  8026    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_3_FILL_TIMEOUT},
-/*  8027    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_4_FILL_TIMEOUT},
-/*  8028    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_5_FILL_TIMEOUT},
-/*  8029    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_6_FILL_TIMEOUT},
-/*  8030    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_7_FILL_TIMEOUT},
-/*  8031    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_8_FILL_TIMEOUT},
+//*  8024    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT},
+//*  8025    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_2_FILL_TIMEOUT},
+//*  8026    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_3_FILL_TIMEOUT},
+//*  8027    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_4_FILL_TIMEOUT},
+//*  8028    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_5_FILL_TIMEOUT},
+//*  8029    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_6_FILL_TIMEOUT},
+//*  8030    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_7_FILL_TIMEOUT},
+//*  8031    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_8_FILL_TIMEOUT},
 
-/*  10002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE},
-/*  10003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL}
+//*  10002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE},
+//*  10003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL}
 
 };
 
@@ -578,7 +578,6 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
         case ALARM_SOURCE_TYPE__HardLimitAlarm:
             usnprintf(AlarmReasonStr, 100, "Dispenser %d hit the hard limit",AlarmItem[AlarmId].DeviceId);
             return JOB_LS_ALARM;
-            break;
         case ALARM_SOURCE_TYPE__DoNotPollAlarm:
             if (AlarmItem[AlarmId].Severity == DEBUG_LOG_CATEGORY__Critical)
             {
@@ -587,7 +586,7 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
             }
             else
             {
-                usnprintf(AlarmReasonStr, 100, "Alarm %d caused a job stop",AlarmId);
+                usnprintf(AlarmReasonStr, 100, "Alarm %d type %d caused a job stop",AlarmId,AlarmItem[AlarmId].EventType);
                 return JOB_OTHER_ALARM;
             }
         default:
@@ -736,12 +735,12 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever
 JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
 {
     //JobTicket* JobTicket = CurrentJob;
-    EventType HeaterEventType[MAX_HEATERS_NUM*2] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,
+    /*EventType HeaterEventType[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,
                                                   EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,
                                                   EVENT_TYPE__MIXER_OVERTEMPERATURE};
-    EventType HeaterEventTypeUnder[MAX_HEATERS_NUM*2] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,
+    EventType HeaterEventTypeUnder[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,
                                                   EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,
-                                                  EVENT_TYPE__MIXER_UNDERTEMPERATURE_B};
+                                                  EVENT_TYPE__MIXER_UNDERTEMPERATURE_B};*/
     int Dispenser_i,Alarm_i,Heater_i,AlarmId=0;
     HeaterState HeaterState;
 
@@ -841,7 +840,12 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     {
         if (HeaterCheckReady()==false)
         {
-            for (Heater_i = 0;Heater_i<MAX_HEATERS_NUM;Heater_i++)
+#warning fit to new head with new alarms
+#ifdef Use_Head_Card
+            for (Heater_i=HEATER_TYPE__DryerAirHeater;Heater_i<HEATER_TYPE_MAX_HEATERS;Heater_i++)
+#else
+            for (Heater_i=HEATER_TYPE__DryerAirHeater;Heater_i<MAX_HEATERS_NUM;Heater_i++)
+#endif
             {
                 LoadHeaterState((HeaterType)Heater_i,&HeaterState);
                 if (HeaterState.setpoint)//temperature is set - heater active
@@ -858,7 +862,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                                 break;
                             }
                         }
-                        if (AlarmItem[Alarm_i].EventType == HeaterEventTypeUnder[Heater_i])
+                        if (AlarmItem[Alarm_i].EventType == HeaterUnderEventType_B[Heater_i])
                         {
                             if (AlarmState[Alarm_i].Status == true)
                             {
@@ -984,6 +988,9 @@ uint32_t AlarmHandlingStop(void)
     }
     return OK;
 }
+uint32_t Save_Alarm_i;
+void *Save_Alarm_ptr;
+EventType Save_Alarm_Type;
 
 uint32_t AlarmHandlingLoop(uint32_t tick)
 {
@@ -1097,14 +1104,18 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
             case ALARM_SOURCE_TYPE__CurrentAlarm:
                 if (CheckCurrentAlarms)
                  {
-                     if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
+#ifndef Use_Head_Card
+                    if (AlarmItem[Alarm_i].DeviceId >= NUM_OF_CURRENT_HEATERS)
+                        break;
+#endif
+                    if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
                      {
                          if (AlarmItem[Alarm_i].AlarmDirection == true)
                          {
-                             if ((doubleValue >= (AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                             if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
                              {
                                  Status = true;
-                                 //ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,AlarmItem[Alarm_i].EventType, RpMessage, (int)doubleValue, 0);
+                                 ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,AlarmItem[Alarm_i].EventType, RpMessage, (int)(doubleValue*100), 0);
                              }
                          }
                          else
@@ -1112,7 +1123,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                              if (doubleValue <= 0.1)
                              {
                                  Status = true;
-                                 //ReportWithPackageFilter(AlarmFilter,"llop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,AlarmItem[Alarm_i].EventType, RpMessage, (int)doubleValue, 0);
+                                 ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,AlarmItem[Alarm_i].EventType, RpMessage, (int)(doubleValue*100), 0);
                              }
                          }
 
@@ -1129,26 +1140,27 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     if (FPGA_WD_Occurred == true)
                     {
                         Status = false;
-                        break;
                     }
-                    if (isMotorConfigured((TimerMotors_t)AlarmItem[Alarm_i].DeviceId) == false)
+                    else if (isMotorConfigured((TimerMotors_t)AlarmItem[Alarm_i].DeviceId) == false)
                     {
                         Status = false;
-                        break;
                     }
-                    value = MotorGetStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
-                    if (AlarmItem[Alarm_i].AlarmDirection == true)
+                    else
                     {
-                        if (value && AlarmItem[Alarm_i].AlarmValue)
+                        value = MotorGetStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                        if (AlarmItem[Alarm_i].AlarmDirection == true)
                         {
-                            Status = true;
+                            if (value && AlarmItem[Alarm_i].AlarmValue)
+                            {
+                                Status = true;
+                            }
                         }
-                    }
-                    else
-                    {
-                        if ((value && AlarmItem[Alarm_i].AlarmValue)==false)
+                        else
                         {
-                            Status = true;
+                            if ((value && AlarmItem[Alarm_i].AlarmValue)==false)
+                            {
+                                Status = true;
+                            }
                         }
                     }
                 }
@@ -1184,7 +1196,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
 
             case ALARM_SOURCE_TYPE__TachoAlarm: // add by shai
                 Status = false;
-                if (CheckTamperAlarms)
+                if (CheckCurrentAlarms)
                 {
 
 //                ReportWithPackageFilter(AlarmFilter,"------------FANS_RPM[Alarm_i]----------------", __FILE__,__LINE__,Alarm_i, RpMessage, value, 0);
@@ -1360,16 +1372,19 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                 }
                 else // alarm off
                 {
+                    ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i);
                     if (AlarmState[Alarm_i].EventPtr)
                     {
                         //ROM_IntMasterDisable();
+                        Save_Alarm_i = Alarm_i;
+                        Save_Alarm_ptr = AlarmState[Alarm_i].EventPtr;
+                        Save_Alarm_Type = AlarmItem[Alarm_i].EventType;
                         my_free(AlarmState[Alarm_i].EventPtr);
                         AlarmState[Alarm_i].EventPtr = NULL;
                         //ROM_IntMasterEnable();
                     }
                     AlarmState[Alarm_i].Status = false;
                     AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info);
-                    ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i);
                 }
             }
         }
@@ -1574,143 +1589,7 @@ uint32_t StopEventsNotificationRequestFunc(MessageContainer* requestContainer)
     my_free(responseContainer.data.data);
     SendChars(container_buffer, container_size);
 
-return OK;
-
-
-/* function :
- * -------------
- * DrawerFansStatus     // uint32_t getDrawerFansStatus(void) 5 fans OK or NotOK
- * SystemFansStatus     // uint32_t getSystemFansStatus(void) 2 fans OK or NotOK
- * Fans_Speed_RPM[MAX_FANS] //
- *
- * Read_Dryer_Fan_Tacho // uint32_t Read_Dryer_Fan_Tacho()
- * Control_Dryer_Fan(bool StartStop, uint8_t PWM_Command_Precent)  //uint32_t Control_Dryer_Fan(bool StartStop, uint8_t PWM_Command_Precent);
- *
- * excell alarm ver9 from Nadav
- * ----------------------------
- * 2009 MACHINE_FANS_RPM_TOO_LOW             Warning
- * 2010 MACHINE_FANS_STOPPED                 Critical
- * 2011 ELECTRICAL_CABINET_FANS_RPM_TOO_LOW  Warning
- * 2012 ELECTRICAL_CABINET_FANS_STOPPED      Critical
- * 4015 DRYER_FAN_RPM_TOO_LOW                Warning
- * 4016 DRYER_FAN_STOPPED                    Critical
- *
- *
- *
- *
-
-
-
-
-    #define MACHINE_FANS_MIN_RPM 1000
-    #define MACHINE_FANS_STOP 0
-    #define ELECTRICAL_CABINET_FANS_MIN_RPM 1000
-    #define ELECTRICAL_CABINET_FANS_STOP 0
-    #define DRYER_FAN_MIN_RPM 1000
-    #define DRYER_FAN_STOP 0
-
-    typedef enum
-    {
-        MACHINE_FANS,
-        ELECTRICAL_CABINET_FANS,
-//        ELECTRICAL_CABINET_FAN_BIG,
-//        ELECTRICAL_CABINET_FAN_SMALL1,
-//        ELECTRICAL_CABINET_FAN_SMALL2,
-//        ELECTRICAL_CABINET_FAN_SMALL3,
-//        ELECTRICAL_CABINET_FAN_SMALL4,
-        DRYER_FAN,
-        NUM_OF_FANS,
-    } Fans_t;
-
-
-    ----- 2009 : -------
-    {eOneSecond,                                             // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    MACHINE_FANS  ,                                         // uint16_t DeviceId;
-    MACHINE_FANS  ,                                         // uint8_t ModuleDeviceId;
-    MACHINE_FANS_MIN_RPM ,                                  // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Warning ,                           // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW                    // EventType EventType;
-    },
-
-    ----- 2010 : -------
-    {eOneSecond,                                             // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    MACHINE_FANS  ,                                         // uint16_t DeviceId;
-    MACHINE_FANS  ,                                         // uint8_t ModuleDeviceId;
-    MACHINE_FANS_STOP ,                                     // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Critical ,                          // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__MACHINE_FANS_STOPPED                        // EventType EventType;
-    },
-
-    ----- 2011 : -------
-    {eOneSecond,                                             // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    ELECTRICAL_CABINET_FANS  ,                              // uint16_t DeviceId;
-    ELECTRICAL_CABINET_FANS  ,                              // uint8_t ModuleDeviceId;
-    ELECTRICAL_CABINET_FANS_MIN_RPM ,                       // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Warning ,                           // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW         // EventType EventType;
-    },
-
-    ----- 2012 : -------
-    {eOneSecond,                                            // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    ELECTRICAL_CABINET_FANS  ,                              // uint16_t DeviceId;
-    ELECTRICAL_CABINET_FANS  ,                              // uint8_t ModuleDeviceId;
-    ELECTRICAL_CABINET_FANS_STOP ,                          // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Critical ,                          // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED             // EventType EventType;
-    },
-
-
-    ----- 2015 : -------
-    {eOneSecond,                                             // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    DRYER_FAN  ,                                            // uint16_t DeviceId;
-    DRYER_FAN  ,                                            // uint8_t ModuleDeviceId;
-    DRYER_FAN_MIN_RPM ,                                     // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Warning ,                           // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW                       // EventType EventType;
-    },
-
-    ----- 2016 : -------
-    {eOneSecond,                                             // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    DRYER_FAN  ,                                            // uint16_t DeviceId;
-    DRYER_FAN  ,                                            // uint8_t ModuleDeviceId;
-    DRYER_FAN_STOP ,                                        // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Critical ,                          // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__DRYER_FAN_STOPPED                           // EventType EventType;
-      },
-
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm,MACHINE_FANS            , MACHINE_FANS           , MACHINE_FANS_MIN_RPM           , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW            },
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm,MACHINE_FANS            , MACHINE_FANS           , MACHINE_FANS_STOP              , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__MACHINE_FANS_STOPPED                },
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_MIN_RPM, FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW },
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_STOP   , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED     },
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_MIN_RPM              , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW               },
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_STOP                 , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__DRYER_FAN_STOPPED                   },
-
-
-* */
+    return OK;
 
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
index 0f73ed4af..be7687f28 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
@@ -8,6 +8,7 @@
 #ifndef MODULES_ALARMHANDLING_ALARMHANDLING_H_
 #define MODULES_ALARMHANDLING_ALARMHANDLING_H_
 #include "StateMachines/Printing/PrintingSTM.h"
+#include  <PMR/Diagnostics/EventType.pb-c.h>
 
 uint32_t AlarmHandlingFlashLoad(void);
 uint32_t AlarmHandlingLoadFile(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 6318de280..76b7aa7a1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -50,7 +50,6 @@
 #include "drivers/Flash_Memory/fatfs/ff.h"
 #include "drivers/Flash_ram/FlashProgram.h"
 
-#include "third_party/fatfs/src/ffconf.h"
 #include "Common/SWUpdate/FileSystem.h"
 
 #include "Communication/Connection.h"
@@ -227,13 +226,18 @@ void OneMilliSecondMillisecInterrupt(UArg arg0)
     return ;
 }
 uint32_t PT100Activity = 0;
+int32_t MillisecReadFromI2CTempSensor(uint32_t TempSensorId,  MSecFptr Callback)
+{
+#warning call I2C temeratures
+    return OK;
+}
+
 int32_t MillisecReadFromTempSensor(uint32_t TempSensorId,  MSecFptr Callback)
 {
     if (TempSensorId >= MAX_MAIN_CARD_TEMP_SENS_ID) return -1;
     PT100Activity++; //read request
     PT100Data[TempSensorId].Callback = Callback;
     PT100Data[TempSensorId].Active = true;
-
     return OK;
 }
 //typedef  uint32_t (* MSecFptr)(uint32_t deviceID, uint32_t ReadValue);
@@ -521,30 +525,77 @@ int MillisecCalculateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId)
 }
 int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId)
 {
+    if (SensorId > WHS_PT100_4_0X82_1)
+        return 0;
     return TemperatureCalc[SensorId];
 }
 bool RapidPressureRead = false;
+float PressureSum[MAX_SYSTEM_DISPENSERS];
+float PressureMin[MAX_SYSTEM_DISPENSERS];
+float PressureMax[MAX_SYSTEM_DISPENSERS];
+float PressureCount[MAX_SYSTEM_DISPENSERS];
+float PressureCalc[MAX_SYSTEM_DISPENSERS];
+void MillisecUpdatePressures (int SensorId,float Pressure)
+{
+   //if(PressureCount[SensorId]++>=10)
+   //    PressureCount[SensorId] = 0;
+    PressureCount[SensorId]++;
+    if (PressureMax[SensorId]<Pressure) PressureMax[SensorId]=Pressure;
+    if (PressureMin[SensorId]>Pressure) PressureMin[SensorId]=Pressure;
+    PressureSum[SensorId]+=Pressure;
+}
+float MillisecCalculatePressures (int SensorId)
+{
+    float calc = 0;
+    PressureSum[SensorId]-=PressureMax[SensorId];
+    PressureSum[SensorId]-=PressureMin[SensorId];
+    calc = PressureSum[SensorId] / (PressureCount[SensorId]-2);
+
+    PressureSum[SensorId] = 0;
+    PressureCount[SensorId] = 0;
+    PressureMin[SensorId] = 30000;
+    PressureMax[SensorId] = -30000;
+    return calc;
+}
+float MillisecGetPressures (int SensorId)
+{
+    if (SensorId > MAX_SYSTEM_DISPENSERS)
+        return 0;
+    return PressureCalc[SensorId];
+}
+
 void setRapidPressureRead(bool value)
 {
     RapidPressureRead = value;
+    if (GetDiagnosticMode() == Diagnostic_Extreme_Mode)
+        RapidPressureRead = true;
 }
 
 uint16_t PumpCounter = 0;
 uint32_t MillisecLowLoop(uint32_t tick)
 {
-    uint8_t Motor_i,Disp_i,Heater_i,temp;
+    uint8_t Motor_i,Disp_i,temp;
     TEMPERATURE_SENSOR_ID_ENUM Sensor_i;
 
     //static int temp=0;
     //call all modules Millisec functions
     //test dancers and speed encoders
     //check all callback units (state machine waiting for completion of a change)
-    bool Ten_msTick, Fifty_msTick, Hundred_msTick , m90msecTick, Onesecond_Tick,O900Millisecond_Tick,OneMinute_Tick,OneHourTick;
+    bool Ten_msTick, Hundred_msTick , m20msecTick,m70msecTick,m90msecTick, Onesecond_Tick,OneMinute_Tick,OneHourTick;
+    bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick;
+    //bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick,O800Millisecond_Tick,O900Millisecond_Tick;
     Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
-    Fifty_msTick      =   (tick%eHundredMillisecond == 0)      ?true:false; //eFiftyMillisecond
     Hundred_msTick  =   (tick%eHundredMillisecond == 0)  ?true:false;
+    m20msecTick  =   (tick%eHundredMillisecond == 20)  ?true:false;
+    m70msecTick  =   (tick%eHundredMillisecond == 70)  ?true:false;
     m90msecTick  =   (tick%eHundredMillisecond == 90)  ?true:false;
-    O900Millisecond_Tick  =   (tick%eOneSecond == 900)           ?true:false;
+    O100Millisecond_Tick  =   (tick%eOneSecond == 100)           ?true:false;
+    O200Millisecond_Tick  =   (tick%eOneSecond == 200)           ?true:false;
+    O400Millisecond_Tick  =   (tick%eOneSecond == 400)           ?true:false;
+    O500Millisecond_Tick  =   (tick%eOneSecond == 500)           ?true:false;
+    O600Millisecond_Tick  =   (tick%eOneSecond == 600)           ?true:false;
+    //O800Millisecond_Tick  =   (tick%eOneSecond == 800)           ?true:false;
+    //O900Millisecond_Tick  =   (tick%eOneSecond == 900)           ?true:false;
     Onesecond_Tick  =   (tick%eOneSecond == 0)           ?true:false;
     OneMinute_Tick  =   (tick%eOneMinute == 0)           ?true:false;
     OneHourTick  =   (tick%eOneHour == 0)           ?true:false;
@@ -561,13 +612,30 @@ uint32_t MillisecLowLoop(uint32_t tick)
         if(Machine_Idle_Mode == true)
             Machine_Idle_Breathing_Led();
     }
-    if(Fifty_msTick)
+#ifdef Use_Head_Card
+    if (m20msecTick) //read odd PT1000
     {
-        Set_HeadCard_PT100();//call every 50mSec (minimum delay 30mSec)
+        for (Sensor_i = HEAD_PT100_ZONE_1_0X80_0;Sensor_i < HEAD_PT100_ZONE_2_0X80_1;Sensor_i++)
+        {
+            MillisecReadFromI2CTempSensor(Sensor_i, NULL);
+        }
+#warning call chip select replace in I2C
     }
+    if (m70msecTick) //read odd PT1000
+    {
+        for (Sensor_i = HEAD_PT100_ZONE_2_0X80_1;Sensor_i < HEAD_PT100_RESERVE_0X8E_1;Sensor_i++)
+        {
+            MillisecReadFromI2CTempSensor(Sensor_i, NULL);
+        }
+    }
+#endif
     if (m90msecTick)
     {
+#ifdef Use_Head_Card
+        for (Sensor_i = TEMP_SENSE_ANALOG_DRYER_TEMP1;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#else
         for (Sensor_i = 0;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#endif
         {
             MillisecReadFromTempSensor(Sensor_i, NULL);
         }
@@ -577,7 +645,11 @@ uint32_t MillisecLowLoop(uint32_t tick)
         Speed_Data = Calculate_Speed_Sensor_Velocity();
         Read_Buttons_Reg();
         //Ink_Cart_Led();
+#ifdef Use_Head_Card
+        for (Sensor_i = TEMP_SENSE_ANALOG_DRYER_TEMP1;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#else
         for (Sensor_i = 0;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#endif
         {
             MillisecUpdateTemperatures (Sensor_i,TemperatureSensorRead(Sensor_i));
         }
@@ -593,37 +665,26 @@ uint32_t MillisecLowLoop(uint32_t tick)
         {
             for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
             {
-                CalculateDispenserPressure(Disp_i);
+                MillisecUpdatePressures(Disp_i, CalculateDispenserPressure(Disp_i));
             }
             ADC_TriggerCollection();
         }
         DispensersCollectionCall();
 
-#ifdef Use_Head_Card
-    Head_Read_IO_Reg(0x46, HIGH);//READ HEAD CARD LS
-#endif
-
     }
-
-    if ((O900Millisecond_Tick)&&(RapidPressureRead == false))
+    if (O100Millisecond_Tick)
     {
-        ADC_TriggerCollection();
+        Trigger_Heater_Current_Read();
     }
-    if (Onesecond_Tick)
+    if (O200Millisecond_Tick)
     {
-        if (RapidPressureRead == false)
-        {
-            for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
-            {
-                CalculateDispenserPressure(Disp_i);
-            }
-        }
         FPGA_GetAllDispensersValveBusyOCD();
         temp = Read_Fans_Tacho();
         DrawerFansStatus = temp & 0x1F;
         SystemFansStatus = temp & 0xE0;
-        MachineUpdateResponseFunc();
-        //KeepAliveOneSecondCall();
+    }
+    if (O400Millisecond_Tick)
+    {
         for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++)
         {
             if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_SCREW)
@@ -631,18 +692,40 @@ uint32_t MillisecLowLoop(uint32_t tick)
             if (isMotorConfigured(Motor_i))
                 MotorGetStatusFromFPGA(Motor_i);
         }
-        if (!(OneMinute_Tick))
+    }
+    if ((O500Millisecond_Tick)&&(RapidPressureRead == false))
+    {
+        ADC_TriggerCollection();
+    }
+    if (O600Millisecond_Tick)
+    {
+        if (RapidPressureRead == false)
         {
-            Trigger_Heater_Current_Read();
-            /*for (Heater_i = 0;Heater_i < NUM_OF_CURRENT_HEATERS;Heater_i++)
+            for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
             {
-                Read_Heaters_Current(Heater_i);
-            }*/
+                CalculateDispenserPressure(Disp_i);
+            }
         }
+    }
+    if (Onesecond_Tick)
+    {
+        MachineUpdateResponseFunc();
+        //KeepAliveOneSecondCall();
+#ifdef Use_Head_Card
+        for (Sensor_i = TEMP_SENSE_ANALOG_DRYER_TEMP1;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#else
         for (Sensor_i = 0;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
+#endif
         {
             TemperatureCalc[Sensor_i] =  MillisecCalculateTemperatures ( Sensor_i);
         }
+        if (RapidPressureRead == true)
+        {
+            for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
+            {
+                PressureCalc[Disp_i] = MillisecCalculatePressures(Disp_i);
+            }
+        }
     }
     if (OneMinute_Tick)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
index 4edc1a8ed..9335a6d08 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
@@ -34,6 +34,7 @@ uint32_t getDrawerFansStatus(void);
 uint32_t getSystemFansStatus(void);
 uint8_t getGasReading(void);
 int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId);
+float MillisecGetPressures (int SensorId);
 void setRapidPressureRead(bool value);
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index 1f5e008d3..b60fb3aa4 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -45,19 +45,27 @@
 //by recieved esign flow of the user from the UI
 ///////////////////////////////////////////////////////////////////////////////////////////
 #include "include.h"
-#include "Modules/General/GeneralHardware.h"
 
 #include <driverlib/timer.h>
 #include <inc/hw_ints.h>
 
+#include  <PMR/Diagnostics/EventType.pb-c.h>
+
 #include "drivers/adc_sampling/adc.h"
+#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
+
 #include "Modules/General/buttons.h"
+#include "Modules/General/GeneralHardware.h"
+
+#include "StateMachines/Printing/PrintingSTM.h"
 
 #include "control.h"
 #include "MillisecTask.h"
-#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
+
+
+
 /******************** Definitions  ********************************************/
-#define MAX_TANGO_CONTROL_DEVICES 100
+#define MAX_TANGO_CONTROL_DEVICES 120
 /******************** STRUCTURES AND ENUMs  ********************************************/
 
 
@@ -169,8 +177,16 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
         ACTIVITY_RED_LED_OFF; // Heaters indication - all the Heaters OFF
         if(FPGA_WD_Occurred == true)
         {
+            FPGA_WD_Occurred = false;
+            AlarmHandlingSetAlarm(EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED,true);
+            JobEndReason = JOB_MOTOR_ALARM;
+            SendJobProgress(0.0,0,false, "Hardware Failure Error");
+            AbortJob("FPGA Watchdog Error");
+            ReportWithPackageFilter(FPGAFilter, "FPGA Watchdog Error",__FILE__,__LINE__,0,RpError, 0,0);
+
             ACTIVITY_GREEN_LED_ON;
-            HWConfigurationInit();
+            FPGA_SetMotorsInit();
+            Motor_ReconfigAllMotors();
         }
 		else
             ACTIVITY_GREEN_LED_OFF;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index 9a81854e6..2911c369a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -128,112 +128,58 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
                 DeActivateCleanerPump();
             break;
         case INTERFACE_IOS__GPO_DRYER_SSR1_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[1] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(1);
             else
                 DeActivateHeater(1);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[1] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DRYER_SSR2_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[2] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(2);
             else
                 DeActivateHeater(2);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[2] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DYEINGH_SSR8_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[3] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(3);
             else
                 DeActivateHeater(3);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[3] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DYEINGH_SSR7_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[4] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(4);
             else
                 DeActivateHeater(4);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[4] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DYEINGH_SSR6_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[5] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(5);
             else
                 DeActivateHeater(5);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[5] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DYEINGH_SSR5_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[6] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(6);
             else
                 DeActivateHeater(6);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[6] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_DILUTORPUMP_SSR10_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[7] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(7);
             else
                 DeActivateHeater(7);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[7] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_EXTWINDER_SSR11_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[8] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(8);
             else
                 DeActivateHeater(8);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[8] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_MIXCHIP_SSR4_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[9] = false;
-#endif
             if (request->value == true)
                 ActivateHeater(9);
             else
                 DeActivateHeater(9);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[9] = true;
-#endif
             break;
         case INTERFACE_IOS__GPO_SPARE_SSR13_CTRL:
             if (request->value == true)
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index ccf5455d4..4c373bb54 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -70,7 +70,7 @@ DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT;
 #define DIAGNOSTICS_LIMIT 3
 #define DIAGNOSTICS_DANCER_LIMIT 30
 int DiagnosticsIndex = 0;
-int DiagnosticCollectionLimit = 2;  //number of data samples to collect before sending to the host
+int DiagnosticCollectionLimit = 3;  //number of data samples to collect before sending to the host
 //int DiagnosticLimit = eHundredMillisecond; //frequency of data collection
 //int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
 int DiagnosticLimit =eHundredMillisecond; //frequency of data collection
@@ -87,15 +87,21 @@ double pollermotor[DIAGNOSTICS_LIMIT+1];
 double windermotor[DIAGNOSTICS_LIMIT+1];
 double screwmotor[DIAGNOSTICS_LIMIT+1];
 double mixertemperature[DIAGNOSTICS_LIMIT+1];
-double headzone1temperature[DIAGNOSTICS_LIMIT+1];
+/*double headzone1temperature[DIAGNOSTICS_LIMIT+1];
 double headzone2temperature[DIAGNOSTICS_LIMIT+1];
 double headzone3temperature[DIAGNOSTICS_LIMIT+1];
 double headzone4temperature[DIAGNOSTICS_LIMIT+1];
 double headzone5temperature[DIAGNOSTICS_LIMIT+1];
 double headzone6temperature[DIAGNOSTICS_LIMIT+1];
+double headzone7temperature[DIAGNOSTICS_LIMIT+1];
+double headzone8temperature[DIAGNOSTICS_LIMIT+1];
+double headzone9temperature[DIAGNOSTICS_LIMIT+1];
+double headzone10temperature[DIAGNOSTICS_LIMIT+1];
+double headzone11temperature[DIAGNOSTICS_LIMIT+1];
+double headzone12temperature[DIAGNOSTICS_LIMIT+1];
 double dryerzone1temperature[DIAGNOSTICS_LIMIT+1];
 double dryerzone2temperature[DIAGNOSTICS_LIMIT+1];
-double dryerzone3temperature[DIAGNOSTICS_LIMIT+1];
+double dryerzone3temperature[DIAGNOSTICS_LIMIT+1];*/
 
 
 double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
@@ -105,6 +111,7 @@ double midtankinklevel[MAX_SYSTEM_DISPENSERS][1];
 double MidTankpressure[MAX_SYSTEM_DISPENSERS][1];
 double HeatersCurrent[NUM_OF_CURRENT_HEATERS][1];
 double VOC_Sensor;
+double OverallTemperature;
 
 DoubleArray DispenserFreq[MAX_SYSTEM_DISPENSERS];
 DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS];
@@ -112,7 +119,7 @@ DoubleArray DispenserInkLevel[MAX_SYSTEM_DISPENSERS];
 DoubleArray DiagnosticsMidTankInkLevel[MAX_SYSTEM_DISPENSERS];
 
 HeaterState **heatersstates;
-HeaterState  HeaterInfo[HEATER_TYPE__MixerHeater+1];
+HeaterState  HeaterInfo[HEATER_TYPE_MAX_HEATERS];
 
 #define NUM_OF_INTERFACE_IOS 21
 DigitalInterfaceState **digitalinterfacestates;
@@ -180,8 +187,8 @@ void DiagnosticsInit(void)
         double_array__init(&DiagnosticsMidTankInkLevel[i]);
         double_array__init(&DispenserInkLevel[i]);
     }
-    heatersstates = (HeaterState**)my_malloc(sizeof(HeaterState *)*(HEATER_TYPE__MixerHeater+1));
-    for(i=0;i<=HEATER_TYPE__MixerHeater;i++)
+    heatersstates = (HeaterState**)my_malloc(sizeof(HeaterState *)*(HEATER_TYPE_MAX_HEATERS));
+    for(i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
     {
         heater_state__init(&HeaterInfo[i]);
         heatersstates[i] = &HeaterInfo[i];
@@ -214,6 +221,11 @@ void SetDiagnosticMode(Diagnostic_Mode Mode)
     DiagnosticMode = Mode;
     REPORT_MSG(Mode,"Diagnostic Mode set");
 }
+Diagnostic_Mode GetDiagnosticMode(void)
+{
+    return DiagnosticMode;
+}
+
 
 void  SetDiagnosticCollectionLimit(int limit)
 {
@@ -221,15 +233,16 @@ void  SetDiagnosticCollectionLimit(int limit)
         DiagnosticCollectionLimit = limit;
     DiagnosticLimit =eHundredMillisecond; //frequency of data collection
 
-    if (DiagnosticMode <= Diagnostic_Normal_Mode)
+    /*if (DiagnosticMode <= Diagnostic_Normal_Mode)
     {
         DiagnosticCollectionLimit = 1;  //overrule - send at least once every second
         DiagnosticLimit =eOneSecond; //frequency of data collection
-    }
+    }*/
+    REPORT_MSG(DiagnosticCollectionLimit,"Diagnostic limit set");
 }
 
-uint8_t HeaterCounterIndex[MAX_HEATERS_NUM]= {0,0,0,0,0,0,0,0,0,0};
-double HeaterTemperature[MAX_HEATERS_NUM][DIAGNOSTICS_LIMIT+1];
+uint8_t HeaterCounterIndex[HEATER_TYPE_MAX_HEATERS]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+double HeaterTemperature[HEATER_TYPE_MAX_HEATERS][DIAGNOSTICS_LIMIT+1];
 uint8_t  DancerCounterIndex[NUM_OF_DANCERS]= {0,0,0};
 double DancerValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT+1];
 int8_t  DancerErrorCounterIndex[NUM_OF_DANCERS]= {0,0,0};
@@ -317,7 +330,7 @@ uint32_t DiagnosticsLoadDigitalValues(void)
 void DiagnosticLoadTemperature(int HeaterId, int temperature)
 {
     double temp = temperature;
-    if (HeaterId >= MAX_HEATERS_NUM)
+    if (HeaterId >= HEATER_TYPE_MAX_HEATERS)
     {
         LOG_ERROR(HeaterId,"wrong Heater Id");
         return;
@@ -342,7 +355,7 @@ void DiagnosticLoadSpeedSensor(float value)
 
 void DiagnosticLoadDancer(int DancerId, uint16_t value)
 {
-    if (DancerId >= MAX_HEATERS_NUM)
+    if (DancerId >= NUM_OF_DANCERS)
     {
         LOG_ERROR(DancerId,"wrong Dancer Id");
         return;
@@ -355,7 +368,7 @@ void DiagnosticLoadDancer(int DancerId, uint16_t value)
 }
 void DiagnosticLoadDancerError(int DancerId, double value)
 {
-    if (DancerId >= MAX_HEATERS_NUM)
+    if (DancerId >= NUM_OF_DANCERS)
     {
         LOG_ERROR(DancerId,"wrong Dancer Id");
         return;
@@ -416,7 +429,8 @@ void DiagnosticOneMinuteCollection(void)
 
     }
     DiagnosticsMonitor.n_overalltemperature = 1;
-    DiagnosticsMonitor.overalltemperature = max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2));
+    OverallTemperature = max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2));
+    DiagnosticsMonitor.overalltemperature = &OverallTemperature;
 
     DiagnosticsMonitor.n_midtank1level = 1;
     DiagnosticsMonitor.midtank1level = MidTankpressure[0];
@@ -488,6 +502,21 @@ void DiagnosticOneMinuteCollection(void)
 void DiagnosticOneSecCollection(void)
 {
     int i;
+#ifdef Use_Head_Card
+    DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone2, MillisecGetTemperatures(HEAD_PT100_ZONE_2_0X80_1));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone3, MillisecGetTemperatures(HEAD_PT100_ZONE_3_0X82_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone4, MillisecGetTemperatures(HEAD_PT100_ZONE_4_0X82_1));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone5, MillisecGetTemperatures(HEAD_PT100_ZONE_5_0X84_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone6, MillisecGetTemperatures(HEAD_PT100_ZONE_6_0X84_1));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone7, MillisecGetTemperatures(HEAD_PT100_ZONE_7_0X86_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone8, MillisecGetTemperatures(HEAD_PT100_ZONE_8_0X86_1));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone9, MillisecGetTemperatures(HEAD_PT100_ZONE_9_0X88_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone10, MillisecGetTemperatures(HEAD_PT100_ZONE_10_0X88_1));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone11, MillisecGetTemperatures(HEAD_PT100_ZONE_11_0X8A_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone12, MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1));
+#else
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
@@ -495,7 +524,7 @@ void DiagnosticOneSecCollection(void)
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
-
+#endif
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP3));
@@ -504,8 +533,9 @@ void DiagnosticOneSecCollection(void)
         dispensermotorfrequency[i][DiagnosticsIndex] = IdsGetMotorSpeed(i);
         //dispensermotorfrequency[i][DiagnosticsIndex] = IDS_Dispenser_Data[i].consumedinnanolitter;
 
-        dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
-
+        if (DiagnosticMode < Diagnostic_Extended_Mode)
+            dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
+        MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
     }
 }
 void Diagnostic100msecCollection(void)
@@ -515,7 +545,7 @@ void Diagnostic100msecCollection(void)
         return;
 
     //DiagnosticLoadSpeedSensor(getSensorSpeedData());
-    if (DiagnosticMode == Diagnostic_Extended_Mode)
+    if (DiagnosticMode != Diagnostic_Extreme_Mode)
         DiagnosticTenMsecCollection(); //call the 10msec function every 100 msec to reduce transport
 
     if (DiagnosticMode >= Diagnostic_Extended_Mode)
@@ -528,32 +558,18 @@ void Diagnostic100msecCollection(void)
             DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
             DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
         }
+        for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
+        {
+            dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
+        }
     }
-    /*
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
-
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP3));
-    for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
+    if (DiagnosticMode == Diagnostic_Extreme_Mode)
     {
-        dispensermotorfrequency[i][DiagnosticsIndex] = IdsGetMotorSpeed(i);
-        //dispensermotorfrequency[i][DiagnosticsIndex] = IDS_Dispenser_Data[i].consumedinnanolitter;
-
-        dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
-        if (midtankDisplay)
-            MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
-        else
-            MidTankpressure[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
+        for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
+        {
+            HeatersCurrent[i][0] = Get_Heaters_Current(i);
+        }
     }
-    */
-
    /*dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
      dispenser2motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2);
      dispenser3motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3);
@@ -577,10 +593,17 @@ void DiagnosticsReset(void)
     SpeedCounterIndex = 0;
     memset(HeaterCounterIndex,0,sizeof(HeaterCounterIndex));
     DiagnosticsIndex = 0;
+    DiagnosticsMonitor.n_dancer1angle =  0;
+    DiagnosticsMonitor.n_dancer2angle =  0;
+    DiagnosticsMonitor.n_dancer3angle =  0;
+    DiagnosticsMonitor.n_windertension =  0;
+    DiagnosticsMonitor.n_pullertension =  0;
+    DiagnosticsMonitor.n_feedertension =  0;
+
 }
 int j=0;
 MessageContainer diagnosticsresponseContainer;
-uint8_t diagnostics_response_buffer[3500];
+uint8_t diagnostics_response_buffer[5500];
 uint8_t *diagnostics_response_ptr = diagnostics_response_buffer;
 char * diagnosticscontainer_buffer=0;
 int LargeMessagesD = 0;
@@ -645,8 +668,8 @@ void SendDiagnostics(void)
         DiagnosticsMonitor.windertension = DancerErrorValue[0];
         DiagnosticsMonitor.pullertension = DancerErrorValue[1];
         DiagnosticsMonitor.feedertension = DancerErrorValue[2];
-        DiagnosticsMonitor.n_threadspeed = SpeedCounterIndex;
-        DiagnosticsMonitor.threadspeed = SpeedValue;
+        //DiagnosticsMonitor.n_threadspeed = SpeedCounterIndex;
+        //DiagnosticsMonitor.threadspeed = SpeedValue;
 
 
         DiagnosticsMonitor.feedermotorfrequency = MotorValue[FEEDER_MOTOR];
@@ -660,27 +683,43 @@ void SendDiagnostics(void)
         DiagnosticsMonitor.n_windermotor =  MotorCounterIndex[WINDER_MOTOR];
         DiagnosticsMonitor.n_screwmotor = MotorCounterIndex[SCREW_MOTOR];
     }
-    DiagnosticsMonitor.mixertemperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__MixerHeater];
-    DiagnosticsMonitor.headzone1temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1];
-    DiagnosticsMonitor.headzone2temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2];
-    DiagnosticsMonitor.headzone3temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3];
-    DiagnosticsMonitor.headzone4temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4];
-    DiagnosticsMonitor.headzone5temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5];
-    DiagnosticsMonitor.headzone6temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6];
-    DiagnosticsMonitor.dryerzone1temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature];
-    DiagnosticsMonitor.dryerzone2temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain];
-    DiagnosticsMonitor.dryerzone3temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary];
+    DiagnosticsMonitor.mixertemperature = HeaterTemperature[HEATER_TYPE__MixerHeater];
+    DiagnosticsMonitor.headzone1temperature = HeaterTemperature[HEATER_TYPE__HeaterZone1];
+    DiagnosticsMonitor.headzone2temperature = HeaterTemperature[HEATER_TYPE__HeaterZone2];
+    DiagnosticsMonitor.headzone3temperature = HeaterTemperature[HEATER_TYPE__HeaterZone3];
+    DiagnosticsMonitor.headzone4temperature = HeaterTemperature[HEATER_TYPE__HeaterZone4];
+    DiagnosticsMonitor.headzone5temperature = HeaterTemperature[HEATER_TYPE__HeaterZone5];
+    DiagnosticsMonitor.headzone6temperature = HeaterTemperature[HEATER_TYPE__HeaterZone6];
+#ifdef Use_Head_Card
+    DiagnosticsMonitor.headzone7temperature = HeaterTemperature[HEATER_TYPE__HeaterZone7];
+    DiagnosticsMonitor.headzone8temperature = HeaterTemperature[HEATER_TYPE__HeaterZone8];
+    DiagnosticsMonitor.headzone9temperature = HeaterTemperature[HEATER_TYPE__HeaterZone9];
+    DiagnosticsMonitor.headzone10temperature = HeaterTemperature[HEATER_TYPE__HeaterZone10];
+    DiagnosticsMonitor.headzone11temperature = HeaterTemperature[HEATER_TYPE__HeaterZone11];
+    DiagnosticsMonitor.headzone12temperature = HeaterTemperature[HEATER_TYPE__HeaterZone12];
+#endif
+    DiagnosticsMonitor.dryerzone1temperature = HeaterTemperature[HEATER_TYPE__DryerAirHeater];
+    DiagnosticsMonitor.dryerzone2temperature = HeaterTemperature[HEATER_TYPE__DryerMainHeater];
+    DiagnosticsMonitor.dryerzone3temperature = HeaterTemperature[HEATER_TYPE__DryerSecondaryHeater];
 
-    DiagnosticsMonitor.n_mixertemperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__MixerHeater];
-    DiagnosticsMonitor.n_headzone1temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1];
-    DiagnosticsMonitor.n_headzone2temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2];
-    DiagnosticsMonitor.n_headzone3temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3];
-    DiagnosticsMonitor.n_headzone4temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4];
-    DiagnosticsMonitor.n_headzone5temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5];
-    DiagnosticsMonitor.n_headzone6temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6];
-    DiagnosticsMonitor.n_dryerzone1temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature];
-    DiagnosticsMonitor.n_dryerzone2temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain];
-    DiagnosticsMonitor.n_dryerzone3temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary];
+    DiagnosticsMonitor.n_mixertemperature = HeaterCounterIndex[HEATER_TYPE__MixerHeater];
+    DiagnosticsMonitor.n_headzone1temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone1];
+    DiagnosticsMonitor.n_headzone2temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone2];
+    DiagnosticsMonitor.n_headzone3temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone3];
+    DiagnosticsMonitor.n_headzone4temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone4];
+    DiagnosticsMonitor.n_headzone5temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone5];
+    DiagnosticsMonitor.n_headzone6temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone6];
+#ifdef Use_Head_Card
+    DiagnosticsMonitor.n_headzone7temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone7];
+    DiagnosticsMonitor.n_headzone8temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone8];
+    DiagnosticsMonitor.n_headzone9temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone9];
+    DiagnosticsMonitor.n_headzone10temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone10];
+    DiagnosticsMonitor.n_headzone11temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone11];
+    DiagnosticsMonitor.n_headzone12temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone12];
+#endif
+    DiagnosticsMonitor.n_dryerzone1temperature = HeaterCounterIndex[HEATER_TYPE__DryerAirHeater];
+    DiagnosticsMonitor.n_dryerzone2temperature = HeaterCounterIndex[HEATER_TYPE__DryerMainHeater];
+    DiagnosticsMonitor.n_dryerzone3temperature = HeaterCounterIndex[HEATER_TYPE__DryerSecondaryHeater];
     DiagnosticsMonitor.n_blowervoltage = 1;
     diagvoltage = getBlowerState();
     DiagnosticsMonitor.blowervoltage = &diagvoltage;
@@ -719,7 +758,6 @@ void SendDiagnostics(void)
             DiagnosticsMonitor.dispenserspressure[i] = &DiagnosticsDispenserPressure[i];
         }
     }
-
     /**/
     DiagnosticsMonitor.n_dispenserslinearpositions = 0;
     DiagnosticsMonitor.n_dispensersangularencoders = 0;
@@ -742,6 +780,43 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.dispenser8pressure = dispenserspressure[7];
 
 
+    DiagnosticsMonitor.n_midtank1level = 1;
+    DiagnosticsMonitor.midtank1level = MidTankpressure[0];
+    DiagnosticsMonitor.n_midtank2level = 1;
+    DiagnosticsMonitor.midtank2level = MidTankpressure[1];
+    DiagnosticsMonitor.n_midtank3level = 1;
+    DiagnosticsMonitor.midtank3level = MidTankpressure[2];
+    DiagnosticsMonitor.n_midtank4level = 1;
+    DiagnosticsMonitor.midtank4level = MidTankpressure[3];
+    DiagnosticsMonitor.n_midtank5level = 1;
+    DiagnosticsMonitor.midtank5level = MidTankpressure[4];
+    DiagnosticsMonitor.n_midtank6level = 1;
+    DiagnosticsMonitor.midtank6level = MidTankpressure[5];
+    DiagnosticsMonitor.n_midtank7level = 1;
+    DiagnosticsMonitor.midtank7level = MidTankpressure[6];
+    DiagnosticsMonitor.n_midtank8level = 1;
+    DiagnosticsMonitor.midtank8level = MidTankpressure[7];
+
+    DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
+    DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
+    DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
+    DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];
+    DiagnosticsMonitor.n_mixer1heatercurrent = 1;
+    DiagnosticsMonitor.mixer1heatercurrent = HeatersCurrent[HEATER_MIXCHIP_CURRENT];
+    DiagnosticsMonitor.n_headzone1heatercurrent = 1;
+    DiagnosticsMonitor.headzone1heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_1];
+    DiagnosticsMonitor.n_headzone2heatercurrent = 1;
+    DiagnosticsMonitor.headzone2heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_2];
+    DiagnosticsMonitor.n_headzone3heatercurrent = 1;
+    DiagnosticsMonitor.headzone3heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_3];
+    DiagnosticsMonitor.n_headzone4heatercurrent = 1;
+    DiagnosticsMonitor.headzone4heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_4];
+    DiagnosticsMonitor.n_headzone5_6heatercurrent = 1;
+    DiagnosticsMonitor.headzone5_6heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6];
+
+    VOC_Sensor = (double) getGasReading();
+    DiagnosticsMonitor.n_filterdeltapressure = 1;
+    DiagnosticsMonitor.filterdeltapressure = &VOC_Sensor;
 
     response.monitors = &DiagnosticsMonitor;
     //response.digitalpins = DigitalPinArray;
@@ -750,12 +825,20 @@ void SendDiagnostics(void)
     response.n_digitalinterfacestates = DiagnosticsLoadDigitalValues();
     response.digitalinterfacestates = digitalinterfacestates;
 
-    for (i=HEATER_TYPE__DryerAirHeater;i<=HEATER_TYPE__MixerHeater;i++)
+#ifdef Use_Head_Card
+    for (i=HEATER_TYPE__DryerAirHeater;i<HEATER_TYPE_MAX_HEATERS;i++)
+#else
+	for (i=HEATER_TYPE__DryerAirHeater;i<MAX_HEATERS_NUM;i++)
+#endif
     {
         LoadHeaterState((HeaterType)i,&HeaterInfo[i]);
         //heatersstates[i] = &HeaterInfo[i];
     }
-    response.n_heatersstates = HEATER_TYPE__MixerHeater+1;
+#ifdef Use_Head_Card
+    response.n_heatersstates = HEATER_TYPE_MAX_HEATERS;
+#else
+    response.n_heatersstates = MAX_HEATERS_NUM;
+#endif
     response.heatersstates = heatersstates;
 
 
@@ -805,26 +888,6 @@ void SendDiagnostics(void)
         DiagnosticsStop();
     }
     DiagnosticsReset();
-/*    DiagnosticsMonitor.n_drierzone1heatercurrent = 0;
-    DiagnosticsMonitor.n_drierzone2heatercurrent = 0;
-    DiagnosticsMonitor.n_mixer1heatercurrent = 0;
-    DiagnosticsMonitor.n_headzone1heatercurrent = 0;
-    DiagnosticsMonitor.n_headzone2heatercurrent = 0;
-    DiagnosticsMonitor.n_headzone3heatercurrent = 0;
-    DiagnosticsMonitor.n_headzone4heatercurrent = 0;
-    DiagnosticsMonitor.n_headzone5_6heatercurrent = 0;
-    DiagnosticsMonitor.n_filterdeltapressure = 0;
-    DiagnosticsMonitor.n_midtank1level = 0;
-    DiagnosticsMonitor.n_midtank2level = 0;
-    DiagnosticsMonitor.n_midtank3level = 0;
-    DiagnosticsMonitor.n_midtank4level = 0;
-    DiagnosticsMonitor.n_midtank5level = 0;
-    DiagnosticsMonitor.n_midtank6level = 0;
-    DiagnosticsMonitor.n_midtank7level = 0;
-    DiagnosticsMonitor.n_midtank8level = 0;
-    DiagnosticsMonitor.n_dispensersinklevel = 0;
-    DiagnosticsMonitor.n_midtanksinklevel = 0;
-*/
 }
 uint32_t DiagnosticsControlId = 0xff;
 uint32_t Diagnostics10MSControlId = 0xff;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
index d6d515598..69482d7a0 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
@@ -23,6 +23,8 @@ typedef enum
 }Diagnostic_Mode;
 
 void SetDiagnosticMode(Diagnostic_Mode Mode);
+Diagnostic_Mode GetDiagnosticMode(void);
+
 uint32_t StartDiagnosticsRequestFunc(MessageContainer* requestContainer);
 uint32_t StopDiagnosticsRequestFunc(MessageContainer* requestContainer);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 38f9b73ba..05a2196ce 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -45,7 +45,7 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
 
     responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
-    responseContainer.continuous = true;
+    responseContainer.continuous = false;
     uint8_t* 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);
@@ -141,7 +141,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
     responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
     responseContainer.errormessage = "Job Active or incorrect motor ID";
     responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse,  requestContainer->token, true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
-    responseContainer.continuous = true;
+    responseContainer.continuous = false;
     uint8_t* 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);
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
index 4ea029610..e2eb264a7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
@@ -174,6 +174,9 @@ uint32_t DispenserJoggingRequestFunc(MessageContainer* requestContainer)
             MotorSetDirection(MotorId,direction);
             MotorSetSpeed(MotorId, speed);
             CurrentDispenserSpeed[request->index] = speed;
+            if(request->direction == MOTOR_DIRECTION__Backward)
+                CurrentDispenserSpeed[request->index] *= (-1);
+
         }
         else
         {
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 7e46d9342..5f2046c3e 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -18,13 +18,8 @@
 
 #include "heaters/heaters_ex.h"
 
-//#include "third_party/fatfs/src/ffconf.h"
-//#include "third_party/fatfs/src/diskio.h"
-//#include "drivers/Flash_Memory/Flash_Memory.h"
-//#include "drivers/Flash_Memory/fatfs/ff.h"
 #include "drivers/Flash_ram/FlashProgram.h"
 
-#include "third_party/fatfs/src/ffconf.h"
 #include "Common/SWUpdate/FileSystem.h"
 
 #include "PMR/common/MessageContainer.pb-c.h"
@@ -54,7 +49,7 @@
 #include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h"
 #include <Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h>
 #include "Modules/General/buttons.h"
-
+#include "Modules/Waste/Waste.h"
 #include "Drivers/I2C_Communication/Main_Board_EEPROM/Main_EEPROM.h"
 
 
@@ -129,6 +124,7 @@ uint32_t HWConfigurationInit(void)
     //UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer);
     if (UploadRequest)
     {
+        AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE,OFF);
         status = HWConfiguration(UploadRequest);
         if (status !=OK)
         {
@@ -142,6 +138,10 @@ uint32_t HWConfigurationInit(void)
         }
         upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
     }
+    else
+    {
+        AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE,ON);
+    }
     if (buffer)
         free (buffer);
 
@@ -153,6 +153,10 @@ uint32_t HWConfigurationInit(void)
 
     ADC_MUX_Init();
     GeneralHwReady = true;
+
+    //I2C_NFC_Test();
+    //RFID_Test();
+
     return status;
 }
 
@@ -167,7 +171,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             configuration_parameters__init(EmbeddedParameters);
             EmbeddedParameters->breaksensorlimit = 10;
             EmbeddedParameters->has_diagnosticcollectionlimit = true;
-            EmbeddedParameters->diagnosticcollectionlimit = 1;
+            EmbeddedParameters->diagnosticcollectionlimit = 3;
             EmbeddedParameters->has_overheatcountlimit = true;
             EmbeddedParameters->overheatcountlimit = 3;
             EmbeddedParameters->has_underheatcountlimit = true;
@@ -421,7 +425,7 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
 
         for (PID_i = 0; PID_i < request->n_pidcontrols ; PID_i++)
         {
-            if (request->pidcontrols[PID_i]->hardwarepidcontroltype <= HARDWARE_PID_CONTROL_TYPE__MixerHeater)
+            if (isHeater(request->pidcontrols[PID_i]->hardwarepidcontroltype))
                 status += HeaterConfigRequestMessage(request->pidcontrols[PID_i]);
             else if ((request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__MotorDryer)&&
                     (request->pidcontrols[PID_i]->hardwarepidcontroltype < HARDWARE_PID_CONTROL_TYPE__Dispenser1))
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
index e1a516e95..157841365 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
@@ -24,7 +24,7 @@
 #include "drivers/Motors/Motor.h"
 
 #include "Modules/General/MachineStatus.h"
-
+#include "Modules/Control/MillisecTask.h"
 #include "modules/ids/ids_ex.h"
 
 MachineState StoredMachineStatus = MACHINE_STATE__Ready;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
index 6868cfda1..22af2b07e 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
@@ -44,12 +44,6 @@ int thredJog();
 #define SECOND2 (2000/BUTTONS_SAMPLE_TIME)
 #define SECOND5 (5000/BUTTONS_SAMPLE_TIME)
 
-//enum PBstat OnOffPBstate = OFFPB;
-//enum PBstat ret
-//enum PBstat threadPB = OFFPB;
-
-
-
 button power, jog, load, cart1, cart2, cart3;
 uint32_t ButtonPowerCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue);
@@ -60,8 +54,6 @@ uint32_t StateMachine( button *pBtn);
 uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint8_t  thraedJogging(uint8_t off);
-//uint32_t setJoggingEnableCondition( button *pBtn);
-uint32_t joggingMachine(  button *pBtn);    //uint8_t OnOffPB,
 
 
 uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
@@ -69,12 +61,6 @@ uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t LoadStatMachine( button *pBtn);
 uint32_t LoadLongPress( button *pBtn);
 bool get_pbAction ( button *pBtn, PB_Status ReadValue);
-/*
-void Power_Reset();
-uint8_t Buttons_LEDS(BUTTON Button, OPERATION_MODE LED_Mode);
-uint8_t Buzzer(OPERATION_MODE Buzzer_Mode);
-bool Read_PWR_Button();//TODO move to GPIO folder
-*/
 
 #define LOADLONGPRESS 3
 
@@ -138,34 +124,53 @@ bool SetPowerMachineState(PBmachineState state)
  */
 bool get_pbAction (button *pBtn, PB_Status ReadValue )
 {
-    if ((pBtn->bttn_status == RELEASE) && ( ReadValue ==  PRESS))
-    {
- //       load.bttn_status = PRESS;
-        load.count = 1 ;
-    }
-    else
+    pBtn->bttn_status = ReadValue;
+    switch (pBtn->Action)
     {
-        load.Action = OFFPB;
-        if ((pBtn->bttn_status == PRESS) && ( ReadValue == PRESS ) && (pBtn->count > 0 ))
-        {
-            pBtn->count ++ ;
-            if (pBtn->count > SECOND5)
+        case OFFPB:
+            if (ReadValue == PRESS)
+            {
+                pBtn->count = 1 ;
+                pBtn->Action = COUNTPB;
+            }
+            else
             {
                 pBtn->count = 0 ;
-                pBtn->Action = LONGPB;
+                pBtn->Action = OFFPB;
             }
-        }
-        else if ((pBtn->bttn_status == PRESS) && ( ReadValue == RELEASE ) && (pBtn->count > 0 ))
-        {
-//            load.bttn_status = RELEASE;
-            pBtn->count = 0 ;
-            pBtn->Action = SHORTPB;
-        }
+            break;
+        case COUNTPB:
+            if (ReadValue == PRESS)
+            {
+                pBtn->count += 1 ;
+                if (pBtn->count > SECOND5)
+                {
+                    pBtn->Action = LONGPB;
+                }
+            }
+            else
+            {
+                pBtn->count = 0 ;
+                pBtn->Action = SHORTPB;
+            }
+            break;
+        case SHORTPB:
+            pBtn->Action = OFFPB;
+            break ;
+        case LONGPB:
+            if (ReadValue == RELEASE)
+            {
+                pBtn->count = 0 ;
+                pBtn->Action = OFFPB;
+            }
+            break ;
+        default:
+            break;
     }
-    pBtn->bttn_status = ReadValue;
-return OK;
+    return OK;
 }
 
+
 /*
  * read GPIO status
  * port: GPIO_PORTN_BASE
@@ -176,23 +181,16 @@ return OK;
 uint32_t ButtonPowerCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
    return Read_PWR_Button();
-   /*
-    *
-     if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7))
-       return 0x00;
-   else
-       return 0x01;
-    */
 }
 
 uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
-    return Get_Thread_Jogging_Button();
-//
-//    if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7))
-//       return 0x00;
-//   else
-//       return 0x01;
+    if (jog.state != sttDISABLE)
+    {
+        ReadValue = Get_Thread_Jogging_Button();
+        get_pbAction (  &jog, ReadValue );
+    }
+    return ReadValue;
 }
 
 uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
@@ -244,18 +242,89 @@ uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     return 0;
 }
 
+
+/*ButtonJogCBFunction()
+ * state machine for thread jogging button:
+ * 1. OFF - when the machine is working
+ * 2. blue - when the machin is not workig so we can jog thread
+ * 3. blink - when pushing the JOG button
+ *            when pushing the JOG more the 5 second
+ *
+ */
 uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
-    jog.bttn_status = ReadValue;
-    //if (ReadValue == PRESS)
+    switch (jog.state)
     {
-        //setJoggingEnableCondition(&jog);
-        joggingMachine(&jog);
+        case sttDISABLE:
+           if (JobIsActive() == false)
+           {
+               jog.color =  colorON;
+               Pannel_Leds(THREAD_JOGGING, MODE_ON);
+               jog.state = sttENABLE;
+           }
+           break;
+        case sttENABLE:
+            if (jog.Action == COUNTPB)
+            {
+                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is sttENABLE and  PRESS-----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);    jog.state = sttJOGGING;
+                jog.color =  colorON;
+                jog.color =  BLINK;
+                ThreadJoggingFunc(40);
+                jog.state = sttJOGGING;
+            }
+            else
+            {
+                if (JobIsActive() == true)
+                {
+                     ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is Disable -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+                     jog.Action = OFFPB;
+                     jog.color =  colorOFF;
+                     Pannel_Leds(THREAD_JOGGING,MODE_OFF);
+                     jog.state = sttDISABLE;
+                }
+            }
+            break;
+        case sttJOGGING:
+            if (jog.Action == SHORTPB) //PB is OFF
+            {
+                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttJOGGING action->SHORTPB-----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);    jog.state = sttJOGGING;
+                ThreadAbortJoggingFunc(); 
+                jog.color =  colorON;
+                Pannel_Leds(THREAD_JOGGING, MODE_ON);
+                jog.state = sttENABLE;
+            }
+            else if (jog.Action == LONGPB)
+            {
+                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttJOGGING action->LONGPB-----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);    jog.state = sttJOGGING;
+                jog.state = sttLONG_JOGGING;
+                if (JobIsActive() == false) // added because sometimes the jog stops because of another reason and the button s stucked blinking
+                {
+                    jog.color =  colorON;
+                    Pannel_Leds(THREAD_JOGGING, MODE_ON);
+                    jog.state = sttENABLE;
+                }
+
+            }
+            break;
+        case sttLONG_JOGGING:
+             if (jog.Action == COUNTPB)
+             {
+                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttLONG_JOGGING action->COUNTPB-----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);    jog.state = sttJOGGING;ThreadAbortJoggingFunc(); // to do!!!!
+                ThreadAbortJoggingFunc();
+                jog.color =  colorON;
+                Pannel_Leds(THREAD_JOGGING, MODE_ON);
+                jog.state = sttENABLE;
+             }
+            break;
+        default:
+            break;
     }
     return OK;
 }
 
 
+
+
 uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
    switch (load.Action)
@@ -447,138 +516,6 @@ return OK;
 }
 
 
-
-
-
-    /*-----------------------------------------------------------------------------------*/
-
-
- /* int rdJoggingEnableCondition()
- * read if we can enabl the thraed jogging
- *
- *  return 0 or 1
- *  disable OFF(0) - the machine is working now you cannot jogging the thread.
- *  enable ON(1) - joggin thread is enable
- */
-
-
-
-//uint32_t    setJoggingEnableCondition( button *pBtn)
-//{
-//    uint8_t parameter = 3;
-//
-//    if (0
-////         to do : what are the conditions for enable / disable
-////            1.
-////            2.
-////            3.
-////            ...
-//            )
-//        {
-//            pBtn->state = sttDISABLE;
-//            REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition  sttDISABLE  ----------------- ");
-//            pBtn->color = colorOFF;
-//            Pannel_Leds(THREAD_JOGGING, MODE_OFF); //AVI+
-//        //    ThreadAbortJoggingFunc();
-//        }
-//
-//    else
-//    {
-//        pBtn->state = sttENABLE;
-////        REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition  sttENABLE  ----------------- ");
-//        pBtn->color = BLUE;
-//        Pannel_Leds(THREAD_JOGGING, MODE_ON); //AVI+
-//        //ThreadJoggingFunc(40);
-//    }
-//
-//return 0;
-//}
-
-
-
-
-
-/*int joggingMachine()
- * state machine for thread jogging button:
- * 1. OFF - when the machine is working
- * 2. blue - when the machin is not workig so we can jog thread
- * 3. blink - when pushing the jog thread button and jogigthread
- *
- */
-
-
-uint32_t joggingMachine(  button *pBtn) //uint8_t OnOffPB,
-{
-
-//    uint8_t parameter = 4;
-
-    if (sttDISABLE == pBtn->state)
-    {
-        // jogging is disable
-        ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is Disable -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-        pBtn->Action = OFFPB;
-        pBtn->color =  colorOFF;
-        Pannel_Leds(THREAD_JOGGING,MODE_OFF);//AVI+
-    }
-    else
-    {
-        if ( (pBtn->Action != OFFPB) && (pBtn->bttn_status == RELEASE))
-        {
-            ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine:  Jogging OnOffPB == 0 -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-            ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: stop Jogging -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-            pBtn->Action = OFFPB;
-            ThreadAbortJoggingFunc(); // to do!!!!
-            pBtn->color =  colorON;
-            Pannel_Leds(THREAD_JOGGING, MODE_ON);//AVI+
-        }
-        else if ((pBtn->Action == OFFPB) && (pBtn->bttn_status == PRESS))
-        {
-            pBtn->Action = LONGPB;
-            ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging OnOffPB == 1 -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-            ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: start Jogging -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-            pBtn->color =  BLINK;
-            ThreadJoggingFunc(40);
-        }
-//        if (pBtn->bttn_status == press)ThreadJoggingFunc(40);
-//        else
-//        {
-//            pBtn->Action = OFFPB;
-//            REPORT_MSG(parameter," ??????????????????? joggingMachine: start Jogging    ???????????????????");
-//        }
-    }
-
-
-
-//        if (OnOffPB == release)
-//        {
-//            REPORT_MSG(parameter," ------------joggingMachine:  Jogging OnOffPB == 00----------------- ");
-//            REPORT_MSG(parameter," ------------joggingMachine: stop Jogging    ----------------- ");
-//            pBtn->Action = OFFPB;
-//            ThreadAbortJoggingFunc(); // to do!!!!
-//            pBtn->color =  BLUE;
-//            Pannel_Leds(THREAD_JOGGING, MODE_ON);//AVI+
-//        }
-//        else
-//        {
-//            if (pBtn->Action == OFFPB)
-//            {
-//                pBtn->Action = LONGPB;
-//                REPORT_MSG(parameter," ------------joggingMachine: Jogging OnOffPB == 1   ----------------- ");
-//                REPORT_MSG(parameter," ------------joggingMachine: start Jogging    ----------------- ");
-//                pBtn->color =  BLINK;
-//                ThreadJoggingFunc(40);
-//            }
-//            else
-//            {
-//                REPORT_MSG(parameter," ??????????????????? joggingMachine: start Jogging    ???????????????????");
-//            }
-//
-//        }
-//    }
-return OK;
-}
-
-
 /*------------------------------------------------------------------------------*/
 
 /*------     THREAD LOAD/UNLOAD        ----------*/
@@ -599,7 +536,7 @@ uint32_t LoadStatMachine( button *pBtn)
                 case (REPLONGPB):
                     pBtn->state = sttPRELOAD;
                     pBtn->color =  BLINK;*/
-                    if (ThreadLoadButton( THREAD_LOAD_INIT) == OK)
+                    if (ThreadLoadButton( THREAD_LOAD_INIT)== OK)
                     {
                         pBtn->state = sttPRELOAD ;    // to do
                         pBtn->color =  colorON;
@@ -624,7 +561,7 @@ uint32_t LoadStatMachine( button *pBtn)
                 case (REPLONGPB):
                     pBtn->color =  BLUE;
                     Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+*/
-                    if (ThreadLoadButton( THREAD_LOAD_INITIAL_TENSION) == OK)
+                    if (ThreadLoadButton( THREAD_LOAD_INITIAL_TENSION)== OK)
                     {
                         pBtn->state = sttRDY ;    // to do
                         pBtn->color =  colorON;
@@ -644,7 +581,7 @@ uint32_t LoadStatMachine( button *pBtn)
             ReportWithPackageFilter(GeneralFilter,"------------ load.state = sttLOADING -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
             pBtn->color =  fastBILNK;
             Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
-            if (ThreadLoadButton( THREAD_LOAD_END) == OK)
+            if (ThreadLoadButton( THREAD_LOAD_END)== OK)
             {
                 pBtn->state = sttRDY ;    // to do
                 pBtn->color =  colorON;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
index f7dbbb25f..646861bc7 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
@@ -34,6 +34,7 @@ typedef enum
     sttDISABLE,
     sttENABLE,
     sttJOGGING,
+    sttLONG_JOGGING,
 
     sttRDY,
     sttPRELOAD,
@@ -44,10 +45,10 @@ typedef enum
 
 typedef struct Button
 {
-    char    bttn_name[10];  //option
-    int     bttn_status;    // 0=RELEASE 1=PRESS
-    PBstat  Action;         // enum : offPB,shortPB,longPB,countPB,replongPB
-    PBcolor color;          // enum : off, blue, blink, bithing
+    char        bttn_name[10];  //option
+    PB_Status   bttn_status;    // 0=RELEASE 1=PRESS
+    PBstat      Action;         // enum : offPB,shortPB,longPB,countPB,replongPB
+    PBcolor     color;          // enum : off, blue, blink, bithing
     PBmachineState state;    // enum : sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING
     uint32_t count;
 }button;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index d7de5797d..4305fac0e 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -20,7 +20,6 @@
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 
 #include "modules/ids/ids_ex.h"
-#include "third_party/fatfs/src/ffconf.h"
 #include "Common/SWUpdate/FileSystem.h"
 #include "StateMachines/Initialization/PowerIdle.h"
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
index b25c3e5c7..05425cc45 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
@@ -4,6 +4,7 @@
 #include "PMR/Hardware/HardwarePidControl.pb-c.h"
 #include "PMR/Hardware/HardwarePidControlType.pb-c.h"
 #include "heaters_ex.h"
+#include "Drivers/Heater/Heater.h"
 /******************** DEFINITIONS  ********************************************/
 #define MAX_AC_HEATERS (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1)
 #define MAX_TIMESLICES 200
@@ -12,7 +13,7 @@ extern uint32_t OutputProportionalSingleStep;  //A/C Heaters step size from one
 extern uint32_t OutputProportionalCycleTime; //A/C Heaters Cycle time in milliseconds - one for all heaters
 //extern uint32_t Heater_timerBase;        //Timer handle
 extern char     TimeSliceAllocation[MAX_TIMESLICES];
-extern int     DCTimeSliceAllocation[MAX_HEATERS_NUM];
+extern int     DCTimeSliceAllocation[HEATER_TYPE_MAX_HEATERS];
 extern int      NumberOFSlicesInUse;
 extern uint32_t MillisecondsPerChange;
 
@@ -48,13 +49,13 @@ typedef struct  HeaterCommandstruc
 }HeaterCommand;
 
 
-extern HeaterPIDControlConfig HeaterControl[MAX_HEATERS_NUM];
-extern HeaterCommand          HeaterCmd[MAX_HEATERS_NUM];
+extern HeaterPIDControlConfig HeaterControl[HEATER_TYPE_MAX_HEATERS];
+extern HeaterCommand          HeaterCmd[HEATER_TYPE_MAX_HEATERS];
 extern uint32_t  Heater_timerBase;
 
 uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_outputproportionalpowerlimit);
 uint32_t HeaterRecalculateHeaterParams(uint32_t deviceId, uint32_t new_outputproportionalpowerlimit);
 
-uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId);
+uint32_t HeatersSingleHeaterEnd(int HeaterId);
 
 #endif
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index 0b65d9e5e..bcc19bd6f 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -1,10 +1,17 @@
+#include "Drivers/Heater/Heater.h"
+
 #include "PMR/common/MessageContainer.pb-c.h"
 #include "PMR/Hardware/HardwarePidControl.pb-c.h"
 #include "PMR/Diagnostics/HeaterType.pb-c.h"
 #include "PMR/Diagnostics/HeaterState.pb-c.h"
+#include "PMR/Diagnostics/EventType.pb-c.h"
 
 #define MAX_HEATERS_NUM  HARDWARE_PID_CONTROL_TYPE__MixerHeater+1
 
+extern EventType HeaterEventType[HEATER_TYPE_MAX_HEATERS];
+extern EventType HeaterUnderEventType[HEATER_TYPE_MAX_HEATERS];
+extern EventType HeaterUnderEventType_B[HEATER_TYPE_MAX_HEATERS];
+
 //uint32_t HeaterCommandRequestMessage(MessageContainer* requestContainer);
 uint32_t HeaterConfigRequestMessage(HardwarePidControl* request);
 uint32_t HeaterConfigSetSharedHeatersParams (uint32_t outputproportionalcycletime, uint32_t outputproportionalsinglestep);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
index 273c497bd..d7fc0703a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
@@ -45,7 +45,7 @@ typedef enum {
 }HEATERS_EVENTS_ENUM;
 */
 /******************** GLOBAL PARAMETERS  ********************************************/
-HeaterPIDControlConfig HeaterControl[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0,0,0};
+HeaterPIDControlConfig HeaterControl[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0};
 bool AcHeaterConfigured[MAX_AC_HEATERS] = {0,0,0};
 
 int      NumberOFSlicesInUse = 0;
@@ -69,7 +69,11 @@ uint32_t Heaters_Init(void)
     FPGA_SensorInitConfig();
 
     memset(HeaterControl,0,sizeof(HeaterControl));
+#ifdef Use_Head_Card
+    for (i = 0;i<HEATER_TYPE_MAX_HEATERS; i++)
+#else
     for (i = 0;i<MAX_HEATERS_NUM; i++)
+#endif
         DeActivateHeater(i);
     return OK;
 }
@@ -82,10 +86,10 @@ uint32_t HeaterConfigRequestMessage(HardwarePidControl* request)
     //uint32_t status = OK;
     HardwarePidControlType HeaterId;
 
-    HeaterId = request->hardwarepidcontroltype;
+    HeaterId = getHeaterId(request->hardwarepidcontroltype);
     //int ValidationError = 0;
 
-    if (HeaterId< MAX_HEATERS_NUM)
+    if (HeaterId< HEATER_TYPE_MAX_HEATERS)
     {
         HeaterControl[HeaterId].configured = true;
         HeaterControl[HeaterId].id = HeaterId;
@@ -95,10 +99,10 @@ uint32_t HeaterConfigRequestMessage(HardwarePidControl* request)
         HeaterControl[HeaterId].ProportionalErrorMultiplier = request->outputonoffhysteresisvalue;
         if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature)
         {
-            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].sensormaxvalue = request->sensormaxvalue*100;
-            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].sensorminvalue = request->sensorminvalue*100;
-            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].sensormaxvalue = request->sensormaxvalue*100;
-            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].sensorminvalue = request->sensorminvalue*100;
+            HeaterControl[HEATER_TYPE__DryerMainHeater].sensormaxvalue = request->sensormaxvalue*100;
+            HeaterControl[HEATER_TYPE__DryerMainHeater].sensorminvalue = request->sensorminvalue*100;
+            HeaterControl[HEATER_TYPE__DryerSecondaryHeater].sensormaxvalue = request->sensormaxvalue*100;
+            HeaterControl[HEATER_TYPE__DryerSecondaryHeater].sensorminvalue = request->sensorminvalue*100;
         }
         HeaterControl[HeaterId].sensormaxvalue = 0;
         HeaterControl[HeaterId].sensorminvalue = 0;
@@ -157,8 +161,8 @@ uint32_t HeaterConfigSetSharedHeatersParams(uint32_t outputproportionalcycletime
    }
 
    // all numbers are rounded down. better to have carefully calculated numbers
-   Heater1000Slices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
-   Heater200aSlices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater1000Slices = HeaterControl[HEATER_TYPE__DryerMainHeater].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater200aSlices = HeaterControl[HEATER_TYPE__DryerSecondaryHeater].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
 
    if ((Heater1000Slices + Heater200aSlices +2)>NumberOFSlicesInUse)
    {
@@ -168,8 +172,8 @@ uint32_t HeaterConfigSetSharedHeatersParams(uint32_t outputproportionalcycletime
 
    //mark the time slices  for heaters operation as empty / Heater1000 / Heater 200
    memset (TimeSliceAllocation,0xFF,sizeof(TimeSliceAllocation));
-   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain;
-   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary;
+   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HEATER_TYPE__DryerMainHeater;
+   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HEATER_TYPE__DryerSecondaryHeater;
 
    return OK;
 
@@ -193,8 +197,8 @@ uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_ou
 
    // all numbers are rounded down. better to have carefully calculated numbers
    HeaterControl[deviceId].outputproportionalpowerlimit = new_outputproportionalpowerlimit;///100;
-   Heater1000Slices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
-   Heater200aSlices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater1000Slices = HeaterControl[HEATER_TYPE__DryerMainHeater].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater200aSlices = HeaterControl[HEATER_TYPE__DryerSecondaryHeater].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
 
 //#warning temporary disable time slice control as we are working with one heater in run time
 /*   if ((Heater1000Slices + Heater200aSlices +2)>NumberOFSlicesInUse)
@@ -205,8 +209,8 @@ uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_ou
 */
    //mark the time slices  for heaters operation as empty / Heater1000 / Heater 200
    memset (TimeSliceAllocation,0xFF,sizeof(TimeSliceAllocation));
-   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain;
-   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary;
+   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HEATER_TYPE__DryerMainHeater;
+   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HEATER_TYPE__DryerSecondaryHeater;
 
    return OK;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 564df6862..b879a1404 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -35,6 +35,7 @@
 #include "Drivers/I2C_Communication/DAC/blower.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
+#include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
 
 #include "StateMachines/Printing/PrintingSTM.h"
 #include "StateMachines/Initialization/PowerIdle.h"
@@ -73,15 +74,15 @@ typedef struct
     bool                m_isReady;
     PID_Config_Params   m_params;
 }HeaterControlConfig_t;
-HeaterControlConfig_t  HeaterPIDConfig[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0,0,0};
+HeaterControlConfig_t  HeaterPIDConfig[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 //PID_Config_Params   temp_params;
 
 /******************** GLOBAL PARAMETERS  ********************************************/
-HeaterCommand          HeaterCmd[MAX_HEATERS_NUM];
-uint32_t    ControlIdtoHeaterId [MAX_HEATERS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
-uint32_t    ControlIdtoMaxHeaterId [MAX_HEATERS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
-uint32_t    OverHeatCounter [MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0};
-uint32_t    UnderHeatCounter [MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0};
+HeaterCommand          HeaterCmd[HEATER_TYPE_MAX_HEATERS];
+uint32_t    ControlIdtoHeaterId [HEATER_TYPE_MAX_HEATERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+uint32_t    ControlIdtoMaxHeaterId [HEATER_TYPE_MAX_HEATERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+uint32_t    OverHeatCounter [HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+uint32_t    UnderHeatCounter [HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 uint32_t    MainDryerHeaterMaxTempControl = 0xFF;
 uint32_t    SecondDryerHeaterMaxTempControl = 0xFF;
 uint32_t    DisasterControlId = 0xFF;
@@ -91,42 +92,50 @@ uint32_t    DisasterControlId = 0xFF;
 #define MINIMUM_HEATER_READ 9.0
 #define MAXIMUM_HEATER_READ 283
 
-//old uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,TEMP_SENSE_AN_ENCLOSURETEMP3};
-uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HEAD6_PT100,MIXER_PT100};
-HEATERS_CURRENT HeaterId2CurrentId[MAX_HEATERS_NUM] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEATER_HEAD_CURRENT_ZONE_1,HEATER_HEAD_CURRENT_ZONE_2,HEATER_HEAD_CURRENT_ZONE_3,HEATER_HEAD_CURRENT_ZONE_4,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_MIXCHIP_CURRENT};
+#ifdef Use_Head_Card
+uint32_t HeaterId2PT100Id[HEATER_TYPE_MAX_HEATERS] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,HEAD_PT100_ZONE_1_0X80_0, HEAD_PT100_ZONE_2_0X80_1, HEAD_PT100_ZONE_3_0X82_0,
+                                                      HEAD_PT100_ZONE_4_0X82_1, HEAD_PT100_ZONE_5_0X84_0, HEAD_PT100_ZONE_6_0X84_1,HEAD_PT100_MIXER_0X8E_0, HEAD_PT100_ZONE_7_0X86_0, HEAD_PT100_ZONE_8_0X86_1,
+                                                      HEAD_PT100_ZONE_9_0X88_0, HEAD_PT100_ZONE_10_0X88_1, HEAD_PT100_ZONE_11_0X8A_0, HEAD_PT100_ZONE_12_0X8A_1 };
+HEATERS_CURRENT HeaterId2CurrentId[HEATER_TYPE_MAX_HEATERS] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEAD_CURRENT_ZONE_1, HEAD_CURRENT_ZONE_2,
+                                                               HEAD_CURRENT_ZONE_3, HEAD_CURRENT_ZONE_4, HEAD_CURRENT_ZONE_5, HEAD_CURRENT_ZONE_6, HEAD_CURRENT_MIXER, HEAD_CURRENT_ZONE_7,
+                                                               HEAD_CURRENT_ZONE_8, HEAD_CURRENT_ZONE_9, HEAD_CURRENT_ZONE_10, HEAD_CURRENT_ZONE_11, HEAD_CURRENT_ZONE_12};
+#else
+uint32_t HeaterId2PT100Id[HEATER_TYPE_MAX_HEATERS] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HEAD6_PT100,MIXER_PT100,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+HEATERS_CURRENT HeaterId2CurrentId[HEATER_TYPE_MAX_HEATERS] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEATER_HEAD_CURRENT_ZONE_1,HEATER_HEAD_CURRENT_ZONE_2,HEATER_HEAD_CURRENT_ZONE_3,HEATER_HEAD_CURRENT_ZONE_4,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_MIXCHIP_CURRENT};
+#endif
 uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
 bool HeatersRestart = false;
 
-bool HeaterMaxTempFlag[MAX_HEATERS_NUM] = {false,false,false,false,false,false,false,false,false,false};
-bool HeaterMinTempFlag[MAX_HEATERS_NUM] = {true,true,true,true,true,true,true,true,true,true};
+bool HeaterMaxTempFlag[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false};
+bool HeaterMinTempFlag[HEATER_TYPE_MAX_HEATERS] = {true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true};
 
 uint32_t OutputProportionalSingleStep = 0;  //A/C Heaters step size from one decision point to another - in cpu clocks. 120000 = 1 millisecod
-uint32_t  Heater_timerBase = TIMER2_BASE;        //Timer handle
+uint32_t  Heater_timerBase = TIMER2_BASE;   //Timer handle
 uint32_t OutputProportionalCycleTime = 0; //A/C Heaters Cycle time in milliseconds - one for all heaters
 char     TimeSliceAllocation[MAX_TIMESLICES] = {0xFF};
-int     DCTimeSliceAllocation[MAX_HEATERS_NUM] = {0};
+int     DCTimeSliceAllocation[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 
 bool TimerActivated = false;
 char ACheatstr[100];
 
-Mailbox_Handle          HeatersControlMsgQ = NULL;
+Mailbox_Handle  HeatersControlMsgQ = NULL;
 //bool InitialHeating = true;
-//bool DCInitialHeating[MAX_HEATERS_NUM] = {true};
-bool    HeaterReady[MAX_HEATERS_NUM] = {true};
-bool    HeaterAtTemp[MAX_HEATERS_NUM] = {true};
-uint32_t HeaterPreviousRead[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters
-EventType HeaterEventType[MAX_HEATERS_NUM] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,
-                                              EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,
-                                              EVENT_TYPE__MIXER_OVERTEMPERATURE};
-EventType HeaterUnderEventType[MAX_HEATERS_NUM] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_A,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,
+//bool DCInitialHeating[HEATER_TYPE_MAX_HEATERS] = {true};
+bool    HeaterReady[HEATER_TYPE_MAX_HEATERS] = {true};
+bool    HeaterAtTemp[HEATER_TYPE_MAX_HEATERS] = {true};
+uint32_t HeaterPreviousRead[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters
+EventType HeaterEventType[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,
+                                         EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,
+                                              EVENT_TYPE__MIXER_OVERTEMPERATURE,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None};
+EventType HeaterUnderEventType[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_A,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,
                                               EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,
-                                              EVENT_TYPE__MIXER_UNDERTEMPERATURE_A};
+                                              EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None};
 
-EventType HeaterUnderEventType_B[MAX_HEATERS_NUM] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,
+EventType HeaterUnderEventType_B[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,
                                               EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,
-                                              EVENT_TYPE__MIXER_UNDERTEMPERATURE_B};
+                                              EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None,EVENT_TYPE__None};
 
-int HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {0,0,0,0,0,0,0,0,0,0};
+int HeaterDisasterCounter[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 #define DISASTER_COUNTER_LIMIT 10
 
 /******************** FUNCTIONS  ********************************************/
@@ -156,7 +165,7 @@ void HeatersControlInit(void)
     ROM_IntEnable(INT_TIMER2A);
     ROM_TimerIntEnable(Heater_timerBase, TIMER_TIMA_TIMEOUT);
 
-    for (i = 0; i < MAX_HEATERS_NUM; i++)
+    for (i = 0; i < HEATER_TYPE_MAX_HEATERS; i++)
     {
         //DCInitialHeating[i] = true;
         HeaterReady[i] = true;
@@ -207,9 +216,11 @@ uint32_t InternalId2PT100Id[MAX_INTERNAL_ALARMS] = {TEMP_SENSE_AN_ENCLOSURETEMP1
 int32_t    InternalOverHeatCounter [MAX_INTERNAL_ALARMS] = {0,0,0};
 bool    InternalAlarmActive[MAX_INTERNAL_ALARMS] = {false,false,false};
 uint32_t ControlIdtoInternalId[MAX_INTERNAL_ALARMS] = {0xFF,0xFF,0xFF};
+EventType InternalTempEventType[MAX_INTERNAL_ALARMS] = {EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE,EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2};
+
 uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
-    int index=MAX_HEATERS_NUM;
+    int index=HEATER_TYPE_MAX_HEATERS;
 
     if (IfIndex>>8 != IfTypeHeaters)
     {
@@ -241,7 +252,7 @@ uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValu
 
                     InternalAlarmActive[index] = true;
                     ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature, turned off",__FILE__,index,readValue,RpWarning,  0,0);
-                    AlarmHandlingSetAlarm(EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE, true);
+                    AlarmHandlingSetAlarm(InternalTempEventType[index], true);
             }
         }
     }
@@ -255,7 +266,7 @@ uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValu
 
                 InternalAlarmActive[index] = true;
                 ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature, turned off",__FILE__,index,readValue,RpWarning,  0,0);
-                AlarmHandlingSetAlarm(EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE, false);
+                AlarmHandlingSetAlarm(InternalTempEventType[index], false);
             }
 
         }
@@ -285,7 +296,7 @@ void HeatersControlStart(void)
 }
 uint32_t LoadHeaterSetPoint(HeaterType HeaterType)
 {
-    if (HeaterType >= MAX_HEATERS_NUM)
+    if (HeaterType >= HEATER_TYPE_MAX_HEATERS)
     {
         ReportWithPackageFilter(HeatersFilter,"Wrong Heater Id",__FILE__,__LINE__,HeaterType,RpError, 0,0);
         return 0;
@@ -311,21 +322,23 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
     HeaterState->isrampingup = 1-HeaterAtTemp[HeaterId];
     HeaterState->has_isinsetpoint = true;
     HeaterState->isinsetpoint = HeaterReady[HeaterId];
-    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
+    if (HeaterId == HEATER_TYPE__DryerMainHeater)
     {
-        HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit;
+        HeaterState->setpoint = HeaterControl[HEATER_TYPE__DryerMainHeater].outputproportionalpowerlimit;
         //HeaterState->isrampingup = InitialHeating;
     }
-    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
+    if (HeaterId == HEATER_TYPE__DryerSecondaryHeater)
     {
-        HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit;
+        HeaterState->setpoint = HeaterControl[HEATER_TYPE__DryerSecondaryHeater].outputproportionalpowerlimit;
         //HeaterState->isrampingup = InitialHeating;
     }
     return;
 }
-uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
+uint32_t HeatersSingleHeaterEnd(int HeaterId)
 {
     int status = OK;
+    assert(HeaterId < HEATER_TYPE_MAX_HEATERS);
+    //HEATER_TYPE_ENUM HeaterId = HeaterPidtoHeaterId(HeaterPID_Id);
     ReportWithPackageFilter(HeatersFilter,"HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, 0, 0);
         if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
         {
@@ -358,8 +371,8 @@ uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
                 status |= RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
                 ControlIdtoMaxHeaterId [HeaterId]=0xFF;
             }
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
             if (MainDryerHeaterMaxTempControl)
             {
                 status |=RemoveControlCallback(MainDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
@@ -370,10 +383,10 @@ uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
                 status |=RemoveControlCallback(SecondDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
                 SecondDryerHeaterMaxTempControl=0xFF;
             }
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+            DeActivateHeater(HEATER_TYPE__DryerMainHeater);
+            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
+            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
             HeaterPIDConfig[HeaterId].m_SetParam = 0;
             HeaterReady[HeaterId] = true;
             HeaterAtTemp[HeaterId] = true;
@@ -392,9 +405,10 @@ uint32_t HeatersEnd(void)
     HardwarePidControlType i;
     uint32_t status = OK;
     HeatersControlStop();
-    for (i=0;i<MAX_HEATERS_NUM;i++)
+    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
     {
-        status = HeatersSingleHeaterEnd(i);
+        if(HeaterIdtoHeaterpid[i]!=HEATER_TYPE_MAX_HEATERS)
+            status = HeatersSingleHeaterEnd(i);
     }
     return status;
 
@@ -443,7 +457,7 @@ int GetFilteredHeaterRead(int HeaterId)
  * called by: Communication from host
  * initialized all global data
  *************************************************************************************/
-bool HeaterRestarted[MAX_HEATERS_NUM] = {false,false,false,false,false,false,false,false,false,false};
+bool HeaterRestarted[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false};
 uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
 {
     //uint32_t status = NOT_SUPPORTED;
@@ -455,7 +469,7 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
     }
 //    Turn_the_Blower_On();
 
-    if (HeaterId< MAX_HEATERS_NUM)
+    if (HeaterId< HEATER_TYPE_MAX_HEATERS)
     {
         if (HeaterControl[HeaterId].id != HeaterId) // heater configuration missing
         {
@@ -466,10 +480,6 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
         HeaterCmd[HeaterId].command = OnOff;
         HeaterCmd[HeaterId].targettemperatue = Temperature*100;
     }
-#ifdef DEMO_TEMPERATURE
-    if (OnOff == false)
-        HeaterTestActive[HeaterId] = false;
-#endif
     bool HeaterState;
     if ( ControlIdtoHeaterId [HeaterId] == 0xFF)
     {
@@ -540,13 +550,13 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
         //HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(DryerInternalPT100Id);
         HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//
         //ReportWithPackageFilter(HeatersFilter,"PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);//MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);// = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
-        if((HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain])||
-           (HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]))
+        HeaterPreviousRead[HEATER_TYPE__DryerMainHeater] =  MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);//MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);
+        HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]  = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);// = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);
+        if((HeaterPreviousRead[HEATER_TYPE__DryerMainHeater]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HEATER_TYPE__DryerMainHeater])||
+           (HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]))
         {
-            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,RpError, HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
-            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,RpError, HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
+            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HEATER_TYPE__DryerMainHeater,RpError, HeaterPreviousRead[HEATER_TYPE__DryerMainHeater],0);
+            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HEATER_TYPE__DryerSecondaryHeater,RpError, HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater],0);
             if (ControlIdtoMaxHeaterId [HeaterId] != 0xFF)
             {
                 RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
@@ -571,8 +581,8 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
         ReportWithPackageFilter(HeatersFilter,"PrepareACHeater control still running",__FILE__,HeaterId,ControlIdtoHeaterId [HeaterId],RpError, HeaterCmd[HeaterId].targettemperatue,0);
         HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//
         //ReportWithPackageFilter(HeatersFilter,"PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);//MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);// = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+        HeaterPreviousRead[HEATER_TYPE__DryerMainHeater] =  MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);//MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);
+        HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]  = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);// = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);
 
     }
     //turn all alarms off
@@ -583,15 +593,15 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
         ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback("HeatersMax", DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
-    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
+    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
 
-    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
-    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
+    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, 0);
+    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
     if (MainDryerHeaterMaxTempControl == 0xFF)
-        MainDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
+        MainDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HEATER_TYPE__DryerMainHeater),HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater],0);
     if (SecondDryerHeaterMaxTempControl == 0xFF)
-        SecondDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
+        SecondDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HEATER_TYPE__DryerSecondaryHeater),HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater],0);
     //InitialHeating = true;
     HeaterReady[HeaterId] = false;
     HeaterAtTemp[HeaterId] = false;
@@ -670,7 +680,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
 {
     double temp ;
     CTRL_TIMING_ENUM Frequency = eOneSecond;
-    if(HeaterId >= MAX_HEATERS_NUM)
+    if(HeaterId >= HEATER_TYPE_MAX_HEATERS)
     {
         ReportWithPackageFilter(HeatersFilter,"HeaterId too high",__FILE__,__LINE__,HeaterId,RpError, 0,0);
         return ERROR;
@@ -720,7 +730,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
         if (PrepareDCHeater(HeaterId,Frequency,SetTemperatue)!=OK)
             return ERROR;
     }
-    else if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
+    else if (HeaterId == HEATER_TYPE__DryerAirHeater) //AC Heaters
     {
         PrepareACHeater(HeaterId,Frequency,SetTemperatue);
     }
@@ -729,7 +739,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
 bool HeaterCheckReady(void)
 {
     int i;
-    for (i=0;i<MAX_HEATERS_NUM;i++)
+    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
     {
         if (HeaterAtTemp[i] == false)
         {
@@ -745,7 +755,7 @@ void HeaterPrepareReady(void)
     {
         return;
     }
-    for (i=0;i<MAX_HEATERS_NUM;i++)
+    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
     {
         if (HeaterAtTemp[i] == false)
         {
@@ -762,13 +772,13 @@ void HeaterPrepareReady(void)
  */
 bool HeaterGetOverTemperatureState(uint8_t HeaterId)
 {
-    if (HeaterId > MAX_HEATERS_NUM) return false;
+    if (HeaterId > HEATER_TYPE_MAX_HEATERS) return false;
     return HeaterMaxTempFlag[HeaterId];
 }
 uint32_t MainPT100Read = 0,SecondaryPT100Read = 0;
 uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
-    int index=MAX_HEATERS_NUM;
+    int index=HEATER_TYPE_MAX_HEATERS;
     int32_t MaxreadValue;
 
     if (IfIndex>>8 != IfTypeHeaters)
@@ -777,7 +787,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
-    if ((index != HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)&&(index != HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)) //AC Heaters
+    if ((index != HEATER_TYPE__DryerMainHeater)&&(index != HEATER_TYPE__DryerSecondaryHeater)) //AC Heaters
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, 0,0);
         return 0xFFFFFFFF;
@@ -788,18 +798,18 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     {
         ReportWithPackageFilter(HeatersFilter,"Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         HeaterMaxTempFlag[index] = true;
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+        DeActivateHeater(HEATER_TYPE__DryerMainHeater);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+        DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
-    if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
+    if (index == HEATER_TYPE__DryerMainHeater)
     {
         MainPT100Read = readValue;
     }
-    if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
+    if (index == HEATER_TYPE__DryerSecondaryHeater)
     {
         SecondaryPT100Read = readValue;
     }
@@ -813,12 +823,12 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
             //LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
             //ReportWithPackageFilter(HeatersFilter," AC Heater Over the max temperature, turned off",__FILE__,index,HeaterReady[index],RpWarning,HeaterControl[index].sensormaxvalue, 0);
         }
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        DeActivateHeater(HEATER_TYPE__DryerMainHeater);
         HeaterMaxTempFlag[index] = true;
-        //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-        //HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true;
-        //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+        //HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+        DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+        //HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] = true;
+        //HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
         return OK;
     }
     if (MaxreadValue <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
@@ -827,15 +837,15 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             if (HeaterMaxTempFlag[index] == true)
             {
-               /* ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature]==false)
+               /* ActivateHeater(HEATER_TYPE__DryerMainHeater);
+                if (HeaterReady[HEATER_TYPE__DryerAirHeater]==false)
                 {
-                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    ActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
                 }*/
                 //ReportWithPackageFilter(HeatersFilter, "Heater Cooled Off max temperature, turned on",__FILE__,__LINE__,(MinreadValue/100),RpError, 0,0);
             }
-            HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
-            HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = false;
+            HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] = false;
+            HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] = false;
         }
         return OK;
     }
@@ -843,7 +853,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 }
 uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
-    int index=MAX_HEATERS_NUM;
+    int index=HEATER_TYPE_MAX_HEATERS;
     if (IfIndex>>8 != IfTypeHeaters)
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
@@ -936,7 +946,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 }
 uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
-    int index=MAX_HEATERS_NUM;
+    int index=HEATER_TYPE_MAX_HEATERS;
     //uint8_t len = 0;
     if (IfIndex>>8 != IfTypeHeaters)
     {
@@ -944,18 +954,18 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         return ERROR;
     }
     index = IfIndex&0xFF;
-    if (index != HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
+    if (index != HEATER_TYPE__DryerAirHeater) //AC Heaters
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, 0,0);
         return ERROR;
     }
     if (HeaterCmd[index].targettemperatue == 0)
     {
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+        DeActivateHeater(HEATER_TYPE__DryerMainHeater);
         //Heaters OFF until coming into the proportional band
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
         //ReportWithPackageFilter(HeatersFilter, "unconfigured",__FILE__,__LINE__,0,RpError, 0,0);
         return ERROR;
     }
@@ -964,20 +974,20 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         ReportWithPackageFilter(HeatersFilter,"AC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         if (readValue > HeaterCmd[index].targettemperatue)
         {
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+            DeActivateHeater(HEATER_TYPE__DryerMainHeater);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
         }
         return ERROR;
     }
     if (HeaterDisasterCounter[index] >= DISASTER_COUNTER_LIMIT)
     {
         ReportWithPackageFilter(HeatersFilter,"AC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+        DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+        DeActivateHeater(HEATER_TYPE__DryerMainHeater);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
@@ -991,11 +1001,11 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     {
         if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
                 {
-                    DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-                    DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+                    DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+                    DeActivateHeater(HEATER_TYPE__DryerMainHeater);
                     //Heaters OFF until coming into the proportional band
-                    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
-                    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+                    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+                    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
                     ReportWithPackageFilter(HeatersFilter, "AC OverHeat - turned off",__FILE__,readValue,HeaterReady[index],RpError, HeaterAtTemp[index],0);
                     return OK;
                 }
@@ -1003,12 +1013,12 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         //if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800))
         {
             //ReportWithPackageFilter(HeatersFilter,"AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
-            if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false))
+            if ((HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)&&(HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] == false))
             {
-                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,100);
-                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,100);
+                ActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+                ActivateHeater(HEATER_TYPE__DryerMainHeater);
+                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,100);
+                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,100);
             }
             return OK;
         }
@@ -1018,8 +1028,8 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 //////////////////
             ReportWithPackageFilter(HeatersFilter,"AC Turn Off secondary",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
             //InitialHeating = false;
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
+            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
             HeatersControlStart();
 ////////////////////////
 
@@ -1039,8 +1049,8 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             //InitialHeating = false;
             ReportWithPackageFilter(HeatersFilter,"AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
-            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
+            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
             HeatersControlStart();
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
             if (BlowerCfg.enabled == true)
@@ -1051,8 +1061,8 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                     Control_Voltage_To_Blower(BlowerCfg.voltage);
             }
             HeaterReady[index] = true;
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
+            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
 
         }
         return OK;
@@ -1074,12 +1084,12 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) //below proportional band
             {
-                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 100);
+                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, 100);
                 //REPORT_MSG (readValue,"AC HEATER Over temperature");
             }
             else if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
             {
-                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
+                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, 0);
                 //REPORT_MSG (readValue,"AC HEATER Under temperature");
             }
         }
@@ -1115,12 +1125,12 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             //        #warning PID is now only proportional (above)
 //             ReportWithPackageFilter(HeatersFilter,ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue,  HeaterPIDConfig[index].m_calculatedError);
             //ReportWithPackageFilter(HeatersFilter,"AC PID",__FILE__,__LINE__,HeaterPIDConfig[index].m_calculatedError/100,RpWarning,readValue, index);
-            if (HeaterRestarted[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == true)
+            if (HeaterRestarted[HEATER_TYPE__DryerMainHeater] == true)
             {
-                ReportWithPackageFilter(HeatersFilter,"Restarting same temperature Heater Temp",__FILE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,HeaterPIDConfig[index].m_calculatedError,RpWarning,readValue,  0);
-                HeaterRestarted[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
+                ReportWithPackageFilter(HeatersFilter,"Restarting same temperature Heater Temp",__FILE__,HEATER_TYPE__DryerMainHeater,HeaterPIDConfig[index].m_calculatedError,RpWarning,readValue,  0);
+                HeaterRestarted[HEATER_TYPE__DryerMainHeater] = false;
             }
-            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, (int)(HeaterPIDConfig[index].m_calculatedError/100));
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, (int)(HeaterPIDConfig[index].m_calculatedError/100));
         }
     }
 
@@ -1132,17 +1142,17 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
  * called by: Communication from host
  * initialized all global data
  */
-//float error[HARDWARE_PID_CONTROL_TYPE__MixerHeater][100];
-//float integral[HARDWARE_PID_CONTROL_TYPE__MixerHeater][100];
-//float output[HARDWARE_PID_CONTROL_TYPE__MixerHeater][100];
-//int Counter[HARDWARE_PID_CONTROL_TYPE__MixerHeater] = {0,0,0,0,0,0,0};
-//char logmsg[HARDWARE_PID_CONTROL_TYPE__MixerHeater][254];
+//float error[HEATER_TYPE__HeadCoverHeater2][100];
+//float integral[HEATER_TYPE__HeadCoverHeater2][100];
+//float output[HEATER_TYPE__HeadCoverHeater2][100];
+//int Counter[HEATER_TYPE__HeadCoverHeater2] = {0,0,0,0,0,0,0};
+//char logmsg[HEATER_TYPE__HeadCoverHeater2][254];
 char heatstr[100];
 //float temp_calculatedError=0,temp_preError = 0, temp_integral = 0;
 
 uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
-    int index=MAX_HEATERS_NUM;
+    int index=HEATER_TYPE_MAX_HEATERS;
     //int len;
    //uint8_t len = 0;
     if (IfIndex>>8 != IfTypeHeaters)
@@ -1182,7 +1192,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     if (readValue>(HeaterCmd[index].targettemperatue+500))
     {
-        ReportWithPackageFilter(HeatersFilter, "DC OverHeating in progress",__FILE__,readValue,HeaterReady[index],RpError, HeaterAtTemp[index],0);
+        ReportWithPackageFilter(HeatersFilter, "DC OverHeating in progress",__FILE__,index,readValue,RpError, HeaterReady[index],0);
     }
 
     // check if the read value is within the proportional band
@@ -1330,13 +1340,13 @@ void EightMilliSecondHeatersInterrupt(UArg arg0)
     return ;
 }
 
-int HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {28000,28000,28000,17000,17000,17000,17000,17000,17000,11000};
-//int HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {8100,8100,8200,8100,8100,8100,8100,8100,8100,8100};
+int HeaterDisasterTemp[HEATER_TYPE__HeadCoverHeater2+1] = {28000,28000,28000,17000,17000,17000,17000,17000,17000,11000,17000,17000,17000,17000,17000,17000,17000,17000};
+//int HeaterDisasterTemp[HEATER_TYPE__HeadCoverHeater2+1] = {8100,8100,8200,8100,8100,8100,8100,8100,8100,8100};
 uint32_t HeatersDisasterControl(uint32_t x,uint32_t y)
 {
     int HeaterId,temperature;
 
-    for ( HeaterId = HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature; HeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;HeaterId++)
+    for ( HeaterId = HEATER_TYPE__DryerAirHeater; HeaterId<= HEATER_TYPE__HeadCoverHeater2;HeaterId++)
     {
         temperature = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
         if (temperature>=HeaterDisasterTemp[HeaterId])
@@ -1370,63 +1380,63 @@ uint32_t HeatersControlLoop(uint32_t tick)
                     ,SliceCounter,TimeSliceAllocation[SliceCounter],HeatersRestart,NumberOFSlicesInUse);
     ReportWithPackageFilter(HeatersFilter,str, __FILE__,__LINE__,0, RpMessage, SliceCounter, TimeSliceAllocation[SliceCounter]);
 */
-    if (HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] >= DISASTER_COUNTER_LIMIT)
+    if (HeaterDisasterCounter[HEATER_TYPE__DryerMainHeater] >= DISASTER_COUNTER_LIMIT)
     {
-        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        DeActivateHeater (HEATER_TYPE__DryerMainHeater);
+        DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
         AcHeaterDisaster = true;
     }
-    if (HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] >= DISASTER_COUNTER_LIMIT)
+    if (HeaterDisasterCounter[HEATER_TYPE__DryerSecondaryHeater] >= DISASTER_COUNTER_LIMIT)
     {
-        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        DeActivateHeater (HEATER_TYPE__DryerMainHeater);
+        DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
         AcHeaterDisaster = true;
     }
 
 
     if (AcHeaterDisaster == false)
     {
-        if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature] == true)
+        if (HeaterReady[HEATER_TYPE__DryerAirHeater] == true)
         {
-            if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
+            if (TimeSliceAllocation[SliceCounter] == HEATER_TYPE__DryerMainHeater)
             {
-                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)
+                if (HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] == false)
                 {
-                    //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain should be active
-                    //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                    //DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    //If HEATER_TYPE__DryerMainHeater should be active
+                    //Activate HEATER_TYPE__DryerMainHeater
+                    ActivateHeater (HEATER_TYPE__DryerMainHeater);
+                    //DeActivate HEATER_TYPE__DryerSecondaryHeater
+                    //DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                 }
-                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)
+                if (HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)
                 {
 #warning trial use both heaters in drier
-                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                    //DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    ActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
+                    //DeActivate HEATER_TYPE__DryerSecondaryHeater
+                    //DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                 }
             }
-            /*else if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
+            /*else if (TimeSliceAllocation[SliceCounter] == HEATER_TYPE__DryerSecondaryHeater)
             {
-                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)
+                if (HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)
                 {
-                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                    //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary should be active
-                    //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    //DeActivate HEATER_TYPE__DryerMainHeater
+                    DeActivateHeater (HEATER_TYPE__DryerMainHeater);
+                    //If HEATER_TYPE__DryerSecondaryHeater should be active
+                    //Activate HEATER_TYPE__DryerSecondaryHeater
+                    ActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                 }
             }*/
             else
             {
-                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    //DeActivate HEATER_TYPE__DryerMainHeater
+                    DeActivateHeater (HEATER_TYPE__DryerMainHeater);
+                    //DeActivate HEATER_TYPE__DryerSecondaryHeater
+                    DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
             }
         }
     }
-    for ( DcHeaterId = HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1; DcHeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;DcHeaterId++)
+    for ( DcHeaterId = HEATER_TYPE__HeaterZone1; DcHeaterId<= HEATER_TYPE__HeaterZone12;DcHeaterId++)
     {
         if (HeaterDisasterCounter[DcHeaterId] >= DISASTER_COUNTER_LIMIT)
         {
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index eba93d445..41e729b9b 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -14,11 +14,11 @@ extern uint32_t DispenserPrepareTimeout ;
 extern uint32_t DispenserPrepareTimeLag ;
 extern uint32_t InitialDispenserSpeed;
 
-extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
 extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 extern float DispenserPressure[MAX_SYSTEM_DISPENSERS];
 uint32_t DispenserConfigMessage(HardwareDispenser * request);
 
+
 extern HardwareDispenser DispensersCfg[ MAX_SYSTEM_DISPENSERS];
 
 extern bool DispensersAlarmState[ MAX_SYSTEM_DISPENSERS];
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
index 2a1a8fa31..bdde05b43 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
@@ -17,7 +17,7 @@
 #include "drivers/valves/valve.h"
 
 int SaveLeftRockerSpeed = 50, SaveRightRockerSpeed = 50;
-#define CLEANING_DISPENSER_ID 6
+
 uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed)
 {
     uint32_t status = OK;
@@ -43,8 +43,8 @@ uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callbac
 uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr callback)
 {
     uint32_t status = OK;
-    status = IDS_Dispenser_Start_Motor_and_Open_Valve(CLEANING_DISPENSER_ID, dispenserSpeed, callback);
-    Report("IDS_Cleaning_Spray_Cleaning_Solution", __FILE__, __LINE__, CLEANING_DISPENSER_ID, RpWarning,   dispenserSpeed, 0);
+    status = IDS_Dispenser_Start_Motor_and_Open_Valve(CLEANER_DISPENSER, dispenserSpeed, callback);
+    Report("IDS_Cleaning_Spray_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning,   dispenserSpeed, 0);
 
     return status;
 
@@ -52,8 +52,8 @@ uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr
 uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback)
 {
     uint32_t status = OK;
-    status = IDS_Dispenser_Close_Valve_And_Stop_Motor(CLEANING_DISPENSER_ID,callback);
-    Report("IDS_Cleaning_Stop_Cleaning_Solution", __FILE__, __LINE__, CLEANING_DISPENSER_ID, RpWarning,   status, 0);
+    status = IDS_Dispenser_Close_Valve_And_Stop_Motor(CLEANER_DISPENSER,callback);
+    Report("IDS_Cleaning_Stop_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning,   status, 0);
 
     return status;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index 9074f867a..8c0fbba1e 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -47,6 +47,8 @@ extern DispenserData IDSDispenserData;
 extern DispenserRunningData **dispenserdata;
 
 extern bool         DispenserUsedInJob[MAX_SYSTEM_DISPENSERS];
+extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
+
 bool IDS_MapDispenserUsedinJob(void *JobDetails);
 
 void IDS_ModuleInit (void);
@@ -102,4 +104,7 @@ float GetDispenserPressure(int DispenserId);
 int32_t IdsGetMotorSpeed(uint32_t DispenserId);
 void DispenserDataRequestFunc(MessageContainer* requestContainer);
 
+void IDS_Start_Pid_Testing(int DispenserId);
+void IDS_Stop_Pid_Testing(int DispenserId);
+
 #endif /* MODULES_IDS_IDS_EX_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index ab5f80af4..0e28ec736 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -82,6 +82,8 @@ uint32_t InitialDispenserTimeout = INITIAL_DISPENSER_TIMEOUT_LIMIT;
 uint32_t InitialDispenserTimeLag = INITIAL_DISPENSER_TIMEOUT;
 uint32_t InitialDispenserSpeed = INITIAL_DISPENSER_SPEED;
 
+uint32_t    ControlIdtoInactiveDispenserId [MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+
 uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t deviceID);
 
 AutoHoming_Config_enum AutoHoming_Config = AutoHoming_off;
@@ -487,6 +489,31 @@ uint32_t IDS_Dispenser_Alarm_Off (uint8_t DispenserId)
     Report("IDS_Dispenser_Alarm_Off",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
     return status;
 }
+uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
+{
+    TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
+    if (JobIsActive())
+    {
+        if (DispenserUsedInJob[DispenserId] == true)
+        {
+            //LOG_ERROR(DispenserId,"IDS_Check_Pressure_Callback active in a job");
+            return ERROR;
+        }
+    }
+    if ((HomingActive[DispenserId] == true)||(PrimingActive[DispenserId] == true))
+    {
+        //LOG_ERROR(DispenserId,"IDS_Check_Pressure_Callback active in a job");
+        return ERROR;
+    }
+
+    if (GetDispenserPressure(DispenserId)>3.0)
+    {
+        Report("Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
+        MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,200);
+    }
+    return OK;
+}
+
 
 void IDS_Dispenser_Init(uint8_t DispenserId)
 {
@@ -497,4 +524,7 @@ 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
+    if (ControlIdtoInactiveDispenserId[DispenserId] == 0xFF)
+        ControlIdtoInactiveDispenserId[DispenserId] = AddControlCallback("IDS_Check_Pressure", IDS_Check_Pressure_Callback, eOneMinute,TemplateDataReadCBFunction ,0, 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 ca9a15008..3af6416cb 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -41,13 +41,14 @@ typedef struct
     PID_Config_Params   m_params;
 }DispenserControlConfig_t;
 HardwarePidControl *DispensersControl;
+HardwarePidControl DispensersCtrl[MAX_SYSTEM_DISPENSERS];
 #define MAX_DYE_DISPENSERS 6
 int32_t DispenserSamples[MAX_SYSTEM_DISPENSERS][MAX_CONTROL_SAMPLES] = {0};
 int DispenserSamplePointer[MAX_SYSTEM_DISPENSERS] = {0};
 double DispenserNormalizedErrorCoEfficient[MAX_SYSTEM_DISPENSERS] = {0};
 double lubricant_speed = 0.0;
 HardwarePidControlType ThreadDispenserIdToControlId[MAX_SYSTEM_DISPENSERS] = {  HARDWARE_PID_CONTROL_TYPE__Dispenser1,HARDWARE_PID_CONTROL_TYPE__Dispenser2,HARDWARE_PID_CONTROL_TYPE__Dispenser3,HARDWARE_PID_CONTROL_TYPE__Dispenser4,HARDWARE_PID_CONTROL_TYPE__Dispenser5,HARDWARE_PID_CONTROL_TYPE__Dispenser6,HARDWARE_PID_CONTROL_TYPE__Dispenser7,HARDWARE_PID_CONTROL_TYPE__Dispenser8};
-
+JobUploadStrategy uploadstrategy = JOB_UPLOAD_STRATEGY__Default;
 bool    DispenserReady[MAX_SYSTEM_DISPENSERS] = {true};
 bool IDS_Active = false;
 /******************** STRUCTURES AND ENUMs  ********************************************/
@@ -58,7 +59,6 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue);
 /******************** GLOBAL PARAMETERS  ********************************************/
 DispenserControlConfig_t DispenserControlConfig[MAX_SYSTEM_DISPENSERS];
 uint32_t    ControlIdtoDispenserId [MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
-uint32_t    ControlIdtoInactiveDispenserId [MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
 int OriginalDispenserSpd_2PPS[MAX_SYSTEM_DISPENSERS] = {0,0,0,0,0,0,0,0};
 bool         DispenserPreSegmentReady[MAX_SYSTEM_DISPENSERS] = {true,true,true,true,true,true,true,true};
 bool         DispenserSegmentReady[MAX_SYSTEM_DISPENSERS] = {true,true,true,true,true,true,true,true};
@@ -118,6 +118,8 @@ int lInterSegmentLength = 0;
 uint32_t IDS_DispenserControlInit()
 {
     DispensersControl = (void *)(DISPENSERS_MAP_IN_FLASH);
+    DispensersControl = DispensersCtrl;
+
     //EraseFlashSection(DispensersControl,sizeof(HardwarePidControl)*MAX_SYSTEM_DISPENSERS);
     return OK;
 }
@@ -134,20 +136,59 @@ uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request)
             break;
         }
     }
-    if (request->pvinputfilterfactormode > MAX_CONTROL_SAMPLES)
-        request->pvinputfilterfactormode = MAX_CONTROL_SAMPLES;
+    memcpy (&DispensersCtrl[Dispenser_i],request,sizeof(HardwarePidControl));
+
     //ReadAppAndProgram(&DispensersControl[Dispenser_i], sizeof(HardwarePidControl), request);
 
     for (i = 0;i < DispensersControl[Dispenser_i].pvinputfilterfactormode; i++)
         DispenserSamples[Dispenser_i][i] = 0;  //reset the samples value for control beginning
-    /*DispenserNormalizedErrorCoEfficient[Dispenser_i] = (2*PI*DancersCfg[ThreadDispenserIdToDancerId[Dispenser_i]].armlength);
-    temp = 1<<(DancersCfg[ThreadDispenserIdToDancerId[Dispenser_i]].resolutionbits);
-    temp=(100*(temp-1)*DancersCfg[ThreadDispenserIdToDancerId[Dispenser_i]].maximalmovementmm);
-    DispenserNormalizedErrorCoEfficient[Dispenser_i] = DispenserNormalizedErrorCoEfficient[Dispenser_i] / temp;*/
+
+    DispenserControlConfig[Dispenser_i].m_params.MAX = 1;
+    DispenserControlConfig[Dispenser_i].m_params.MIN = DispensersCtrl[Dispenser_i].outputproportionalpowerlimit*-1;
+    DispenserControlConfig[Dispenser_i].m_params.Kd = DispensersCtrl[Dispenser_i].derivativetime;
+    DispenserControlConfig[Dispenser_i].m_params.Kp = DispensersCtrl[Dispenser_i].proportionalgain;
+    DispenserControlConfig[Dispenser_i].m_params.Ki = DispensersCtrl[Dispenser_i].integraltime;
+    DispenserControlConfig[Dispenser_i].m_params.IntegralErrorMultiplier = DispensersCtrl[Dispenser_i].setpointramprateorsoftstartramp;
+    DispenserControlConfig[Dispenser_i].m_params.ProportionalErrorMultiplier = DispensersCtrl[Dispenser_i].outputonoffhysteresisvalue;
+    DispenserControlConfig[Dispenser_i].m_params.epsilon = DispensersCtrl[Dispenser_i].epsilon;
+    DispenserControlConfig[Dispenser_i].m_params.dt = DispensersCtrl[Dispenser_i].controloutputtype;
+    //DispenserControlConfig[Dispenser_i].m_ingnoreValue =  DispensersCtrl[Dispenser_i].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
+    DispenserControlConfig[Dispenser_i].m_calculatedError = 0;
+    DispenserControlConfig[Dispenser_i].m_integral = 0;
+    DispenserControlConfig[Dispenser_i].m_isEnabled = true;
+    DispenserControlConfig[Dispenser_i].m_isReady = true;
+    DispenserControlConfig[Dispenser_i].m_mesuredParam = 0;
+    DispenserControlConfig[Dispenser_i].m_preError = 0;
+    DispenserControlConfig[Dispenser_i].m_SetParam = 1.65;//need to update SetParams on presegment stage
+
 
     return OK;
 }
+uint32_t DispenserPidControlId[MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+uint32_t IDS_Pid_Testing_Func(uint32_t DispenserId, uint32_t ReadValue)
+{
+    float calculated_speed;
+    DispenserControlConfig[DispenserId].m_mesuredParam = MillisecGetPressures(DispenserId);
+    DispenserControlConfig[DispenserId].m_calculatedError = AdvancedPIDAlgorithmCalculation((float)DispenserControlConfig[DispenserId].m_SetParam , (float)DispenserControlConfig[DispenserId].m_mesuredParam,
+                                                      &DispenserControlConfig[DispenserId].m_params,   &DispenserControlConfig[DispenserId].m_preError, &DispenserControlConfig[DispenserId].m_integral);
+    DispenserControlConfig[DispenserId].m_calculatedError = (-1*DispenserControlConfig[DispenserId].m_calculatedError);
+    calculated_speed = (1-DispenserControlConfig[DispenserId].m_calculatedError)*CurrentDispenserSpeed[DispenserId];
+    Report("IDS_Pid_Testing_Func ",__FILE__,DispenserId,(int)(DispenserControlConfig[DispenserId].m_mesuredParam*1000),RpWarning,(int)calculated_speed,0);
 
+    return OK;
+}
+void IDS_Start_Pid_Testing(int DispenserId)
+{
+    DispenserPidControlId[DispenserId] = AddControlCallback(NULL, IDS_Pid_Testing_Func,eOneSecond , TemplateDataReadCBFunction,DispenserId,DispenserId, DispenserId );
+    Report("IDS_Start_Pid_Testing ",__FILE__,__LINE__,DispenserId,RpWarning,(int)DispenserPidControlId[DispenserId],0);
+}
+void IDS_Stop_Pid_Testing(int DispenserId)
+{
+    //stop this control loop
+    RemoveControlCallback(DispenserPidControlId[DispenserId], IDS_Pid_Testing_Func );
+    DispenserPidControlId[DispenserId] = 0xFF;
+    Report("IDS_Stop_Pid_Testing ",__FILE__,__LINE__,DispenserId,RpWarning,(int)DispenserPidControlId[DispenserId],0);
+}
 /*
  * IDS Printing support
  * Prepare: build pressure in all participating dispensers
@@ -169,7 +210,9 @@ JobDescriptionFileBrushStop *GetNextBrushStopFromJobFile();
 void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
 
  */
- //********************************************************************************************************************
+JobDescriptionFileBrushStop *FirstBrushStop = NULL;
+
+//********************************************************************************************************************
  //************************** IDS JOB BUILDUP *************************************************************************
  //********************************************************************************************************************
  /************************************************************************************************************************************/
@@ -213,6 +256,8 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
                      BrushStop = GetNextBrushStopFromJobFile();
                      if (BrushStop)
                      {
+                         if (FirstBrushStop == NULL)
+                             FirstBrushStop = BrushStop;
                          if ((brushCounter % 100)==0)
                          {
                              SendJobProgress(0.0,0,false, "Processing file");
@@ -255,7 +300,8 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
                          {
                              LOG_ERROR (BrushStop->index, "no dispensers in brushstop");
                          }
-                         FreeBrushStopFileData(BrushStop);
+                         if (FirstBrushStop!= BrushStop)
+                             FreeBrushStopFileData(BrushStop);
                          BrushStop = NULL;
                      }
                      else
@@ -311,6 +357,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      JobTicket* JobTicket = JobDetails;
      int Dispenser_i, Segment_i,Brush_i,DispenserId;
 
+     uploadstrategy = JobTicket->uploadstrategy;
      if (JobTicket->uploadstrategy == JOB_UPLOAD_STRATEGY__JobDescriptionFile)
      {
          return (IDS_MapDispenserUsedinFileJob(JobDetails));
@@ -379,7 +426,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 {
     if (AutoHoming_Config >= AutoHoming_JobEnd_PowerOn_off)
     {
-        if ((HomingActive[DispenserId] == false)&&(PrimingActive == false))
+        if ((HomingActive[DispenserId] == false)&&(PrimingActive[DispenserId] == false))
         {
             Report("Homing Inactive dispenser",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
             IDS_HomeDispenser (DispenserId, 1000 , NULL);
@@ -407,7 +454,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
      {
          if (DispenserUsedInJob[i] == false)
          {
-             if ((HomingActive[i] == false)&&(PrimingActive == false))
+             if ((HomingActive[i] == false)&&(PrimingActive[i] == false))
              {
                  Report("Inactive dispenser close valve",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
                  Control3WayValvesWithCallback (i, MidTank_Dispenser, InactiveDispenserHome); //direction: MidTank_Dispenser or Dispenser_Mixer
@@ -429,61 +476,170 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
       return OK; // all configured heaters are ready
   }
+  char IdsMessage[100];
+  int SegmentPrepareWFCFCounter = 0;
+  bool pressureReady = false,endOfPrepareWCF = false;
  //********************************************************************************************************************
  uint32_t IDS_Prepare_Callback(uint32_t DispenserId, uint32_t ReadValue)
  {
-     bool pressureReady = false;
      int i;
      int NumofReadyDispensers = 0;
      TimerMotors_t  HW_Motor_Id;
      float updatedSpeed,tempSpeed;
+     JobDispenser **Dispensers;
+ //set the speed only before the first segment, speed is constant accros job
+     int Dispenser_i,n_dispensers;
+     double segmentfirst_speed;
+
      //REPORT_MSG((int)DispenserPrepareControlId, "Prepare Callback");
 
      DispenserBuildTimeCounter+=PRESSURE_READ_TIME_GAP;
 
-     if (DispenserBuildTimeCounter<(2*eOneSecond))
-     {
-         //REPORT_MSG(DispenserBuildTimeCounter,"waiting 2 seconds for pressure changes");
-         return OK;
-     }
-     for (i = 0; i < MAX_DYE_DISPENSERS; i++)
+     if (pressureReady == false)
      {
-         //IDS_StopHomeDispenser(i);
-         if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
+         if (DispenserBuildTimeCounter<(2*eOneSecond))
          {
-             HW_Motor_Id = DispenserIdToMotorId[i];
-             if (GetDispenserPressure(i) > DispenserPreparePressure)
-             {
-                 NumofReadyDispensers++;
-                 tempSpeed = CurrentDispenserSpeed[i];
-                 updatedSpeed = (tempSpeed*0.985>100)?tempSpeed*0.985:100;
-                 MotorSetSpeed(HW_Motor_Id, updatedSpeed);
-                 CurrentDispenserSpeed[i] = updatedSpeed;
-                 //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
-             }
-             else
+             //REPORT_MSG(DispenserBuildTimeCounter,"waiting 2 seconds for pressure changes");
+             return OK;
+         }
+         for (i = 0; i < MAX_DYE_DISPENSERS; i++)
+         {
+             //IDS_StopHomeDispenser(i);
+             if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
              {
-                 tempSpeed = CurrentDispenserSpeed[i];
-                 updatedSpeed = (tempSpeed*1.02<InitialDispenserSpeed)?tempSpeed*1.02:InitialDispenserSpeed;
-                 MotorSetSpeed(HW_Motor_Id, updatedSpeed);
-                 CurrentDispenserSpeed[i] = updatedSpeed;
-                 //Report("IDS accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+                 HW_Motor_Id = DispenserIdToMotorId[i];
+                 if (GetDispenserPressure(i) > DispenserPreparePressure)
+                 {
+                     NumofReadyDispensers++;
+                     tempSpeed = CurrentDispenserSpeed[i];
+                     updatedSpeed = (tempSpeed*0.985>100)?tempSpeed*0.985:100;
+                     MotorSetSpeed(HW_Motor_Id, updatedSpeed);
+                     CurrentDispenserSpeed[i] = updatedSpeed;
+                     //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+                 }
+                 else
+                 {
+                     tempSpeed = CurrentDispenserSpeed[i];
+                     updatedSpeed = (tempSpeed*1.02<InitialDispenserSpeed)?tempSpeed*1.02:InitialDispenserSpeed;
+                     MotorSetSpeed(HW_Motor_Id, updatedSpeed);
+                     CurrentDispenserSpeed[i] = updatedSpeed;
+                     //Report("IDS accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+                 }
              }
          }
-     }
 
-     if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
-         Report("IDS_Prepare_Callback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+         if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
+         {
+             Report("IDS_Prepare_Callback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+         }
+         if (NumofReadyDispensers>=NumOfActiveDispensers)
+         {
+             pressureReady = true;
+             Report("pressureReady = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+         }
+         if ((DispenserBuildTimeCounter >= DispenserPrepareTimeout)||(pressureReady == true))
+         {
+             DispenserBuildTimeCounter = 0;
+             pressureReady = true;
+             Report("pressureReady = true  or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+         }
+     }
+     else if (endOfPrepareWCF == false)
+     {
+         if ((DispenserBuildTimeCounter == PRESSURE_READ_TIME_GAP)&&(FirstBrushStop))
+         {
+             Report("start prepare dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+             if (FirstBrushStop)
+             {
+                 REPORT_MSG(FirstBrushStop->index,"WFCFBrushStopRead Index");
+                 Dispensers = FirstBrushStop->dispensers;
+                 n_dispensers = FirstBrushStop->n_dispensers;
+                 if (n_dispensers)
+                 {
+                     for (Dispenser_i = 0; Dispenser_i < n_dispensers; Dispenser_i++)
+                     {
+                         DispenserId = Dispensers[Dispenser_i]->index;
+                         HW_Motor_Id = DispenserIdToMotorId[DispenserId];
+                         if (MotorsCfg[HW_Motor_Id].hardwaremotortype
+                                 != DispenserIdToMotorId[DispenserId])
+                             continue;
+                         if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER))
+                         {
+                             continue;
+                         }
+                         //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius)
+                         segmentfirst_speed = Dispensers[Dispenser_i]->nanolitterpersecond
+                                 / Dispensers[Dispenser_i]->nanoliterperpulse;
+                         if (Dispensers[Dispenser_i]->dispenserstepdivision
+                                 != DISPENSER_STEP_DIVISION__Auto)
+                         {
+                             //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
+                             segmentfirst_speed /=
+                                     Dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep
+                         }
+                         else
+                         {
+                             segmentfirst_speed/=8;//MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
+                         }
+                         if (segmentfirst_speed > MINIMAL_MOTOR_SPEED)
+                         {
+                             char IdMessage[100];
+                             segmentfirst_speed *= (100+WFCF);
+                             segmentfirst_speed /= 100;
+                             DispenserSegmentReady[DispenserId] = false;
+                             //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+                             //IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed,NULL);
+                             MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
+                             CurrentDispenserSpeed[Dispenser_i] = segmentfirst_speed;
 
-     if (NumofReadyDispensers>=NumOfActiveDispensers)
-         pressureReady = true;
+                             usnprintf(IdMessage, 80,
+                                       "WFCF Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d",
+                                       DispenserId,
+                                       (int) Dispensers[Dispenser_i]->nanolitterpersecond,
+                                       (int) Dispensers[Dispenser_i]->nanoliterperpulse,
+                                       (int) Dispensers[Dispenser_i]->pulsepersecond*1000,
+                                       (int) segmentfirst_speed*1000);
+                             //REPORT_MSG(segmentfirst_speed,IdsMessage);
+                             Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
+                             //SendJobProgress(0.0, 0, false, IdsMessage);
+                         }
+                         else
+                         {
+                             if (DispenserUsedInJob[DispenserId] == true)
+                             {
+                                 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);
+                             }
+                         }
+                     }//for
+                 }//if n_dis
+             }
+         }
+         if ((InterSegmentStartWFCFDispensers > 0)&&((InterSegmentStartWFCFDispensers-1000) == DispenserBuildTimeCounter))
+         {
+             //close waste valve one second before segment - trial
+             Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
+         }
+         if (DispenserBuildTimeCounter >=  InterSegmentStartWFCFDispensers)
+         {
+             endOfPrepareWCF = true;
+             FreeBrushStopFileData(FirstBrushStop);
+             FirstBrushStop =NULL;
+             Report("endOfPrepareWCF = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
 
-     if ((DispenserBuildTimeCounter >= DispenserPrepareTimeout)||(pressureReady == true))
+         }
+     }
+         //start new stage
+     if (endOfPrepareWCF == true)
      {
          SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
          DispenserPrepareControlId = 0xFF;
          Report("IDS_Prepare_Callback SafeRemoveControlCallback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
          setRapidPressureRead(false);
+         pressureReady = false;
+         endOfPrepareWCF = false;
          //DispenserPrepareReady();
          PrepareReady(Module_IDS,ModuleDone);
      }
@@ -547,39 +703,6 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
     }
     return OK;
 }
- /*uint32_t IDSPrepareStartDispenserAfterHoming(uint32_t DispenserId, uint32_t Result)
- {
-     double dispenserspeed = 0;
-     Report("IDSPrepare Start Dispenser After Homing",__FILE__,__LINE__,DispenserId,RpWarning,(int)Result,0);
-     dispenserspeed = DispenserPrepareSpeed;
-     if (DispenserUsedInJob[DispenserId] == true) //we actually should check for all dispensers
-     {
-         Report("Prepare Speed",__FILE__,__LINE__,DispenserId,RpWarning,(int)dispenserspeed,0);
-         IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,dispenserspeed, NULL);
-     }
-     return OK;
-
- }*/
-
- uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
- {
-     TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
-     if (DispenserUsedInJob[DispenserId] == true)
-     {
-         LOG_ERROR(DispenserId,"IDS_Check_Pressure_Callback active in a job");
-     }
-     if (JobIsActive())
-     {
-         SafeRemoveControlCallback(ControlIdtoInactiveDispenserId[DispenserId], IDS_Check_Pressure_Callback );
-         ControlIdtoInactiveDispenserId[DispenserId] = 0xFF;
-     }
-     if (GetDispenserPressure(DispenserId)>3.0)
-     {
-         Report("Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
-         MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,200);
-     }
-     return OK;
- }
 
  void IDSPrepareStart(void)
  {
@@ -593,7 +716,10 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
      }
 
      NumOfActiveDispensers = 0;
-     IDS_StopHomeDispenser(CLEANER_DISPENSER);
+     if (lubricant_speed > 0.1)
+         IDS_StopHomeDispenser(LUBRICANT_DISPENSER);
+      if ((EnableIntersegment == true)&&(IntersegmentLength>0))
+         IDS_StopHomeDispenser(CLEANER_DISPENSER);
      for (i = 0; i < MAX_DYE_DISPENSERS; i++)
      {
          if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
@@ -607,11 +733,37 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
          }
          else
          {
-             if ((HomingActive[i] == false)&&(PrimingActive == false))
+             /**/if (AutoHoming_Config >= AutoHoming_JobEnd_PowerOn_off)
+             {
+                 if ((HomingActive[i] == false)&&(PrimingActive[i] == false))
+                 {
+                     Report("Homing Inactive dispenser",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+                     IDS_HomeDispenser (i, 1000 , NULL);
+                 }
+                 else
+                 {
+                     Report("Inactive dispenser already homing",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+                 }
+             }/**/
+             /*if ((HomingActive[i] == false)&&(PrimingActive[i] == false))
              {
                  Report("Inactive dispenser open valve",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
                  Control3WayValvesWithCallback (i, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-             }
+                     Report("Homing Inactive dispenser",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+                     IDS_HomeDispenser (i, 1000 , NULL);
+                 }
+                 else
+                 {
+                     Report("Inactive dispenser already homing",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+                 }
+             }*/
+             //if ((HomingActive[i] == false)&&(PrimingActive[i] == false))
+             //{
+             //    Report("Inactive dispenser open valve",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+             //    Control3WayValvesWithCallback (i, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+             //}
+             //ControlIdtoInactiveDispenserId[Dispenser_i] = AddControlCallback( IDS_Check_Pressure_Callback, eOneMinute,TemplateDataReadCBFunction ,0, 0, 0 );
+
          }
      }
      if (NumOfActiveDispensers)
@@ -763,11 +915,13 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  }
                  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);
-
+                     if (DispenserUsedInJob[DispenserId] == true)
+                     {
+                         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);
+                     }
                  }
              }
              DispenserBuildTimeCounter = 0;
@@ -855,6 +1009,8 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          Report("End of Pre-segment Handling",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
          //PreSegmentReady(Module_IDS,ModuleDone);
          SafeRemoveControlCallback(DispenserPreSegmentControlId,IDSPreSegmentStateCallbackRunner);
+         if (CurrentDispenserSpeed[CLEANER_DISPENSER]>0)
+             IDS_Cleaning_Stop_Cleaning_Solution (NULL);
          setRapidPressureRead(false);
      }
      if (EnableCleaning == true)
@@ -1103,7 +1259,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
         }
         else
         {
-            LOG_ERROR(FileBrushStop,"BrushStopReadError");
+            LOG_ERROR(FileBrushStop,"End run - BrushStopReadError");
             JobEndReason = JOB_OUT_OF_DYE;
             PreSegmentReady(Module_IDS,ModuleFail);
         }
@@ -1145,12 +1301,15 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             }
             if ((EnableIntersegment == true)&&(IntersegmentLength>0.1)&&(SegmentId>0))
             {
-                MotorStop(HW_Motor_Id,Soft_Hiz); //26/03/19 test  without valves
-                CurrentDispenserSpeed[DispenserId] = 0;
-                //MotorSetSpeed(HW_Motor_Id, 5);
-                //CurrentDispenserSpeed[Dispenser_i] = 5;
-                DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped
-                REPORT_MSG(DispenserId,"Dispenser stopped pre Segment");
+                if (DispenserUsedInJob[DispenserId] == true)
+                {
+                    MotorStop(HW_Motor_Id,Soft_Hiz); //26/03/19 test  without valves
+                    CurrentDispenserSpeed[DispenserId] = 0;
+                    //MotorSetSpeed(HW_Motor_Id, 5);
+                    //CurrentDispenserSpeed[Dispenser_i] = 5;
+                    DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped
+                    REPORT_MSG(DispenserId,"Dispenser stopped pre Segment");
+                }
             }
             IDS_Valve_PresegmentReady(DispenserId,0); //27/03/19 to be removed when the presegment handler will be added
         }
@@ -1226,8 +1385,11 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
             {
                 DispenserSegmentReady[DispenserId] = true;
                 //IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);*/
-                MotorStop(HW_Motor_Id, Hard_Hiz);
-                CurrentDispenserSpeed[DispenserId] = 0;
+                if (DispenserUsedInJob[DispenserId] == true)
+                {
+                    MotorStop(HW_Motor_Id, Hard_Hiz);
+                    CurrentDispenserSpeed[DispenserId] = 0;
+                }
                 //Report("inActive dispenser stopped", __FILE__, __LINE__, DispenserId, RpWarning,   segmentfirst_speed, 0);
             }
         }
@@ -1276,6 +1438,18 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
     }
     return OK;
 }
+#define VALVE_DELAY 1
+#ifdef VALVE_DELAY
+
+uint32_t IDSValveControlId = 0xFF;
+uint32_t IDSSegmentStateSetValve(uint32_t IfIndex, uint32_t BusyFlag)
+{
+    SafeRemoveControlCallback(IDSValveControlId,IDSSegmentStateSetValve);
+    Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
+    Report("IDSSegmentState set valve after 1 second",__FILE__,__LINE__,(int)0,RpWarning,(int)0,0);
+    return OK;
+}
+#endif
 //********************************************************************************************************************
 uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
 {
@@ -1283,8 +1457,11 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      JobDispenser **Dispensers;
      int n_dispensers;
 
+#ifdef VALVE_DELAY
+     IDSValveControlId = AddControlCallback("VALVE_DELAY",IDSSegmentStateSetValve, eOneSecond,TemplateDataReadCBFunction,0,0,0);
+#else
      Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
-
+#endif
      IDS_Cleaning_Stop_Cleaning_Solution(NULL);
      SegmentNumOfBrushStops = Segment->n_brushstops;
      BrushStopTime = Segment->length/SegmentNumOfBrushStops;  //brushstop in meters
@@ -1412,7 +1589,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      {
          Report("IDS_Valve_EndValveReady start homing",__FILE__,deviceID,(int)AutoHoming_Config,RpWarning,(int)AutoHoming_JobEnd_PowerOn_off,0);
 
-         if (deviceID!=LUBRICANT_DISPENSER)
+         //if (deviceID!=LUBRICANT_DISPENSER)
          IDS_HomeDispenser (deviceID, 1000 , NULL);
      }
      return OK;
@@ -1432,6 +1609,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      if (FileBrushStop)
          FreeBrushStopFileData(FileBrushStop);
      FileBrushStop = NULL;
+     FirstBrushStop = NULL;
      if (DispenserPrepareControlId != 0xFF)
      {
          RemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
@@ -1455,8 +1633,8 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          }
          else
          {
-             RemoveControlCallback(ControlIdtoInactiveDispenserId[Dispenser_i], IDS_Check_Pressure_Callback );
-             ControlIdtoInactiveDispenserId[Dispenser_i] = 0xFF;
+//             RemoveControlCallback(ControlIdtoInactiveDispenserId[Dispenser_i], IDS_Check_Pressure_Callback );
+//             ControlIdtoInactiveDispenserId[Dispenser_i] = 0xFF;
              IDS_Valve_EndValveReady(Dispenser_i,false);
          }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index e1c529e4a..45cc80dff 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -202,6 +202,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     else
     if((request->amount == 0xDD) && (request->delay == 0xDD)) //Read Input Voltage
     {
+        LOG_ERROR(request->delay,"CheckAcInputVoltage");
        CheckAcInputVoltage();
 
        response.progress = (double)Input_Voltage;
@@ -210,6 +211,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     else
     if((request->amount == 0x0CE) && (request->delay == 0x0CE)) //Get Gas Sensor
     {
+        LOG_ERROR(request->delay,"FlashInitAndLoad");
         FlashInitAndLoad();
         response.progress = (double)OK;
         response.has_progress = true;
@@ -218,6 +220,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     else
     if(request->amount == 0x0CC)  //Cùøàøïâò÷ Vùêïâùàïíî ø÷ãôíîã÷
     {
+        LOG_ERROR(request->delay,"ResponseDemo");
 		ResponseDemo(request->delay);
         response.progress = (double)OK;
         response.has_progress = true;
@@ -226,12 +229,32 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     else
     if(request->amount == 0xE0)  //fast refresh for pressure
     {
+        LOG_ERROR(request->delay,"setRapidPressureRead");
         setRapidPressureRead(request->delay);
         response.progress = (double)OK;
         response.has_progress = true;
 
     }
-    else     if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
+    else
+    if(request->amount == 0xE1)  //fast refresh for pressure
+    {
+        LOG_ERROR(request->delay,"Starting Dispenser PID");
+        IDS_Start_Pid_Testing(request->delay);
+        response.progress = (double)OK;
+        response.has_progress = true;
+
+    }
+    else
+    if(request->amount == 0xE2)  //fast refresh for pressure
+    {
+        LOG_ERROR(request->delay,"Stoping Dispenser PID");
+        IDS_Stop_Pid_Testing(request->delay);
+        response.progress = (double)OK;
+        response.has_progress = true;
+
+    }
+    else
+    if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
     {
         PowerOffInit();
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
index 701c7b1fc..2baa6bb2d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
@@ -41,6 +41,7 @@
 #include "driverlib/ssi.h"
 #include "drivers/SPI/SPI_Comm.h"
 #include "Modules/Thread/Thread_ex.h"
+#include "Modules/Ids/Ids_ex.h"
 
 
 #include "Modules/thread/thread.h"
@@ -209,6 +210,14 @@ void Stub_MotorRunRequest(MessageContainer* requestContainer)
 
     MotorSetDirection(Motor_Id,Direction);
     MotorSetSpeed(Motor_Id, Run_Value);
+    if ((Motor_Id >= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)&&(Motor_Id <= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8))
+    {
+        CurrentDispenserSpeed[Motor_Id-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1] = Run_Value;
+        if(request->direction == 0)
+            CurrentDispenserSpeed[Motor_Id-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1] *= (-1);
+
+    }
+
 #endif
 
 
@@ -278,6 +287,10 @@ void Stub_MotorStopRequest(MessageContainer* requestContainer)
     TimerMotors_t Motor_Id  = (TimerMotors_t)request->motor_id; //to remove warning
     MotorStop(Motor_Id, Stop_Command);
 #endif
+    if ((Motor_Id >= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)&&(Motor_Id <= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8))
+    {
+        CurrentDispenserSpeed[Motor_Id-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1] = 0;
+    }
 
     //status = FPGA_ReadVersion((unsigned char)request->fpgaid, &Version, &Year, &Month, &Day);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 856812c12..852c19a1a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -67,6 +67,7 @@
     uint8_t CallbackCounter = 0;
     uint8_t TimeoutsCounter = 0;
 
+    uint32_t UnloadingStart = 0;
     uint8_t NumberOfDrierLoaderCycles = 0;
     uint32_t status = OK;
     uint32_t LoadingControlId = 0xFF,PullerControlId = 0xFF,WinderControlId = 0xFF;
@@ -184,8 +185,6 @@
         {
             Report("Thread_Load_Set_Load_Arm_To_Start_Position_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
             //storeLoadArmParameters();
-            MotorMove(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,LoadArmInfo.LoadArmBackLash );
-
             SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
             LoadStages++;
             ThreadLoadStateMachine(LoadStages);
@@ -215,6 +214,8 @@
 //move to exact location?
 //        Report("Thread Load State Machine Callback.",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
         CallbackCounter = 0;
+        Report("Thread_Load_Set_Load_Arm_To_Stopper time",__FILE__,msec_millisecondCounter - UnloadingStart,msec_millisecondCounter,RpMessage,UnloadingStart,0);
+
         Report("Thread_Load_Set_Load_Arm_To_Stopper_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
         NumberOfDrierLoaderCycles=0;
         //storeLoadArmParameters();
@@ -614,7 +615,7 @@
         LoadArmInfo.LoadArmRounds = 0;
         //uint32_t numberOfSteps = 0;
         //Start Feeder Pid, Rotate Loading Arm Counter Thread Direction X Circles According To Rml. Feeder Speed Is 40
-        SetOriginMotorSpeed(19);
+        SetOriginMotorSpeed(30);
 //        OriginalMotorSpd_2PPS[FEEDER_MOTOR] = 1000;
 //        CurrentControlledSpeed[FEEDER_MOTOR] = 1000;
 
@@ -670,14 +671,14 @@
         CallbackCounter++;
         //MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
         //                       numberOfSteps,    Thread_Load_Dryer_Loading_Callback, 100000);
-        Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+        UnloadingStart = msec_millisecondCounter;
+        Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,UnloadingStart,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
         LoadArmInfo.LoadArmBackLash = 5;
-
         status |= MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
-                                        MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4, Thread_Load_Set_Load_Arm_To_Stopper_Callback,LoadArmInfo.LoadArmBackLash,1000);
+                                        MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/2, Thread_Load_Set_Load_Arm_To_Stopper_Callback,LoadArmInfo.LoadArmBackLash,1000);
 
         //Keep Notation How Many Rotations In The Dryer
-        LoadArmInfo.LoadArmBackLash = 5;
+        //LoadArmInfo.LoadArmBackLash = 0;
         LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
         load.color = BLINK;
         return OK;
@@ -840,7 +841,7 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         CurrentControlledSpeed[index] = calculated_speed;
         MotorSetSpeed(ThreadMotorIdToMotorId[index], calculated_speed);
     }
-    if (index == POOLER_MOTOR)
+   /* if (index == POOLER_MOTOR)
     {
         if ((TranslatedReadValue)<(-1200))
         {
@@ -868,7 +869,7 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 
         }
 
-    }
+    }*/
 /*    LoadCounter++;
     if ((LoadCounter % 5001) == 0)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 741fed7af..4db985954 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -62,7 +62,7 @@ static uint32_t WindingConeLocation;
 static uint32_t WinderBackToBaseTime = 800;
 
 InternalWinderConfigStruc InternalWinderCfg = {0};
-#define READ_SCREW_ENCODER
+//#define READ_SCREW_ENCODER
 #ifdef READ_SCREW_ENCODER
 uint32_t ScrewLocationLimitSwitch = 0,ScrewLocationStart = 0;
 uint32_t ScrewLocationRun[3];
@@ -107,6 +107,8 @@ uint32_t InternalWindingConfigMessage(JobSpool* request)
     InternalWinderCfg.startoffsetpulses = request->startoffsetpulses;
     InternalWinderCfg.SpoolBottomBackingRate =  request->bottombackingrate;
     InternalWinderCfg.NumberOfRotationPerPassage = 3.1415926*2;//request->rotationsperpassage;
+    if (request->rotationsperpassage > 6.1)
+        InternalWinderCfg.NumberOfRotationPerPassage = request->rotationsperpassage;
     InternalWinderCfg.diameter = request->diameter;
     usnprintf(ScrewStr, 150, "WindingConfig start,offset,head,tail {, %d, %d, %d, %d, %d}",InternalWinderCfg.startoffsetpulses,(int)InternalWinderCfg.segmentoffsetpulses,
               (int)InternalWinderCfg.spoolbackingrate,(int)InternalWinderCfg.SpoolBottomBackingRate);
@@ -138,13 +140,13 @@ uint32_t Winder_Prepare(void *JobDetails)
      * report ready to the job STM
      */
 
-    /*if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
+    if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
     {
         REPORT_MSG(LIMIT, "No cone in winder");
-        PrepareReady(Module_Winder,ModuleFail);
-        AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
-        return ERROR;
-    }*/
+     //   PrepareReady(Module_Winder,ModuleFail);
+     //   AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
+     //   return ERROR;
+    }
 
 #ifdef READ_SCREW_ENCODER
     ScrewLocationRun[0] = 0;
@@ -279,7 +281,6 @@ numOfSteps = InternalWinderCfg.startoffsetpulses*MotorsCfg[HARDWARE_MOTOR_TYPE__
 double WinderReferenceSpeed=0;
 double  TotalWinderSpeed=0;
 bool Add100 = false;
-double Rotations = 6.0;
 int flipflop = 0;
 uint32_t motspeed;
 float speedf;
@@ -288,14 +289,8 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 {
     //uint32_t Steps;
     double temp,tempScrewSpeed;
-    double screw_horizontal_speed = 0;
-    double RotationsPerSecond;
-    //double Averagewinderspeed = 0;
-
-//    {
-//        TotalWinderSpeed-=WinderMotorSpeed[WinderMotorSpeedCounter];
-//        WinderMotorSpeed[WinderMotorSpeedCounter] = CurrentControlledSpeed[WINDER_MOTOR];
-//        TotalWinderSpeed+=WinderMotorSpeed[WinderMotorSpeedCounter];
+    //double screw_horizontal_speed = 0;
+    //double RotationsPerSecond;
         if (WinderMotorSpeedCounter++>=MAX_WINDER_SPEED_CALCULATION)
         {
             if (WinderMotorSpeedRollOver == false)
@@ -305,17 +300,6 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
             }
 //            WinderMotorSpeedCounter=0;
         }
-//    }
-    /*if (flipflop == 0)
-    {
-        MotorGetSpeedFromFPGA1(HARDWARE_MOTOR_TYPE__MOTO_SCREW);
-    }
-    else if (flipflop == 1)
-    {
-        speedf = MotorGetSpeedFromFPGA_Res(HARDWARE_MOTOR_TYPE__MOTO_SCREW);
-    }
-    flipflop ++;
-    */
     if (ScrewDirectionChangeCounter == CalculationDirectionChangeCounter)
         return OK;
     //deley TODO
@@ -353,16 +337,6 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
          Report("Winder difference",__FILE__,CalculationDirectionChangeCounter,ScrewLocationPrev[0],RpWarning,ScrewLocationRun[0], 0);
      }
      ScrewLocationPrev[0] = ScrewLocationRun[0];
-     //else
-     //    Report("winder run error value" ,__FILE__,WinderRun,ScrewLocationRun[0],RpWarning,ScrewLocationRun[1], 0);
-
-         //Report(ScrewStr,__FILE__,__LINE__,CalculationDirectionChangeCounter,RpWarning,ScrewLocationStart, 0);
-    //REPORT_MSG(abs(ScrewLocationRun[1] - ScrewLocationRun[0]), "Screw Run NumberOfSteps");
-    //usnprintf(ScrewStr, 100, "Winder Encoder: 0 0x%x 1 0x%x diff %d intent %d rot %d",ScrewLocationRun[0],ScrewLocationRun[1],abs(ScrewLocationRun[1] - ScrewLocationRun[0]),ScrewNumberOfSteps,Rotations*10);
-    //usnprintf(ScrewStr, 150, "Winder Encoder:id, diff, intended,  winderspeed,  rotation, speed, time, mot speed {, %d, %d, %d, %d, %d, %d, %d, %d, }",CalculationDirectionChangeCounter,
-    //          abs(ScrewLocationRun[1] - ScrewLocationRun[0]),ScrewNumberOfSteps,(int)(WinderReferenceSpeed),(int)(Rotations*10),(int)ScrewSpeed,(int)ScrewRunningTime,(int)speedf);
-    //usnprintf(ScrewStr, 100, "Winder Encoder: 0 %d 1 %d diff %d ",ScrewLocationRun[0],ScrewLocationRun[1],ScrewLocationRun[1] - ScrewLocationRun[0]);
-    //Report(ScrewStr,__FILE__,__LINE__,CalculationDirectionChangeCounter,RpWarning,ScrewLocationStart, 0);
 #endif
     if (ScrewCurrentDirection == 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize) //next time going out
     {
@@ -388,24 +362,6 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
     //        Report("Bottom Backing ",__FILE__,__LINE__,CalculationDirectionChangeCounter,RpWarning,ScrewNumberOfSteps, 0);
         }
     }
-   /* if (WinderMotorSpeedRollOver)
-    {
-        if (WinderCalculation%60000 == 0)//100 minutes
-        {
-            Averagewinderspeed = TotalWinderSpeed/MAX_WINDER_SPEED_CALCULATION;
-            //Report("WinderSpeedUpdated",__FILE__,__LINE__,(int)TotalWinderSpeed,RpWarning,(int)Averagewinderspeed,0);
-            WinderReferenceSpeed = Averagewinderspeed;
-        }
-        WinderCalculation++;
-    }*/
-    //WinderReferenceSpeed = 1000;
-    //ScrewNumberOfSteps = 1000;
-    screw_horizontal_speed = ScrewNumberOfSteps /  Rotations;//InternalWinderCfg.NumberOfRotationPerPassage;
-  //  if (Rotations > 6.6)//7.0)
-  //      Rotations = 6.0;
-    RotationsPerSecond =  WinderReferenceSpeed / (double)MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround;
-    tempScrewSpeed = screw_horizontal_speed*RotationsPerSecond;
-    //ROM_IntMasterDisable();
     tempScrewSpeed = ScrewSpeed;
 
     CurrentControlledSpeed[SCREW_MOTOR] = ScrewSpeed;
@@ -468,7 +424,6 @@ uint32_t Winder_Presegment(void *SegmentDetails, uint32_t SegmentId)
             InternalWinderCfg.SpoolBottomBackingRate =  2000; //no cone shape for samples
             InternalWinderCfg.NumberOfRotationPerPassage = 100; // a very slow movement of the screw
             JobSegment* Segment = SegmentDetails;
-            InternalWinderCfg.NumberOfRotationPerPassage = 100; // a very slow movement of the screw
             ScrewSpeed = InternalWinderCfg.segmentoffsetpulses/(((Segment->length *100)/dyeingspeed)/3);
             ScrewNumberOfSteps = InternalWinderCfg.segmentoffsetpulses;//*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep;
 
@@ -481,7 +436,6 @@ uint32_t Winder_Presegment(void *SegmentDetails, uint32_t SegmentId)
             InternalWinderCfg.SpoolBottomBackingRate =  2000; //no cone shape for samples
             InternalWinderCfg.NumberOfRotationPerPassage = 100; // a very slow movement of the screw
             JobSegment* Segment = SegmentDetails;
-            InternalWinderCfg.NumberOfRotationPerPassage = 100; // a very slow movement of the screw
             ScrewSpeed = InternalWinderCfg.segmentoffsetpulses/(((Segment->length *100)/dyeingspeed)/20);
             ScrewNumberOfSteps = InternalWinderCfg.segmentoffsetpulses;//*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep;
         }
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index 226bb2559..0df950f34 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -154,12 +154,12 @@ char DancerConfigPath[50] = "0://SysInfo//DancCfg.cfg";
 uint32_t StoreDancerConfigMessage()
 {
     uint32_t status = OK;
-  /*  FRESULT Fresult = FR_OK;
-  //  HardwareConfiguration DancerConfig;
-  //  HardwareDancer Dancers[MAX_SYSTEM_DANCERS];
+  //  FRESULT Fresult = FR_OK;
+    HardwareConfiguration DancerConfig;
+    HardwareDancer Dancers[MAX_SYSTEM_DANCERS];
   //  uint8_t* response_buffer;
   //  size_t response_size = 0;
-  //  int Dancer_i;
+    int Dancer_i;
 
     hardware_configuration__init(&DancerConfig);
     DancerConfig.dancers = (HardwareDancer**)my_malloc(sizeof(HardwareDancer*)*MAX_SYSTEM_DANCERS);
@@ -174,7 +174,7 @@ uint32_t StoreDancerConfigMessage()
         DancerConfig.n_dancers++;
         DancersCfg[Dancer_i].zeropoint = DancerConfig.dancers[Dancer_i]->zeropoint;
     }
-    */
+
     status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_0,DancersCfg[0].zeropoint);
     status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_1,DancersCfg[1].zeropoint);
     status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_2,DancersCfg[2].zeropoint);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 9d408a4a6..34934af0c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -118,7 +118,7 @@ uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Rea
   if (Current_Read < Previous_Read)
   {
     Time_Pass = (MAX_COUNTER - Previous_Read) + Current_Read + 1;
-    Report("Length rollover",__FILE__,__LINE__,(int)Current_Read,RpWarning,(int)Previous_Read,0);
+    ReportWithPackageFilter(ThreadFilter,"Length rollover",__FILE__,__LINE__,(int)Current_Read,RpWarning,(int)Previous_Read,0);
   }
   else
     Time_Pass = Current_Read - Previous_Read;
@@ -192,7 +192,7 @@ uint32_t ThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             usnprintf(Lenstr, 100, "length huge: length %d, diff 0x%x, pos 0x%x prev 0x%x",(int)length*100,(int)positionDiff,PreviousPosition,prevprev);
             SendJobProgress(0.0,0,false, Lenstr);
-            Report(Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+            ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
             length = 0;
 
         }
@@ -224,7 +224,7 @@ uint32_t ThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     {
         usnprintf(Lenstr, 100, "Total processed length: Feeder: %d Pooler %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
         SendJobProgress(0.0,0,false, Lenstr);
-        Report(Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+        ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
         // segment/intersegment/distance to spool finished
         if (ProcessedLengthFuncPtr)
             ProcessedLengthFuncPtr();
@@ -282,7 +282,7 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             usnprintf(Lenstr, 100, "length huge: length %d, diff 0x%x, pos 0x%x prev 0x%x",(int)length*100,(int)positionDiff,PreviousPosition,prevprev);
             SendJobProgress(0.0,0,false, Lenstr);
-            Report(Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+            ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
             length = 0;
 
         }
@@ -300,9 +300,12 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     {
         if (PrepareState == true)
         {
+#ifdef Use_Head_Card
+            strcpy(Lenstr,"Heating up");
+#else
             //later - add temperatures
              TemperatureListString(Lenstr);
-
+#endif
             SendJobProgress(0.0,0,false, Lenstr);
         }
         else
@@ -315,7 +318,7 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     {
         usnprintf(Lenstr, 100, "Total processed length: Feeder: %d Pooler %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
         SendJobProgress(0.0,0,false, Lenstr);
-        Report(Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+        ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
         // segment/intersegment/distance to spool finished
         if (ProcessedLengthFuncPtr)
             ProcessedLengthFuncPtr();
@@ -421,7 +424,7 @@ void testDancersControl()
     len = usnprintf(time, 150, "params: speed 50, divider %d p %d * %d i %d * %d Dt*1000 %d Norm Coef %d initial speed %d",NORMAL_COEF_DIVIDER,(int)MotorsControl[FEEDER_MOTOR].proportionalgain,(int)MotorsControl[FEEDER_MOTOR].outputonoffhysteresisvalue,
                     (int)MotorsControl[FEEDER_MOTOR].integraltime,(int)MotorsControl[FEEDER_MOTOR].setpointramprateorsoftstartramp,(int)(MotorsControl[FEEDER_MOTOR].controloutputtype*1000),
                     (int)(NormalizedErrorCoEfficient[FEEDER_MOTOR]*1000000000),OriginalMotorSpd_2PPS[FEEDER_MOTOR]);
-    Report(time,__FILE__,__LINE__,111,RpError,111,0);
+    ReportWithPackageFilter(ThreadFilter,time,__FILE__,__LINE__,111,RpError,111,0);
     Task_sleep(100);
     ThreadControlCBFunction(IfTypeThread*0x100+FEEDER_MOTOR, DancersCfg[HARDWARE_DANCER_TYPE__RightDancer].zeropoint - mm20);
     ThreadControlCBFunction(IfTypeThread*0x100+FEEDER_MOTOR, DancersCfg[HARDWARE_DANCER_TYPE__RightDancer].zeropoint - mm10);
@@ -478,7 +481,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         if (ReadValue < 10)
         {
             MotorFailedSample[index]++;
-            Report("Dancer value read too small.",__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
+            ReportWithPackageFilter(ThreadFilter,"Dancer value read too small.",__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
             return OK;
         }
         if (ReadValue == 0x3FFF)
@@ -533,7 +536,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                             SendSegmentFail();
                             //AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true);
                             //EndState(CurrentJob,"ReadBreakSensor Error" );
-                            LOG_ERROR(index, "ReadBreakSensor Error");
+                            ReportWithPackageFilter(ThreadFilter,"ReadBreakSensor Error",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
                             return OK;
                         } //passed limit
                     }//ReadBreakSensor()==ERROR
@@ -541,7 +544,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                     {
                         if (BreakSensorCounter)
                         {
-                            LOG_ERROR(BreakSensorCounter, "ReadBreakSensor Spike");
+                            ReportWithPackageFilter(ThreadFilter,"ReadBreakSensor Spike",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
                         }
                         BreakSensorCounter = 0;
                     }
@@ -559,7 +562,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 	                        SendSegmentFail();
 	                        //AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true);
 	                        //EndState(CurrentJob,"ReadBreakSensor Error" );
-	                        LOG_ERROR(index, "thread speed too low Error");
+                            ReportWithPackageFilter(ThreadFilter,"thread speed too low Error",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
 	                        return OK;
 						}
                     }
@@ -573,7 +576,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             keepdata = false;
             usnprintf(TMessage, 60, "Dancer %d limit %d value %d Zero %d",DancerId,DancerStopActivityLimit[index],avreageSampleValue,DancersCfg[DancerId].zeropoint);
-            Report(TMessage,__FILE__,__LINE__,avreageSampleValue,RpWarning,DancerStopActivityLimit[index],0);
+            ReportWithPackageFilter(ThreadFilter,TMessage,__FILE__,__LINE__,avreageSampleValue,RpWarning,DancerStopActivityLimit[index],0);
             //JobAbortedByUser = true;
             ThreadControlActive = false;
             //MotorGetStatusFromFPGA(ThreadMotorIdToMotorId[index]);
@@ -593,7 +596,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                     AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,true);
                     break;
             }*/
-            LOG_ERROR (DancerId, "Dancer Failure");
+            ReportWithPackageFilter(ThreadFilter,"Dancer Failure",__FILE__,DancerId,(int)avreageSampleValue,RpError,(int)JobCounter,0);
             return OK;
         }
         NormalizedError = avreageSampleValue*NormalizedErrorCoEfficient[index];
@@ -613,7 +616,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             //if (index == WINDER_MOTOR) //feeder unit handles errors opposite to left unit
             //{
-              //  Report("MotorSpeedUpdated",__FILE__,index,OriginalMotorSpd_2PPS[index],RpWarning,CurrentControlledSpeed[index],0);
+              //  ReportWithPackageFilter(ThreadFilter,"MotorSpeedUpdated",__FILE__,index,OriginalMotorSpd_2PPS[index],RpWarning,CurrentControlledSpeed[index],0);
             //}
             /`*if (JobCounter >= 3000)
             {
@@ -624,7 +627,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                 for (i=0;i<MAX_CONTROL_SAMPLES;i++)
                     avreageMotorSampleValue += MotorSpeedSamples[index][i];
                 avreageMotorSampleValue = avreageMotorSampleValue / MAX_CONTROL_SAMPLES;
-                //Report("MotorSpeedUpdated",__FILE__,index,OriginalMotorSpd_2PPS[index],RpWarning,avreageMotorSampleValue,0);
+                //ReportWithPackageFilter(ThreadFilter,"MotorSpeedUpdated",__FILE__,index,OriginalMotorSpd_2PPS[index],RpWarning,avreageMotorSampleValue,0);
                 OriginalMotorSpd_2PPS[index] = avreageMotorSampleValue;
             }*`/
         }*/
@@ -640,7 +643,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             MotorSetSpeed(ThreadMotorIdToMotorId[index], calculated_speed);
             /*if (((JobCounter % 2000) == index*100)&&(index == WINDER_MOTOR)) //feeder unit handles errors opposite to left unit
             {
-                Report("MotorSpeedUpdated",__FILE__,index,(int)OriginalMotorSpd_2PPS[index],RpWarning,(int)CurrentControlledSpeed[index],0);
+                ReportWithPackageFilter(ThreadFilter,"MotorSpeedUpdated",__FILE__,index,(int)OriginalMotorSpd_2PPS[index],RpWarning,(int)CurrentControlledSpeed[index],0);
             }*/
 #ifdef TEST_PID_THREAD
             int len;
@@ -659,7 +662,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                                 ReadValue,avreageSampleValue,(int)(MotorControlConfig[index].m_mesuredParam*1000000),
                                 (int)(MotorControlConfig[index].m_integral*1000000000),(int)((MotorControlConfig[index].m_mesuredParam*MotorControlConfig[index].m_params.dt)*1000000000),
                                 (int)(MotorControlConfig[index].m_calculatedError*1000),(int)calculated_speed);
-                Report(TMessage,__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
+                ReportWithPackageFilter(ThreadFilter,TMessage,__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
                 //Task_sleep(100);
                 //if (controlIndex++>=MAX_THREAD_CONTROL_LOG)
                 //    controlIndex = 0;
@@ -725,6 +728,8 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
     AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER,false);
     AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,false);
     AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,false);
+    AlarmHandlingSetAlarm(EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED,false);
+
 
     EnableLubrication = JobTicket->enablelubrication;
     EnableIntersegment = JobTicket->enableintersegment;
@@ -735,16 +740,16 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
     if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) != LIMIT)
     {
         ReportWithPackageFilter(ThreadFilter,"Dyeing head is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpFatalError,LIMIT,0);
-        JobEndReason = JOB_LIDS_OPEN;
-        PrepareReady(Module_Thread,ModuleFail);
-        return ERROR;
+        //JobEndReason = JOB_LIDS_OPEN;
+        //PrepareReady(Module_Thread,ModuleFail);
+        //return ERROR;
     }
     if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID]) != LIMIT)
     {
         ReportWithPackageFilter(ThreadFilter,"Dryer lid is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,RpFatalError,LIMIT,0);
-        JobEndReason = JOB_LIDS_OPEN;
-        PrepareReady(Module_Thread,ModuleFail);
-        return ERROR;
+        //JobEndReason = JOB_LIDS_OPEN;
+        //PrepareReady(Module_Thread,ModuleFail);
+        //return ERROR;
     }
 
     //start thread control for all motors
@@ -774,7 +779,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
 
             if (Motor_i == FEEDER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
             {
-                Report("Feeder Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
+                ReportWithPackageFilter(ThreadFilter,"Feeder Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
                 if (SpeedControlId != 0xFF)
                 {
                     RemoveControlCallback(SpeedControlId,ThreadLengthCBFunction);
@@ -786,7 +791,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
             }
             if (Motor_i == POOLER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
             {
-                Report("Puller Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
+                ReportWithPackageFilter(ThreadFilter,"Puller Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
                 if (PoolerSpeedControlId != 0xFF)
                 {
                     if (RemoveControlCallback(PoolerSpeedControlId,PoolerThreadLengthCBFunction)!=OK)
@@ -826,7 +831,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
             }
             if (Motor_i == WINDER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will n//ot be controlled
             {
-                Report("Winder Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
+                ReportWithPackageFilter(ThreadFilter,"Winder Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
                 if (ControlIdtoMotorId[Motor_i] != 0xFF)
                 {
                     if(RemoveControlCallback(ControlIdtoMotorId[Motor_i],ThreadControlCBFunction)!=OK)
@@ -869,7 +874,7 @@ void SetOriginMotorSpeed(float process_speed)
         OriginalMotorSpd_2PPS[Motor_i] = (int) motor_speed;
         InitialDryerSpeed = 0.0;
         CurrentControlledSpeed[Motor_i] = (int) motor_speed;
-        //Report("Original Speed",__FILE__,Motor_i,motor_speed,RpWarning,process_speed,0);
+        //ReportWithPackageFilter(ThreadFilter,"Original Speed",__FILE__,Motor_i,motor_speed,RpWarning,process_speed,0);
 
         for (i = 0; i <= MAX_CONTROL_SAMPLES; i++)
             MotorSpeedSamples[Motor_i][i] = motor_speed;
@@ -881,8 +886,6 @@ void ThreadPreSegmentEnded(void)
     REPORT_MSG (0,"First ThreadPreSegmentEnded");
     PreSegmentReady(Module_Thread,ModuleDone);
 }
-#define DRYER_RAMPUP 1
-#ifdef DRYER_RAMPUP
 int DrierDivider = 10;
 uint32_t ThreadDryerRampUp(uint32_t IfIndex, uint32_t BusyFlag)
 {
@@ -895,12 +898,11 @@ uint32_t ThreadDryerRampUp(uint32_t IfIndex, uint32_t BusyFlag)
     }
 
     MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,InitialDryerSpeed );
-    Report("ThreadDryerRampUp",__FILE__,ControlIdtoMotorId[DRYER_MOTOR],(int)InitialDryerSpeed,RpWarning,(int)OriginalMotorSpd_2PPS[DRYER_MOTOR],0);
+    //ReportWithPackageFilter(ThreadFilter,"ThreadDryerRampUp",__FILE__,ControlIdtoMotorId[DRYER_MOTOR],(int)InitialDryerSpeed,RpWarning,(int)OriginalMotorSpd_2PPS[DRYER_MOTOR],0);
 
 
     return OK;
 }
-#endif
 
 //********************************************************************************************************************
 uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
@@ -922,16 +924,12 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
         PrepareState = false;
 #ifndef TEST_PID_THREAD
         // set the new speed in the dryer motor to the speed of the new segment
-#ifndef DRYER_RAMPUP
-        MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING, OriginalMotorSpd_2PPS[DRYER_MOTOR]);
-#else
         DrierDivider = dyeingspeed/5;  //ramp up drier in 5 cm/sec steps
-        Report("Drier ramp up",__FILE__,__LINE__,(int)dyeingspeed,RpWarning,(int)DrierDivider,0);
+        ReportWithPackageFilter(ThreadFilter,"Drier ramp up",__FILE__,__LINE__,(int)dyeingspeed,RpWarning,(int)DrierDivider,0);
         InitialDryerSpeed = OriginalMotorSpd_2PPS[DRYER_MOTOR]/DrierDivider;
         MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,InitialDryerSpeed );
         ControlIdtoMotorId[DRYER_MOTOR] = AddControlCallback("DryerRampUp",ThreadDryerRampUp, 200,TemplateDataReadCBFunction,0,0,0);
 #endif
-#endif
 #ifdef HUNDRED_MICROSECONDS_DANCER_READ
      MillisecLogInit();
 #endif
@@ -1051,7 +1049,7 @@ char Endstr[150];
 
      usnprintf(Endstr, 100, "Total _processed length: Feeder: %d Pooler %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
      SendJobProgress(0.0,0,false, Endstr);
-     Report(Endstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+     ReportWithPackageFilter(ThreadFilter,Endstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
 
      ThreadUpdateProcessLength (0.0,(void *)NULL);
      //TotalProcessedLength = 0.0;
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index 9c4628f4f..c5c092ae4 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -371,20 +371,22 @@ bool SetValveDirection()
 U8 CartridgeWasteFilling(bool status)
 {
     bool ret = notOK;
-    //SetValveDirection();
+    SetValveDirection();
     if ((status == ON) && (WHS_info.active_cartridge != no_waste_cartridge))
     {
-        SetValveDirection();//Valve_Set(VALVE_WASTE_TANK, WHS_info.active_cartridge); //set the valve direction
+        //SetValveDirection();//Valve_Set(VALVE_WASTE_TANK, WHS_info.active_cartridge); //set the valve direction
         //Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mode); //set cartridge led color slow blink
         SetWastePump(OPEN);
         //WHS_info.WHS_pump.time = 0;
         REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP  ----------------- ");
+        AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  false);
         ret=OK;
     }
     else // stop Waste cartridge filling
     {
         SetWastePump(CLOSE);
-        Valve_Set(VALVE_WASTE_TANK, VALVE_DIR_WASTE_CARTRIDGE1);  //set the valve direction set to low POWER !!!
+        //Valve_Set(VALVE_WASTE_TANK, VALVE_DIR_WAST_CARTRIDGE1);  //set the valve direction set to low POWER !!!
+        AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  true);
 
         switch (WHS_info.active_cartridge)
            {
@@ -496,7 +498,7 @@ bool initWHS_WasteTank()
     WHS_info.WHS_sensors.waste_tank_empty_sensor = RdWasteTankEmptySensor();
     WHS_info.WHS_sensors.waste_tank_full_sensor =  SENSORnotFULL;
     UpdateStateMachine();
-    AddControlCallback("Waste tank",WasteTankCBFunction, WasteTankCallBackTime , WasteTankCallBackFunction, 0,0,0);//eOneMinute
+    AddControlCallback(NULL,WasteTankCBFunction, WasteTankCallBackTime , WasteTankCallBackFunction, 0,0,0);//eOneMinute
     return OK;
 }
 
@@ -567,6 +569,14 @@ WHS_sensor WasteTankCallBackFunction()
     return ret;
 }
 
+/*
+bool start_WHS_machin()
+{
+    AddControlCallback( WasteTankCBFunction,  eTenMillisecond, WasteTankCallBackFunction, 0,0,0 );// eOneMinute
+    return OK;
+}
+ */
+
 bool WasteTankCBFunction()
 {
 
@@ -617,6 +627,8 @@ bool WasteTankCBFunction()
                 REPORT_MSG(WHS_emptying," ------------ WHS_full , cartridge cover is open cant start the pump!!!! ----------------- ");
                 REPORT_MSG(WHS_emptying," ------------ close the cartridge cover to start the pump!!!! ----------------- ");
                 //pump_on_flag = OPEN;
+                AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  true);
+
                 WHS_info.WHS_sensors.waste_tank_full_sensor = SENSORnotFULL;
                 break;
             }
@@ -745,6 +757,7 @@ bool WasteTankCBFunction()
                     REPORT_MSG(WHS_full," ------------ Mid-tank filling in process ----------------- ");
                     Pannel_Leds(CART_1, MODE_ON);
                     cart1.color  = BLINK;
+                    MidTankValvesAction(Cartridge_MidTank_ON);
                     //add timeout
                     IFS_TimeOutAlarm(false);
                     IFS_info.Ink.time_out = 1;
@@ -1203,27 +1216,22 @@ bool SetActiveWastCartridge()
     uint8_t parameter = 5;
 
     bool ret = notOK;
-    if (( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == PRECENSE )
-         &&   (WHS_info.cartridge_1.autheticate == PASSED)
-         &&   (WHS_info.cartridge_1.status == WasteEmpty))
+    if (( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == PRECENSE ) &&
+            (WHS_info.cartridge_1.autheticate == PASSED))
         {
             REPORT_MSG(parameter," ------------  WHS : active_cartridge = waste_cartridge  1   ----------------- ");
             WHS_info.active_cartridge = waste_cartridge1;
-            AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  false);
         }
-    else if (( WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == PRECENSE)
-            && (WHS_info.cartridge_2.autheticate == PASSED)
-            && (WHS_info.cartridge_2.status == WasteEmpty))
+    else if (( WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == PRECENSE) &&
+            (WHS_info.cartridge_2.autheticate == PASSED))
         {
             REPORT_MSG(parameter," ------------  WHS : active_cartridge = waste_cartridge  2   ----------------- ");
             WHS_info.active_cartridge = waste_cartridge2;
-            AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  false);
         }
     else
         {
             REPORT_MSG(parameter," ------------  WHS : NO active_cartridge   ----------------- ");
             WHS_info.active_cartridge = no_waste_cartridge;
-            AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  true);
         }
     return ret;
 
diff --git a/Software/Embedded_SW/Embedded/Software Release Notes.txt b/Software/Embedded_SW/Embedded/Software Release Notes.txt
index 091d74d92..6a00adf48 100644
--- a/Software/Embedded_SW/Embedded/Software Release Notes.txt
+++ b/Software/Embedded_SW/Embedded/Software Release Notes.txt
@@ -1,17 +1,59 @@
 Embedded SW Release note - Version 1.4.6.0
 =============================================================
+Common:
+logs: better control (filter messages and priorities)
+
+Drivers:
 I2C reading task for better handling of slow I2C interactions (head etc)
+observe and handle FPGA watchdog reset (report, reinitialize motors) 
+
+Modules:
 textual names for control calls to help debuggng
 add midtank and dispenser ink content to diagnostics
-*observe and handle FPGA watchdog reset (reinitialize motors) 
+alarm handling: 
+	7midtamk overflow, 
+	*fix current alarms, 
+	*consequent actions and job verification, 
+	*critical alarms, 
+	*use alarms file (remote update)
+IDS: 
+	*dispenser data, 
+	*improve autofill on job start, 
+	*puller_tension from RML as cleaner speed, 
+	*handle inactive dispenser pressure,
+	*dispensers PID preparation, 
+	*bring dispensers to first segment pressures before job
+Thread: 
+	*real dryer rampup. 
+	*dancers from EEPROM only. 
+	*insure rockers motors voltage value;
+
+State machines:
+print: *prevent job on open covers (dryer, head) (suspended until new head)
 
-alarm handling: midtamk overflow, fix current alarms, consequent actions and job verification, critical alrms.
-diagnostics: improved 
-*heaters: band alarm fixed 
-IDS: *dispenser data, *improve autofill on job start, *puller_tension from RML as cleaner speed
-Thread: *real dryer rampup. dancers from EEPROM only. *insure rockers motors voltage value;
-print: *prevent job on open covers (dryer, head)
+preparation for new head:
+I2C scheduling (control, task)
+larger number of heaters (heaters module, control, diagnostics, alarms.
 
+Embedded SW Release note - Version 1.4.5.104 (alpha 1 ++)
+=============================================================
+restart HW and report if FPGA fails
+stop led blinking when jogging job fails
+fix IDS bug that prevented cleaning job at power off
+log power off temperature. fix bug that causes premature shutoff (PT100 spike)
+
+
+Embedded SW Release note - Version 1.4.5.100 (alpha 1 +)
+=============================================================
+magnet handling improved
+sw_ver in report log
+mock whs alarms
+read midtank every 1 hour (with valves handling)
+lubricant homing at half speed
+autohoming for lubricant
+fix bugs: ifs, stubs, 
+dryer ramp fixed
+out of idle on job start
 
 Embedded SW Release note - Version 1.4.5.96 (alpha 1 +)
 =============================================================
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
index f384210b4..01fcfb505 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
@@ -134,10 +134,12 @@ void InitSequenceBuiltInTestCallBack(uint32_t IfIndex, uint32_t BusyFlag)
     {
         InitStages++;
         //InitSequenceStateMachine(InitStages);
+        AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE,false);
     }
     else
     {
         MachineStateDetail = MACHINE_STATE_BUILT_IN_FAILED;
+        AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE,true);
     }
     //return OK;
 }
@@ -198,6 +200,9 @@ uint32_t InitSequenceBlowerCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
         Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
     else
         Control_Voltage_To_Blower(3000);
+
+    AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_INITIAL_BLOWER_FAILED,OFF);  //handle alarm detection and operation
+
     Safety_Init();
     InitStages++;
     //InitSequenceStateMachine(InitStages);
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
index 909135c71..e4efad2a0 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
@@ -70,6 +70,7 @@ void PowerOffSetTemperatureThreshold (int32_t temperature)
     if (temperature)
     {
         PowerOffTemperatureThreshold =  temperature*100;
+        Report("PowerOff Set Temperature",__FILE__,__LINE__,(int)PowerOffTemperatureThreshold,RpWarning,(int)3600,0);
     }
 }
 /*******************************************************************************************************/
@@ -373,6 +374,7 @@ uint32_t PowerOffWaitForTemperatureCallback(uint32_t IfIndex, uint32_t BusyFlag)
 /*******************************************************************************************************/
 uint32_t PowerOffWaitForTemperature(void)
 {
+    Report("PowerOff Wait For Temperature",__FILE__,__LINE__,(int)PowerOffTemperatureThreshold,RpWarning,(int)3600,0);
     if (WaitForProcessControlId == 0xFF)
     {
         WaitForProcessCounter = 0;
@@ -384,9 +386,14 @@ uint32_t PowerOffWaitForTemperature(void)
 /*******************************************************************************************************/
 uint32_t PowerOffTurnOffDryerFan(void)
 {
+    int i;
     Control_Dryer_Fan(STOP,75);//use START or STOP,  0 - 100%
     PowerOffMachineState++;
 
+    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 42f5572cf..83f4f032e 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -98,8 +98,6 @@ JobSpool *Tspool;
 bool CopyConfigured[MAX_SYSTEM_MODULES];
 bool CleaningJobActive = false, JoggingJobActive = false;
 char ErrorMsg[100];
-JobUploadStrategy uploadstrategy = JOB_UPLOAD_STRATEGY__Default;
-
 ModuleStateEnum PrepareWaiting[MAX_SYSTEM_MODULES] = {ModuleIdle,ModuleIdle,ModuleIdle,ModuleIdle,ModuleIdle};
 
 double job_length = 0.0;
@@ -747,11 +745,9 @@ void JobRequestFunc(MessageContainer* requestContainer)
                 if (CurrentJob->uploadstrategy == JOB_UPLOAD_STRATEGY__JobDescriptionFile)
                 {
                     LOG_ERROR(JobActive, "Job upload strategy file");
-                    uploadstrategy = JOB_UPLOAD_STRATEGY__JobDescriptionFile;
                 }
                 else
                 {
-                    uploadstrategy = JOB_UPLOAD_STRATEGY__Default;
                     n_segments = CurrentJob->n_segments;
                 }
                 status  = PASSED;
@@ -1151,6 +1147,7 @@ Void jobTask(UArg arg0, UArg arg1)
                 JobEndReason = JOB_OK;
                 Report("JobRequestMsg",__FILE__,__LINE__, JobActive,RpMessage,JobResumed,0);
                 JobActive = true;
+                PowerIdleOutOfIdleState();
                 SetMachineStatus(MACHINE_STATE__PreparingJob);
                 JobResumed = false;
                 setmachineActive(true);
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
index 710876e4a..587b1d2e8 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
@@ -19,6 +19,8 @@
 #include "include.h"
 #include "./printingSTM.h"
 
+#include "Drivers/Heater/Heater.h"
+
 #include "Modules/General/MachineStatus.h"
 #include "modules/General/process.h"
 #include "modules/thread/thread_ex.h"
@@ -335,7 +337,7 @@ uint32_t PrintingHWConfiguration(void *Configuration)
     {
         for (i = 0; i < request->n_pidcontrols ; i++)
         {
-            if (request->pidcontrols[i]->hardwarepidcontroltype <= HARDWARE_PID_CONTROL_TYPE__MixerHeater)
+            if (isHeater(request->pidcontrols[i]->hardwarepidcontroltype))
             {
                 Configured[Module_Heaters] = true;
                 break;
@@ -382,7 +384,11 @@ uint32_t PreSegmentReady(int ModuleId, ModuleStateEnum result)
     }
 
     PreSegmentWaiting[ModuleId] = result;
-    if (result == ModuleFail) status = ERROR;
+    if (result == ModuleFail)
+        {
+            status = ERROR;
+            Report("PreSegmentReady Fail!",__FILE__,__LINE__,(int)ModuleId,RpWarning,(int)result,0);
+        }
     for (i=0;i<MAX_SYSTEM_MODULES ;i++)
     {
         if (PreSegmentWaiting[i] == ModuleWaiting)
@@ -401,6 +407,7 @@ uint32_t PreSegmentReady(int ModuleId, ModuleStateEnum result)
             {
                 PrtMessage->messageId = PreSegmentResultsFail;
                 SendJobProgress(0.0, 0, false, "PreSegment Failed");
+	            Report("PreSegment Fail!",__FILE__,__LINE__,(int)ModuleId,RpWarning,(int)result,0);
             }
         //memcpy(Message.messageData,JobDetails,MAX_MSG_LEN);
         Message.msglen = 10;