Merge branch 'master' of https://twinetfs.visualstudio.com/Tango/_git/Tango

50 files changed, 5568 insertions, 3314 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 01d372aae..53394f4c0 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -24,15 +24,20 @@
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/FPGA/FPGA.h"
+#include "drivers/FPGA/Full_Vme/FPGA_Programming_Up.h"
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h"
+#include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
 #include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
+#include <Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h>
 #include "Common/SWUpdate/FileSystem.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
 
 #include "modules/thread/thread_ex.h"
 #include "modules/heaters/heaters_ex.h"
 #include "modules/ids/ids_ex.h"
+#include "modules/waste/waste_ex.h"
+#include "modules/General/process.h"
 #include  <PMR/Diagnostics/Event.pb-c.h>
 #include  <PMR/Diagnostics/EventType.pb-c.h>
 #include  <PMR/Diagnostics/StartEventsNotificationRequest.pb-c.h>
@@ -58,6 +63,8 @@
 
 #include "drivers/Valves/Valve.h"
 
+#include "StateMachines/Initialization/PowerIdle.h"
+
 Task_Handle AlarmHandling_Task_Handle;
 Mailbox_Handle          AlarmHandlingMsgQ = NULL;
 
@@ -66,6 +73,7 @@ bool AlarmHandlingActive = false;
 uint32_t AlarmHandlingControlId = 0xFF;
 uint32_t AlarmHandlingTick = 0;
 
+int MotorConfiguredTimeout = 100;
 double     CurrentAlarmHighLimit ,CurrentAlarmLowLimit;
 bool    CheckHardLimitAlarms = false,CheckCurrentAlarms = false,CheckTamperAlarms = false,CheckMotorAlarms = false;
 uint8_t alarm_response_buffer[500];
@@ -442,6 +450,7 @@ uint16_t FluidLevelWarning = 20,FluidLevelError = 50;
 int NumOfSystemAlarms = MAX_SYSTEM_ALARMS;
 //bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 bool EventsNotificationRequestAccepted = false;
+char AlarmReasonStr[100];
 //read dispensers limit switches. 25 - send warning. up - stop job and send alarm
 //Cone missing
 //Dyeing head over temperature
@@ -496,7 +505,7 @@ uint32_t AlarmHandlingLoadFile(void)
 
                     if (F_count == 4)
                     {
-                        ReportWithPackageFilter(AlarmFilter,"Writing four alarms", __FILE__,AlarmPtr,F_count, RpMessage, p_size, 0);
+                        //ReportWithPackageFilter(AlarmFilter,"Writing four alarms", __FILE__,AlarmPtr,F_count, RpMessage, p_size, 0);
                         F_count = 0;
                         ReadAppAndProgram(AlarmPtr, p_size,FileAlarmItem);
                         AlarmPtr+=p_size;
@@ -538,7 +547,7 @@ void AlarmHandlingInit(void)
 
     Error_init(&eb);
 
-    AlarmHandlingMsgQ = Mailbox_create(sizeof(AlarmHandlingMessageStruc), 20, NULL,&eb);
+    AlarmHandlingMsgQ = Mailbox_create(sizeof(AlarmHandlingMessageStruc), 40, NULL,&eb);
 
     int Alarm_i;
     for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
@@ -590,7 +599,8 @@ void     AlarmHandlingLoadFlags(void)
     CheckCurrentAlarms = (AlarmhandlingFlags && 0x0002);
     CheckTamperAlarms = (AlarmhandlingFlags && 0x0004);
     CheckMotorAlarms = (AlarmhandlingFlags && 0x0008);
-    ReportWithPackageFilter(AlarmFilter,"Alarm group setting", __FILE__,__LINE__,0, RpMessage, 1*CheckHardLimitAlarms+2*CheckCurrentAlarms+3*CheckTamperAlarms+4*CheckMotorAlarms, 0);
+    usnprintf(AlarmReasonStr, 100, "Alarm group from EEPPROM Current %d Motor %d Tamper %d",CheckCurrentAlarms,CheckMotorAlarms,CheckTamperAlarms);
+    ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,0, RpMessage, 1*CheckHardLimitAlarms+2*CheckCurrentAlarms+3*CheckTamperAlarms+4*CheckMotorAlarms, 0);
 }
 
 void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms, bool checkTamperAlarms, bool checkMotorAlarms)
@@ -600,7 +610,9 @@ void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms
     CheckCurrentAlarms = checkCurrentAlarms;
     CheckTamperAlarms = checkTamperAlarms;
     CheckMotorAlarms = checkMotorAlarms;
-    ReportWithPackageFilter(AlarmFilter,"Alarm group setting", __FILE__,__LINE__,0, RpMessage, 1*CheckHardLimitAlarms+2*CheckCurrentAlarms+3*CheckTamperAlarms+4*CheckMotorAlarms, 0);
+    usnprintf(AlarmReasonStr, 100, "Alarm group setting Current %d Motor %d Tamper %d",CheckCurrentAlarms,CheckMotorAlarms,CheckTamperAlarms);
+    ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,0, RpMessage, 1*CheckHardLimitAlarms+2*CheckCurrentAlarms+3*CheckTamperAlarms+4*CheckMotorAlarms, 0);
+
     if (CheckHardLimitAlarms) flags |= 0x1;
     if (CheckCurrentAlarms) flags |= 0x2;
     if (CheckTamperAlarms) flags |= 0x4;
@@ -611,7 +623,6 @@ void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms
         AlarmhandlingFlags = flags;
     }
 }
-char AlarmReasonStr[100];
 JobEndReasonEnum getEndReason(uint32_t AlarmId)
 {
     switch (AlarmItem[AlarmId].AlarmSource)
@@ -648,6 +659,9 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
                 usnprintf(AlarmReasonStr, 100, "Alarm %d type %d caused a job stop",AlarmId,AlarmItem[AlarmId].EventType);
                 return JOB_OTHER_ALARM;
             }
+        case ALARM_SOURCE_TYPE__FluidLevelAlarm:
+            usnprintf(AlarmReasonStr, 100, "Midtank %d is empty",AlarmItem[AlarmId].DeviceId);
+            return JOB_OUT_OF_DYE;
         default:
             usnprintf(AlarmReasonStr, 100, "Alarm %d type %d caused a job stop",AlarmId,AlarmItem[AlarmId].EventType);
             return JOB_OTHER_ALARM;
@@ -809,12 +823,12 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     //{
     //    DispenserInUse[Dispenser_i] = false;
     //}
-    JobEndReasonEnum status = JOB_OK;
+    JobEndReasonEnum FoundReason = JOB_OK,tempFoundReason;
     Task_Handle TaskHandle1 = Task_self();
     int pri = Task_getPri(TaskHandle1);
 
     ACTIVITY_GREEN_LED_ON;
-    Task_setPri(TaskHandle1, 2);
+    Task_setPri(TaskHandle1, 11);
     Task_sleep(10);
     Report("Task_setPri", __FILE__, pri, 3, RpWarning,   (int)TaskHandle1, 0);
     IDS_MapDispenserUsedinJob(CurrentJob);
@@ -824,14 +838,14 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     ACTIVITY_GREEN_LED_OFF;
     if (n_segments == 0)
     {
-        ReportWithPackageFilter(AlarmFilter,"no segments in the job", __FILE__,__LINE__,0, DEBUG_LOG_CATEGORY__Warning, AlarmItem[Alarm_i].DeviceId, 0);
-        return JOB_OK;
+        ReportWithPackageFilter(AlarmFilter,"no segments in the job", __FILE__,__LINE__,0, DEBUG_LOG_CATEGORY__Warning, 222, 0);
+        return JOB_FILE_PROBLEM;
     }
     if (AlarmItem == NULL)
     {
-        ReportWithPackageFilter(AlarmFilter,"missing alarm file", __FILE__,__LINE__,0, DEBUG_LOG_CATEGORY__Warning, AlarmItem[Alarm_i].DeviceId, 0);
+        ReportWithPackageFilter(AlarmFilter,"missing alarm file", __FILE__,__LINE__,0, DEBUG_LOG_CATEGORY__Warning, 223, 0);
         usnprintf(AlarmReasonStr, 100, "No alarm file in the machine",111);
-        return JOB_UNSPECIFIED_ERROR;
+        return JOB_NO_ALARM_FILE;
     }
 
     /*for (Segment_i=0;Segment_i<JobTicket->n_segments;Segment_i++)
@@ -865,7 +879,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                     {
                         if (AlarmState[Alarm_i].Status == true)
                         {
-                            status = JOB_LS_ALARM;
+                            FoundReason = JOB_LS_ALARM;
                             AlarmId = Alarm_i;
                             break;
                         }
@@ -878,7 +892,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     {
         if ((AlarmState[Alarm_i].Status == true)&&(AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical))
         {
-            status = JOB_SAFETY_CRITICAL_ALARM;
+            FoundReason = JOB_SAFETY_CRITICAL_ALARM;
             ReportWithPackageFilter(AlarmFilter,"critical alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
             AlarmId = Alarm_i;
             break;
@@ -886,9 +900,9 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
 
         if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__CoversAlarm)
         {
-            if (AlarmState[Alarm_i].Status == true)
+            if ((AlarmState[Alarm_i].Status == true)&&(AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error))
             {
-                status = JOB_TAMPER_ALARM;
+                FoundReason = JOB_TAMPER_ALARM;
                 ReportWithPackageFilter(AlarmFilter,"tamper alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                 AlarmId = Alarm_i;
                 break;
@@ -902,7 +916,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                 {
                     if (DispenserUsedInJob[AlarmItem[Alarm_i].DeviceId] == true)
                     {
-                        status = ERROR;
+                        FoundReason = JOB_OUT_OF_DYE;
                         ReportWithPackageFilter(AlarmFilter,"fluid level alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                         AlarmId = Alarm_i;
                         break;
@@ -916,7 +930,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
             {
                 if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
 				{
-	                status = JOB_MOTOR_ALARM;
+	                FoundReason = JOB_MOTOR_ALARM;
                     ReportWithPackageFilter(AlarmFilter,"motor alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
     	            AlarmId = Alarm_i;
         	        break;
@@ -939,7 +953,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                         {
                             if (AlarmState[Alarm_i].Status == true)
                             {
-                                status = JOB_TEMPERATURE_ALARM;
+                                FoundReason = JOB_TEMPERATURE_ALARM;
                                 AlarmId = Alarm_i;
                                 ReportWithPackageFilter(AlarmFilter,"temperature alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                                 break;
@@ -949,7 +963,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                         {
                             if (AlarmState[Alarm_i].Status == true)
                             {
-                                status = JOB_TEMPERATURE_ALARM;
+                                FoundReason = JOB_TEMPERATURE_ALARM;
                                 AlarmId = Alarm_i;
                                 ReportWithPackageFilter(AlarmFilter,"temperature alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                                 break;
@@ -960,13 +974,55 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
             }
         }
     }
-    if (status != JOB_OK)
+    if ((IFS_Availability[1] == IFS_RECOGNIZED_INIT_PASSED)&&(IFS_Availability[2] == IFS_RECOGNIZED_INIT_PASSED)) //ifs installed -check cartridges
+    {
+
+        tempFoundReason = Waste_CheckState(&AlarmId);
+        if (tempFoundReason!=JOB_OK)
+        {
+            FoundReason = tempFoundReason;
+            ReportWithPackageFilter(AlarmFilter,"waste handling alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+        }
+    }
+    if ((AlarmState[Alarm_i].Status == true)&&(FoundReason == JOB_OK))
+    {
+        if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
+        {
+            ReportWithPackageFilter(AlarmFilter,"an alarm existing before job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+            switch (AlarmItem[Alarm_i].EventType )
+            {
+                case EVENT_TYPE__INSUFFICIENT_AIR_FLOW:
+                case EVENT_TYPE__VOC_SENSOR_ALARM_TIME:
+#warning unmark to prevent job on voc alarm//case EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE:
+                //case EVENT_TYPE__POWER_UP_BIT_FAILURE:
+                    FoundReason = JOB_WASTE_HANDLING_PROBLEM;
+                    AlarmId = Alarm_i;
+                    ReportWithPackageFilter(AlarmFilter,"an alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+                    break;
+                case EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE:
+                case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE:
+                case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2:
+                    FoundReason = JOB_TEMPERATURE_ALARM;
+                    AlarmId = Alarm_i;
+                    ReportWithPackageFilter(AlarmFilter,"machine internal over-temperature is preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    if (FoundReason != JOB_OK)
     {
         JobEndReason = getEndReason(AlarmId);
+        if (JobEndReason!=FoundReason)
+        {
+            ReportWithPackageFilter(AlarmFilter,"end reason mismatch!!!", __FILE__,AlarmId,JobEndReason, RpMessage, FoundReason, 0);
+            JobEndReason=FoundReason;
+        }
         //AbortJob(AlarmReasonStr);
         //PrepareReady(Module_Alarms,ModuleFail);
         ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,AlarmId, RpMessage, DEBUG_LOG_CATEGORY__Error, 0);
-		return (JobEndReason);
+		return (FoundReason);
     }
     return JOB_OK;
 }
@@ -989,6 +1045,7 @@ uint32_t AlarmHandling_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
     return OK;
 }
 void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value);
+StartEventsNotificationResponse PersistentEventsResponse = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
 
 void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value)
 {
@@ -1004,46 +1061,77 @@ void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value)
 }
 void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value)
 {
-    int Alarm_i;
+    int Alarm_i,Event_i;
+    Event **re_events;
     if (AlarmItem == NULL)
         return;
     for (Alarm_i = 0;Alarm_i < NumOfSystemAlarms;Alarm_i++)
     {
         if (AlarmItem[Alarm_i].EventType == AlarmId)
         {
-            if (AlarmState[Alarm_i].Status != value)
+            if (0) // PERSISTENT ALARM
             {
-                if (value == true)
+                PersistentEventsResponse.n_events++;
+                if (PersistentEventsResponse.events == NULL)
+                    PersistentEventsResponse.events = (Event **)my_malloc(sizeof(Event*)*PersistentEventsResponse.n_events);
+                else
                 {
-                    // no need to call consequent actionsAlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity);
-                    // report the alarm!
-                    AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
-                    if (AlarmState[Alarm_i].EventPtr)
-                    {
-                        event__init(AlarmState[Alarm_i].EventPtr);
-                        AlarmState[Alarm_i].EventPtr->has_type = true;
-                        AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
-                        AlarmState[Alarm_i].EventPtr->message = NULL;//AlarmItem[Alarm_i].EventName;
-	                    AlarmState[Alarm_i].Status = value;
-                    }
-                    ReportWithPackageFilter(AlarmFilter,"Alarm ON ", __FILE__,AlarmState[Alarm_i].EventPtr,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
-                    if ((AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical)&&(JobIsActive()))
+                    re_events = (Event **)my_malloc(sizeof(Event*)*PersistentEventsResponse.n_events);
+                    for (Event_i = 0;Event_i < (PersistentEventsResponse.n_events-1);Event_i++)
                     {
-                        JobEndReason = getEndReason(Alarm_i);
-                        SendJobProgress(0.0,0, false, "Critical alarm!!!!");
-                        AbortJob("Critical alarm");
-                        ReportWithPackageFilter(AlarmFilter, AlarmReasonStr,__FILE__,__LINE__,Alarm_i,RpError, 0,0);
+                        re_events[Event_i] = PersistentEventsResponse.events[Event_i];
                     }
+                    my_free(PersistentEventsResponse.events);
+                    PersistentEventsResponse.events = re_events;
                 }
-                else
+                AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
+                if (AlarmState[Alarm_i].EventPtr)
                 {
-                    ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
-                    if (AlarmState[Alarm_i].EventPtr)
+                    event__init(AlarmState[Alarm_i].EventPtr);
+                    AlarmState[Alarm_i].EventPtr->has_type = true;
+                    AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
+                    AlarmState[Alarm_i].EventPtr->message = NULL;//AlarmItem[Alarm_i].EventName;
+                }
+                AlarmState[Alarm_i].Status = true;
+                PersistentEventsResponse.events[PersistentEventsResponse.n_events] = AlarmState[Alarm_i].EventPtr;
+                ReportWithPackageFilter(AlarmFilter,"Persistent Alarm ", __FILE__,PersistentEventsResponse.n_events,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
+            }
+            else
+            {
+                if (AlarmState[Alarm_i].Status != value)
+                {
+                    if (value == true)
                     {
-                        my_free(AlarmState[Alarm_i].EventPtr);
-                        AlarmState[Alarm_i].EventPtr = NULL;
+                        // no need to call consequent actionsAlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity);
+                        // report the alarm!
+                        AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
+                        if (AlarmState[Alarm_i].EventPtr)
+                        {
+                            event__init(AlarmState[Alarm_i].EventPtr);
+                            AlarmState[Alarm_i].EventPtr->has_type = true;
+                            AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
+                            AlarmState[Alarm_i].EventPtr->message = NULL;//AlarmItem[Alarm_i].EventName;
+                            AlarmState[Alarm_i].Status = value;
+                        }
+                        ReportWithPackageFilter(AlarmFilter,"Alarm ON ", __FILE__,AlarmState[Alarm_i].EventPtr,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
+                        if ((AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical)&&(JobIsActive()))
+                        {
+                            JobEndReason = getEndReason(Alarm_i);
+                            SendJobProgress(0.0,0, false, "Critical alarm!!!!");
+                            AbortJob("Critical alarm");
+                            ReportWithPackageFilter(AlarmFilter, AlarmReasonStr,__FILE__,__LINE__,Alarm_i,RpError, 0,0);
+                        }
+                    }
+                    else
+                    {
+                        ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
+                        if (AlarmState[Alarm_i].EventPtr)
+                        {
+                            my_free(AlarmState[Alarm_i].EventPtr);
+                            AlarmState[Alarm_i].EventPtr = NULL;
+                        }
+                        AlarmState[Alarm_i].Status = value;
                     }
-                    AlarmState[Alarm_i].Status = value;
                 }
             }
             break;
@@ -1105,6 +1193,9 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
     if (AlarmItem == NULL)
         return ERROR;
     int AlarmCounter=0;
+    if (MotorConfiguredTimeout)
+        MotorConfiguredTimeout--;
+
     for (Alarm_i = 0;Alarm_i < NumOfSystemAlarms;Alarm_i++)
     {
         Status = false;
@@ -1193,7 +1284,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                 }
                 break;
             case ALARM_SOURCE_TYPE__CurrentAlarm:
-                if (CheckCurrentAlarms)
+                if ((CheckCurrentAlarms)&&(getIdleState()==false))
                  {
                     if (AlarmItem[Alarm_i].ModuleDeviceId == 0xFF)
                     {
@@ -1210,14 +1301,14 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                                     if (doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit))
                                     {
                                         Status = true;
-                                        if (AlarmState[Alarm_i].Status == false)
-                                            ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                        //if (AlarmState[Alarm_i].Status == false)
+                                        //    ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                     }
-                                    if ((doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit))&&(isHeaterReady(AlarmItem[Alarm_i].DeviceId)==false))
+                                    if ((doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit))&&(isHeaterReady(AlarmItem[Alarm_i].DeviceId)==false)&&(doubleValue>100))
                                     {
                                         Status = true;
-                                        if (AlarmState[Alarm_i].Status == false)
-                                            ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                        //if (AlarmState[Alarm_i].Status == false)
+                                        //    ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                     }
                                 }
                                 else
@@ -1225,8 +1316,8 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                                     if (doubleValue <= 0.1)
                                     {
                                         Status = true;
-                                        if (AlarmState[Alarm_i].Status == false)
-                                            ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                        //if (AlarmState[Alarm_i].Status == false)
+                                        //    ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                     }
                                 }
                             }
@@ -1234,28 +1325,43 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     }
                     else
                     {
-                        if (Get_Head_Current(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
-                         {
-                             if (AlarmItem[Alarm_i].AlarmDirection == true)
+                        if (Head_Type < HEAD_TYPE_UNKNOWN_WITH_CARD) //no current alarms for old head
+                        {
+                            Status = false;
+                        }
+                        else
+                        {
+                            if (Get_Head_Current(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
                              {
-                                 if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                                 if (AlarmItem[Alarm_i].AlarmDirection == true)
                                  {
-                                     Status = true;
-                                     if (AlarmState[Alarm_i].Status == false)
-                                         ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                     if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit))&&(doubleValue>100))
+                                     {
+                                         Status = true;
+                                         if (AlarmState[Alarm_i].Status == false)
+                                         {
+                                             //usnprintf(AlarmReasonStr, 100, "OverCurrent Alarm %d ON dev %d debounce %d/%d value %d",AlarmItem[Alarm_i].EventType,AlarmItem[Alarm_i].DeviceId,AlarmState[Alarm_i].DebounceCounter,AlarmItem[Alarm_i].DebounceValue,(int)(doubleValue*100));
+                                             //ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                            // ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                         }
+                                     }
                                  }
-                             }
-                             else
-                             {
-                                 if (doubleValue <= 0.1)
+                                 else
                                  {
-                                     Status = true;
-                                     if (AlarmState[Alarm_i].Status == false)
-                                         ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                     if (doubleValue <= 0.1)
+                                     {
+                                         Status = true;
+                                         if (AlarmState[Alarm_i].Status == false)
+                                         {
+                                             //usnprintf(AlarmReasonStr, 100, "LOOP BREAK Alarm %d ON dev %d debounce %d/%d value %d",AlarmItem[Alarm_i].EventType,AlarmItem[Alarm_i].DeviceId,AlarmState[Alarm_i].DebounceCounter,AlarmItem[Alarm_i].DebounceValue,(int)(doubleValue*100));
+                                             //ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                            // ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                         }
+                                     }
                                  }
-                             }
 
-                         }
+                             }
+                        }
                     }
                  }
                  else
@@ -1266,7 +1372,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
             case ALARM_SOURCE_TYPE__MotorAlarm:
                 if (CheckMotorAlarms)
                 {
-                    if (FPGA_WD_Occurred == true)
+                    if ((FPGA_WD_Occurred == true)||(MotorConfiguredTimeout > 0))
                     {
                         Status = false;
                     }
@@ -1274,9 +1380,38 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     {
                         Status = false;
                     }
+                    else if (AlarmItem[Alarm_i].DeviceId == HARDWARE_MOTOR_TYPE__MOTO_SCREW)
+                    {
+                        Status = false;
+                    }
                     else
                     {
-                        value = MotorGetStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                        switch (AlarmItem[Alarm_i].AlarmValue)
+                        {
+                            case 1:
+                                Status = MotorGetOverCurrentStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Overcurrent on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            case 2:
+                                Status = MotorGetUnderVoltageStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Undervoltage on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            case 3:
+                                Status = MotorGetStallStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Stall on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            case 4:
+                                Status = MotorGetOverHeatStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Overtemperature on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            default:
+                                Status = false;
+                        }
+                        /*value = MotorGetStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
                         if (AlarmItem[Alarm_i].AlarmDirection == true)
                         {
                             if (value && AlarmItem[Alarm_i].AlarmValue)
@@ -1290,7 +1425,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                             {
                                 Status = true;
                             }
-                        }
+                        }*/
                     }
                 }
                 else
@@ -1302,7 +1437,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     break;
                 if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Warning)
                     FluidLevelWarning = AlarmItem[Alarm_i].AlarmValue;
-                else if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error)
+                else if ((AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error)&&(AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE))
                     FluidLevelError = AlarmItem[Alarm_i].AlarmValue;
                 value = Get_MidTank_Int1000_Sensor(AlarmItem[Alarm_i].DeviceId);
                 if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE)
@@ -1407,35 +1542,65 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                             }
                             break;
                         case DRYER_FAN :
-                            value = Read_Dryer_Fan_Tacho();
-                            if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
-                                if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value == DRYER_FAN_STOP))
-                                {
-                                    Status = true;
-                                    //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
-                                }
-                            else if (AlarmItem[Alarm_i].Severity ==  DEBUG_LOG_CATEGORY__Warning)
+							if (IsDryerStopped()==STOP)
                             {
-                                if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value < DRYER_FAN_MIN_RPM))
+                                Status = false;
+                                //ReportWithPackageFilter(AlarmFilter,"----------- DRYER_FAN skip-----------", __FILE__,IsDryerStopped(),Alarm_i, RpMessage, Status, 0);
+                            }
+                            else
+                            {
+                                value = Read_Dryer_Fan_Tacho();
+                                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
+                                    if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value == DRYER_FAN_STOP))
+                                    {
+                                        Status = true;
+                                        //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
+                                    }
+                                else if (AlarmItem[Alarm_i].Severity ==  DEBUG_LOG_CATEGORY__Warning)
                                 {
-                                    Status = true;
-                                    //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
+                                    if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value < DRYER_FAN_MIN_RPM))
+                                    {
+                                        Status = true;
+                                        //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
+                                    }
                                 }
+                             //ReportWithPackageFilter(AlarmFilter,"----------- DRYER_FAN----------------", __FILE__,value,Alarm_i, RpMessage, Status, 0);
                             }
                             break;
-                    }
+                        default:
 
-                    //ReportWithPackageFilter(AlarmFilter,"------------FANS_RPM[Alarm_i]----------------", __FILE__,__LINE__,Alarm_i, RpMessage, value, 0);
-
-                    if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
-                    {
-                        if (AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE)
-                        {
-                            if (value < AlarmItem[Alarm_i].AlarmValue)
+		                    //ReportWithPackageFilter(AlarmFilter,"------------FANS_RPM[Alarm_i]----------------", __FILE__,__LINE__,Alarm_i, RpMessage, value, 0);
+                            if (AlarmItem[Alarm_i].DeviceId >= WHS_FAN_1 )
                             {
-                                Status = true;
+                                value = WHS_Get_fan_tach(AlarmItem[Alarm_i].DeviceId - WHS_FAN_1+1);
+                                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
+                                    if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value == DRYER_FAN_STOP))
+                                    {
+                                        Status = true;
+                                        //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
+                                    }
+                                else if (AlarmItem[Alarm_i].Severity ==  DEBUG_LOG_CATEGORY__Warning)
+                                {
+                                    if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value < DRYER_FAN_MIN_RPM))
+                                    {
+                                        Status = true;
+                                        //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
+                                    }
+                                }
+                                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
+                                {
+                                    if (AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE)
+                                    {
+                                        if (value < AlarmItem[Alarm_i].AlarmValue)
+                                        {
+                                            Status = true;
+                                        }
+                                    }
+                                }
                             }
-                        }
+                            else
+                                Status = false;
+                            break;
                     }
                 }
                 break;
@@ -1590,6 +1755,8 @@ void SendEventNotifications(void)
         LargeMessagesAH++;
         return;
     }
+    if (FPGABurningActive==true)
+        return;
 
     EventsResponse.n_events = 0;
     //UInt Key = Task_disable();
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
index 3b39370bf..0ce6d4816 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
@@ -10,6 +10,8 @@
 #include "StateMachines/Printing/PrintingSTM.h"
 #include  <PMR/Diagnostics/EventType.pb-c.h>
 
+extern int MotorConfiguredTimeout;
+
 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 fab0831fe..689219583 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -43,10 +43,10 @@
 #include "modules/thread/thread_ex.h"
 #include "modules/ifs/ifs.h"
 #include "modules/ids/ids_ex.h"
+#include "modules/waste/waste_ex.h"
 #include "modules/Diagnostics/Diagnostics.h"
 #include "Modules/General/MachineStatus.h"
 
-#include "drivers/Flash_Memory/Flash_Memory.h"
 #include "drivers/Flash_Memory/fatfs/ff.h"
 #include "drivers/Flash_ram/FlashProgram.h"
 
@@ -62,6 +62,16 @@
 #include "Modules/Heaters/Heaters_ex.h"
 #include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
+#include <Drivers/I2C_Communication/I2C_Task.h>
+
+#include "drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.h"
+#include "Drivers/Uart_Comm/WHS_Controller_Comm/Shinko/ACS-13AC5E3.h"
+
+#include <Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.h>
+#include <Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h>
+#include <Drivers/I2C_Communication/RFID_NFC/RFIDTagInfo.h>
+#include <Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h>
+#include <Drivers/I2C_Communication/RFID_NFC/NFC.h>
 
 Task_Handle Millisecond_Task_Handle;
 /******************** Definitions  ********************************************/
@@ -490,9 +500,23 @@ uint32_t MillisecLoop(uint32_t tick)
 #ifdef HUNDRED_MICROSECONDS_DANCER_READ
    SaveLogData();
 #else
-    Dancer_Data[FEEDER_DANCER] = Read_Dancer_Position(FEEDER_DANCER);
-    Dancer_Data[POOLER_DANCER] = Read_Dancer_Position(POOLER_DANCER);
-    Dancer_Data[WINDER_DANCER] = Read_Dancer_Position(WINDER_DANCER);
+
+    #ifdef test_RTFU_dancer
+       test_dancer_responce_RTFU();
+    #else
+#ifdef FOUR_WINDERS
+        Dancer_Data[HARDWARE_DANCER_0] = Read_Dancer_Position(HARDWARE_DANCER_0);
+        Dancer_Data[HARDWARE_DANCER_1] = Read_Dancer_Position(HARDWARE_DANCER_1);
+        Dancer_Data[HARDWARE_DANCER_2] = Read_Dancer_Position(HARDWARE_DANCER_2);
+        Dancer_Data[HARDWARE_DANCER_3] = Read_Dancer_Position(HARDWARE_DANCER_3);
+        Dancer_Data[HARDWARE_DANCER_4] = Read_Dancer_Position(HARDWARE_DANCER_4);
+#else
+        Dancer_Data[FEEDER_DANCER] = Read_Dancer_Position(FEEDER_DANCER);
+        Dancer_Data[POOLER_DANCER] = Read_Dancer_Position(POOLER_DANCER);
+        Dancer_Data[WINDER_DANCER] = Read_Dancer_Position(WINDER_DANCER);
+#endif
+    #endif
+
 #endif
     return OK;
 }
@@ -564,25 +588,29 @@ float MillisecGetPressures (int SensorId)
     return PressureCalc[SensorId];
 }
 
+bool getRapidPressureRead(void)
+{
+    return RapidPressureRead;
+}
 void setRapidPressureRead(bool value)
 {
     RapidPressureRead = value;
     if (GetDiagnosticMode() == Diagnostic_Extreme_Mode)
         RapidPressureRead = true;
 }
-
 uint16_t PumpCounter = 0;
 uint16_t realtimetest[101];
 uint32_t MillisecLowLoop(uint32_t tick)
 {
     uint8_t Motor_i,Disp_i,temp;
     TEMPERATURE_SENSOR_ID_ENUM Sensor_i;
+    RFID_READER_ID readerID;
 
     //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 , m20msecTick,m70msecTick,m90msecTick, Onesecond_Tick,Tensecond_Tick,OneMinute_Tick,OneHourTick,Gradient_Tick;
+    bool Ten_msTick, Fifty_msTick, Hundred_msTick , m20msecTick,m70msecTick,m90msecTick, Onesecond_Tick,Tensecond_Tick,OneMinute_Tick,TenMinutes_Tick,OneHourTick,Gradient_Tick;
     bool O700Millisecond_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;
@@ -602,23 +630,29 @@ uint32_t MillisecLowLoop(uint32_t tick)
     Onesecond_Tick  =   (tick%eOneSecond == 0)           ?true:false;
     Tensecond_Tick  =   (tick%10000 == 0)           ?true:false;
     OneMinute_Tick  =   (tick%eOneMinute == 0)           ?true:false;
+    TenMinutes_Tick  =   (tick%eTenMinutes == 0)           ?true:false;
     OneHourTick  =   (tick%eOneHour == 0)           ?true:false;
     realtimetest[(tick%1000)/10]++;
     //gather Motor data from FPGA
     //ROM_IntMasterDisable();
     int StartPT100 = 0;
     //Screw_ENC_Velocity_to_DAC(); - for testing the screw enc
-    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
         StartPT100 = TEMP_SENSE_ANALOG_DRYER_TEMP1;
+
     if (Ten_msTick)
     {
-        Speed_Data = Read_Speed_Sensor_TypeII();
+        //Speed_Data = Read_Speed_Sensor_TypeII();
         //MillisecReadFromTempSensor(Sensor_Read, NULL);
         //if (Sensor_Read++ >= MAX_MAIN_CARD_TEMPERATURE_SENSOR_ID) Sensor_Read = 0;
         if(Machine_Idle_Mode == true)
             Machine_Idle_Breathing_Led();
         Trigger_HeaterWriting();
-
+        Read_Dryer_ENC_Position();
+    }
+    if (m20msecTick)
+    {
+        ADC0SS0Handler();
     }
     if(Fifty_msTick)
     {
@@ -643,7 +677,6 @@ uint32_t MillisecLowLoop(uint32_t tick)
 #ifndef EVALUATION_BOARD
         Read_Buttons_Reg();
 #endif
-        //Ink_Cart_Led();
         ///////////////////////////////////////////////////////////////////
 
 
@@ -669,6 +702,18 @@ uint32_t MillisecLowLoop(uint32_t tick)
         }
 
         Trigger_InputsReading();
+
+        #ifdef USE_RFID
+            //every 100 m sec
+            for(readerID = READER_1; readerID < Max_Readers ; readerID++)
+            {
+                if(DiscoverRFIDTagEvery100mSec[readerID] == true)
+                {
+                    RFIDCallEvery100mSec(readerID);
+                    break;
+                }
+            }
+        #endif
     }
     if (Gradient_Tick)
         DispensersCollectionCall();
@@ -714,9 +759,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
     {
         //char Lenstr[160];
         //static int Counter = 0;
-        MachineUpdateResponseFunc();
-        //KeepAliveOneSecondCall();
-
+        //MachineUpdateResponseFunc();
+        KeepAliveOneSecondCall();
         //TemperatureListString(Lenstr);
         //ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)Counter++,RpWarning,(int) msec_millisecondCounter,0);
         for (Sensor_i = StartPT100;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
@@ -734,9 +778,15 @@ uint32_t MillisecLowLoop(uint32_t tick)
         {
             //Trigger_WHS_PT100_Read_All();
             WHS_Blower_Avarege(HEAD_FLOW_METER);
+            WHS_Blower_Avarege(NU_FLOW_METER);
             WHS_Blower_Avarege(DRIER_FLOW_METER);
             WHS_Start_Blower_Control_Closed_Loop ();
 
+            if (ReadingVocEverySec == true)//eOneSecond
+            {
+                Trigger_WHS_MAX11614_Read_Gas_Sensor();
+            }
+
            /* static uint8_t Whs_emptying_cycle = 0;
 
             // #warning TBD need to define the timing
@@ -750,19 +800,32 @@ uint32_t MillisecLowLoop(uint32_t tick)
                 Whs_emptying_cycle++;
             }
             */
+
+            if(Shinko_first_read < 2)//read the two steps once and than in cycle every 10 minutes, also will be used to read after updating the temperature
+            {
+                Shinko_Cycle_Comm();
+            }
+        }
+        if (Head_Type == HEAD_TYPE_ARC) {
+            HeadBlowersControlLoop();
         }
+
+        //call waste state machine
+        Waste_StateMachine_OneSecond_Call();
+
+        //call IFS state machine
+        midTankStateMachine();
+
+        #ifdef USE_RFID
+                RFIDCycleEvery1Sec();
+        #endif
     }
     if (Tensecond_Tick)
     {
-        //Trigger_MidTank_Pressure_Read();
-        for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
-        {
-            Read_MidTank_Pressure_Sensor(Disp_i);
-        }
     }
     if (OneMinute_Tick)
     {
-//        MachineUpdateResponseFunc();
+        MachineUpdateResponseFunc();
         /*        for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++)
         {
             if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_SCREW)
@@ -773,14 +836,35 @@ uint32_t MillisecLowLoop(uint32_t tick)
         midtankDisplay = 1-midtankDisplay;
         /*if (WHS_Type == WHS_TYPE_UNKNOWN)
             Gas_PPM_Info = Calculate_Gas_Power_Consumption();*/
-        if (WHS_Type == WHS_TYPE_NEW)
-            waste_seq_step1();// include 1Sec delay
 //            ReportWithPackageFilter(ThreadFilter,"waste tank calculate level",__FILE__,__LINE__,(int)(GetWHSWasteTankLevelMiliLiter()*1000),RpWarning,(int) msec_millisecondCounter,0);
         //Trigger_WHS_MAX11614_Read_allADC();
+        if ((WHS_Type == WHS_TYPE_NEW) && (ReadingVocEverySec == false))//OneMinute_Tick
+        {
+            Trigger_WHS_MAX11614_Read_Gas_Sensor();
+        }
 #ifdef CONTROL_DEBUG
         ResetControlTime();
 #endif
     }
+    if (TenMinutes_Tick)
+    {
+        /*if (WHS_Type == WHS_TYPE_NEW)
+        {
+            waste_seq_step1();// include 1Sec delay           <- to open !!!!
+        }*/
+        if (WHS_Type == WHS_TYPE_NEW)
+        {
+            Shinko_Cycle_Comm();
+        }
+#ifndef RUN_AS_MAIN_JIG
+        //Trigger_MidTank_Pressure_Read();
+        for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
+        {
+            Read_MidTank_Pressure_Sensor(Disp_i);
+        }
+#endif
+
+    }
     if (OneHourTick)
     {
 #define PUMP_LIMIT 4
@@ -791,6 +875,11 @@ uint32_t MillisecLowLoop(uint32_t tick)
             PumpCounter = 0;
         }
         MidTankReading();
+        if (WHS_Type == WHS_TYPE_NEW)
+        {
+            waste_seq_step1();// include 1Sec delay           <- to open !!!!
+        }
+        //Trigger_WHS_MAX11614_Read_Gas_Sensor();
     }
     //ROM_IntMasterEnable();
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
index 9335a6d08..0d7c42ad6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
@@ -36,6 +36,7 @@ uint8_t getGasReading(void);
 int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId);
 float MillisecGetPressures (int SensorId);
 void setRapidPressureRead(bool value);
+bool getRapidPressureRead(void);
 
 
 void MillisecInit(void);
@@ -49,7 +50,6 @@ void MillisecLogClose(void);
 
 #endif
 
-
 extern bool watchdogCriticalAlarm;
 
 extern Task_Handle Millisecond_Task_Handle;
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c b/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c
index 3d1d353c2..eac1f605a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c
@@ -5,7 +5,7 @@ float PIDAlgorithmCalculation(float _setPoint,float _mesuredParam , PID_Config_P
 {
     float error;
     float derivative;
-    float output;
+    float output = 0;
 
     //Calculate P,I,D
     error = _setPoint - _mesuredParam;
@@ -19,7 +19,7 @@ float PIDAlgorithmCalculation(float _setPoint,float _mesuredParam , PID_Config_P
     derivative = (error - *_pre_error)/params->dt;
 
     output = params->Kp*error/params->ProportionalErrorMultiplier + params->Ki**_integral/params->IntegralErrorMultiplier + params->Kd*derivative;
-
+    //}
     //Saturation Filter
     if(output > params->MAX)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index 0f9848ba1..0a092821e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -170,6 +170,7 @@ void ControlStop(void)
     ControlRestart = false;
     ADCAcquireStop();
 }
+int FPGA_ReInit_Count = 0; ///avoid too many reinitializations of motors as happens when FPGA is corrupted
 uint32_t ControlActivityLed( uint32_t Parameter1)
 {
     static bool flag = false;
@@ -189,19 +190,39 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
                 if (JobIsActive())
                 {
                     JobEndReason = JOB_MOTOR_ALARM;
+                    usnprintf(AlarmReasonStr, 100, "Hardware Failure Error");
                     SendJobProgress(0.0,0,false, "Hardware Failure Error");
                     AbortJob("FPGA Watchdog Error");
                 }
-                ReportWithPackageFilter(FPGAFilter, "FPGA Watchdog Error",__FILE__,__LINE__,0,RpError, 0,0);
+                if (FPGA_ReInit_Count++<20)
+                {
+                    ReportWithPackageFilter(FPGAFilter, "FPGA Watchdog Error",__FILE__,__LINE__,0,RpError, 0,0);
+
+                    ACTIVITY_GREEN_LED_ON;
+                    MotorConfiguredTimeout = 100;
 
-                ACTIVITY_GREEN_LED_ON;
-                FPGA_SetMotorsInit();
-                Motor_ReconfigAllMotors();
+                    FPGA_SetMotorsInit();
+                    Motor_ReconfigAllMotors();
+                }
             }
         }
 		else
             ACTIVITY_GREEN_LED_OFF;
 
+        if(power.color == colorOFF) Pannel_Leds(POWER_ON_OFF,MODE_OFF);
+        if(jog.color   == colorOFF) Pannel_Leds(THREAD_JOGGING,MODE_OFF);
+        if(load.color  == colorOFF) Pannel_Leds(THREAD_JOGGING,MODE_OFF);
+        if(cart1.color == colorOFF) Pannel_Leds(CART_1,MODE_OFF);
+        if(cart2.color == colorOFF) Pannel_Leds(CART_2,MODE_OFF);
+        if(cart3.color == colorOFF) Pannel_Leds(CART_3,MODE_OFF);
+
+        if(power.color == colorON) Pannel_Leds(POWER_ON_OFF,MODE_ON);
+        if(jog.color   == colorON) Pannel_Leds(THREAD_JOGGING,MODE_ON);
+        if(load.color  == colorON) Pannel_Leds(THREAD_JOGGING,MODE_ON);
+        if(cart1.color == colorON) Pannel_Leds(CART_1,MODE_ON);
+        if(cart2.color == colorON) Pannel_Leds(CART_2,MODE_ON);
+        if(cart3.color == colorON) Pannel_Leds(CART_3,MODE_ON);
+
         if(power.color == fastBILNK)
             Pannel_Leds(POWER_ON_OFF,MODE_OFF);
         else
@@ -593,6 +614,9 @@ uint32_t ControlLowLoop(uint32_t tick)
                 continue;
             if (ControlArray[ControlLowDevice_i].ControlTiming == eOneMillisecond)
                 continue;
+            if (ControlArray[ControlLowDevice_i].StartTick == tick)
+                continue;
+
             if (((tick - ControlArray[ControlLowDevice_i].StartTick)%ControlArray[ControlLowDevice_i].ControlTiming)<=skipped_ticks) // run the control on exact intervals
             {
                 ControlBacklog[backlogindex]=ControlLowDevice_i;
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.h b/Software/Embedded_SW/Embedded/Modules/Control/control.h
index 78e24f495..4b6a80967 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h
@@ -21,6 +21,7 @@ typedef enum {
     eHundredMillisecond = 100,
     eOneSecond = 1000,
     eOneMinute = 60000,
+    eTenMinutes = 600000,
     eOneHour = 3600000
 }CTRL_TIMING_ENUM;
 typedef enum
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index 42739f20f..79e84ebca 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -24,13 +24,15 @@
 #include  <PMR/Diagnostics/SetBlowerStateResponse.pb-c.h>
 #include  <PMR/Hardware/HardwareBlowerType.pb-c.h>
 
+#include <Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h>
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/I2C_Communication/DAC/blower.h"
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h"
+#include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
 #include "drivers/Valves/Valve.h"
 #include "drivers/Heater/Heater.h"
-#include "modules/waste/waste.h"
+#include "modules/waste/waste_ex.h"
 #include "Drivers/I2C_Communication/I2C_Task.h"
 #include "Drivers/I2C_Communication/I2C.h"
 #include "modules/ids/ids_ex.h"
@@ -213,6 +215,11 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
                 Trigger_SetWHSValveWatseCartridge(request->value);
             break;
         case INTERFACE_IOS__GPO_WHS_WTANKPUMP2:
+            if ((IFS_Availability[1] == IFS_RECOGNIZED_INIT_PASSED)&&(IFS_Availability[2] == IFS_RECOGNIZED_INIT_PASSED)) //ifs installed -check cartridges
+            {
+                if (NoCartAvailable())
+                    return ERROR;
+            }
             SetWastePump( request->value);
             break;
         case INTERFACE_IOS__GPO_SPARE_SSR12_CTRL:
@@ -225,7 +232,10 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
                 Pumps_Control(WASTECH_PUMP2, request->value);
             break;
         case INTERFACE_IOS__GPO_LED3:
-            Trigger_Head_Actuators_Control(ACTIN, LOW,request->value);
+            if (request->value == true)
+                Trigger_Head_Actuators_Control(ACTIN, LOW,request->value);
+            else
+                HeadCard_Actuators_Relocate();
             break;
         case INTERFACE_IOS__GPO_LED4:
             Trigger_Head_Actuators_Control(ACTOT, LOW,request->value);
@@ -368,7 +378,7 @@ uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer)
                 Turn_the_Blower_Off();
             break;
         case HARDWARE_BLOWER_TYPE__HeadBlower1:
-            if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+            if (Head_Type == HEAD_TYPE_ARC)
             {
                 if ((request->has_voltage)&&(request->isactive == true))
                     Trigger_Head_Fan_Control(HEAD_FAN_RIGHT,request->voltage);
@@ -380,7 +390,7 @@ uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer)
 
             break;
         case HARDWARE_BLOWER_TYPE__HeadBlower2:
-            if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+            if (Head_Type == HEAD_TYPE_ARC)
             {
                 if ((request->has_voltage)&&(request->isactive == true))
                     Trigger_Head_Fan_Control(HEAD_FAN_LEFT,request->voltage);
@@ -390,6 +400,16 @@ uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer)
             else
                 status = NOT_SUPPORTED;
             break;
+        case HARDWARE_BLOWER_TYPE__WHSSmallFans:
+            Trigger_SetWHSFanSpeed(FAN1, request->voltage);
+            Trigger_SetWHSFanSpeed(FAN2, request->voltage);
+            Trigger_SetWHSFanSpeed(FAN3, request->voltage);
+            Trigger_SetWHSFanSpeed(FAN4, request->voltage);
+            break;
+        case HARDWARE_BLOWER_TYPE__WHSLargeFans:
+            Trigger_SetWHSFanSpeed(FAN5, request->voltage);
+            Trigger_SetWHSFanSpeed(FAN6, request->voltage);
+            break;
         default:
             status = NOT_SUPPORTED;
             break;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 7758ebd8b..de4c31ed1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -17,12 +17,14 @@
 #include "drivers/Motors/Motor.h"
 #include "drivers/Heater/TemperatureSensor.h"
 #include "drivers/SSI_Comm/Dancer/Dancer.h"
+#include <Drivers/SSI_Comm/SSI_Comm.h>
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/FPGA/FPGA.h"
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
 #include "drivers/I2C_Communication/DAC/Blower.h"
+#include <Drivers/I2C_Communication/I2C_Task.h>
 #include "drivers/valves/valve.h"
 
 #include "modules/ids/ids_ex.h"
@@ -31,7 +33,7 @@
 #include "Modules/AlarmHandling/AlarmHandling.h"
 #include "Modules/heaters/heaters_ex.h"
 #include "modules/thread/thread_ex.h"
-#include "modules/waste/waste.h"
+#include "modules/waste/waste_ex.h"
 
 #include "PMR/Hardware/HardwareDancerType.pb-c.h"
 #include  <PMR/Diagnostics/StartDiagnosticsRequest.pb-c.h>
@@ -47,11 +49,15 @@
 #include  <PMR/debugging/DebugLogCategory.pb-c.h>
 
 #include "StateMachines/Printing/PrintingSTM.h"
+#include "StateMachines/Initialization/InitSequence.h"
 
 #include <drivers/FPGA/FPGA_Comm.h>
 
 #include "diagnostics.h"
 #include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
+#include <Drivers/I2C_Communication/WHS_Card/D_AD5272_Rheostat/WHS_Rheostat.h>
+#include "drivers/Uart_Comm/WHS_Controller_Comm/Shinko/ACS-13AC5E3.h"
+#include "Modules/IFS/ifs.h"
 
 extern F2_CTRL_REG F2_CTRL_Reg;
 
@@ -108,11 +114,11 @@ double dryerzone3temperature[DIAGNOSTICS_LIMIT+1];*/
 
 double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
 double dispenserspressure[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
-double dispenserinklevel[MAX_SYSTEM_DISPENSERS][1];
-double midtankinklevel[MAX_SYSTEM_DISPENSERS][1];
+//double dispenserinklevel[MAX_SYSTEM_DISPENSERS][1];
+//double midtankinklevel[MAX_SYSTEM_DISPENSERS][1];
 double MidTankpressure[MAX_SYSTEM_DISPENSERS][1];
-double HeadFlowMeter;
-double tempFlow = 0.0;
+double HeadFlowMeter,TotalFlowMeter;
+//double tempFlow = 0.0;
 double DrierFlowMeter;
 double AcVoltage;
 double WasteLevel = 0.0;
@@ -123,13 +129,13 @@ double OverallTemperature;
 
 DoubleArray DispenserFreq[MAX_SYSTEM_DISPENSERS];
 DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS];
-DoubleArray DispenserInkLevel[MAX_SYSTEM_DISPENSERS];
-DoubleArray DiagnosticsMidTankInkLevel[MAX_SYSTEM_DISPENSERS];
+//DoubleArray DispenserInkLevel[MAX_SYSTEM_DISPENSERS];
+//DoubleArray DiagnosticsMidTankInkLevel[MAX_SYSTEM_DISPENSERS];
 
 HeaterState **heatersstates;
 HeaterState  HeaterInfo[HEATER_TYPE_MAX_HEATERS];
 
-#define NUM_OF_INTERFACE_IOS 23
+#define NUM_OF_INTERFACE_IOS 26
 DigitalInterfaceState **digitalinterfacestates;
 DigitalInterfaceState DigitalOutputState[NUM_OF_INTERFACE_IOS];
 /*double dispenser1motorfrequency[DIAGNOSTICS_LIMIT+1];
@@ -144,6 +150,7 @@ double dispenser8motorfrequency[DIAGNOSTICS_LIMIT+1];
 Task_Handle Diagnostics_Task_Handle;
 Mailbox_Handle          DiagnosticsMsgQ = NULL;
 
+extern uint8_t Head_Fan_PWM_Command[2] ;
 bool blowervolatgedisplay = false;
 bool midtankDisplay = false;
 double diagvoltage = 0;
@@ -187,14 +194,14 @@ void DiagnosticsInit(void)
 
     DiagnosticsMonitor.dispensersmotorsfrequency = (DoubleArray**)my_malloc(sizeof(DoubleArray *)*MAX_SYSTEM_DISPENSERS);
     DiagnosticsMonitor.dispenserspressure = (DoubleArray**)my_malloc(sizeof(DoubleArray)*MAX_SYSTEM_DISPENSERS);
-    DiagnosticsMonitor.midtanksinklevel = (DoubleArray**)my_malloc(sizeof(DoubleArray)*MAX_SYSTEM_DISPENSERS);
-    DiagnosticsMonitor.dispensersinklevel = (DoubleArray**)my_malloc(sizeof(DoubleArray)*MAX_SYSTEM_DISPENSERS);
+    //DiagnosticsMonitor.midtanksinklevel = (DoubleArray**)my_malloc(sizeof(DoubleArray)*MAX_SYSTEM_DISPENSERS);
+    //DiagnosticsMonitor.dispensersinklevel = (DoubleArray**)my_malloc(sizeof(DoubleArray)*MAX_SYSTEM_DISPENSERS);
     for (i = 0; i<MAX_SYSTEM_DISPENSERS;i++)
     {
         double_array__init(&DispenserFreq[i]);
         double_array__init(&DiagnosticsDispenserPressure[i]);
-        double_array__init(&DiagnosticsMidTankInkLevel[i]);
-        double_array__init(&DispenserInkLevel[i]);
+        //double_array__init(&DiagnosticsMidTankInkLevel[i]);
+        //double_array__init(&DispenserInkLevel[i]);
     }
     heatersstates = (HeaterState**)my_malloc(sizeof(HeaterState *)*(HEATER_TYPE_MAX_HEATERS));
     for(i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
@@ -259,6 +266,8 @@ uint8_t  MotorCounterIndex[MAX_THREAD_MOTORS_NUM]= {0,0,0};
 double MotorValue[MAX_THREAD_MOTORS_NUM][DIAGNOSTICS_LIMIT+1];
 uint8_t  SpeedCounterIndex= 0;
 double SpeedValue[DIAGNOSTICS_DANCER_LIMIT+1];
+double headblowervoltage1 = 0.0, headblowervoltage2 = 0.0;
+double headblower1airflow = 0.0, headblower2airflow = 0.0;
 
 void DiagnosticLoadMotor(int MotorId, int frequency)
 {
@@ -321,23 +330,40 @@ uint32_t DiagnosticsLoadDigitalValues(void)
         DigitalOutputState[index++].value = HeadCard_Actuators_Status(ACTOT);
     }*/
 
+    #ifdef USE_VOC_BUZZER_ALARM
+        if (WHS_Type == WHS_TYPE_NEW)
+        {
+            DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_BUZZER;
+            DigitalOutputState[index++].value = ReadingVocEverySec; // if true WHS_IsVocPpmOverAlarmLimit is true
+        }
+    #endif
+
     DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPI_WCONTAINER_FULL;
     DigitalOutputState[index++].value = WHS_IsContainerFull();
 
     DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPI_WCONTAINER_WARN;
     DigitalOutputState[index++].value = WHS_IsContainerEmpty();
 
-    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE1_1; /*waste lower cartridge presence*/
-    DigitalOutputState[index++].value = WHS_WasteCartridgeLowerPresent();
-
-    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE1_2; /*waste middle cartridge presence*/
-    DigitalOutputState[index++].value = WHS_WasteCartridgeMiddlePresent();
-
     DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE_SSR12_CTRL; /*lubricant valve*/
     DigitalOutputState[index++].value = GetLubricantState();
 
-    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_TFEED_BREAK_1; /*Secondary Pump Active*/
-    DigitalOutputState[index++].value = SecondaryPumpActive;
+    DigitalOutputState[index].interfaceio = INTERFACE_IOS__CART1; /*Secondary Pump Active*/
+    DigitalOutputState[index++].value = Is_Cartridge_Present(CART_1);
+
+    DigitalOutputState[index].interfaceio = INTERFACE_IOS__CART2; /*Secondary Pump Active*/
+    DigitalOutputState[index++].value = Is_Cartridge_Present(CART_2);
+
+    DigitalOutputState[index].interfaceio = INTERFACE_IOS__CART3; /*Secondary Pump Active*/
+    DigitalOutputState[index++].value = Is_Cartridge_Present(CART_3);
+
+    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE1_1; /*Waste filling middle cartridge*/
+    DigitalOutputState[index++].value = (cartGetState(WasteCartridge_middle)==CartridgeStateACTIVE)?1:0;
+
+    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE1_2; /*Waste filling lower cartridge*/
+    DigitalOutputState[index++].value = (cartGetState(WasteCartridge_lower)==CartridgeStateACTIVE)?1:0;
+
+    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_TFEED_BREAK_1; /*IFS MidTank Filling*/
+    DigitalOutputState[index++].value = IFS_MidTankFilling();
 
     return index;
 }
@@ -349,10 +375,10 @@ void DiagnosticLoadTemperature(int HeaterId, int temperature)
         ReportWithPackageFilter(DiagnosticsFilter,"wrong Heater Id",__FILE__,__LINE__,(int)HeaterId,RpError,(int)0,0);
         return;
     }
-    if ((temperature < 1000)||(temperature>28000)) //error read, all 0xF or all 0
+    /*if ((temperature < 1000)||(temperature>28000)) //error read, all 0xF or all 0
     {
         return;
-    }
+    }*/
     HeaterTemperature[HeaterId][HeaterCounterIndex[HeaterId]] = temp/100;
     if (HeaterCounterIndex[HeaterId]<DIAGNOSTICS_LIMIT )
         HeaterCounterIndex[HeaterId]++;
@@ -393,6 +419,178 @@ void DiagnosticLoadDancerError(int DancerId, double value)
     //    DancerErrorCounterIndex[DancerId] = 0;
 
 }
+double Shinko_Sv = 12,Shinko_Pv = 15;
+void LoadChillerState(HeaterType HeaterType,HeaterState *HeaterState)
+{
+    int HeaterId = HeaterType;
+    HeaterState->has_heatertype = true;
+    HeaterState->heatertype = HeaterType;
+    HeaterState->has_setpoint = true;
+    HeaterState->setpoint = (float)(ShinkoTempDeg.Read_Setup);
+    HeaterState->has_currentvalue = true;
+    HeaterState->currentvalue = (float)(ShinkoTempDeg.Read_value);
+    HeaterState->has_isactive = true;
+    HeaterState->isactive = false;
+    HeaterState->has_isrampingup = true;
+    HeaterState->isrampingup = false;
+    HeaterState->has_isinsetpoint = true;
+    HeaterState->isinsetpoint = true;
+
+    return;
+}
+
+#ifdef FOUR_WINDERS
+    double dancer2,dancer3,dancer4;
+#endif
+void CopyTemperaturesToMonitor(void)
+{
+    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.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];
+    if ((Head_Type == HEAD_TYPE_FLAT)
+            || (Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD))
+    {
+        DiagnosticsMonitor.headzone4temperature =
+                HeaterTemperature[HEATER_TYPE__HeaterZone4];
+        DiagnosticsMonitor.headzone5temperature =
+                HeaterTemperature[HEATER_TYPE__HeaterZone5];
+        DiagnosticsMonitor.headzone6temperature =
+                HeaterTemperature[HEATER_TYPE__HeaterZone6];
+        DiagnosticsMonitor.n_headzone4temperature =
+                HeaterCounterIndex[HEATER_TYPE__HeaterZone4];
+        DiagnosticsMonitor.n_headzone5temperature =
+                HeaterCounterIndex[HEATER_TYPE__HeaterZone5];
+        DiagnosticsMonitor.n_headzone6temperature =
+                HeaterCounterIndex[HEATER_TYPE__HeaterZone6];
+    }
+    if (Head_Type == HEAD_TYPE_FLAT)
+    {
+        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];
+        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];
+        //temporary
+        DiagnosticsMonitor.headcoverheater1temperature =
+                HeaterTemperature[HEATER_TYPE__HeadCoverHeater1];
+        DiagnosticsMonitor.headcoverheater2temperature =
+                HeaterTemperature[HEATER_TYPE__HeadCoverHeater2];
+        DiagnosticsMonitor.n_headcoverheater1temperature =
+                HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater1];
+        DiagnosticsMonitor.n_headcoverheater2temperature =
+                HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater2];
+    }
+    //if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_STAPLE_SPUN))
+    if (Head_Type == HEAD_TYPE_ARC)
+    {
+        DiagnosticsMonitor.headcoverheater1temperature =
+                HeaterTemperature[HEATER_TYPE__HeadCoverHeater1];
+        DiagnosticsMonitor.headcoverheater2temperature =
+                HeaterTemperature[HEATER_TYPE__HeadCoverHeater2];
+        DiagnosticsMonitor.n_headcoverheater1temperature =
+                HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater1];
+        DiagnosticsMonitor.n_headcoverheater2temperature =
+                HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater2];
+        DiagnosticsMonitor.headzone11temperature =
+                HeaterTemperature[HEATER_TYPE__HeaterZone11];
+        DiagnosticsMonitor.headzone12temperature =
+                HeaterTemperature[HEATER_TYPE__HeaterZone12];
+        DiagnosticsMonitor.n_headzone11temperature =
+                HeaterCounterIndex[HEATER_TYPE__HeaterZone11];
+        DiagnosticsMonitor.n_headzone12temperature =
+                HeaterCounterIndex[HEATER_TYPE__HeaterZone12];
+
+        DiagnosticsMonitor.n_headblower1airflow = HeaterCounterIndex[HEATER_TYPE__HeaterZone5];
+        DiagnosticsMonitor.n_headblower2airflow = HeaterCounterIndex[HEATER_TYPE__HeaterZone7];
+        headblower1airflow = PressureSensorGetPressure(HEAD_PT100_ZONE_5_0X84_0);
+        headblower2airflow = PressureSensorGetPressure(HEAD_PT100_ZONE_7_0X86_0);
+        DiagnosticsMonitor.headblower1airflow = &headblower1airflow;
+        DiagnosticsMonitor.headblower2airflow = &headblower2airflow;
+
+        DiagnosticsMonitor.n_headblowervoltage1 = 1;
+        DiagnosticsMonitor.n_headblowervoltage2 = 1;
+        headblowervoltage1 = HeadBlowersGetRPM(HEAD_FAN_RIGHT);
+        headblowervoltage2 = HeadBlowersGetRPM(HEAD_FAN_LEFT);
+        DiagnosticsMonitor.headblowervoltage1 = &headblowervoltage1;
+        DiagnosticsMonitor.headblowervoltage2 = &headblowervoltage2;
+    }
+#ifdef FOUR_WINDERS
+//    double dancer2,dancer3,dancer4;
+    dancer2 = Control_Read_Dancer_Position(HARDWARE_DANCER_2,0);
+    dancer3 = Control_Read_Dancer_Position(HARDWARE_DANCER_3,0);
+    dancer4 = Control_Read_Dancer_Position(HARDWARE_DANCER_4,0);
+    DiagnosticsMonitor.n_headzone4heatercurrent = 1;
+    DiagnosticsMonitor.n_headzone56heatercurrent = 1;
+    DiagnosticsMonitor.n_headzone8heatercurrent = 1;
+    DiagnosticsMonitor.headzone4heatercurrent = &dancer4;
+    DiagnosticsMonitor.headzone56heatercurrent = &dancer3;
+    DiagnosticsMonitor.headzone8heatercurrent = &dancer2;
+#endif
+
+    DiagnosticsMonitor.dryerzone1temperature =
+            HeaterTemperature[HEATER_TYPE__DryerAirHeater];
+    DiagnosticsMonitor.dryerzone2temperature =
+            HeaterTemperature[HEATER_TYPE__DryerMainHeater];
+    DiagnosticsMonitor.dryerzone3temperature =
+            HeaterTemperature[HEATER_TYPE__DryerSecondaryHeater];
+    DiagnosticsMonitor.n_dryerzone1temperature =
+            HeaterCounterIndex[HEATER_TYPE__DryerAirHeater];
+    DiagnosticsMonitor.n_dryerzone2temperature =
+            HeaterCounterIndex[HEATER_TYPE__DryerMainHeater];
+    DiagnosticsMonitor.n_dryerzone3temperature =
+            HeaterCounterIndex[HEATER_TYPE__DryerSecondaryHeater];
+}
+void CopyPressuresToMonitor(int count)
+{
+    DiagnosticsMonitor.n_dispenser1pressure = count;
+    DiagnosticsMonitor.dispenser1pressure = dispenserspressure[0];
+    DiagnosticsMonitor.n_dispenser2pressure = count;
+    DiagnosticsMonitor.dispenser2pressure = dispenserspressure[1];
+    DiagnosticsMonitor.n_dispenser3pressure = count;
+    DiagnosticsMonitor.dispenser3pressure = dispenserspressure[2];
+    DiagnosticsMonitor.n_dispenser4pressure = count;
+    DiagnosticsMonitor.dispenser4pressure = dispenserspressure[3];
+    DiagnosticsMonitor.n_dispenser5pressure = count;
+    DiagnosticsMonitor.dispenser5pressure = dispenserspressure[4];
+    DiagnosticsMonitor.n_dispenser6pressure = count;
+    DiagnosticsMonitor.dispenser6pressure = dispenserspressure[5];
+    DiagnosticsMonitor.n_dispenser7pressure = count;
+    DiagnosticsMonitor.dispenser7pressure = dispenserspressure[6];
+    DiagnosticsMonitor.n_dispenser8pressure = count;
+    DiagnosticsMonitor.dispenser8pressure = dispenserspressure[7];
+}
 void DiagnosticTenMsecCollection(void)
 {
     if (DiagnosticsActive == false)
@@ -420,9 +618,9 @@ void DiagnosticOneMinuteCollection(void)
     for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
     {
         MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
-        dispenserinklevel[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
-        midtankinklevel[i][0] = Get_MidTank_Pressure_Sensor(i);
-        if (DiagnosticsMonitor.dispensersinklevel)
+        //dispenserinklevel[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
+        //midtankinklevel[i][0] = Get_MidTank_Pressure_Sensor(i);
+        /*if (DiagnosticsMonitor.dispensersinklevel)
         {
             DiagnosticsMonitor.n_dispensersinklevel = MAX_SYSTEM_DISPENSERS;
             //DiagnosticsDispenserPressure[i] = dispenserspressure[i];
@@ -430,8 +628,8 @@ void DiagnosticOneMinuteCollection(void)
             DispenserInkLevel[i].data = dispenserinklevel[i];
             DispenserInkLevel[i].n_data = 1;
             DiagnosticsMonitor.dispensersinklevel[i] = &DispenserInkLevel[i];
-        }
-        if (DiagnosticsMonitor.midtanksinklevel)
+        }*/
+        /*if (DiagnosticsMonitor.midtanksinklevel)
         {
             DiagnosticsMonitor.n_midtanksinklevel = MAX_SYSTEM_DISPENSERS;
             //DiagnosticsDispenserPressure[i] = dispenserspressure[i];
@@ -439,12 +637,12 @@ void DiagnosticOneMinuteCollection(void)
             DiagnosticsMidTankInkLevel[i].data = midtankinklevel[i];
             DiagnosticsMidTankInkLevel[i].n_data = 1;
             DiagnosticsMonitor.midtanksinklevel[i] = &DiagnosticsMidTankInkLevel[i];
-        }
+        }*/
 
     }
     DiagnosticsMonitor.n_overalltemperature = 1;
-    OverallTemperature = max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2));
-    OverallTemperature = ((int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1)/100)*1000 + (int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2)/100));
+    OverallTemperature = (max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2)))/100;
+    //OverallTemperature = ((int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1)/100)*1000 + (int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2)/100));
     DiagnosticsMonitor.overalltemperature = &OverallTemperature;
 
     DiagnosticsMonitor.n_midtank1level = 1;
@@ -463,7 +661,7 @@ void DiagnosticOneMinuteCollection(void)
     DiagnosticsMonitor.midtank7level = MidTankpressure[6];
     DiagnosticsMonitor.n_midtank8level = 1;
     DiagnosticsMonitor.midtank8level = MidTankpressure[7];
-    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD) //rapid/pp machines
+    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD) //rapid/pp machines
     {
         /*DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
         DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
@@ -472,7 +670,7 @@ void DiagnosticOneMinuteCollection(void)
         Get_Head_Current(HEAD_CURRENT_MIXER,&HeadCurrent[HEAD_CURRENT_ZONE_12+1][0]);
         DiagnosticsMonitor.n_mixer1heatercurrent = 1;
         DiagnosticsMonitor.mixer1heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_12+1];
-        if (Head_Type == HEAD_TYPE_SYLKO)
+        if (Head_Type == HEAD_TYPE_FLAT)
         {
             for (i=0;i<HEAD_CURRENT_ZONE_12;i++)
             {
@@ -498,8 +696,8 @@ void DiagnosticOneMinuteCollection(void)
                         DiagnosticsMonitor.headzone4heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_4];
                         break;
                     case HEAD_CURRENT_ZONE_5:
-                        DiagnosticsMonitor.n_headzone5_6heatercurrent = 1;
-                        DiagnosticsMonitor.headzone5_6heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_5];
+                        DiagnosticsMonitor.n_headzone56heatercurrent = 1;
+                        DiagnosticsMonitor.headzone56heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_5];
                         break;
 /*                    case HEAD_CURRENT_ZONE_6:
                         DiagnosticsMonitor.n_headzone6heatercurrent = 1;
@@ -559,21 +757,21 @@ void DiagnosticOneMinuteCollection(void)
                 DiagnosticsMonitor.headzone3heatercurrent = HeadCurrent[i];
                 i++;
             }
-            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTIN_1) == true)
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_ZONE_4) == true)
             {
                 Get_Head_Current(HEAD_CURRENT_HTIN_1,&HeadCurrent[i][0]);
-                DiagnosticsMonitor.n_headzone4heatercurrent = 1;
-                DiagnosticsMonitor.headzone4heatercurrent = HeadCurrent[i];
+                DiagnosticsMonitor.n_headcoverheater1current= 1;
+                DiagnosticsMonitor.headcoverheater1current = HeadCurrent[i];
                 i++;
             }
-            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTOT_1) == true)
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_ZONE_5) == true)
             {
                 Get_Head_Current(HEAD_CURRENT_HTOT_1,&HeadCurrent[i][0]);
-                DiagnosticsMonitor.n_headzone5_6heatercurrent = 1;
-                DiagnosticsMonitor.headzone5_6heatercurrent = HeadCurrent[i];
+                DiagnosticsMonitor.n_headcoverheater2current = 1;
+                DiagnosticsMonitor.headcoverheater2current = HeadCurrent[i];
                 i++;
             }
-            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTIN_1) == true)
+            /*if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTIN_1) == true)
             {
                 Get_Head_Current(HEAD_CURRENT_HTIN_2,&HeadCurrent[i][0]);
                 DiagnosticsMonitor.n_headzone7heatercurrent = 1;
@@ -614,7 +812,7 @@ void DiagnosticOneMinuteCollection(void)
                 DiagnosticsMonitor.n_headzone12heatercurrent = 1;
                 DiagnosticsMonitor.headzone12heatercurrent = HeadCurrent[i];
                 i++;
-            }
+            }*/
         }
 
     }
@@ -656,22 +854,16 @@ void DiagnosticOneMinuteCollection(void)
                     DiagnosticsMonitor.headzone4heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_4];
                     break;
                 case HEATER_HEAD_CURRENT_ZONE_5_6:
-                    DiagnosticsMonitor.n_headzone5_6heatercurrent = 1;
-                    DiagnosticsMonitor.headzone5_6heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6];
+                    DiagnosticsMonitor.n_headzone56heatercurrent = 1;
+                    DiagnosticsMonitor.headzone56heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6];
                     break;
                 default:
                     break;
                 }
             }
         }
-    }
-
-    VOC_Sensor = (double) getGasReading();
-    DiagnosticsMonitor.n_filterdeltapressure = 1;
-    DiagnosticsMonitor.filterdeltapressure = &VOC_Sensor;
-    DiagnosticsMonitor.n_gassensor = 1;
-    DiagnosticsMonitor.gassensor = &VOC_Sensor;
 
+    }
     DiagnosticsMonitor.n_blowervoltage = 1;
     diagvoltage = getBlowerState();
     DiagnosticsMonitor.blowervoltage = &diagvoltage;
@@ -681,11 +873,11 @@ void DiagnosticOneMinuteCollection(void)
     DiagnosticsMonitor.dryerairflow = &DrierFlowMeter;
 
     HeadFlowMeter = GetWHSAirFlow(HEAD_FLOW_METER);
-    if (fabs(tempFlow - HeadFlowMeter)>0.05)
+    /*if (fabs(tempFlow - HeadFlowMeter)>0.05)
     {
         Report("Head flow change 1m",__FILE__,(int)diagvoltage,(int)(tempFlow*1000),RpWarning,(int)(HeadFlowMeter*1000),0);
         tempFlow = HeadFlowMeter;
-    }
+    }*/
     DiagnosticsMonitor.n_headairflow = 1;
     DiagnosticsMonitor.headairflow = &HeadFlowMeter;
 
@@ -696,16 +888,18 @@ void DiaglosticChangeBlowerData()
     diagvoltage = getBlowerState();
     DiagnosticsMonitor.blowervoltage = &diagvoltage;
 }
+
+
 void DiagnosticOneSecCollection(void)
 {
     int i;
     memset(HeaterCounterIndex,0,sizeof(HeaterCounterIndex));
 
-    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD) //rapid/pp machines
+    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD) //rapid/pp machines
     {
         AcVoltage = ReadVAC();
-        DiagnosticsMonitor.whsblower2voltage = &AcVoltage;
-        DiagnosticsMonitor.n_whsblower2voltage = 1;
+        //DiagnosticsMonitor.whsblower2voltage = &AcVoltage;
+        //DiagnosticsMonitor.n_whsblower2voltage = 1;
         DiagnosticsMonitor.incomingvoltage = &AcVoltage;
         DiagnosticsMonitor.n_incomingvoltage = 1;
     }
@@ -718,14 +912,29 @@ void DiagnosticOneSecCollection(void)
         HeadFlowMeter = GetWHSAirFlow(HEAD_FLOW_METER);
         DiagnosticsMonitor.n_headairflow = 1;
         DiagnosticsMonitor.headairflow = &HeadFlowMeter;
-        if (fabs(tempFlow - HeadFlowMeter)>0.25)
+
+        TotalFlowMeter = GetWHSAirFlow(NU_FLOW_METER);
+        DiagnosticsMonitor.n_totalwhsflow = 1;
+        DiagnosticsMonitor.totalwhsflow = &TotalFlowMeter;
+
+        /*if (fabs(tempFlow - HeadFlowMeter)>0.25)
         {
             Report("Head flow change 1s",__FILE__,(int)diagvoltage,(int)(tempFlow*1000),RpWarning,(int)(HeadFlowMeter*1000),0);
             tempFlow = HeadFlowMeter;
+        }*/
+        WasteLevel = GetWHSWasteTankLevelMiliLiter()/1000;//change from ml to litter
+        static double InitCounter = 60.0;
+        if ((GetMachineState()<MACHINE_STATE_NO_PROCESS_PARAMS) &&(GetMachineState()>=MACHINE_STATE_WAIT_FOR_COOLER))
+        {
+            InitCounter-=1.0;
+            if(InitCounter<0)InitCounter = 0;
+        }
+        else
+        {
+            InitCounter =  ShinkoTempDeg.Read_value;
         }
-        WasteLevel = GetWHSWasteTankLevelMiliLiter();
+        DiagnosticsMonitor.chillertemperature = &InitCounter;
         DiagnosticsMonitor.n_chillertemperature = 1;
-        DiagnosticsMonitor.chillertemperature = &WasteLevel;
         DiagnosticsMonitor.n_wastelevel = 1;
         DiagnosticsMonitor.wastelevel = &WasteLevel;
    }
@@ -736,7 +945,7 @@ void DiagnosticOneSecCollection(void)
     DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
     DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];
 
-    if (Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    if (Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD)
     {
         DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
         DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
@@ -746,7 +955,7 @@ void DiagnosticOneSecCollection(void)
         DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
         DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
     }
-    if (Head_Type == HEAD_TYPE_SYLKO)
+    if (Head_Type == HEAD_TYPE_FLAT)
     {
         DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
@@ -761,8 +970,11 @@ void DiagnosticOneSecCollection(void)
         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));
+
+        DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater1, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater2, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0));
     }
-    if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    if (Head_Type == HEAD_TYPE_ARC)
     {
         DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
@@ -770,6 +982,13 @@ void DiagnosticOneSecCollection(void)
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone3, MillisecGetTemperatures(HEAD_PT100_ZONE_3_0X82_0));
         DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater1, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1));
         DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater2, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0));
+        
+        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__HeaterZone11, MillisecGetTemperatures(HEAD_PT100_ZONE_11_0X8A_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone12, MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1));
     }
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2));
@@ -777,16 +996,18 @@ void DiagnosticOneSecCollection(void)
     for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
     {
         dispensermotorfrequency[i][0] = IdsGetMotorSpeed(i);
-        /*if ((i == 1)&&(JobIsActive()))
-           {
-            Report("Dispenser 1",__FILE__,(int)__LINE__,(int)dispensermotorfrequency[i][DiagnosticsIndex],RpWarning,(int)DiagnosticsIndex,0);
-           }*/
-        //dispensermotorfrequency[i][DiagnosticsIndex] = IDS_Dispenser_Data[i].consumedinnanolitter;
-
         if (DiagnosticMode < Diagnostic_Extended_Mode)
             dispenserspressure[i][0] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
         MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
     }
+    //if (DiagnosticMode < Diagnostic_Extended_Mode)
+    CopyTemperaturesToMonitor();
+
+    if (DiagnosticMode < Diagnostic_Extended_Mode)
+    {
+        CopyPressuresToMonitor(1);
+    }
+
 }
 void Diagnostic100msecCollection(void)
 {
@@ -802,11 +1023,19 @@ void Diagnostic100msecCollection(void)
     {
         //if (JobIsActive())
         {
+#ifdef FOUR_WINDERS
+            DiagnosticLoadMotor(FEEDER_MOTOR, ThreadGetMotorSpeed (WINDER_2_MOTOR));
+            DiagnosticLoadMotor(DRYER_MOTOR, ThreadGetMotorSpeed (WINDER_3_MOTOR));
+            DiagnosticLoadMotor(POOLER_MOTOR, ThreadGetMotorSpeed (WINDER_4_MOTOR));
+            DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
+            DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
+#else
             DiagnosticLoadMotor(FEEDER_MOTOR, ThreadGetMotorSpeed (FEEDER_MOTOR));
             DiagnosticLoadMotor(DRYER_MOTOR, ThreadGetMotorSpeed (DRYER_MOTOR));
             DiagnosticLoadMotor(POOLER_MOTOR, ThreadGetMotorSpeed (POOLER_MOTOR));
             DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
             DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
+#endif
         }
         for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
         {
@@ -851,11 +1080,13 @@ uint8_t *diagnostics_response_ptr = diagnostics_response_buffer;
 char * diagnosticscontainer_buffer=0;
 int LargeMessagesD = 0;
 
+
 void SendDiagnostics(void)
 {
     //MessageContainer responseContainer;
     StartDiagnosticsResponse response = START_DIAGNOSTICS_RESPONSE__INIT;
     //int i;
+    int chillerHeaterId = 0;
 
     if (DiagnosticsActive == false)
     {
@@ -897,7 +1128,8 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.dancer2angle = dancer2angle;
     DiagnosticsMonitor.dancer3angle = dancer3angle;
 */
-    if ((JobIsActive())&&(DiagnosticMode >= Diagnostic_Extended_Mode))
+//    if ((JobIsActive())&&(DiagnosticMode >= Diagnostic_Extended_Mode))
+    if (DiagnosticMode >= Diagnostic_Extended_Mode)
     {
         DiagnosticsMonitor.n_dancer1angle =  DancerCounterIndex[0];
         DiagnosticsMonitor.n_dancer2angle =  DancerCounterIndex[1];
@@ -926,54 +1158,6 @@ void SendDiagnostics(void)
         DiagnosticsMonitor.n_windermotor =  MotorCounterIndex[WINDER_MOTOR];
         DiagnosticsMonitor.n_screwmotor = MotorCounterIndex[SCREW_MOTOR];
     }
-    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.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];
-    if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD))
-    {
-        DiagnosticsMonitor.headzone4temperature = HeaterTemperature[HEATER_TYPE__HeaterZone4];
-        DiagnosticsMonitor.headzone5temperature = HeaterTemperature[HEATER_TYPE__HeaterZone5];
-        DiagnosticsMonitor.headzone6temperature = HeaterTemperature[HEATER_TYPE__HeaterZone6];
-        DiagnosticsMonitor.n_headzone4temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone4];
-        DiagnosticsMonitor.n_headzone5temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone5];
-        DiagnosticsMonitor.n_headzone6temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone6];
-    }
-    if (Head_Type == HEAD_TYPE_SYLKO)
-    {
-        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];
-        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];
-    }
-    if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_STAPLE_SPUN))
-//    if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
-    {
-        DiagnosticsMonitor.headcoverheater1temperature = HeaterTemperature[HEATER_TYPE__HeadCoverHeater1];
-        DiagnosticsMonitor.headcoverheater2temperature = HeaterTemperature[HEATER_TYPE__HeadCoverHeater2];
-        DiagnosticsMonitor.n_headcoverheater1temperature = HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater1];
-        DiagnosticsMonitor.n_headcoverheater2temperature = HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater2];
-    }
-    DiagnosticsMonitor.dryerzone1temperature = HeaterTemperature[HEATER_TYPE__DryerAirHeater];
-    DiagnosticsMonitor.dryerzone2temperature = HeaterTemperature[HEATER_TYPE__DryerMainHeater];
-    DiagnosticsMonitor.dryerzone3temperature = HeaterTemperature[HEATER_TYPE__DryerSecondaryHeater];
-
-    DiagnosticsMonitor.n_dryerzone1temperature = HeaterCounterIndex[HEATER_TYPE__DryerAirHeater];
-    DiagnosticsMonitor.n_dryerzone2temperature = HeaterCounterIndex[HEATER_TYPE__DryerMainHeater];
-    DiagnosticsMonitor.n_dryerzone3temperature = HeaterCounterIndex[HEATER_TYPE__DryerSecondaryHeater];
-
     int i,temp;
     DiagnosticsMonitor.n_dispensersmotorsfrequency = 0;
     /**/
@@ -1016,23 +1200,14 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.n_dispenserslinearpositions = 0;
     DiagnosticsMonitor.n_dispensersangularencoders = 0;
 
-    DiagnosticsMonitor.n_dispenser1pressure = temp;
-    DiagnosticsMonitor.dispenser1pressure = dispenserspressure[0];
-    DiagnosticsMonitor.n_dispenser2pressure = temp;
-    DiagnosticsMonitor.dispenser2pressure = dispenserspressure[1];
-    DiagnosticsMonitor.n_dispenser3pressure = temp;
-    DiagnosticsMonitor.dispenser3pressure = dispenserspressure[2];
-    DiagnosticsMonitor.n_dispenser4pressure = temp;
-    DiagnosticsMonitor.dispenser4pressure = dispenserspressure[3];
-    DiagnosticsMonitor.n_dispenser5pressure = temp;
-    DiagnosticsMonitor.dispenser5pressure = dispenserspressure[4];
-    DiagnosticsMonitor.n_dispenser6pressure = temp;
-    DiagnosticsMonitor.dispenser6pressure = dispenserspressure[5];
-    DiagnosticsMonitor.n_dispenser7pressure = temp;
-    DiagnosticsMonitor.dispenser7pressure = dispenserspressure[6];
-    DiagnosticsMonitor.n_dispenser8pressure = temp;
-    DiagnosticsMonitor.dispenser8pressure = dispenserspressure[7];
-
+    /*if (DiagnosticMode >= Diagnostic_Extended_Mode)
+    {
+        CopyTemperaturesToMonitor();
+    }*/
+    if (DiagnosticMode >= Diagnostic_Extended_Mode)
+    {
+        CopyPressuresToMonitor(temp);
+    }
 
     DiagnosticsMonitor.n_midtank1level = 1;
     DiagnosticsMonitor.midtank1level = MidTankpressure[0];
@@ -1068,9 +1243,8 @@ void SendDiagnostics(void)
     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;
+    VOC_Sensor = (double) Get_latest_Gas_Sensor_PPM();//(double) getGasReading();
+
     DiagnosticsMonitor.n_gassensor = 1;
     DiagnosticsMonitor.gassensor = &VOC_Sensor;
 
@@ -1091,27 +1265,40 @@ void SendDiagnostics(void)
     LoadHeaterState(HEATER_TYPE__HeaterZone2,&HeaterInfo[i++]);
     LoadHeaterState(HEATER_TYPE__HeaterZone3,&HeaterInfo[i++]);
 
-    if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD))
+    if ((Head_Type == HEAD_TYPE_FLAT)||(Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD))
     {
-        LoadHeaterState(HEATER_TYPE__HeaterZone4,&HeaterInfo[i++]);
-        LoadHeaterState(HEATER_TYPE__HeaterZone5,&HeaterInfo[i++]);
-        LoadHeaterState(HEATER_TYPE__HeaterZone6,&HeaterInfo[i++]);
+        LoadHeaterState(HEATER_TYPE__HeaterZone4,&HeaterInfo[i++]);    
     }
-    if (Head_Type == HEAD_TYPE_SYLKO)
+	LoadHeaterState(HEATER_TYPE__HeaterZone5,&HeaterInfo[i++]);
+	//LoadHeaterState(HEATER_TYPE__HeaterZone6,&HeaterInfo[i++]);
+	 if ((Head_Type == HEAD_TYPE_FLAT)||(Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD))
     {
+        LoadHeaterState(HEATER_TYPE__HeaterZone6,&HeaterInfo[i++]);  
+    }
+	if ((Head_Type == HEAD_TYPE_FLAT)||(Head_Type == HEAD_TYPE_ARC))
+	{
         LoadHeaterState(HEATER_TYPE__HeaterZone7,&HeaterInfo[i++]);
+		//LoadHeaterState(HEATER_TYPE__HeaterZone8,&HeaterInfo[i++]);
+	}
+    if (Head_Type == HEAD_TYPE_FLAT)
+    {		
         LoadHeaterState(HEATER_TYPE__HeaterZone8,&HeaterInfo[i++]);
-        LoadHeaterState(HEATER_TYPE__HeaterZone9,&HeaterInfo[i++]);
+		LoadHeaterState(HEATER_TYPE__HeaterZone9,&HeaterInfo[i++]);
         LoadHeaterState(HEATER_TYPE__HeaterZone10,&HeaterInfo[i++]);
         LoadHeaterState(HEATER_TYPE__HeaterZone11,&HeaterInfo[i++]);
         LoadHeaterState(HEATER_TYPE__HeaterZone12,&HeaterInfo[i++]);
     }
-    if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_STAPLE_SPUN))
+    if (Head_Type == HEAD_TYPE_ARC)
     //if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
     {
         LoadHeaterState(HEATER_TYPE__HeadCoverHeater1,&HeaterInfo[i++]);
         LoadHeaterState(HEATER_TYPE__HeadCoverHeater2,&HeaterInfo[i++]);
     }
+    if(WHS_Type == WHS_TYPE_NEW)
+    {
+        chillerHeaterId = (Head_Type == HEAD_TYPE_ARC)?HEATER_TYPE__HeaterZone12:HEATER_TYPE__HeadCoverHeater1;
+        LoadChillerState(chillerHeaterId,&HeaterInfo[i++]);
+    }
     response.n_heatersstates = i;
     response.heatersstates = heatersstates;
 
@@ -1347,6 +1534,8 @@ void DiagnosticsTask(UArg arg0, UArg arg1)
                 break;
             case DiagnosticsOneSecTrigger:
                 DiagnosticOneSecCollection();
+                if (DiagnosticMode >= Diagnostic_Extreme_Mode)
+                    DiagnosticOneMinuteCollection();
                 break;
             case DiagnosticsOneMinuteTrigger:
                 DiagnosticOneMinuteCollection();
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index fecfa5057..7f8c9b8d8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -30,6 +30,7 @@
 #include "drivers/Valves/Valve.h"
 #include "Drivers/I2C_Communication/DAC/blower.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
+#include <Drivers/SSI_Comm/Dancer/Dancer.h>
 
 #include "ids/ids_ex.h"
 #include "General/process.h"
@@ -39,29 +40,35 @@
 char HomingToken[NUM_OF_MOTORS][36+1]={0};
 int HomingCounter[NUM_OF_MOTORS];
 uint32_t HomingControlId[NUM_OF_MOTORS];
-int NumberOfCycles;
+
+uint32_t Diagnostics_Dryer_UnLoading(void);
+uint32_t Diagnostics_Dryer_Loading(void);
+int kval_upper_value;
 
 /********************************************************************************
  * Motor Homing
  ********************************************************************************/
-//int32_t keepkvalright,keepkvalleft;
+int32_t keepkvalright,keepkvalleft;
 uint32_t MotorHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
 {
+    if (HomingToken[deviceID][0] == 0)
+        return OK;
+
     MessageContainer responseContainer;
     MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
     bool last = false;
     response.has_progress = true;
     response.has_maxprogress = true;
     response.maxprogress = 1000;
-    if (HomingCounter[deviceID]>=1000)
+    if (HomingCounter[deviceID]>=240)
     {
         last = true;
         SafeRemoveControlCallback(HomingControlId[deviceID],MotorHomingProgressReport);
-        Report("MotorHomingProgressReport stopped 1000",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
+        ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingProgressReport stopped 1000",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
         HomingControlId[deviceID] = 0xff;
     }
     response.progress = HomingCounter[deviceID]++;
-    Report("MotorHomingProgressReport",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
+    ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingProgressReport",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
     responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], last, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
     responseContainer.has_continuous = true;
     responseContainer.continuous = true;
@@ -73,7 +80,8 @@ uint32_t MotorHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
     return OK;
 
 }
-
+bool resetPullerDancer = false;
+bool resetWinderDancer = false;
 uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
 {
     MessageContainer responseContainer;
@@ -81,22 +89,34 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
 
     if(deviceID == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)
     {
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 24);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, keepkvalright);
     }
     if(deviceID == HARDWARE_MOTOR_TYPE__MOTO_LLOADING)
     {
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 24);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, keepkvalleft);
+    }
+    if (resetPullerDancer == true)
+    {
+        resetPullerDancer = false;
+        MCU_E2PromProgram(EEPROM_PULLER_TENSION_POSITION,1);
+    }
+    if (resetWinderDancer == true)
+    {
+        resetWinderDancer = false;
+        MCU_E2PromProgram(EEPROM_WINDER_TENSION_POSITION,1);
     }
     if (HomingControlId[deviceID] != 0xff)
     {
-        Report("MotorHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
+        ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
         RemoveControlCallback(HomingControlId[deviceID],MotorHomingProgressReport);
         HomingControlId[deviceID] = 0xff;
     }
-    if (deviceID == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
+    /*if (deviceID == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
     {
         MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,NumberOfCycles);//it takes two cycles to identify a stop of the arm
-    }
+    }*/
+    if (HomingToken[deviceID][0] == 0)
+        return OK;
     responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
     responseContainer.has_continuous = true;
     responseContainer.continuous = true;
@@ -109,10 +129,15 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
 return OK;
 
 }
+uint32_t LoadArmRounds;
+
+uint32_t D_numberOfSteps = 0;
+float D_numberOfCycles = 0;
+uint32_t D_DrierPrevLocation = 0;
+
+
 uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
 {
-    uint32_t numberOfSteps = 0;
-    uint32_t LoadArmRounds = (int)dryerbufferlength;
     uint32_t status = FAILED;
     MessageContainer responseContainer;
 
@@ -120,6 +145,14 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
 
     MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
 
+    LoadArmRounds = (int)dryerbufferlength;
+
+    if (Is_PP_Machine())
+        kval_upper_value = 28;
+    else
+        kval_upper_value = 70;
+
+
     int direction;
     TimerMotors_t MotorId = (TimerMotors_t)request->motortype;
     if (LoadArmRounds <= 2)
@@ -144,35 +177,36 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                     {
                         direction = DRIER_LID_OPEN;
                     }
-                    Report("MotorHomingRequestFunc Dryer lid open",__FILE__,MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType,DRIER_LID_OPEN,RpMessage,GPI_LS_DRYER_LID_OPEN,0);
-                    MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, GPI_LS_DRYER_LID_OPEN, MotorHomingRequestCallback,4000);
+                    ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingRequestFunc Dryer lid open",__FILE__,MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType,DRIER_LID_OPEN,RpMessage,GPI_LS_DRYER_LID_OPEN,0);
+                    MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, GPI_LS_DRYER_LID_OPEN, MotorHomingRequestCallback,10000);
                     status = OK;
                 }
                 else
                 {
                     if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
                     {
-                        numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
-                        Report("MotorHomingRequestFunc Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,numberOfSteps,RpMessage,LoadArmRounds,0);
-                        MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
-                                                        MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/2, MotorHomingRequestCallback,0,1000);
-                        NumberOfCycles = 0;
-
-                        //MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
-                        //                                numberOfSteps, MotorHomingRequestCallback,1000);
+                        Diagnostics_Dryer_UnLoading();
                         status = OK;
                     }
                     if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI)
                     {
+                        if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LDANCER2)
+                        {
+                            resetPullerDancer = true;
+                        }
+                        if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LDANCER1)
+                        {
+                            resetWinderDancer = true;
+                        }
                         if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)
                         {
-                            //keepkvalright = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
-                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
+                            keepkvalright = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, kval_upper_value);
                         }
                         if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING)
                         {
-                            //keepkvalleft = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].kvalrun;
-                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
+                            keepkvalleft = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].kvalrun;
+                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, kval_upper_value);
                         }
                         MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback,30000);
                         status = OK;
@@ -192,39 +226,28 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                     {
                         direction = DRIER_LID_CLOSE;
                     }
-                    Report("MotorHomingRequestFunc Dryer lid close",__FILE__,MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType,DRIER_LID_CLOSE,RpMessage,GPI_LS_DRYER_LID_CLOSED,0);
-                    MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, GPI_LS_DRYER_LID_CLOSED, MotorHomingRequestCallback,4000);
+                    ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingRequestFunc Dryer lid close",__FILE__,MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType,DRIER_LID_CLOSE,RpMessage,GPI_LS_DRYER_LID_CLOSED,0);
+                    MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, GPI_LS_DRYER_LID_CLOSED, MotorHomingRequestCallback,10000);
                     status = OK;
                 }
                 else
                 {
                     if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
                     {
-                        if (LoadArmRounds <= 2)
-                                LoadArmRounds = 30;
-
-                        numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
-                        numberOfSteps -= 100;
-                        NumberOfCycles = LoadArmRounds;
-                        Report("MotorHomingRequestFunc Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,numberOfSteps,RpMessage,LoadArmRounds,0);
-
-                        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4);
-
-                        MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
-                                               numberOfSteps,    MotorHomingRequestCallback, 100000);
+                        Diagnostics_Dryer_Loading();
                         status = OK;
                     }
                     if ( Motor_Id_to_LS_IdUp[MotorId] != MAX_GPI)
                     {
                         if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)
                         {
-                            //keepkvalright = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
-                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
+                            keepkvalright = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, kval_upper_value);
                         }
                         if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING)
                         {
-                            //keepkvalleft = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].kvalrun;
-                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
+                            keepkvalleft = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].kvalrun;
+                            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, kval_upper_value);
                         }
                         MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback,30000);
                         status = OK;
@@ -237,7 +260,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
     {
         HomingControlId[MotorId] = AddControlCallback(NULL, MotorHomingProgressReport,  2*eOneSecond, TemplateDataReadCBFunction,MotorId, 0, 0 );
         HomingCounter[MotorId] = 0;
-        Report("MotorHomingProgressReport started",__FILE__,__LINE__,MotorId,RpMessage,HomingControlId[MotorId],0);
+        ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingProgressReport started",__FILE__,__LINE__,MotorId,RpMessage,HomingControlId[MotorId],0);
     }
     else
     {
@@ -267,6 +290,24 @@ uint32_t MotorAbortHomingRequestFunc(MessageContainer* requestContainer)
     TimerMotors_t MotorId = (TimerMotors_t)request->motortype;
     MotorAbortMovetoLimitSwitch(MotorId);
     MotorHomingRequestCallback(MotorId,0);
+    if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LDANCER2)
+    {
+        resetPullerDancer = false;
+    }
+    if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LDANCER1)
+    {
+        resetWinderDancer = false;
+    }
+    if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)
+    {
+        if (keepkvalright)
+            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, keepkvalright);
+    }
+    if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING)
+    {
+        if (keepkvalleft)
+            MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, keepkvalleft);
+    }
 
     responseContainer = createContainer(MESSAGE_TYPE__MotorAbortHomingResponse,  requestContainer->token, false, &response, &motor_abort_homing_response__pack, &motor_abort_homing_response__get_packed_size);
     responseContainer.continuous = false;
@@ -286,15 +327,18 @@ uint32_t DispenserHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
     MessageContainer responseContainer;
     DispenserHomingResponse response = DISPENSER_HOMING_RESPONSE__INIT;
 
+    uint8_t MotorId = deviceID+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
+    if (HomingToken[MotorId][0] == 0)
+        return OK;
+
     bool last = false;
     response.has_progress = true;
     response.has_maxprogress = true;
     response.maxprogress = 5800000;
     response.progress = IDS_Dispenser_Data[deviceID].consumedinnanolitter;
-    uint8_t MotorId = deviceID+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
 
     responseContainer = createContainer(MESSAGE_TYPE__DispenserHomingResponse, HomingToken[MotorId], last, &response, &dispenser_homing_response__pack, &dispenser_homing_response__get_packed_size);
-    Report("DispenserHomingProgressReport",__FILE__,__LINE__,deviceID,RpMessage,IDS_Dispenser_Data[deviceID].consumedinnanolitter,0);
+    ReportWithPackageFilter(DiagnosticsFilter,"DispenserHomingProgressReport",__FILE__,__LINE__,deviceID,RpMessage,IDS_Dispenser_Data[deviceID].consumedinnanolitter,0);
     responseContainer.has_continuous = true;
     responseContainer.continuous = true;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -315,13 +359,15 @@ uint32_t DispenserHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     {
         RemoveControlCallback(HomingControlId[MotorId],DispenserHomingProgressReport);
         HomingControlId[MotorId] = 0xff;
-        Report("DispenserHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingControlId[MotorId],0);
+        ReportWithPackageFilter(DiagnosticsFilter,"DispenserHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingControlId[MotorId],0);
     }
 
     //close dry air valve in the dispenser
     //Valve_Set((Valves_t) (DispenserId+VALVE_2W_MID_AIR_8), Atm_MidTank_OFF);
     //MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
 
+    if (HomingToken[MotorId][0] == 0)
+        return OK;
     responseContainer = createContainer(MESSAGE_TYPE__DispenserHomingResponse, HomingToken[MotorId], true, &response, &dispenser_homing_response__pack, &dispenser_homing_response__get_packed_size);
     responseContainer.has_continuous = true;
     responseContainer.continuous = true;
@@ -366,7 +412,7 @@ uint32_t DispenserHomingRequestFunc(MessageContainer* requestContainer)
             if (status == OK)
             {
                 HomingControlId[MotorId] = AddControlCallback(NULL, DispenserHomingProgressReport,  2*eOneSecond, TemplateDataReadCBFunction,request->index, 0, 0 );
-                Report("DispenserHomingProgressReport started",__FILE__,__LINE__,request->index,RpMessage,HomingControlId[MotorId],0);
+                ReportWithPackageFilter(DiagnosticsFilter,"DispenserHomingProgressReport started",__FILE__,__LINE__,request->index,RpMessage,HomingControlId[MotorId],0);
             }
         }
         else
@@ -399,7 +445,7 @@ uint32_t DispenserAbortHomingRequestFunc(MessageContainer* requestContainer)
     {
         RemoveControlCallback(HomingControlId[MotorId],DispenserHomingProgressReport);
         HomingControlId[MotorId] = 0xff;
-        Report("DispenserHomingProgressReport stopped",__FILE__,__LINE__,request->index,RpMessage,HomingControlId[MotorId],0);
+        ReportWithPackageFilter(DiagnosticsFilter,"DispenserHomingProgressReport stopped",__FILE__,__LINE__,request->index,RpMessage,HomingControlId[MotorId],0);
     }
     /*
     TimerMotors_t MotorId = (request->index)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
@@ -416,4 +462,198 @@ uint32_t DispenserAbortHomingRequestFunc(MessageContainer* requestContainer)
 
 return OK;
 }
+/********************************************************************************
+ * Drier Loading Arm Homing
+ ********************************************************************************/
+uint32_t Drier_Center_read = 0;
+uint32_t Diagnostics_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_t BusyFlag)
+{
+    MessageContainer responseContainer;
+    MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
+    uint32_t angle, temp = Read_Dryer_ENC_Position();
+
+    angle = Calculate_Arm_Distance(D_DrierPrevLocation,temp);
+
+    if ((angle<14000  )||(BusyFlag == BUSY)) // OK - take another round
+    {
+        responseContainer.has_error = true;
+        responseContainer.error = ERROR_CODE__GENERAL_ERROR;
+
+    }
+    ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Set_Load_Arm_To_Stopper time",__FILE__,__LINE__,msec_millisecondCounter,RpMessage,0,0);
+    if (HomingControlId[deviceID] != 0xff)
+    {
+        ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingProgressReport stopped",__FILE__,__LINE__,deviceID,RpMessage,HomingCounter[deviceID],0);
+        RemoveControlCallback(HomingControlId[deviceID],MotorHomingProgressReport);
+        HomingControlId[deviceID] = 0xff;
+    }
+
+    //NumberOfDrierLoaderCycles=0;
+    //storeLoadArmParameters();
+    //SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
+    ThreadLoadingRestartReport();
+    responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
+    responseContainer.has_continuous = true;
+    responseContainer.continuous = true;
+    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);
+    SendChars(container_buffer, container_size);
+    HomingToken[deviceID][0] = 0;
+
+    return OK;
+}
+
+/*uint32_t Diagnostics_Dryer_UnLoading_Callback(uint32_t MotorId, uint32_t ReadValue)
+{
+    bool direction;
+
+    D_numberOfCycles++;
+    uint32_t temp = Read_Dryer_ENC_Position();
+    ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_UnLoading_Callback",__FILE__,ReadValue,temp,RpMessage,D_DrierPrevLocation,0);
+    //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_UnLoading_Callback details",__FILE__,(int)(TotalLoadedLen),D_numberOfCycles,RpMessage,CallbackCounter,0);
+    //if ((AccumulatedArmMovement>8000  )&&(ReadValue == NOTBUSY)) // OK - take another round
+    if (ReadValue == NOTBUSY) // OK - take another round
+    {
+        ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_UnLoading cycles",__FILE__,D_numberOfCycles,LoadArmRounds,RpMessage,0,0);
+        MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,0);
+        ReportWithPackageFilter(DiagnosticsFilter,"Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+        if (abs(temp -Drier_Center_read)<200)
+        {
+            ReportWithPackageFilter(DiagnosticsFilter,"drier center proximity",__FILE__,temp,Drier_Center_read,RpMessage,abs(temp -Drier_Center_read),0);
+            if (temp<Drier_Center_read)
+                direction = 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize;
+            else
+                direction = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize;
+            MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Diagnostics_Set_Load_Arm_To_Stopper_Callback,3000,direction,10);
+
+        }
+        else
+            MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Stop);
+
+    }
+    else  //timeout or no movement
+    {
+        ReportWithPackageFilter(DiagnosticsFilter,"Unloading drier - halted",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+        //MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-(D_numberOfCycles-2));//it takes two cycles to identify a stop of the arm
+
+        ReportWithPackageFilter(DiagnosticsFilter,"Dryer unloading timeout(1) or no movement",__FILE__,temp,D_DrierPrevLocation,RpWarning,ReadValue,0);
+        Diagnostics_Set_Load_Arm_To_Stopper_Callback(MotorId, ReadValue);
+    }
+    return OK;
+}*/
+uint32_t Diagnostics_Dryer_UnLoading(void)
+{
+    D_DrierPrevLocation = Read_Dryer_ENC_Position();
+
+    LoadingArmReset(Diagnostics_Set_Load_Arm_To_Stopper_Callback,300000);
+    /*uint32_t temp;
+
+    MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
+    if (LoadArmRounds == 0) //prev trial stopped
+    {
+        LoadArmRounds = (int)dryerbufferlength;
+    }
+    if (LoadArmRounds <= 2)
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
+
+    D_numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
+    D_numberOfCycles = 0;
+
+    MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&temp);
+    Drier_Center_read = temp;
+    D_DrierPrevLocation = temp;
+    ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,D_DrierPrevLocation,RpMessage, LoadArmRounds,0);
+    MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
+
+//        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, Diagnostics_Set_Load_Arm_To_Stopper_Callback,0,1000);
+    //MotorRunWithCallback
+    MotorRunWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+                          MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius,    Diagnostics_Dryer_UnLoading_Callback, 300000);
+*/
+    return OK;
+}
+uint32_t Diagnostics_Dryer_MovetoEncoderPosition_Callback(uint32_t MotorId, uint32_t ReadValue)
+{
+    MessageContainer responseContainer;
+    MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
+    ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_MovetoEncoderPosition_Callback time",__FILE__,__LINE__,msec_millisecondCounter,RpMessage,0,0);
+    if (HomingControlId[MotorId] != 0xff)
+    {
+        ReportWithPackageFilter(DiagnosticsFilter,"MotorHomingProgressReport stopped",__FILE__,__LINE__,MotorId,RpMessage,HomingCounter[MotorId],0);
+        RemoveControlCallback(HomingControlId[MotorId],MotorHomingProgressReport);
+        HomingControlId[MotorId] = 0xff;
+    }
+
+    ReportWithPackageFilter(DiagnosticsFilter,"Store angle of arm drier - ended",__FILE__,__LINE__,(int)(Calculate_Arm_Angle(Drier_Center_read,ReadValue)*360),RpMessage,D_numberOfCycles,0);
+    //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_MovetoEncoderPosition_Callback",__FILE__,__LINE__,0,RpMessage,CallbackCounter,0);
+    MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
+    responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[MotorId], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
+    responseContainer.has_continuous = true;
+    responseContainer.continuous = true;
+    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);
+    SendChars(container_buffer, container_size);
+    HomingToken[MotorId][0] = 0;
+
+    return OK;
+}
+
+uint32_t Diagnostics_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue)
+{
+    D_numberOfCycles++;
+    uint32_t angle, temp = Read_Dryer_ENC_Position();
+
+    angle = Calculate_Arm_Distance(D_DrierPrevLocation,temp);
+    ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback",__FILE__,(int)angle,(int)ReadValue,RpMessage,temp,0);
+
+    MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,D_numberOfCycles);
+    if ((angle>14000  )&&(ReadValue == NOTBUSY)) // OK - take another round
+    {
+        D_DrierPrevLocation = temp;
+        //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+        //ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback details",__FILE__,(int)(TotalLoadedLen),numberOfCycles,RpMessage,CallbackCounter,0);
+        if (D_numberOfCycles<LoadArmRounds)
+        {
+            MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+                                   D_numberOfSteps,    Diagnostics_Dryer_Loading_Callback, 10000);
+        }
+        else
+        {
+            MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Diagnostics_Dryer_MovetoEncoderPosition_Callback,15000,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,40);
+            ReportWithPackageFilter(DiagnosticsFilter,"Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+        }
+    }
+    else
+    {
+        ReportWithPackageFilter(DiagnosticsFilter,"Loading drier - halted",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+        ReportWithPackageFilter(DiagnosticsFilter,"Store angle of arm drier - halted",__FILE__,__LINE__,(int)(Calculate_Arm_Angle(Drier_Center_read,ReadValue)*360),RpMessage,D_numberOfCycles,0);
+        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
+        Diagnostics_Dryer_MovetoEncoderPosition_Callback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,0);
+    }
+    return OK;
+}
+
+uint32_t Diagnostics_Dryer_Loading(void)
+{
+    //float Calc_angle;
+    if (dryerbufferlength)
+        LoadArmRounds = (int)dryerbufferlength;
+    MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&D_DrierPrevLocation);
+    //MCU_E2PromProgram(EEPROM_DRIER_LOADING_ARM_ANGLE,Calc_angle);
+    ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading request: current ",__FILE__,D_DrierPrevLocation,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+    Drier_Center_read = D_DrierPrevLocation;
+    D_numberOfCycles = 0;
+    D_numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/**LoadArmRounds*/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
+    D_numberOfSteps -= 100;
+    MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
+    //6 seconds per round
+
+    //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
+    MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+                           D_numberOfSteps,    Diagnostics_Dryer_Loading_Callback, 10000);
+    return OK;
+}
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
index 5b8866a28..6d09e9f9e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
@@ -39,6 +39,7 @@
 uint32_t MotorJoggingRequestFunc(MessageContainer* requestContainer)
 {
     uint32_t status = OK;
+    bool allowedInJob  =true;
 
     MessageContainer responseContainer;
 
@@ -51,9 +52,23 @@ uint32_t MotorJoggingRequestFunc(MessageContainer* requestContainer)
     int speed = request->speed;
     if (speed == 0) speed = 150;
 
+    if (JobIsActive() == true)
+    {
+        switch (MotorId)
+        {
+            case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4:
+            case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8:
+            case HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING:case HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM:case HARDWARE_MOTOR_TYPE__MOTO_SCREW:case HARDWARE_MOTOR_TYPE__MOTO_WINDER:
+            case HARDWARE_MOTOR_TYPE__MOTO_LDRIVING:case HARDWARE_MOTOR_TYPE__MOTO_LLOADING:case HARDWARE_MOTOR_TYPE__MOTO_RDRIVING:case HARDWARE_MOTOR_TYPE__MOTO_RLOADING:
+                allowedInJob = false;
+                break;
+            default:
+                break;
+        }
+    }
     if (MotorId <= NUM_OF_MOTORS)
     {
-        if ((JobIsActive() == false)&&(isMotorConfigured(MotorId) == true))
+        if ((allowedInJob == true)&&(isMotorConfigured(MotorId) == true))
         {
             {
                 switch (request->direction)
@@ -217,7 +232,7 @@ uint32_t DispenserAbortJoggingRequestFunc(MessageContainer* requestContainer)
     TimerMotors_t MotorId = (request->index)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
     MotorStop(MotorId,Hard_Hiz);
     CurrentDispenserSpeed[request->index] = 0;
-    Control3WayValvesWithCallback ((Valves_t) request->index, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+    Control3WayValvesWithCallback ((Valves_t) request->index, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
 
     if (request->index == LUBRICANT_DISPENSER)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index e2ee53645..90c18caa0 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -42,6 +42,8 @@
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "Drivers/I2C_Communication/I2C.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
+#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
+#include "drivers/FPGA/Full_Vme/FPGA_Programming_Up.h"
 
 #include "StateMachines/Printing/PrintingSTM.h"
 #include "StateMachines/Initialization/InitSequence.h"
@@ -50,10 +52,11 @@
 #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 "Modules/Waste/Waste_ex.h"
 #include "Drivers/I2C_Communication/Main_Board_EEPROM/Main_EEPROM.h"
 #include <Modules/Waste/newWHS_init.h>
 #include <Drivers/I2C_Communication/I2C_Task.h>
+#include "drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.h"
 
 uint32_t EmbeddedParametersInit(void);
 uint32_t EmbeddedParametersWrite(void * buffer, uint16_t size);
@@ -64,6 +67,7 @@ bool GeneralHwReady = false;
 bool PP_Machine = false;
 
 HardwareBlower BlowerCfg;
+HardwareBlower HeadBlowerCfg[2];
 char *SW_INFO_DIR = "0://SysInfo";
 
 char HwConfigPath[50] = "0://SysInfo//GenHwCfg.cfg";
@@ -157,13 +161,33 @@ uint32_t HWConfigurationInit(void)
         free (buffer);
 
     Trigger_Head_Init_PT100();//OK
+
+    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
+    {
+        //Activation the heaters latch + sensors card
+        Trigger_OutputsLatchWriting();//need to be done ~ at least 100uSec after Trigger_Head_io_Init
+
+        if (Head_Type == HEAD_TYPE_ARC)
+        {
+            Trigger_Head_Config_Fans();//Initialization
+        }
+
+    }
+
+
+
     //EmbeddedParametersInit();
     IDS_Dispenser_Content_Init();
     //ProcessParamsInit();
     Buttons_Init();
+#ifndef DISPESER_TEST
     if (WHS_Type == WHS_TYPE_NEW)
         newWHS_init();
-    WHS_init();
+    //WHS_init(); // remove call to old WHS
+#endif
+
+    // Waste Init (WHS)
+    Waste_Init();
 
     ADC_MUX_Init();
     GeneralHwReady = true;
@@ -215,8 +239,8 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->has_startheatingoninitsequence = true;
             EmbeddedParameters->startheatingoninitsequence = true; //set to true shlomo 14/5/2019
 
-            EmbeddedParameters->n_generalparameters = 8;
-            EmbeddedParameters->generalparameters = malloc (sizeof(double)*10);
+            EmbeddedParameters->n_generalparameters = 12;
+            EmbeddedParameters->generalparameters = malloc (sizeof(double)*13);
             if (EmbeddedParameters->generalparameters)
             {
                 EmbeddedParameters->generalparameters[0] = 1.0; //CheckHardLimitAlarms
@@ -227,6 +251,10 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
                 EmbeddedParameters->generalparameters[5] = 1000.0; //Dispenser initial pressure speed
                 EmbeddedParameters->generalparameters[6] = Diagnostic_Extended_Mode; //Diagnostic Mode SetDiagnosticMode
                 EmbeddedParameters->generalparameters[7] = AutoHoming_JobEnd_PowerOn_off; //
+                EmbeddedParameters->generalparameters[8] = false; //PowerOffDisableCleaning
+                EmbeddedParameters->generalparameters[9] = 30; //   sublimation
+                EmbeddedParameters->generalparameters[10] = 0.07; //    AllowedRangeForHeadBlowerDeviation;
+                EmbeddedParameters->generalparameters[11] = 0.2; //                AllowedRangeForWasteBlowerDeviation = WasteLimit;
             }
 
             EmbeddedParameters->has_currentalarmlowlimit = true;
@@ -260,7 +288,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->has_ids_presegment_wfcf_timebeforesegment = true;
             EmbeddedParameters->ids_presegment_wfcf_timebeforesegment = 20000;
             uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(EmbeddedParameters));
-            size_t response_size = 0;
+
             if (response_buffer)
             {
                 /*response_size = configuration_parameters__pack(EmbeddedParameters, response_buffer);
@@ -317,14 +345,14 @@ uint32_t EmbeddedParametersInit(void)
         }
     }
 
-   /* if (EmbeddedParameters->n_generalparameters >= 6)
+    if (EmbeddedParameters->n_generalparameters >= 6)
     {
         IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,EmbeddedParameters->generalparameters[5]);
     }
     else
     {
         IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,1000);
-    }*/
+    }
 
     IDS_Dispenser_SetTimeOutValues(EmbeddedParameters->closevalvetimeout, EmbeddedParameters->openvalvetimeout);
     IDS_Dispenser_SetPrepareValues(EmbeddedParameters->dispenserbuildpressurespeed,   EmbeddedParameters->dispenserbuildpressurelimit, EmbeddedParameters->dispenserbuildpressuretimeout, EmbeddedParameters->dispenserbuildpressurelag);
@@ -366,6 +394,19 @@ uint32_t EmbeddedParametersInit(void)
         else if (EmbeddedParameters->generalparameters[7]< 3.5) IDS_Dispenser_SetAutoHoming_Config(AutoHoming_JobEnd_PowerOn_off);
         else         Report("SetAutoHoming_Config error", __FILE__,__LINE__,(int)(EmbeddedParameters->generalparameters[7]*100), RpMessage, 0, 0);
     }
+    if (EmbeddedParameters->n_generalparameters >= 9)
+    {
+        if (EmbeddedParameters->generalparameters[8]< 0.5) setPowerOffDisableCleaning(false);
+        else setPowerOffDisableCleaning(true);
+    }
+    if (EmbeddedParameters->n_generalparameters >= 10)
+    {
+        setSublimationBlowTime(EmbeddedParameters->generalparameters[9]);
+    }
+    if (EmbeddedParameters->n_generalparameters >= 12)
+    {
+        setWastePrepareValues(EmbeddedParameters->generalparameters[10],EmbeddedParameters->generalparameters[11]);
+    }
     PowerIdleSetParameters(EmbeddedParameters->switchtoidletimeinseconds,EmbeddedParameters->idledriertemperature,EmbeddedParameters->idleheadtemperature,EmbeddedParameters->idlemixertemperature);
 
     return Fresult;
@@ -388,7 +429,7 @@ uint32_t GenHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
 uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
 {
     uint32_t status  = 0;
-    int Dancer_i, Dispenser_i,PID_i,tempheaterId;
+    int Dancer_i, Dispenser_i,PID_i,tempheaterId,DispenserId;
     HardwareBlowerType blowerType = HARDWARE_BLOWER_TYPE__DefaultBlower;
 
     if (UploadRequest == NULL)
@@ -396,6 +437,13 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         LOG_ERROR (0, "Wrong Data Allocation");
         return ERROR;
     }
+    if (InitFailures > 3)
+    {
+        Report("HWConfigurationInit repeated failure",__FILE__,__LINE__,(int)InitFailures,RpWarning,(int)EEPROM_INIT_FAILURE_COUNTER,0);
+        AlarmHandlingSetAlarm (EVENT_TYPE__POWER_UP_BIT_FAILURE,ON);
+        return ERROR;
+    }
+
     HardwareConfiguration *request =    UploadRequest->hardwareconfiguration;
 
     if (JobIsActive())
@@ -403,6 +451,11 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         LOG_ERROR(1,"JobIsActive");
         return ERROR;
     }
+    if (FPGABurningActive == true)
+    {
+        LOG_ERROR(1,"FPGABurningActive");
+        return ERROR;
+    }
     if (watchdogCriticalAlarm == true)
     {
         LOG_ERROR(1,"Critical Alarm cleared - Watchdog de-activated");
@@ -411,9 +464,10 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
     EmbeddedParametersInit();
 
     PrintingHWConfiguration(request);
-    if (request->n_winders == 1)
-        status += InternalWinderConfigMessage(request->winders);
+    //if (request->n_winders == 1)
+    //    status += InternalWinderConfigMessage(request->winders);
 
+    MotorConfiguredTimeout = 100;
 
     status += MotorsInit();
  
@@ -461,8 +515,15 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
             else if ((request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__MotorDryer)&&
                     (request->pidcontrols[PID_i]->hardwarepidcontroltype < HARDWARE_PID_CONTROL_TYPE__Dispenser1))
                 status += MotorPidRequestMessage(request->pidcontrols[PID_i]);
-            else if (request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__Dispenser1)
+            else if ((request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__Dispenser1)&&
+                (request->pidcontrols[PID_i]->hardwarepidcontroltype < HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7))
                 status += IDS_DispenserPidRequestMessage(request->pidcontrols[PID_i]);
+            else if (request->pidcontrols[PID_i]->hardwarepidcontroltype == HARDWARE_PID_CONTROL_TYPE__WasteControl)
+                WHS_PidRequestMessage(request->pidcontrols[PID_i]);
+            else if (request->pidcontrols[PID_i]->hardwarepidcontroltype == HARDWARE_PID_CONTROL_TYPE__HeadBlower_1)
+                HeadBlowerPidRequestMessage(request->pidcontrols[PID_i], HEAD_FAN_RIGHT);
+            else if (request->pidcontrols[PID_i]->hardwarepidcontroltype == HARDWARE_PID_CONTROL_TYPE__HeadBlower_2)
+                HeadBlowerPidRequestMessage(request->pidcontrols[PID_i], HEAD_FAN_LEFT);
         }
     }
     else
@@ -475,15 +536,18 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
     {
         for (Dispenser_i = 0; Dispenser_i < request->n_dispensers ; Dispenser_i++)
         {
-            Valve_Set(IDS_Id_to_AirValve[Dispenser_i], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
-            Valve_Set(IDS_Id_to_CartrideValve[Dispenser_i], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
-            status += DispenserConfigMessage(request->dispensers[Dispenser_i]);
-            if (Check_Dispenser_Type(request->dispensers[Dispenser_i]->index) == LS_STATUS_ERROR)
+            DispenserId = request->dispensers[Dispenser_i]->index;
+            Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
+            Valve_Set(IDS_Id_to_CartrideValve[DispenserId], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
+            //status += DispenserConfigMessage(request->dispensers[Dispenser_i]);
+            if (Check_Dispenser_Type(DispenserId) == LS_STATUS_ERROR)
             {
-                LOG_ERROR (Dispenser_i, "Dispenser identification failed");
+                LOG_ERROR (DispenserId, "Dispenser identification failed");
                 //return ERROR;
             }
+            Trigger_Dispenser_ReadData(DispenserId);
         }
+        Calculateinit();
     }
     else
     {
@@ -526,11 +590,30 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
 
                 break;
             }
+            if((request->blowers[Dispenser_i]->enabled)&&(request->blowers[Dispenser_i]->hardwareblowertype == HARDWARE_BLOWER_TYPE__WHSSmallFans))
+            {
+                SmallFansCfg = request->blowers[Dispenser_i]->voltage;
+            }
+            if((request->blowers[Dispenser_i]->enabled)&&(request->blowers[Dispenser_i]->hardwareblowertype == HARDWARE_BLOWER_TYPE__WHSLargeFans))
+            {
+                LargeFansCfg = request->blowers[Dispenser_i]->voltage;
+            }
+            if((request->blowers[Dispenser_i]->enabled)&&(request->blowers[Dispenser_i]->hardwareblowertype == HARDWARE_BLOWER_TYPE__HeadBlower1))
+            {
+                HeadBlowerCfg[0].enabled = true;
+                HeadBlowerCfg[0].voltage = request->blowers[Dispenser_i]->voltage;
+                HeadBlowerCfg[0].heatingvoltage = request->blowers[Dispenser_i]->heatingvoltage;
+            }
+            if((request->blowers[Dispenser_i]->enabled)&&(request->blowers[Dispenser_i]->hardwareblowertype == HARDWARE_BLOWER_TYPE__HeadBlower2))
+            {
+                HeadBlowerCfg[1].enabled = true;
+                HeadBlowerCfg[1].voltage = request->blowers[Dispenser_i]->voltage;
+                HeadBlowerCfg[1].heatingvoltage = request->blowers[Dispenser_i]->heatingvoltage;
+            }
         }
     }
     ControlStart();
     AlarmHandlingStart();
-    //ThreadInitialTestStub(request);
     GeneralHwReady = true;
     STATUS_RED_LED_OFF;
     return OK;
@@ -597,21 +680,14 @@ uint32_t MidTankDataSetupFunc(MessageContainer* requestContainer)
     }
     //debug only
     Task_sleep(1000);
+    ADC_MUX_Init();
     for (i = 0;i<8;i++)
     {
         float a=0,b=0;
-        a = MCU_E2PromReadMidtank_A(i);
-        b = MCU_E2PromReadMidtank_B(i);
+        a = Initial_Offset_A[i];
+        b = Slope_B[i];
         Report("MidTankData Read", __FILE__,__LINE__,(int)(a*1000), RpMessage, (int)(b*1000), 0);
     }
-    //debug only
-    /*
-    Task_sleep(1000);
-    //MCU_E2PromSerialNumProgram ("Take me to the sky");
-    memset (Serial,0,20);
-    MCU_E2PromSerialNumRead(&Serial);
-    Report(Serial, __FILE__,__LINE__,22, RpMessage, 21, 0);
-    */
 
     MidTankDataSetupResponse response = MID_TANK_DATA_SETUP_RESPONSE__INIT;
 
@@ -629,24 +705,48 @@ uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
 {
     uint32_t status  = 0;
     uint32_t DataLen  = 0;
+    uint32_t ExistingDataLen  = 0;
+    int compare = 0;
     MessageContainer responseContainer;
     UploadHardwareConfigurationResponse response = UPLOAD_HARDWARE_CONFIGURATION_RESPONSE__INIT;
+    UploadHardwareConfigurationRequest* UploadRequest = NULL;
+    if (JobIsActive())
+    {
+        LOG_ERROR(1,"JobIsActive");
+        status = ERROR;
+    }
+    else
+    {
+        GeneralHwReady = false;
+        Control_WD(ENABLE,250);
+        //compare existing data to new data. update if different
+        memcpy(&ExistingDataLen,(void *)GENHWCFG_MAP_IN_FLASH,sizeof(ExistingDataLen));
+        if (ExistingDataLen == requestContainer->data.len)
+        {
+            compare = memcmp (requestContainer->data.data,((void *)(GENHWCFG_MAP_IN_FLASH+4)),requestContainer->data.len);
+            Report("!!!!!!!!!data compare hw func", __FILE__,compare,requestContainer->data.len,RpMessage,ExistingDataLen,0);
+        }
+        else
+            compare = ExistingDataLen - requestContainer->data.len;
+            //if compare is equal no need to store the data
+        if (compare != 0)
+        {
+            DataLen = requestContainer->data.len;
+            EraseFlashSection(GENHWCFG_SECTION_FLASH);
+            ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&DataLen);
+            ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, DataLen, requestContainer->data.data);
+            Report("store hw configuration", __FILE__,compare,requestContainer->data.len,RpMessage,ExistingDataLen,0);
 
-    DataLen = requestContainer->data.len;
-    EraseFlashSection(GENHWCFG_SECTION_FLASH);
-    ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&DataLen);
-    ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, DataLen, requestContainer->data.data);
-
-    FileWrite(requestContainer->data.data, requestContainer->data.len,HwConfigPath,BIOS_WAIT_FOREVER);
+            FileWrite(requestContainer->data.data, requestContainer->data.len,HwConfigPath,BIOS_WAIT_FOREVER);
+        }
+        UploadRequest = upload_hardware_configuration_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
-    UploadHardwareConfigurationRequest* UploadRequest = upload_hardware_configuration_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
-    GeneralHwReady = false;
-    Control_WD(ENABLE,250);
+        status = HWConfiguration(UploadRequest);
 
-    status = HWConfiguration(UploadRequest);
+        GeneralHwReady = true;
+    }
 
-    GeneralHwReady = true;
 
     responseContainer = createContainer(MESSAGE_TYPE__UploadHardwareConfigurationResponse, requestContainer->token, true, &response, &upload_hardware_configuration_response__pack, &upload_hardware_configuration_response__get_packed_size);
     if (status!= OK)
@@ -662,7 +762,8 @@ uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
     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);
-    upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
+    if (UploadRequest)
+        upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
     SendChars(container_buffer, container_size);
 
     return OK;
@@ -750,10 +851,11 @@ void FlashInitAndLoad(void)
     uint32_t Bytes = 0;
 
     ConfigurationParameters *Params = NULL;
-    ProcessParameters*  ProcessParams = NULL;
-    UploadProcessParametersRequest* request = NULL;
+    //ProcessParameters*  ProcessParams = NULL;
+    //UploadProcessParametersRequest* request = NULL;
+
+    //char ProcessParamsPath[50] = "0://SysInfo//ProcessP.cfg";
 
-    char ProcessParamsPath[50] = "0://SysInfo//ProcessP.cfg";
 #ifdef WATCHDOG
         ROM_WatchdogResetDisable(WATCHDOG0_BASE);
         uint32_t timeout = 0xFFFFFFFFU;
@@ -776,11 +878,11 @@ void FlashInitAndLoad(void)
 
     StoreDancerConfigMessage();
     Report("Dancer Initialized", __FILE__,DancersCfg[0].zeropoint,DancersCfg[1].zeropoint, RpMessage, DancersCfg[2].zeropoint, 0);
-    Bytes = AlarmHandlingLoadFile();
+    /*Bytes = AlarmHandlingLoadFile();
     if (Bytes>0)
     {
         Report("Alarm Initialized from file", __FILE__,__LINE__,Bytes, RpMessage, ALARM_MAP_IN_FLASH, 0);
-    }
+    }*/
     EraseFlashSection(EMBEDDED_PARAMETERS_SECTION_FLASH);
 
     Fresult = FileRead(EmbeddedParametersPath, &Bytes, &buffer);
@@ -803,20 +905,23 @@ void FlashInitAndLoad(void)
         Report("Parameters Initialized from default", __FILE__,__LINE__,sizeof(EmbeddedParameters), RpMessage, EMBEDDED_PARAMETERS_MAP_IN_FLASH, 0);
     }
 
-    Fresult = FileRead(ProcessParamsPath, &Bytes, &buffer);
+    /*Fresult = FileRead(ProcessParamsPath, &Bytes, &buffer);
     if (Fresult == FR_OK)
     {
         request = upload_process_parameters_request__unpack(NULL, Bytes, buffer);
-        ProcessParams = request->processparameters;
-        Bytes = sizeof(ProcessParams);
-        ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
-        ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, &ProcessParams);
-        upload_process_parameters_request__free_unpacked(request,NULL);
-        FlashInitResults[2] = true;
-        Report("Process Initialized", __FILE__,__LINE__,Bytes, RpMessage, (int)ProcessParams->dryerzone1temp, 0);
+        if (request)
+        {
+            ProcessParams = request->processparameters;
+            Bytes = sizeof(ProcessParams);
+            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
+            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, &ProcessParams);
+            upload_process_parameters_request__free_unpacked(request,NULL);
+            FlashInitResults[2] = true;
+            Report("Process Initialized", __FILE__,__LINE__,Bytes, RpMessage, (int)ProcessParams->dryerzone1temp, 0);
+        }
     }
     else
-        Report("Process not Initialized", __FILE__,__LINE__,0, RpMessage, 0, 0);
+        Report("Process not Initialized", __FILE__,__LINE__,0, RpMessage, 0, 0);*/
 #ifdef WATCHDOG
         ROM_WatchdogResetEnable(WATCHDOG0_BASE);
         timeout = 120000000*3;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h
index 55490a140..e99931acc 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h
@@ -20,6 +20,7 @@ uint32_t LoadConfigurationParamsFromFile(bool);
 void HWConfigurationLoadFile(void);
 
 extern HardwareBlower BlowerCfg;
+extern HardwareBlower HeadBlowerCfg[2];
 
 extern bool DataUpdated;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
index 146c62bb6..801f48576 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
@@ -15,34 +15,61 @@
 #include "PMR/MachineStatus/StopMachineStatusUpdateRequest.pb-c.h"
 #include "PMR/MachineStatus/StartMachineStatusUpdateResponse.pb-c.h"
 #include "PMR/MachineStatus/StopMachineStatusUpdateResponse.pb-c.h"
+#include "PMR/Diagnostics/EventType.pb-c.h"
 #include "PMR/MachineStatus/MachineStatus.pb-c.h"
 #include "PMR/MachineStatus/MachineState.pb-c.h"
 #include "PMR/MachineStatus/IDSPackLevel.pb-c.h"
 
+#include "PMR/IFS/CartridgeStatus.pb-c.h"
+#include "PMR/IFS/InkFillingStatus.pb-c.h"
+#include "PMR/IFS/StartInkFillingStatusRequest.pb-c.h"
+#include "PMR/IFS/StartInkFillingStatusResponse.pb-c.h"
+
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "Drivers/Heater/TemperatureSensor.h"
 #include "drivers/Motors/Motor.h"
 
+#include "StateMachines/Initialization/InitSequence.h"
+
 #include "Modules/General/MachineStatus.h"
+#include "Modules/AlarmHandling/AlarmHandling.h"
 #include "Modules/Control/MillisecTask.h"
+#include "modules/waste/waste_ex.h"
 #include "modules/ids/ids_ex.h"
+#include "modules/ifs/ifs.h"
 
 MachineState StoredMachineStatus = MACHINE_STATE__PowerUp;
-
+bool SetMAchineStateProblem = false;
 void SetMachineStatus (MachineState State)
 {
+    if (StoredMachineStatus == MACHINE_STATE__PowerOff)
+    {
+        ReportWithPackageFilter(GeneralFilter,"not changing MachineStatus while on power down",__FILE__,__LINE__,State,RpWarning,StoredMachineStatus, 0);
+        return;
+    }
+    if (State == MACHINE_STATE__Ready)
+    {
+        if ((GetMachineState()<MACHINE_STATE_MACHINE_READY_TO_DYE)&&(GetMachineState()!=MACHINE_STATE_NO_PROCESS_PARAMS))
+        {
+            ReportWithPackageFilter(GeneralFilter,"SetMachineStatus problem",__FILE__,__LINE__,State,RpWarning,GetMachineState(), 0);
+            SetMAchineStateProblem = true;
+        }
+    }
     ReportWithPackageFilter(GeneralFilter,"SetMachineStatus",__FILE__,__LINE__,State,RpWarning,StoredMachineStatus, 0);
 
     StoredMachineStatus = State;
+    MachineUpdateResponseFunc();
 }
 char MachineUpdateToken[36+1] = {0};
 IDSPackLevel IDS_Level[MAX_SYSTEM_DISPENSERS];
 TimerMotors_t msDispenserIdToMotorId[MAX_SYSTEM_DISPENSERS] = {HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8};
 
+bool temp_measure_alarm = false;
 int MachineUpdateResponseFunc(void)
 {
     int i;
-
+    int internaltemp1,internaltemp2,usetemp;
+    bool int1valid = true,int2valid = true;
     MessageContainer responseContainer;
     if (MachineUpdateToken[0] == 0)
         return OK;
@@ -56,6 +83,52 @@ int MachineUpdateResponseFunc(void)
     MachineStatus.state = StoredMachineStatus;
     MachineStatus.n_idspackslevels = 0;
     MachineStatus.idspackslevels = (IDSPackLevel**)my_malloc(sizeof(IDSPackLevel *)*8);
+    MachineStatus.has_spoolstate = true;
+
+    internaltemp1 = MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1);
+    internaltemp2 = MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2);
+
+    if((internaltemp1<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=internaltemp1))
+        int1valid = false;
+    if((internaltemp2<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=internaltemp2))
+        int2valid = false;
+    MachineStatus.has_overalltemperature = true;
+    if ((int2valid == true)&&(int1valid == true))
+    {
+            usetemp = (max(internaltemp1,internaltemp2))/100;
+            if (temp_measure_alarm == true)
+            {
+                AlarmHandlingSetAlarm(EVENT_TYPE__TEMPERATURE_MEASUREMENT_ERROR, false);
+                temp_measure_alarm = false;
+            }
+    }
+    else
+    {
+        //AlarmHandlingSetAlarm(EVENT_TYPE__TEMPERATURE_MEASUREMENT_ERROR, true);
+        temp_measure_alarm = true;
+        if ((int2valid == false)&&(int1valid == true))
+            usetemp = internaltemp1/100;
+        else if ((int2valid == false)&&(int1valid == false))
+        {
+            MachineStatus.has_overalltemperature = FALSE;
+            usetemp = 0;
+        }
+        else  if ((int1valid == false)&&(int2valid == true))
+            usetemp = internaltemp2/100;
+    }
+    MachineStatus.overalltemperature = usetemp;
+
+
+
+    if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
+    {
+      MachineStatus.spoolstate = SPOOL_STATE__Absent;
+    }
+    else
+    {
+        MachineStatus.spoolstate = SPOOL_STATE__Present;
+
+    }
     if (MachineStatus.idspackslevels)
     {
         for (i = 0; i<MAX_SYSTEM_DISPENSERS;i++)
@@ -74,14 +147,12 @@ int MachineUpdateResponseFunc(void)
             IDS_Level[i].midtanklevel = Get_MidTank_Pressure_Sensor(i);
             MachineStatus.idspackslevels[MachineStatus.n_idspackslevels] = &IDS_Level[i];
             MachineStatus.n_idspackslevels++;
-            MachineStatus.overalltemperature = max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2));
         }
     }
     else
         return ERROR;
 
 
-
     responseContainer = /*MachineUpdate*/createContainer(MESSAGE_TYPE__StartMachineStatusUpdateResponse, MachineUpdateToken, false, &response, &start_machine_status_update_response__pack, &start_machine_status_update_response__get_packed_size);
     responseContainer.has_continuous = true;
     responseContainer.continuous = true;
@@ -150,4 +221,106 @@ uint32_t StopMachineUpdateFunc(MessageContainer* requestContainer)
 
 return OK;
 }
+/*struct  _Cartridge
+{
+  ProtobufCMessage base;
+  protobuf_c_boolean has_slot;
+  CartridgeSlot slot;
+  CartridgeTagContent *tag;
+  protobuf_c_boolean has_index;
+  int32_t index;
+};
+ typedef enum _CartridgeSlot {
+  CARTRIDGE_SLOT__Ink = 0,
+  CARTRIDGE_SLOT__WasteMiddle = 1,
+  CARTRIDGE_SLOT__WasteLower = 2
+    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(CARTRIDGE_SLOT)
+} CartridgeSlot;
+ * */
+
+char WasteEmptyingToken[36+1] = {0};
+uint32_t CartridgeStateUpdate(CartridgeSlot Slot,CartridgeState State, double percentage)
+{
+    if (WasteEmptyingToken[0] == 0)
+        return ERROR;
+    uint32_t status = NOT_SUPPORTED;
+    MessageContainer responseContainer;
+    CartridgeStatus CartridgeStatus = CARTRIDGE_STATUS__INIT;
+    Cartridge CartData = CARTRIDGE__INIT;
+    StartInkFillingStatusResponse response = START_INK_FILLING_STATUS_RESPONSE__INIT;
+    response.status->n_cartridgesstatuses = 1;
+    response.status->cartridgesstatuses[0] = &CartridgeStatus;
+    CartridgeStatus.has_state = true;
+    CartridgeStatus.state = State;
+    CartridgeStatus.cartridge = &CartData;
+    if (percentage>1)
+    {
+        CartridgeStatus.has_progresspercentage = true;
+        CartridgeStatus.progresspercentage = percentage;
+    }
+    CartData.has_slot = true;
+    CartData.slot = Slot;
+
+    /*
+        struct  _CartridgeStatus
+        {
+          ProtobufCMessage base;
+          Cartridge *cartridge;
+          protobuf_c_boolean has_state;
+          CartridgeState state;
+          protobuf_c_boolean has_progresspercentage;
+          double progresspercentage;
+          char *message;
+        };
+          size_t n_cartridgesstatuses;
+          CartridgeStatus **cartridgesstatuses;
+          typedef enum _CartridgeState {
+              CARTRIDGE_STATE__None = 0,
+              CARTRIDGE_STATE__Absent = 1,
+              CARTRIDGE_STATE__Exists = 2,
+              CARTRIDGE_STATE__Inserted = 3,
+              CARTRIDGE_STATE__Filling = 4,
+              CARTRIDGE_STATE__FillingCompleted = 5,
+              CARTRIDGE_STATE__Emptying = 6,
+              CARTRIDGE_STATE__EmptyingCompleted = 7,
+              CARTRIDGE_STATE__Empty = 8,
+              CARTRIDGE_STATE__Full = 9,
+              CARTRIDGE_STATE__Error = 10
+              PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(CARTRIDGE_STATE)
+        } CartridgeState;
+     */
+
+    responseContainer = createContainer(MESSAGE_TYPE__StartInkFillingStatusResponse, WasteEmptyingToken, false, &response, &start_ink_filling_status_response__pack, &start_ink_filling_status_response__get_packed_size);
+    responseContainer.has_continuous = true;
+    responseContainer.continuous = true;
+    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);
+    //USBCDCD_sendData(container_buffer, container_size,10);
+
+    SendChars((char*)container_buffer, container_size);
+    //MessageContainer responseContainer;
+
+    return status;
+}
+
+uint32_t StartInkFillingStatusRequestFunc(MessageContainer* requestContainer)
+{
+    uint32_t status = NOT_SUPPORTED;
+    //MessageContainer responseContainer;
+
+//    MachineUpdateInitParams InitParams;
+
+    Report("StartInkFillingStatusRequestFunc",__FILE__,__LINE__,(int)0,RpWarning,(int)0,0);
+    StartInkFillingStatusRequest* request = start_ink_filling_status_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    ustrncpy (WasteEmptyingToken, requestContainer->token,36);
+
+    CartridgeStateUpdate(CARTRIDGE_SLOT__Ink,CARTRIDGE_STATE__None,0);
+    CartridgeStateUpdate(CARTRIDGE_SLOT__WasteMiddle,CARTRIDGE_STATE__None,0);
+    CartridgeStateUpdate(CARTRIDGE_SLOT__WasteLower,CARTRIDGE_STATE__None,0);
+    start_ink_filling_status_request__free_unpacked(request,NULL);
+    return status;
+//    case MESSAGE_TYPE__StartWasteEmptyingRequest:
+
+}
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h
index 489a8f638..b3b773b1e 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.h
@@ -9,11 +9,16 @@
 #define MODULES_GENERAL_MACHINESTATUS_H_
 #include <PMR/Common/MessageContainer.pb-c.h>
 #include "PMR/MachineStatus/MachineState.pb-c.h"
+#include "PMR/IFS/CartridgeState.pb-c.h"
+#include "PMR/Diagnostics/CartridgeSlot.pb-c.h"
 
 uint32_t MachineUpdateInitFunc(MessageContainer* requestContainer);
 uint32_t StopMachineUpdateFunc(MessageContainer* requestContainer);
 void SetMachineStatus (MachineState State);
 int MachineUpdateResponseFunc(void);
+uint32_t StartInkFillingStatusRequestFunc(MessageContainer* requestContainer);
+
+uint32_t CartridgeStateUpdate(CartridgeSlot Slot,CartridgeState State, double percentage);
 
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/Safety.c b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
index 9680e11d0..422b4745f 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/Safety.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
@@ -54,7 +54,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
 #endif
    for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
    {
-       if (isMotorConfigured(Disp_i + HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)==true)
+       //Check safety in the dispensers only for configured, available and supports dispensers (with EEPROM 128KB)
+       if ((isMotorConfigured(Disp_i + HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)==true) && (Dispenser_struct[Disp_i].Type == DISP_TYPE_EEPROM128KB))
        {
            Indication = Check_Disp_Safety_Stop_Indication(Disp_i);
            AllDispensersInSafety &= Indication;
@@ -64,7 +65,46 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
 
    if (AllDispensersInSafety)
    {
-       if (Get_COVER_1_State(DryerDoor))
+       if (WHS_GPI_SW_FILTER_PRES())
+       {
+           //report and handle filter missing
+           AlarmHandlingSetAlarm(EVENT_TYPE__AIR_FILTER_NOT_INSTALLED, true);
+           mAirFilterAlarmState = true;
+           AirFilterAlarmState = true;
+       }
+       else
+       {
+           if (WHS_GPI_WASTE_FLOW_SWITCH() == false)
+           {
+               //report and handle air flow failure
+               //if blower if off handling is different
+               AlarmHandlingSetAlarm(EVENT_TYPE__NO_AIR_PRESSURE, true);
+               mAirFlowAlarmState = true;
+               AirFlowAlarmState = true;
+           }
+           else
+           {
+               if (Get_COVER_1_State(DryerDoor))
+               {
+                   //report and handle dryer door open
+                   AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, true);
+                   mDrierDoorAlarmState = true;
+                   DrierDoorAlarmState = true;
+               }
+               else
+               {
+                   //if (WHS_GPI_WASTE_OVERFULL()) - cannot read this switch
+                   {
+                       //report and handle waste overflow
+                       AlarmHandlingSetAlarm(EVENT_TYPE__CHILLER_DRY_CONTACT, true);
+                       mWasteOverflowAlarmState = true;
+                       WasteOverflowAlarmState = true;
+                   }
+               }
+           }
+       }
+
+/*     if (Get_COVER_1_State(DryerDoor))
        {
            //report and handle dryer door open
            AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, true);
@@ -102,6 +142,7 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
                }
            }
        }
+       */
    }
    else if (AnyDispensersInSafety)
    {
@@ -193,12 +234,12 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
        AlarmHandlingSetAlarm(EVENT_TYPE__AIR_FILTER_NOT_INSTALLED, false);
        AirFilterAlarmState = mAirFilterAlarmState;
    }
-   if  ((mWasteOverflowAlarmState != WasteOverflowAlarmState)|| (mWasteOverflowAlarmState == false))
+   /*if  ((mWasteOverflowAlarmState != WasteOverflowAlarmState)|| (mWasteOverflowAlarmState == false))
    {
       //alarm went off
        AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, false);
        WasteOverflowAlarmState = mWasteOverflowAlarmState;
-   }
+   }*/
 #ifdef CONTROL_DEBUG
                 tempq = HibernateRTCSSGet();
                 if (tempq < tempp)
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
index 7326dc039..0dda71d16 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
@@ -58,8 +58,8 @@ uint8_t  thraedJogging(uint8_t off);
 
 uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue);
-uint32_t LoadStatMachine( button *pBtn);
-uint32_t LoadLongPress( button *pBtn);
+//uint32_t LoadStatMachine( button *pBtn);
+//uint32_t LoadLongPress( button *pBtn);
 bool get_pbAction ( button *pBtn, PB_Status ReadValue);
 
 #define LOADLONGPRESS 3
@@ -152,14 +152,37 @@ bool get_pbAction (button *pBtn, PB_Status ReadValue )
             }
             else
             {
+                if (pBtn->count > SECOND1)
+                {
+                    pBtn->Action = SHORTPB;
+                    ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> SHORTPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+                }
+                else
+                {
+                    pBtn->Action = OFFPB;
+                    ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+                }
                 pBtn->count = 0 ;
-                pBtn->Action = SHORTPB;
-                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> SHORTPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
             }
             break;
         case SHORTPB:
-            pBtn->Action = OFFPB;
-            ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: SHORTPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+            if (ReadValue == PRESS)
+            {
+                pBtn->count += 1 ;
+                if (pBtn->count > SECOND5)
+                {
+                    pBtn->Action = LONGPB;
+                    ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> LONGPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+                }
+            }
+            else
+            {
+                pBtn->Action = OFFPB;
+                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+                pBtn->count = 0 ;
+            }
+            //pBtn->Action = OFFPB;
+            //ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: SHORTPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
             break ;
         case LONGPB:
             if (ReadValue == RELEASE)
@@ -328,7 +351,7 @@ uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 //            }
             break;
         case sttJOGGING:
-            if (jog.Action == SHORTPB) //PB is OFF
+            if (jog.Action == OFFPB) //PB is OFF
             {
                 ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttJOGGING action SHORTPB, sttJOGGING -> sttENABLE,  stop JOGGING----------------", __FILE__,__LINE__,jog.state, RpMessage, jog.Action, 0);
                 ThreadAbortJoggingFunc(); 
@@ -373,11 +396,18 @@ uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue)
    {
        case SHORTPB:
            ReportWithPackageFilter(GeneralFilter,"------------ thread loading SHORTPB  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-           LoadStatMachine( &load );
+           if (ThreadLoadingActive() == true)
+               ThreadLoadButton(0);  //fix failures and continue of planned stop
            break;
        case LONGPB:
            ReportWithPackageFilter(GeneralFilter,"------------ thread loading LONGPB  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-           LoadLongPress( &load );
+           if (ThreadLoadingActive() == false)
+		   {
+               ReportWithPackageFilter(GeneralFilter,"------------ NOT starting loading from button  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+               //ThreadLoadButton(0); //INIT CHANGE HERE FOR 1.4.6.44
+		   }
+           else
+               Thread_Load_End(); //END
            break;
        case REPLONGPB:
            ReportWithPackageFilter(GeneralFilter,"------------ thread loading REPLONGPB please release the PB  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
@@ -386,9 +416,15 @@ uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue)
            if (ThreadLoadingActive() == false)
            {
                if (JobIsActive())
+               {
                    load.color =  colorOFF;
+                   Pannel_Leds(THREAD_LOAD, MODE_OFF);
+               }
                else
+               {
                    load.color =  colorON;
+                   Pannel_Leds(THREAD_LOAD, MODE_ON);
+               }
            }
            break;
    }
@@ -573,77 +609,80 @@ return OK;
 /*------     THREAD LOAD/UNLOAD        ----------*/
 
 
-uint32_t LoadStatMachine( button *pBtn)
+/*uint32_t LoadStatMachine( button *pBtn)
 {
 
     ReportWithPackageFilter(GeneralFilter,"------------ (state) (color) -----------------", __FILE__,__LINE__,pBtn->state, RpMessage, pBtn->color, 0);
     switch (pBtn->state)
     {
         case sttRDY :
-//            ReportWithPackageFilter(GeneralFilter,"------------ load.state = sttRDY -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-///*            switch (pBtn->Action)
-//            {
-//                case (SHORTPB):
-//                case (LONGPB):
-//                case (REPLONGPB):
-//                    pBtn->state = sttPRELOAD;
-//                    pBtn->color =  BLINK;*/
-//                    if (ThreadLoadButton( THREAD_LOAD_INIT)== OK)
-//                    {
-//                        pBtn->state = sttPRELOAD ;    // to do
+            ReportWithPackageFilter(GeneralFilter,"------------ load.state = sttRDY -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+            switch (pBtn->Action)
+            {
+                case (SHORTPB):
+                //case (LONGPB):
+                case (REPLONGPB):
+                    pBtn->state = sttPRELOAD;
+//                    pBtn->color =  BLINK;
+                    if (ThreadLoadButton( THREAD_LOAD_INIT)== OK)
+                    {
+                        pBtn->state = sttPRELOAD ;    // to do
 //                        pBtn->color =  colorON;
 //                        Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
-//                    }
+                    }
 //                    else
 //                    {
 //                       // pBtn->state = sttDISABLE ;
 //                        Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+
 //                    }
-//                    /*break;
-//                default :
-//                    break;
-//            }*/
+                    break;
+                case (LONGPB):
+                    Thread_Load_End();
+                        break;
+                default :
+                    break;
+            }
             break;
         case sttPRELOAD:
             ReportWithPackageFilter(GeneralFilter,"------------ load.state = sttPRELOAD -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-            /*switch (pBtn->Action)
+            /`*switch (pBtn->Action)
             {
                 case (SHORTPB):
                 case (LONGPB):
                 case (REPLONGPB):
                     pBtn->color =  BLUE;
-                    Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+*/
+                    Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+*`/
                     if (ThreadLoadButton( THREAD_LOAD_INITIAL_TENSION)== OK)
                     {
                         pBtn->state = sttRDY ;    // to do
-                        pBtn->color =  colorON;
-                        Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
+//                        pBtn->color =  colorON;
+//                        Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                     }
                     else
                     {
                         //pBtn->state = sttLOADFAIL ;
-                        pBtn->color = fastBILNK ;    // to do
+//                        pBtn->color = fastBILNK ;    // to do
                     }
-                    /*break;
+                    /`*break;
                 default :
                     break;
-            }*/
+            }*`/
             break;
         case sttLOADING:
             ReportWithPackageFilter(GeneralFilter,"------------ load.state = sttLOADING -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-            pBtn->color =  fastBILNK;
-            Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
+//            pBtn->color =  fastBILNK;
+//            Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
             if (ThreadLoadButton( THREAD_LOAD_END)== OK)
             {
                 pBtn->state = sttRDY ;    // to do
-                pBtn->color =  colorON;
-                Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
+//                pBtn->color =  colorON;
+//                Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
             }
             else
             {
                 pBtn->state = sttRDY ;    // to do
                 //pBtn->state = sttLOADFAIL ;
-                pBtn->color = fastBILNK ;    // to do
+//                pBtn->color = fastBILNK ;    // to do
             }
             break;
 //        case sttLOADSUCSESS ?????
@@ -659,35 +698,7 @@ uint32_t LoadStatMachine( button *pBtn)
             break;
     }
     return OK;
-}
-
-void Ink_Cart_Led()//temporary for ITMA
-{
-    if(Is_Cartridge_Present(CART_1) == true)
-    {
-        Pannel_Leds( CART_1,  MODE_ON);
-    }
-    else
-    {
-        Pannel_Leds( CART_1,  MODE_OFF);
-    }
-    if(Is_Cartridge_Present(CART_2) == true)
-    {
-        Pannel_Leds( CART_2,  MODE_ON);
-    }
-    else
-    {
-        Pannel_Leds( CART_2,  MODE_OFF);
-    }
-    if(Is_Cartridge_Present(CART_3) == true)
-    {
-        Pannel_Leds( CART_3,  MODE_ON);
-    }
-    else
-    {
-        Pannel_Leds( CART_3,  MODE_OFF);
-    }
-}
+}*/
 
 void test_avi()
 {
@@ -699,10 +710,11 @@ void test_avi()
 
 }
 
-uint32_t LoadLongPress( button *pBtn)
+/*uint32_t LoadLongPress( button *pBtn)
 {
     ReportWithPackageFilter(GeneralFilter,"------------ load.state = LoadLongPress -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-    switch (pBtn->state)
+    Thread_Load_End();
+/`*    switch (pBtn->state)
     {
         case sttRDY :
             ReportWithPackageFilter(GeneralFilter,"------------ load.state = sttRDY -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
@@ -720,7 +732,7 @@ uint32_t LoadLongPress( button *pBtn)
             break;
         default:
             Thread_Load_End();
-    }
+    }*`/
     return OK;
-}
+}*/
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
index 646861bc7..6a15d3765 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
@@ -59,7 +59,6 @@ uint32_t Buttons_Init(void);
 uint32_t Button_load_Init(void);
 uint32_t Button_JOG_Init(void);
 bool SetPowerMachineState(PBmachineState state);
-void Ink_Cart_Led();
 
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index ab4c6daac..4538d0336 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -26,18 +26,23 @@
 
 #include "drivers/Flash_ram/FlashProgram.h"
 #include <Drivers/I2C_Communication/I2C_Task.h>
+#include "drivers/Flash_ram/MCU_E2Prom.h"
+
+#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
 
 double dyeingspeed = 0;
 double dryerbufferlength = 0;
 double mininkuptake = 0;
 double feedertension = 0;
-double pullertension = 5000;
-double windertension = 5000;
+double pullertension = 0;
+double windertension = 0;
 double headairflow = 5.0;
 double dryerairflow = 5.0;
 double pressurebuildup = 0;
 double dryerzone1temp = 0;
 int32_t tableindex = 0;
+double headBlowersFlow[2] = {1.0,1.0};
+double ArcCleaningMotorSpeed = 0.0;
 
 double dryerbufferMeters = 0;
 double dryerbufferCentimeters = 0;
@@ -116,15 +121,27 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     }
     if (saveData == true)
     {
-        if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
+        if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone1temp > 0.1))//NOT turning off heaters
         {
             Bytes = sizeof(ProcessParameters);
             FileWrite(ProcessParams,Bytes,ProcessParamsConfigPath,BIOS_WAIT_FOREVER);
-            EraseFlashSection(EMBEDDED_PARAMETERS_SECTION_FLASH);
+            EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH);
             ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
             ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
             REPORT_MSG(Bytes,"Bytes write to flash");
         }
+        else
+        {
+            if (ProcessParams->has_headairflow == false)
+                ProcessParams->headairflow = headairflow;
+            if (ProcessParams->has_feedertension == false)
+                ProcessParams->feedertension = feedertension;
+            if (ProcessParams->has_windertension == false)
+                ProcessParams->windertension = windertension;
+            if (ProcessParams->has_pullertension == false)
+                ProcessParams->pullertension = pullertension;
+            ReportWithPackageFilter(InitFilter,"HandleProcessParameters temp off blower on",__FILE__,(int)__LINE__,(int)ProcessParams->headairflow,RpWarning,(int)ProcessParametersKeep.headairflow,0);
+        }
     }
     HeatersStopControlOnHeatersOff(ProcessParams);
     dyeingspeed = ProcessParams->dyeingspeed;
@@ -133,6 +150,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     dryerbufferCentimeters = dryerbufferlength*76+90;
 
 
+
     mininkuptake = ProcessParams->mininkuptake;
     feedertension = ProcessParams->feedertension;
     pullertension = ProcessParams->pullertension;
@@ -141,6 +159,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     dryerairflow = ProcessParams->dryerairflow;
     pressurebuildup = ProcessParams->pressurebuildup;
     dryerzone1temp = ProcessParams->dryerzone1temp;
+    ArcCleaningMotorSpeed = ProcessParams->archeadcleaningmotorspeed;
 
     if (MachineReadyForHeating == false)
     {
@@ -151,7 +170,9 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     }
 
     //Report("drier buffer length",__FILE__,(int)dryerbufferlength,(int)dryerbufferMeters*100,RpWarning,(int)dryerbufferCentimeters,0);
-    ReportWithPackageFilter(InitFilter,"HandleProcessParameters Head type",__FILE__,(int)__LINE__,(int)Head_Type,RpWarning,(int)dryerbufferCentimeters,0);
+    ReportWithPackageFilter(InitFilter,"HandleProcessParameters Head type",__FILE__,(int)headairflow,(int)Head_Type,RpWarning,(int)dryerbufferCentimeters,0);
+
+    WHS_Set_SetPoint_Q_value(headairflow);
 
     if (ProcessParams->mixertemp>1)
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__MixerHeater, true,ProcessParams->mixertemp);
@@ -181,8 +202,9 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, false,ProcessParams->headzone3temp);
     }
-    if(Head_Type != HEAD_TYPE_STAPLE_SPUN)
+    if(Head_Type != HEAD_TYPE_ARC)
     {
+        Trigger_HeaterWriting();
         if (ProcessParams->headzone4temp>1)
         {
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, true,ProcessParams->headzone4temp);
@@ -212,7 +234,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, true,ProcessParams->dryerzone1temp);
     else
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, false,ProcessParams->dryerzone1temp);
-    if(Head_Type == HEAD_TYPE_SYLKO)
+    if(Head_Type == HEAD_TYPE_FLAT)
     {
         if (ProcessParams->headzone7temp>1)
         {
@@ -222,6 +244,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
         {
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, false,ProcessParams->headzone7temp);
         }
+        Trigger_HeaterWriting();
         if (ProcessParams->headzone8temp>1)
         {
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, true,ProcessParams->headzone8temp);
@@ -246,6 +269,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
         {
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, false,ProcessParams->headzone10temp);
         }
+        Trigger_HeaterWriting();
         if (ProcessParams->headzone11temp>1)
         {
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, true,ProcessParams->headzone11temp);
@@ -263,8 +287,9 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, false,ProcessParams->headzone12temp);
         }
     }
-    if(Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    if(Head_Type == HEAD_TYPE_ARC)
     {
+        Trigger_HeaterWriting();
         if (ProcessParams->rblowertemp>1)
         {
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, true,ProcessParams->rblowertemp);
@@ -273,6 +298,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
         {
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, false,ProcessParams->rblowertemp);
         }
+        Trigger_HeaterWriting();
         if (ProcessParams->lblowertemp>1)
         {
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, true,ProcessParams->lblowertemp);
@@ -281,8 +307,10 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
         {
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, false,ProcessParams->lblowertemp);
         }
-        Trigger_Head_Fan_Control(HEAD_FAN_RIGHT,ProcessParams->rblowerflow);
-        Trigger_Head_Fan_Control(HEAD_FAN_LEFT,ProcessParams->lblowerflow);
+
+        status |= HeadBlowerCommandRequestMessage(HEAD_FAN_RIGHT, ProcessParams->rblowerflow);
+        status |= HeadBlowerCommandRequestMessage(HEAD_FAN_LEFT, ProcessParams->lblowerflow);
+        Trigger_HeaterWriting();
     }
 
     if (status)
@@ -320,22 +348,20 @@ void ProcessRequestFunc(MessageContainer* requestContainer)
 */
 /////////////////////////////////////////////////////////
     UploadProcessParametersResponse response = UPLOAD_PROCESS_PARAMETERS_RESPONSE__INIT;
-
     responseContainer = createContainer(MESSAGE_TYPE__UploadProcessParametersResponse, requestContainer->token, true, &response, &upload_process_parameters_response__pack, &upload_process_parameters_response__get_packed_size);
-    container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
-
 
     //REPORT_MSG (ProcessParams->dryerzone1temp,"Process Params Dryer");
     PowerIdleOutOfIdleState();
 
     if (status == 0)
         status = HandleProcessParameters(ProcessParams,true);
-    if (status)
+    if ((status)&&(status != ERROR_CODE__GENERAL_ERROR)) //ignore init not ready result
     {
         responseContainer.has_error = true;
         responseContainer.error = (ErrorCode)status;
         responseContainer.errormessage = ProcessErrorMsg;
     }
+    container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
     my_free(responseContainer.data.data);
     SendChars(container_buffer, container_size);
@@ -358,7 +384,7 @@ uint32_t LoadProcessParamsFromFile(void)
             if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
             {
                 Bytes = sizeof(ProcessParameters);
-                EraseFlashSection(EMBEDDED_PARAMETERS_SECTION_FLASH);
+                EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH);
                 ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
                 ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
                 REPORT_MSG(Bytes,"ProcessParameters Bytes write to flash");
@@ -376,7 +402,7 @@ uint32_t LoadProcessParamsFromFile(void)
 }
 uint32_t ProcessParamsInit(void)
 {
-    FRESULT Fresult = FR_OK;
+    FRESULT Fresult = FR_NOT_READY;
     uint32_t Bytes;
 
     memcpy(&Bytes,(void *)PROCESS_PARAMETERS_MAP_IN_FLASH,sizeof(Bytes));
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.h b/Software/Embedded_SW/Embedded/Modules/General/process.h
index 6318596f1..4a1583aa8 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.h
@@ -19,12 +19,16 @@ extern double headairflow;
 extern double dryerairflow;
 extern double pressurebuildup;
 extern double dryerzone1temp;
+extern double headBlowersFlow[2];
+extern double ArcCleaningMotorSpeed;
 
 extern int32_t tableindex;
 
 extern double dryerbufferMeters;
 extern double dryerbufferCentimeters;
 
+extern bool MachineReadyForHeating;
+
 extern ProcessParameters ProcessParametersKeep;
 
 extern void ProcessRequestFunc(MessageContainer* requestContainer);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
new file mode 100644
index 000000000..4a43485cd
--- /dev/null
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
@@ -0,0 +1,401 @@
+/************************************************************************************************************************
+ * Heaters_print.c
+ **************************************************************************************************************************/
+
+////////////////////////////////State machine operation////////////////////////////////////
+//the state machine operation is used to operate in runtime correct profile flow execution
+//by recieved esign flow of the user from the UI
+///////////////////////////////////////////////////////////////////////////////////////////
+#include "include.h"
+#include <DataDef.h>
+#include <math.h>
+#include "heaters.h"
+#include "Heaters_ex.h"
+
+#include "PMR/Hardware/HardwarePidControlType.pb-c.h"
+#include "PMR/Hardware/HardwarePidControl.pb-c.h"
+#include "PMR/Hardware/HardwareBlower.pb-c.h"
+/*#include "PMR/Diagnostics/SetHeaterStateRequest.pb-c.h"
+#include "PMR/Diagnostics/SetHeaterStateResponse.pb-c.h"
+#include "PMR/Diagnostics/HeaterType.pb-c.h"
+#include "PMR/Diagnostics/HeaterState.pb-c.h"*/
+#include "PMR/common/MessageContainer.pb-c.h"
+#include "PMR/Diagnostics/EventType.pb-c.h"
+
+#include "../AlarmHandling/AlarmHandling.h"
+#include "../control/control.h"
+#include "../control/pidalgo.h"
+#include "../control/MillisecTask.h"
+#include "../Ids/Ids_ex.h"
+#include "../General/process.h"
+
+#include <ti/sysbios/knl/Task.h>
+#include <driverlib/timer.h>
+#include <inc/hw_ints.h>
+#include <inc/hw_memmap.h>
+
+#include "Drivers/Heater/Heater.h"
+#include "Drivers/Heater/TemperatureSensor.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 "Drivers/I2C_Communication/I2C.h"
+#include <Drivers/I2C_Communication/I2C_Task.h>
+#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
+
+#include "StateMachines/Initialization/InitSequence.h"
+
+/******************** Data Structures  ********************************************/
+#define MIN_ALLOWED_PWM 0
+#define MAX_ALLOWED_PWM 255
+#define ARC_ALARM_LIMIT 3
+
+#define PRESSURE_SENSOR_CP  0.269
+extern uint16_t Head_Fan_Tach[2];
+extern uint8_t Head_Fan_PWM_Command[2];
+
+double      PressureSensorV0[2] = {0.0, 0.0};
+uint8_t     HeadBlowersCloseLoopTime[2] = {2, 2};
+uint8_t     HeadBlowersEnable = 1;
+uint8_t     BlowerIdToSensorId[2] = {HEAD_PT100_ZONE_5_0X84_0, HEAD_PT100_ZONE_7_0X86_0}; //HEAD_FAN_RIGHT, HEAD_FAN_LEFT
+
+typedef struct
+{
+    bool                m_isEnabled;
+    float               m_SetParam;
+    float               m_mesuredParam;
+    float               m_preError;
+    float               m_integral;
+    float               m_calculatedError;
+    bool                m_isReady;
+    int                 SamplesFilterSize;
+    PID_Config_Params   m_params;
+}HeadBlowerConfig;
+HeadBlowerConfig HeadBlowerControl[2] = {0,0};
+
+/******************** FUNCTIONS  ********************************************/
+int HeadBlowersGetPWM(uint8_t blowerId);
+
+/********************************************************************************
+ * Arc Head Pressure sensors
+ *******************************************************************************/
+
+void HeadBlowersInit()
+{
+    Trigger_Head_Fan_Control(HEAD_FAN_RIGHT, 0);
+    Trigger_Head_Fan_Control(HEAD_FAN_LEFT, 0);
+
+    //PID parameters init
+    HeadBlowerControl[0].m_params.MAX = 200;
+    HeadBlowerControl[0].m_params.MIN = -200;
+    HeadBlowerControl[0].m_params.Kd = 0;
+    HeadBlowerControl[0].m_params.Kp = 350;
+    HeadBlowerControl[0].m_params.Ki = 25;
+    HeadBlowerControl[0].m_params.IntegralErrorMultiplier = 10;
+    HeadBlowerControl[0].m_params.ProportionalErrorMultiplier = 10;
+    HeadBlowerControl[0].m_params.epsilon = 0;
+    HeadBlowerControl[0].m_params.dt = 2;
+    //HeadBlowerControl[0].m_ingnoreValue =  PID_Request->sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
+    HeadBlowerControl[0].m_calculatedError = 0;
+    HeadBlowerControl[0].m_integral = 0;
+    HeadBlowerControl[0].m_isEnabled = true;
+    HeadBlowerControl[0].m_isReady = true;
+    HeadBlowerControl[0].m_mesuredParam = 0;
+    HeadBlowerControl[0].m_preError = 0;
+    HeadBlowerControl[0].m_SetParam = 5.0;//need to update SetParams on presegment stage
+
+    HeadBlowerControl[1].m_params.MAX = 200;
+    HeadBlowerControl[1].m_params.MIN = -200;
+    HeadBlowerControl[1].m_params.Kd = 0;
+    HeadBlowerControl[1].m_params.Kp = 350;
+    HeadBlowerControl[1].m_params.Ki = 25;
+    HeadBlowerControl[1].m_params.IntegralErrorMultiplier = 10;
+    HeadBlowerControl[1].m_params.ProportionalErrorMultiplier = 10;
+    HeadBlowerControl[1].m_params.epsilon = 0;
+    HeadBlowerControl[1].m_params.dt = 2;
+    //HeadBlowerControl[0].m_ingnoreValue =  PID_Request->sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
+    HeadBlowerControl[1].m_calculatedError = 0;
+    HeadBlowerControl[1].m_integral = 0;
+    HeadBlowerControl[1].m_isEnabled = true;
+    HeadBlowerControl[1].m_isReady = true;
+    HeadBlowerControl[1].m_mesuredParam = 0;
+    HeadBlowerControl[1].m_preError = 0;
+    HeadBlowerControl[1].m_SetParam = 5.0;//need to update SetParams on presegment stage
+}
+
+uint32_t HeadBlowerPidRequestMessage(void* request, int BlowerId)
+{
+    HardwarePidControl * PID_Request = request;
+
+    HeadBlowerControl[BlowerId].m_params.MAX = 200;
+    HeadBlowerControl[BlowerId].m_params.MIN = -200;
+    HeadBlowerControl[BlowerId].m_params.Kd = PID_Request->derivativetime;
+    HeadBlowerControl[BlowerId].m_params.Kp = PID_Request->proportionalgain;
+    HeadBlowerControl[BlowerId].m_params.Ki = PID_Request->integraltime;
+    HeadBlowerControl[BlowerId].m_params.IntegralErrorMultiplier = PID_Request->setpointramprateorsoftstartramp;
+    HeadBlowerControl[BlowerId].m_params.ProportionalErrorMultiplier = PID_Request->outputonoffhysteresisvalue;
+    HeadBlowerControl[BlowerId].m_params.epsilon = PID_Request->epsilon;
+    HeadBlowerControl[BlowerId].m_params.dt = PID_Request->controloutputtype;
+    //HeadBlowerControl.m_ingnoreValue =  PID_Request->sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
+    HeadBlowerControl[BlowerId].m_calculatedError = 0;
+    HeadBlowerControl[BlowerId].m_integral = 0;
+    HeadBlowerControl[BlowerId].m_isEnabled = true;
+    HeadBlowerControl[BlowerId].m_isReady = true;
+    HeadBlowerControl[BlowerId].m_mesuredParam = 0;
+    HeadBlowerControl[BlowerId].m_preError = 0;
+    HeadBlowerControl[BlowerId].m_SetParam = PID_Request->outputproportionalcycletime;//need to update SetParams on presegment stage
+    return OK;
+}
+
+uint32_t HeadBlowerPidFunc(double setParam,double measuredParam, int blowerId)
+{
+    int calculatedPwm;
+
+    HeadBlowerControl[blowerId].m_mesuredParam = measuredParam;
+    HeadBlowerControl[blowerId].m_SetParam = setParam;
+    HeadBlowerControl[blowerId].m_calculatedError = PIDAlgorithmCalculation((float)HeadBlowerControl[blowerId].m_SetParam , (float)HeadBlowerControl[blowerId].m_mesuredParam,
+                                                      &HeadBlowerControl[blowerId].m_params,   &HeadBlowerControl[blowerId].m_preError, &HeadBlowerControl[blowerId].m_integral);
+    calculatedPwm = HeadBlowersGetPWM(blowerId) + HeadBlowerControl[blowerId].m_calculatedError;
+    HeadBlowersCloseLoopTime[blowerId] = HeadBlowerControl[blowerId].m_params.dt;
+
+    if (calculatedPwm < MIN_ALLOWED_PWM) {
+        //ReportWithPackageFilter(HeatersFilter,"calculatedPwm < MIN_ALLOWED_PWM",__FILE__,__LINE__,calculatedPwm,RpError, MIN_ALLOWED_PWM,0);
+        HeadBlowerControl[blowerId].m_integral = 0;
+        calculatedPwm = MIN_ALLOWED_PWM;
+    }
+    if (calculatedPwm > MAX_ALLOWED_PWM) {
+        //ReportWithPackageFilter(HeatersFilter,"calculatedPwm > MAX_ALLOWED_PWM",__FILE__,__LINE__,calculatedPwm,RpError, MAX_ALLOWED_PWM,0);
+        HeadBlowerControl[blowerId].m_integral = 0;
+        calculatedPwm = MAX_ALLOWED_PWM;
+    }
+    Trigger_Head_Fan_Control(blowerId, calculatedPwm);
+    return OK;
+}
+
+int HeadBlowerSensorIdToFanId(uint8_t sensorId)
+{
+    if (sensorId == HEAD_PT100_ZONE_5_0X84_0)
+        return HEAD_FAN_RIGHT;
+    else
+        return HEAD_FAN_LEFT;
+}
+
+bool HeadBlowerFlowControl(double Q_value, uint8_t blowerId)
+{
+    double currentFlow = 0.0;
+
+    currentFlow = PressureSensorGetPressure(BlowerIdToSensorId[blowerId]);
+    HeadBlowerPidFunc(Q_value,currentFlow, blowerId);
+    return OK;
+}
+
+void HeadBlowersOff(int off)
+{
+    if (off == 1)
+        HeadBlowersEnable = 0;
+    else
+        HeadBlowersEnable = 1;
+    ReportWithPackageFilter(HeatersFilter,"HeadBlowersOff",__FILE__,__LINE__,off,RpError, 0,0);
+    return;
+}
+
+uint32_t HeadBlowersOffGet()
+{
+    ReportWithPackageFilter(HeatersFilter,"HeadBlowersOffGet",__FILE__,__LINE__,HeadBlowersEnable,RpError, 0,0);
+    return HeadBlowersEnable;
+}
+
+void ArcHeadAlarms(void)
+{
+    double currentFlow = 0.0;
+    static int8_t count1 = 0, count2 = 0, count3 = 0, count4 = 0, count5 = 0;
+    static int8_t count6 = 0, count7 = 0, count8 = 0, count9 = 0, count10 = 0;
+
+    if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_ARC) != LIMIT) {
+        if (++count9 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, true);
+        count9 = (count9 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count9);
+    } else {
+        if (--count9 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, false);
+        count9 = (count9 < 0)?(0):(count9);
+    }
+
+    if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_TUNNEL_ARC) != LIMIT) {
+        if (++count10 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, true);
+        count10 = (count10 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count10);
+    } else {
+        if (--count10 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, false);
+        count10 = (count10 < 0)?(0):(count10);
+    }
+
+    if (Head_Fan_Tach[0] == 0x1FFE) {
+        if (++count1 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, true);
+        count1 = (count1 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count1);
+    } else {
+        if (--count1 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, false);
+        count1 = (count1 < 0)?(0):(count1);
+    }
+    if (Head_Fan_Tach[1] == 0x1FFE) {
+        if (++count2 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, true);
+        count2 = (count2 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count2);
+    } else {
+        if (--count2 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, false);
+        count2 = (count2 < 0)?(0):(count2);
+    }
+
+    if (HeadBlowersGetRPM(HEAD_FAN_RIGHT) < 2000) {
+        if (++count3 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, true);
+        count3 = (count3 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count3);
+    } else {
+        if (--count3 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, false);
+        count3 = (count3 < 0)?(0):(count3);
+    }
+    if (HeadBlowersGetRPM(HEAD_FAN_LEFT) < 2000) {
+        if (++count4 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, true);
+        count4 = (count4 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count4);
+    } else {
+        if (--count4 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, false);
+        count4 = (count4 < 0)?(0):(count4);
+    }
+
+    currentFlow = PressureSensorGetPressure(HEAD_PT100_ZONE_5_0X84_0);
+    if (currentFlow > 5.0) {
+        if (++count5 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, true);
+        count5 = (count5 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count5);
+    } else {
+        if (--count5 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, false);
+        count5 = (count5 < 0)?(0):(count5);
+    }
+    if (currentFlow < 1.0) {
+        if (++count6 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, true);
+        count6 = (count6 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count6);
+    } else {
+        if (--count6 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, false);
+        count6 = (count6 < 0)?(0):(count6);
+    }
+
+    currentFlow = PressureSensorGetPressure(HEAD_PT100_ZONE_7_0X86_0);
+    if (currentFlow > 5.0) {
+        if (++count7 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, true);
+        count7 = (count7 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count7);
+    } else {
+        if (--count7 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, false);
+        count7 = (count7 < 0)?(0):(count7);
+    }
+    if (currentFlow < 1.0) {
+        if (++count8 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, true);
+        count8 = (count8 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count8);
+    } else {
+        if (--count8 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, false);
+        count8 = (count8 < 0)?(0):(count8);
+    }
+}
+
+void HeadBlowersControlLoop ()
+{
+    int blowerId;
+    static int count[2] = {0, 0};
+
+    ArcHeadAlarms();
+
+    if (GetMachineState() < MACHINE_STATE_WAIT_FOR_COOLER)
+        return; //do not start before controller is initialized and running
+
+    if (!HeadBlowersEnable) {
+        return;
+    }
+    for (blowerId = 0; blowerId <= 1; blowerId++) {
+        if (count[blowerId] == HeadBlowersCloseLoopTime[blowerId]) {
+            count[blowerId] = 0;
+            HeadBlowerFlowControl(headBlowersFlow[blowerId], blowerId);
+        } else {
+            count[blowerId] += 1;
+        }
+    }
+}
+
+void HeadBlowersCfg()
+{
+    if (HeadBlowerCfg[0].enabled) {
+        Trigger_Head_Fan_Control(HEAD_FAN_RIGHT, HeadBlowerCfg[0].voltage);
+    }
+    if (HeadBlowerCfg[1].enabled) {
+        Trigger_Head_Fan_Control(HEAD_FAN_LEFT, HeadBlowerCfg[1].voltage);
+    }
+}
+
+double PressureSensorInit(int blowerId)
+{
+    PressureSensorV0[blowerId] = MillisecGetTemperatures(BlowerIdToSensorId[blowerId]);
+    PressureSensorV0[blowerId] /= 10;
+    return PressureSensorV0[blowerId];
+}
+
+int HeadBlowersGetRPM(uint8_t blowerId)
+{
+    Trigger_Head_Read_Tacho(blowerId);
+
+    if (Head_Fan_Tach[blowerId] == 0x1FFE) {
+        return 0;
+    } else {
+        return 7864320/Head_Fan_Tach[blowerId];
+    }
+}
+
+int HeadBlowersGetPWM(uint8_t blowerId)
+{
+    return Head_Fan_PWM_Command[blowerId];
+}
+
+double PressureSensorGetPressure(uint8_t SensorId)
+{
+    double V0, Vm, Q, Cp;
+    int FanId;
+
+    Cp = PRESSURE_SENSOR_CP;
+    FanId = HeadBlowerSensorIdToFanId(SensorId);
+    V0 = PressureSensorV0[FanId];
+    Vm = (double)(MillisecGetTemperatures(SensorId));
+    Vm /= 10.0;
+    Q = sqrt(Vm - V0 + 22) * Cp;
+    return Q;
+}
+
+uint32_t  HeadBlowerCommandRequestMessage(int blowerId, float flow)
+{
+    if ((blowerId != HEAD_FAN_RIGHT) && (blowerId != HEAD_FAN_LEFT)) {
+        ReportWithPackageFilter(HeatersFilter,"blowerId not in range",__FILE__,__LINE__,blowerId,RpError, 0,0);
+        return ERROR;
+    }
+/*
+    if (HeadBlowerCfg[blowerId].enabled == false) {
+        ReportWithPackageFilter(HeatersFilter,"HeadBlower not configured",__FILE__,__LINE__,blowerId,RpError, 0,0);
+        return ERROR;
+    }
+*/
+    if ((flow < 0.0) || (flow > 5.0)) {
+        ReportWithPackageFilter(HeatersFilter,"flow not in range",__FILE__, flow, blowerId,RpError, 0,0);
+        return ERROR;
+    }
+    headBlowersFlow[blowerId] = flow;
+    return OK;
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index aeec7d696..e85694c48 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -11,6 +11,7 @@
 extern EventType HeaterEventType[HEATER_TYPE_MAX_HEATERS];
 extern EventType HeaterUnderEventType[HEATER_TYPE_MAX_HEATERS];
 extern EventType HeaterUnderEventType_B[HEATER_TYPE_MAX_HEATERS];
+extern bool specialHeaterState;
 
 extern uint32_t stub_heating_limit;
 //uint32_t HeaterCommandRequestMessage(MessageContainer* requestContainer);
@@ -21,6 +22,8 @@ void HeatingTestSendResonse(uint32_t status, bool last,bool heater1Active,bool h
 uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature);
 void HeatingTestRequest(MessageContainer* requestContainer);
 void HeatingTestPollRequest(MessageContainer* requestContainer);
+void SetHeaterStateRequestFunc(MessageContainer* requestContainer);
+
 
 bool HeaterCheckReady(void);
 bool isHeaterReady(uint8_t HeaterId);
@@ -40,3 +43,14 @@ uint32_t HeatersEnd(void);
 void HeatersControlStart(void);
 void HeatersControlStop(void);
 uint32_t Heaters_Init(void);
+double PressureSensorGetPressure(uint8_t SensorId);
+int HeadBlowersGetRPM(uint8_t fanId);
+double PressureSensorInit();
+void HeadBlowersInit();
+uint32_t HeadBlowerPidRequestMessage(void* request, int BlowerId);
+void HeadBlowersCfg();
+void HeadBlowersControlLoop ();
+uint32_t  HeadBlowerCommandRequestMessage(int blowerId, float flow);
+void HeadBlowersOff(int off);
+uint32_t HeadBlowersOffGet();
+
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 89bdcc66b..56b46c98c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -8,12 +8,15 @@
 ///////////////////////////////////////////////////////////////////////////////////////////
 #include "include.h"
 #include <DataDef.h>
+#include <math.h>
 #include "heaters.h"
 #include "Heaters_ex.h"
 
 #include "PMR/Hardware/HardwarePidControlType.pb-c.h"
 #include "PMR/Hardware/HardwarePidControl.pb-c.h"
 #include "PMR/Hardware/HardwareBlower.pb-c.h"
+#include "PMR/Diagnostics/SetHeaterStateRequest.pb-c.h"
+#include "PMR/Diagnostics/SetHeaterStateResponse.pb-c.h"
 #include "PMR/Diagnostics/HeaterType.pb-c.h"
 #include "PMR/Diagnostics/HeaterState.pb-c.h"
 #include "PMR/common/MessageContainer.pb-c.h"
@@ -38,6 +41,7 @@
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
 #include "Drivers/I2C_Communication/I2C.h"
+#include <Drivers/I2C_Communication/I2C_Task.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
 
 #include "StateMachines/Printing/PrintingSTM.h"
@@ -49,6 +53,9 @@
 /******************** Data Structures  ********************************************/
 #define OVERHEAT_COUNT_LIMIT 3
 #define UNDERHEAT_COUNT_LIMIT 3
+#define MIN_ALLOWED_PWM 0
+#define MAX_ALLOWED_PWM 255
+#define ARC_ALARM_LIMIT 3
 
  int Overheat_Count_Limit = OVERHEAT_COUNT_LIMIT;
  int Underheat_Count_Limit = UNDERHEAT_COUNT_LIMIT;
@@ -87,15 +94,16 @@ 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,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,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,0,0};
+uint32_t    BlowerOverHeatCounter[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+uint32_t    BlowersControlIdtoMaxHeaterId [HEATER_TYPE_MAX_HEATERS] =  {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
 uint32_t    UnderHeatCounter [HEATER_TYPE_MAX_HEATERS] = {0,0,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;
+
 #define DRYER_AIR_PT100  TEMP_SENSE_ANALOG_DRYER_TEMP1
 #define DRYER_MAIN_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP2
 #define DRYER_SECONDARY_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP3
-#define MINIMUM_HEATER_READ 9.0
-#define MAXIMUM_HEATER_READ 283
 
 bool UseSecondaryDrierHeater = true;
 
@@ -113,7 +121,7 @@ void initializeArrays(void)
         HeaterId2PT100Id[i] = 0xFF;
         HeaterId2CurrentId[i] = NUM_OF_CURRENT_HEATERS;
     }
-    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    if (Head_Type == HEAD_TYPE_FLAT)
     {
         HeaterId2PT100Id[HEATER_TYPE__DryerAirHeater] =       DRYER_AIR_PT100;
         HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater] =      DRYER_MAIN_PT100;
@@ -154,7 +162,7 @@ void initializeArrays(void)
         HeaterId2CurrentId[HEATER_TYPE__HeadCoverHeater2] =     HEAD_CURRENT_HTOT_1;
 
     }
-    else
+    else if (Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD)
     {
         HeaterId2PT100Id[HEATER_TYPE__DryerAirHeater] =       DRYER_AIR_PT100;
         HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater] =      DRYER_MAIN_PT100;
@@ -185,13 +193,59 @@ void initializeArrays(void)
         HeaterId2CurrentId[HEATER_TYPE__HeaterZone5] =          HEATER_HEAD_CURRENT_ZONE_5_6;
         HeaterId2CurrentId[HEATER_TYPE__HeaterZone6] =          HEATER_HEAD_CURRENT_ZONE_5_6;
         HeaterId2CurrentId[HEATER_TYPE__MixerHeater] =          HEATER_MIXCHIP_CURRENT;
-
+    }
+    else if (Head_Type == HEAD_TYPE_ARC)
+    {
+        HeaterId2PT100Id[HEATER_TYPE__DryerAirHeater] =       DRYER_AIR_PT100;
+        HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater] =      DRYER_MAIN_PT100;
+        HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater] = DRYER_SECONDARY_PT100;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone1] =          HEAD_PT100_ZONE_1_0X80_0;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone2] =          HEAD_PT100_ZONE_2_0X80_1;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone3] =          HEAD_PT100_ZONE_3_0X82_0;
+        //HeaterId2PT100Id[HEATER_TYPE__HeaterZone4] =          HEAD_PT100_ZONE_4_0X82_1;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone5] =          HEAD_PT100_ZONE_5_0X84_0;
+        //HeaterId2PT100Id[HEATER_TYPE__HeaterZone6] =          HEAD_PT100_ZONE_6_0X84_1;*/
+        HeaterId2PT100Id[HEATER_TYPE__MixerHeater] =          HEAD_PT100_MIXER_0X8E_0;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone7] =          HEAD_PT100_ZONE_7_0X86_0;
+        /*HeaterId2PT100Id[HEATER_TYPE__HeaterZone8] =          HEAD_PT100_ZONE_8_0X86_1;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone9] =          HEAD_PT100_ZONE_9_0X88_0;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone10] =         HEAD_PT100_ZONE_10_0X88_1;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone11] =         HEAD_PT100_ZONE_11_0X8A_0;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone12] =         HEAD_PT100_ZONE_12_0X8A_1;
+        */
+#ifdef USE_TUNNEL_PT100
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater1] =     HEAD_PT100_ZONE_11_0X8A_0; //HEAD_PT100_AIR_HEATER_2_0X8C_1;
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     HEAD_PT100_ZONE_12_0X8A_1; //HEAD_PT100_AIR_HEATER_1_0X8C_0;
+#else
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater1] =     HEAD_PT100_AIR_HEATER_2_0X8C_1;  //notice HEAD_PT100_AIR_HEATER_2_0X8C_1 refer to HeadCoverHeater1
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     HEAD_PT100_AIR_HEATER_1_0X8C_0;  //notice HEAD_PT100_AIR_HEATER_1_0X8C_0 refer to HeadCoverHeater2
+#endif
+        HeaterId2CurrentId[HEATER_TYPE__DryerAirHeater] =       NUM_OF_CURRENT_HEATERS;
+        HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater] =      HEATER_DRYER_CURRENT_1;
+        HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater] = HEATER_DRYER_CURRENT_2;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone1] =          HEAD_CURRENT_ZONE_1;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone2] =          HEAD_CURRENT_ZONE_2;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone3] =          HEAD_CURRENT_ZONE_3;
+        //HeaterId2CurrentId[HEATER_TYPE__HeaterZone4] =          HEAD_CURRENT_ZONE_4;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone5] =          HEAD_CURRENT_ZONE_5;
+        //HeaterId2CurrentId[HEATER_TYPE__HeaterZone6] =          HEAD_CURRENT_ZONE_6;
+        HeaterId2CurrentId[HEATER_TYPE__MixerHeater] =          HEAD_CURRENT_MIXER;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone7] =          HEAD_CURRENT_ZONE_7;
+        /*HeaterId2CurrentId[HEATER_TYPE__HeaterZone8] =          HEAD_CURRENT_ZONE_8;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone9] =          HEAD_CURRENT_ZONE_9;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone10] =         HEAD_CURRENT_ZONE_10;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone11] =         HEAD_CURRENT_ZONE_11;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone12] =         HEAD_CURRENT_ZONE_12;
+        */
+        HeaterId2CurrentId[HEATER_TYPE__HeadCoverHeater1] =     HEAD_CURRENT_HTIN_1;
+        HeaterId2CurrentId[HEATER_TYPE__HeadCoverHeater2] =     HEAD_CURRENT_HTOT_1;
     }
 }
 uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
 bool HeatersRestart = false;
 
 bool HeaterMaxTempFlag[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false};
+bool BlowerHeaterMaxTempFlag[HEATER_TYPE_MAX_HEATERS] = {false,false,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,true,true};
 
 uint32_t OutputProportionalSingleStep = 0;  //A/C Heaters step size from one decision point to another - in cpu clocks. 120000 = 1 millisecod
@@ -229,6 +283,7 @@ int HeaterDisasterCounter[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,
 
 /******************** FUNCTIONS  ********************************************/
 uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue);
+uint32_t HeaterBlowerMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue);
 uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue);
 uint32_t HeaterControlCBFunction(uint32_t deviceID, uint32_t readValue);
 uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue);
@@ -237,7 +292,6 @@ uint32_t HeatersDisasterControl(uint32_t x,uint32_t y);
 uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue);
 void HeatersStartControlTimer (void);
 
-
 //**********************************************************************
 //******************** CODE  *******************************************/
 //**********************************************************************
@@ -305,7 +359,7 @@ 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};
+EventType InternalTempEventType[MAX_INTERNAL_ALARMS] = {EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2};
 
 uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
@@ -335,13 +389,24 @@ uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValu
     {
         if (InternalAlarmActive[index] == false)
         {
-            if(InternalOverHeatCounter[index]++ >=Overheat_Count_Limit)
+            ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature",__FILE__,index,readValue,RpWarning,  InternalOverHeatCounter[index],0);
+            if(InternalOverHeatCounter[index]++ >=Overheat_Count_Limit*10)
             {
                 InternalOverHeatCounter[index] = Overheat_Count_Limit;
 
                     InternalAlarmActive[index] = true;
-                    ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature, turned off",__FILE__,index,readValue,RpWarning,  0,0);
                     AlarmHandlingSetAlarm(InternalTempEventType[index], true);
+                    if (JobIsActive())
+                    {
+                        JobEndReason = JOB_TEMPERATURE_ALARM;
+                        usnprintf(AlarmReasonStr, 100, "Internal Temperature %d Error %d",index,readValue);
+                        SendJobProgress(0.0,0,false, "Internal Temperature Error");
+                        AbortJob("Internal Over Temperature Error");
+                        //SegmentReady(Module_Heaters,ModuleFail);
+                        ReportWithPackageFilter(HeatersFilter, "Internal Temperature Error",__FILE__,__LINE__,index,RpError, 0,0);
+                        HeatersEnd();
+                        return OK;
+                    }
             }
         }
     }
@@ -349,12 +414,13 @@ uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValu
     {
         if (InternalAlarmActive[index] == true)
         {
+            ReportWithPackageFilter(HeatersFilter,"Internal Under the max temperature",__FILE__,index,readValue,RpWarning,  InternalOverHeatCounter[index],0);
             if(InternalOverHeatCounter[index]-- <= 0)
             {
                 InternalOverHeatCounter[index] = 0;
 
-                InternalAlarmActive[index] = true;
-                ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature, turned off",__FILE__,index,readValue,RpWarning,  0,0);
+                InternalAlarmActive[index] = false;
+                ReportWithPackageFilter(HeatersFilter,"Internal Under the max temperature, alarm turned off",__FILE__,index,readValue,RpWarning,  0,0);
                 AlarmHandlingSetAlarm(InternalTempEventType[index], false);
             }
 
@@ -392,6 +458,7 @@ uint32_t LoadHeaterSetPoint(HeaterType HeaterType)
     }
     return HeaterCmd[HeaterType].targettemperatue;
 }
+bool specialHeaterState = false;
 void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
 {
     int HeaterId = HeaterType;
@@ -415,11 +482,19 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
     {
         HeaterState->setpoint = HeaterControl[HEATER_TYPE__DryerMainHeater].outputproportionalpowerlimit;
         //HeaterState->isrampingup = InitialHeating;
+        if (specialHeaterState == true)
+        {
+            HeaterState->setpoint = HeaterPIDConfig[HEATER_TYPE__DryerAirHeater].m_integral/10000;
+        }
     }
     if (HeaterId == HEATER_TYPE__DryerSecondaryHeater)
     {
         HeaterState->setpoint = HeaterControl[HEATER_TYPE__DryerSecondaryHeater].outputproportionalpowerlimit;
         //HeaterState->isrampingup = InitialHeating;
+        if (specialHeaterState == true)
+        {
+            HeaterState->setpoint = HeaterPIDConfig[HEATER_TYPE__DryerAirHeater].m_calculatedError/100;
+        }
     }
     return;
 }
@@ -441,13 +516,20 @@ uint32_t HeatersSingleHeaterEnd(int HeaterId)
                 status |= RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
                 ControlIdtoMaxHeaterId [HeaterId]=0xFF;
             }
+#ifdef USE_TUNNEL_PT100
+            if (BlowersControlIdtoMaxHeaterId [HeaterId]!=0xFF)
+            {
+                status |= RemoveControlCallback(BlowersControlIdtoMaxHeaterId [HeaterId], HeaterBlowerMaxTempCBFunction);
+                BlowersControlIdtoMaxHeaterId [HeaterId]=0xFF;
+            }
+#endif
             HeaterRecalculateHeaterParams(HeaterId, 0);
             DeActivateHeater(HeaterId);
             HeaterPIDConfig[HeaterId].m_SetParam = 0;
             HeaterCmd[HeaterId].targettemperatue = 0;
             HeaterReady[HeaterId] = true;
             HeaterAtTemp[HeaterId] = true;
-            if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+            if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
                 Disable_Reading_Heaters_ADC(HeaterId2CurrentId[HeaterId]);
             else
                 Disable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
@@ -552,6 +634,40 @@ int GetFilteredHeaterRead(int HeaterId)
  * initialized all global data
  *************************************************************************************/
 bool HeaterRestarted[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false};
+
+void SetHeaterStateRequestFunc(MessageContainer* requestContainer)
+{
+
+    uint32_t status = PASSED;
+    MessageContainer responseContainer;
+
+    SetHeaterStateRequest* request = set_heater_state_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    SetHeaterStateResponse response = SET_HEATER_STATE_RESPONSE__INIT;
+
+    if (request->has_heatertype)
+    {
+        if ((request->has_isactive)&&(request->has_setpoint))
+            status = HeaterCommandRequestMessage(request->heatertype,true,request->setpoint);
+        else
+            status = HeaterCommandRequestMessage(request->heatertype,false,request->setpoint);
+    }
+
+    responseContainer = createContainer(MESSAGE_TYPE__SetHeaterStateResponse, requestContainer->token, true, &response, &set_heater_state_response__pack, &set_heater_state_response__get_packed_size);
+    if (status)
+    {
+        responseContainer.has_error = true;
+        responseContainer.error = (ErrorCode)status;
+    }
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    free(responseContainer.data.data);
+    SendChars((char*)container_buffer, container_size);
+
+    set_heater_state_request__free_unpacked(request,NULL);
+
+}
 uint32_t  HeaterCommandRequestMessage(int HeaterNum, bool OnOff, int Temperature)
 {
     //uint32_t status = NOT_SUPPORTED;
@@ -658,6 +774,13 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
                 RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
                 ControlIdtoMaxHeaterId [HeaterId] = 0xFF;
             }
+#ifdef USE_TUNNEL_PT100
+            if (BlowersControlIdtoMaxHeaterId [HeaterId]!=0xFF)
+            {
+                RemoveControlCallback(BlowersControlIdtoMaxHeaterId [HeaterId], HeaterBlowerMaxTempCBFunction);
+                BlowersControlIdtoMaxHeaterId [HeaterId] = 0xFF;
+            }
+#endif
             if (ControlIdtoHeaterId [HeaterId] != 0xFF)
             {
                 RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
@@ -665,8 +788,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
             }
             DeActivateHeater(HeaterId);
             HeaterCmd[HeaterId].targettemperatue = 0;
-#warning PT100 error is misidentified as overheat in alarms
-            AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
+            AlarmHandlingSetAlarm(EVENT_TYPE__TEMPERATURE_MEASUREMENT_ERROR, true);
 
             return;
         }
@@ -704,9 +826,9 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     HeaterAtTemp[HeaterId] = false;
     if (BlowerCfg.enabled == true)
     {
-        if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+        if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
         {
-            WHS_Set_SetPoint_Q_value(headairflow/2);
+            WHS_Set_SetPoint_Q_value(headairflow);
         }
         else
         {
@@ -742,13 +864,20 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
             RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
             ControlIdtoMaxHeaterId [HeaterId] = 0xFF;
         }
+#ifdef USE_TUNNEL_PT100
+        if (BlowersControlIdtoMaxHeaterId [HeaterId]!=0xFF)
+        {
+            RemoveControlCallback(BlowersControlIdtoMaxHeaterId [HeaterId], HeaterBlowerMaxTempCBFunction);
+            BlowersControlIdtoMaxHeaterId [HeaterId]=0xFF;
+        }
+#endif
         if (ControlIdtoHeaterId [HeaterId] != 0xFF)
         {
             RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
             ControlIdtoHeaterId [HeaterId] = 0xFF;
         }
         DeActivateHeater(HeaterId);
-        AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
+        AlarmHandlingSetAlarm(EVENT_TYPE__TEMPERATURE_MEASUREMENT_ERROR, true);
         HeaterCmd[HeaterId].targettemperatue = 0;
 
         return ERROR;
@@ -766,15 +895,24 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
     AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false);
     AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);
 
-    if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
-        Enable_Reading_Heaters_ADC(HeaterId2CurrentId[HeaterId]);
-    else
-        Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
+    if (HeaterPreviousRead[HeaterId] < HeaterCmd[HeaterId].targettemperatue )
+    {
+        if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
+            Enable_Reading_Heaters_ADC(HeaterId2CurrentId[HeaterId]);
+        else
+            Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
+    }
 
     //ReportWithPackageFilter(HeatersFilter,"PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
         ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback("DcHeatersMax", DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
-
+#ifdef USE_TUNNEL_PT100
+    if ((HeaterId == HEATER_TYPE__HeadCoverHeater1)||(HeaterId == HEATER_TYPE__HeadCoverHeater2)) //tunnel Heaters
+    {
+        if (BlowersControlIdtoMaxHeaterId [HeaterId] == 0xFF)
+            BlowersControlIdtoMaxHeaterId [HeaterId] = AddControlCallback("DcHeatersMax", HeaterBlowerMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+    }
+#endif
     return OK;
 }
 /*
@@ -975,6 +1113,61 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     return ERROR;
 }
+
+uint32_t HeaterBlowerMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
+{
+    uint32_t BlowerPt100Read = 0;
+
+    int index=HEATER_TYPE_MAX_HEATERS;
+
+    if (IfIndex>>8 != IfTypeHeaters)
+    {
+        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
+        return 0xFFFFFFFF;
+    }
+    if (Head_Type != HEAD_TYPE_ARC)
+    {
+        ReportWithPackageFilter(HeatersFilter, "Wrong  head type",__FILE__,__LINE__,Head_Type,RpError, 0,0);
+        return 0xFFFFFFFF;
+    }
+    index = IfIndex&0xFF;
+    if ((index != HEATER_TYPE__HeadCoverHeater1)&&(index != HEATER_TYPE__HeadCoverHeater2)) //AC Heaters
+    {
+        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, index,0);
+        return 0xFFFFFFFF;
+    }
+    //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]);
+    if (Head_Type == HEAD_TYPE_ARC) {
+        if (index == HEATER_TYPE__HeadCoverHeater1) {
+            BlowerPt100Read = MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1);
+        }
+        if (index == HEATER_TYPE__HeadCoverHeater2) {
+            BlowerPt100Read = MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0);
+        }
+    }
+
+    if (BlowerPt100Read > 26000)
+    {
+        if (index == HEATER_TYPE__HeadCoverHeater1)
+        {
+            DeActivateHeater(HEATER_TYPE__HeadCoverHeater1);
+            HeaterRecalculateHeaterParams(HEATER_TYPE__HeadCoverHeater1,0);
+        }
+        else
+        {
+            DeActivateHeater(HEATER_TYPE__HeadCoverHeater2);
+            HeaterRecalculateHeaterParams(HEATER_TYPE__HeadCoverHeater2,0);
+        }
+        BlowerHeaterMaxTempFlag[index] = true;
+    } else {
+        if (BlowerPt100Read <= 25800)
+        {
+           BlowerHeaterMaxTempFlag[index] = false;
+        }
+    }
+    return OK;
+}
+
 uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=HEATER_TYPE_MAX_HEATERS;
@@ -996,23 +1189,42 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
             if (JobIsActive()&&(HeaterReady[index]==true))
             {
                 JobEndReason = JOB_TEMPERATURE_ALARM;
+                usnprintf(AlarmReasonStr, 100, "Temperature %d Error %d",index,readValue);
                 SendJobProgress(0.0,0,false, "Temperature Error");
                 AbortJob("Over Temperature Error");
                 //SegmentReady(Module_Heaters,ModuleFail);
                 ReportWithPackageFilter(HeatersFilter, "Temperature Error",__FILE__,__LINE__,index,RpError, 0,0);
                 return OK;
             }
+            //if (getIdleState() == false)
+                //not idle, not cooling to temp
+            {
+                if ((HeaterReady[index]==false)&&(HeaterPreviousRead[index]>HeaterCmd[index].targettemperatue))
+                {
+                    ReportWithPackageFilter(HeatersFilter,"DC Heater Over the max temperature, cooling off",__FILE__,index,HeaterPreviousRead[index],RpWarning,  HeaterCmd[index].targettemperatue,0);
+                }
+                else
+                {
+                    ReportWithPackageFilter(HeatersFilter,"DC Heater Over the max temperature, turned off",__FILE__,index,HeaterPreviousRead[index],RpWarning,  HeaterReady[index],0);
+                    ReportWithPackageFilter(HeatersFilter,"Heater over the max temperature",__FILE__,index,OverHeatCounter[index],RpWarning,HeaterControl[index].sensormaxvalue,  0);
+                    AlarmHandlingSetAlarm(HeaterEventType[index], true);
+                }
+            }
         }
-        DeActivateHeater(index);
-        HeaterRecalculateHeaterParams(index, 0);
-        HeaterMaxTempFlag[index] = true;
-        //ReportWithPackageFilter(HeatersFilter,(MinreadValue/100), "Heater Over the max temperature, turned off");
-        if (getIdleState() == false)
+        if (index == HEATER_TYPE__DryerAirHeater)
+        {
+            DeActivateHeater(HEATER_TYPE__DryerMainHeater);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
+            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
+            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
+        }
+        else
         {
-            ReportWithPackageFilter(HeatersFilter,"DC Heater Over the max temperature, turned off",__FILE__,index,HeaterPreviousRead[index],RpWarning,  HeaterReady[index],0);
-            ReportWithPackageFilter(HeatersFilter,"Heater over the max temperature",__FILE__,index,OverHeatCounter[index],RpWarning,HeaterControl[index].sensormaxvalue,  0);
-            AlarmHandlingSetAlarm(HeaterEventType[index], true);
+            DeActivateHeater(index);
+            HeaterRecalculateHeaterParams(index, 0);
         }
+        HeaterMaxTempFlag[index] = true;
+        //ReportWithPackageFilter(HeatersFilter,(MinreadValue/100), "Heater Over the max temperature, turned off");
         return OK;
     }
     else if ((HeaterPreviousRead[index]) < (HeaterControl[index].sensorminvalue))
@@ -1029,6 +1241,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
             if (JobIsActive()&&(HeaterReady[index]==true))
             {
                 JobEndReason = JOB_TEMPERATURE_ALARM;
+                usnprintf(AlarmReasonStr, 100, "Temperature %d Error %d",index,readValue);
                 SendJobProgress(0.0,0,false, "Temperature Error");
                 AbortJob("Under Temperature Error");
                 ReportWithPackageFilter(HeatersFilter, "Temperature Error",__FILE__,__LINE__,index,RpError, 0,0);
@@ -1070,6 +1283,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     return ERROR;
 }
+
 uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=HEATER_TYPE_MAX_HEATERS;
@@ -1113,6 +1327,17 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             DeActivateHeater(HEATER_TYPE__DryerMainHeater);
             HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
             HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
+            if (HeaterSpikeRead[index] == 0)
+            {
+                HeaterSpikeRead[index] = readValue;
+            }
+            else
+            {
+                ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
+                HeaterPreviousRead[index] = HeaterSpikeRead[index];
+                HeaterSpikeRead[index] = 0;
+            }
+
         }
         return ERROR;
     }
@@ -1130,7 +1355,8 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 
     if ((readValue>(HeaterCmd[index].targettemperatue+800))&&(getIdleState() == false))
     {
-        ReportWithPackageFilter(HeatersFilter, "AC OverHeating in progress",__FILE__,readValue,HeaterReady[index],RpError, HeaterAtTemp[index],0);
+        ReportWithPackageFilter(HeatersFilter, "AC OverHeating in progress",__FILE__,readValue,GetHeaterState(HEATER_TYPE__DryerMainHeater),RpError, GetHeaterState(HEATER_TYPE__DryerSecondaryHeater),0);
+        ReportWithPackageFilter(HeatersFilter, "AC OverHeating PID",__FILE__,(int)HeaterPIDConfig[index].m_calculatedError,(int)HeaterPIDConfig[index].m_SetParam,RpError, (int)HeaterPIDConfig[index].m_integral,0);
     }
     // check if the read value is within the proportional band
     if (HeaterReady[index]==false)
@@ -1148,9 +1374,9 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
         //if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800))
         {
-            //ReportWithPackageFilter(HeatersFilter,"AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
             if ((HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)&&(HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] == false))
             {
+                //ReportWithPackageFilter(HeatersFilter,"AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
                 ActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
                 ActivateHeater(HEATER_TYPE__DryerMainHeater);
                 HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,100);
@@ -1180,6 +1406,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         }
         */
 //        if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
+
         if    (   (readValue >  (HeaterCmd[index].targettemperatue * ((100-HeaterControl[index].outputproportionalband)/100)))
               &&  (readValue < (HeaterCmd[index].targettemperatue *  ((100+HeaterControl[index].outputproportionalband)/100))))
         {
@@ -1189,9 +1416,9 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
             HeatersControlStart();
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
-            if (BlowerCfg.enabled == true)
+            /*if (BlowerCfg.enabled == true)
             {
-                if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+                if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
                 {
                     WHS_Set_SetPoint_Q_value(headairflow);
                 }
@@ -1201,7 +1428,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                     if (BlowerCfg.voltage)
                         Control_Voltage_To_Blower(BlowerCfg.voltage);
                 }
-            }
+            }*/
             HeaterReady[index] = true;
             //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
             //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
@@ -1219,6 +1446,16 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                 HeaterPrepareReady();
             }
     }
+    else
+    {
+        if ((readValue < (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))||(readValue > (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
+            {
+                //InitialHeating = false;
+                ReportWithPackageFilter(HeatersFilter,"AC returning to NOT Ready",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
+                HeaterAtTemp[index] = false;
+                HeaterPrepareReady();
+            }
+    }
     if(HeaterPIDConfig[index].m_isEnabled && (HeaterPIDConfig[index].m_SetParam != 0))
     {
         HeaterPIDConfig[index].m_mesuredParam = readValue;
@@ -1254,11 +1491,16 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
                                      &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
             //}
-//            len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError);
-            //        ReportWithPackageFilter(HeatersFilter,logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);
-            //        #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 (ReportFilterTest(HeatersFilter))
+            {
+               int len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} H1 %d H2 %d ",index,
+                               (int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError,
+                               GetHeaterState(HEATER_TYPE__DryerMainHeater),GetHeaterState(HEATER_TYPE__DryerSecondaryHeater));
+               //        ReportWithPackageFilter(HeatersFilter,logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);
+               //        #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[HEATER_TYPE__DryerMainHeater] == true)
             {
                 ReportWithPackageFilter(HeatersFilter,"Restarting same temperature Heater Temp",__FILE__,HEATER_TYPE__DryerMainHeater,HeaterPIDConfig[index].m_calculatedError,RpWarning,readValue,  0);
@@ -1358,7 +1600,8 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                 }
         if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
                 {
-                    ActivateHeater(index);
+                    if ((HeaterMaxTempFlag[index] == false) && (BlowerHeaterMaxTempFlag[index] == false))
+                        ActivateHeater(index);
                     //HeaterRecalculateHeaterParams(index, 100);
                     //Heaters OFF until coming into the proportional band
                     //ReportWithPackageFilter(HeatersFilter,"DC HEATER Under temperature ", __FILE__,__LINE__,index, RpMessage, readValue, 0);
@@ -1373,7 +1616,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             //DCInitialHeating[index] = false;
             HeatersControlStart();
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
-            if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+            if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
                 Disable_Reading_Heaters_ADC(HeaterId2CurrentId[index]);
             else
                 Disable_Reading_Heaters_Current(HeaterId2CurrentId[index]);
@@ -1395,6 +1638,15 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             HeaterPrepareReady();
         }
     }
+    else
+    {
+        if ((readValue < (HeaterCmd[index].targettemperatue * DcHeatersLoweroperationLimit/1000))||(readValue > (HeaterCmd[index].targettemperatue * DcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
+            {
+                ReportWithPackageFilter(HeatersFilter,"DC AC returning to NOT Ready",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
+                HeaterAtTemp[index] = false;
+                HeaterPrepareReady();
+            }
+    }
 
     if(HeaterPIDConfig[index].m_isEnabled && (HeaterPIDConfig[index].m_SetParam != 0))
     {
@@ -1479,9 +1731,9 @@ void EightMilliSecondHeatersInterrupt(UArg arg0)
         ROM_TimerLoadSet(Heater_timerBase, TIMER_A,OutputProportionalSingleStep);
     }
     else
-	{
+    {
         TimerDisable(Heater_timerBase, TIMER_A);
-	}
+    }
     //
     // Enable all interrupts.
     //
@@ -1528,11 +1780,17 @@ void HeaterSafetyTestSetLimits(int limit)
         HeaterDisasterTemp[i] = limit;
         RemoveControlCallback(ControlIdtoMaxHeaterId [i], DcHeaterMaxTempCBFunction);
     }
-     RemoveControlCallback(DisasterControlId, HeatersDisasterControl);
-     RemoveControlCallback(MainDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
-     RemoveControlCallback(SecondDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
-
-     MaxAllowedTemperature = limit+1;
+    RemoveControlCallback(DisasterControlId, HeatersDisasterControl);
+    RemoveControlCallback(MainDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
+    RemoveControlCallback(SecondDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
+#ifdef USE_TUNNEL_PT100
+    for(i = HEATER_TYPE__HeadCoverHeater1; i<=HEATER_TYPE__HeadCoverHeater2;i++)
+    {
+        HeaterDisasterTemp[i] = limit;
+        RemoveControlCallback(BlowersControlIdtoMaxHeaterId [i], HeaterBlowerMaxTempCBFunction);
+    }
+#endif
+    MaxAllowedTemperature = limit+1;
 }
 
 double TotalCurrentLimit(double VAC)
@@ -1551,15 +1809,24 @@ double TotalCurrentLimit(double VAC)
     }
 
 }
+uint8_t Histeresis = 0;
+
 uint32_t DrierHeaterVoltageSetup(void)
 {
     double DrierAcVoltage = 0.0;
     char str[100];
     bool tempDrier2 = UseSecondaryDrierHeater;
-    double Z1Current,Z2AssumedCurrent,LimitCurrent;
+    double Z1Current = 0,Z2AssumedCurrent = 0,LimitCurrent = 0;
 
+    if ((Histeresis>0)&&(Histeresis<4))
+    {
+        Histeresis++;
+        REPORT_MSG(Histeresis, "AC handling Histeresis");
+        return OK;
+    }
+    Histeresis = 0;
 #ifndef VAC_TEST
-    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD) //rapid/pp machines
+    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD) //rapid/pp machines
 #endif
     {
         DrierAcVoltage = ReadVAC();
@@ -1587,9 +1854,10 @@ uint32_t DrierHeaterVoltageSetup(void)
         }
         else
         {
-            Z1Current = Get_Heaters_Current(HEATER_DRYER_CURRENT_1);
+            Z1Current = GetZone1RMSCurrent(DrierAcVoltage); //changed to assumed current as calculated on init
             Z2AssumedCurrent = GetZone2RMSCurrent(DrierAcVoltage);
             LimitCurrent = TotalCurrentLimit(DrierAcVoltage);
+            //hysteresis: activate
             if ((Z2AssumedCurrent+Z1Current)>LimitCurrent)
             {
                 UseSecondaryDrierHeater = false;
@@ -1608,8 +1876,9 @@ uint32_t DrierHeaterVoltageSetup(void)
 #endif
     if (tempDrier2 != UseSecondaryDrierHeater)
     {
-        usnprintf(str, 100, "Changing Drier 2 from %d to %d  VAC %d D1 Current %d D2 assumed current %d limit %d" ,tempDrier2,UseSecondaryDrierHeater
-                        ,(int)DrierAcVoltage,(int)(Z1Current*100),(int)(Z2AssumedCurrent*100),(int)(LimitCurrent*100));
+        Histeresis = 1;
+        usnprintf(str, 100, "Changing Dryer 2 from %d to %d  VAC %d D1 Current %d D2 assumed current %d limit %d" ,tempDrier2,UseSecondaryDrierHeater
+                        ,(int)DrierAcVoltage,(int)(Z1Current*100),(int)(Z2AssumedCurrent*100),(int)(abs(LimitCurrent)*100));
         ReportWithPackageFilter(HeatersFilter,str, __FILE__,__LINE__,DrierAcVoltage, RpMessage, UseSecondaryDrierHeater, 0);
         if (UseSecondaryDrierHeater == false)
         {
@@ -1667,6 +1936,10 @@ uint32_t HeatersControlLoop(uint32_t tick)
                     //DeActivate HEATER_TYPE__DryerSecondaryHeater
                     //DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                 }
+                else
+                {
+                    DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
+                }
             }
             /*else if (TimeSliceAllocation[SliceCounter] == HEATER_TYPE__DryerSecondaryHeater)
             {
@@ -1699,21 +1972,21 @@ uint32_t HeatersControlLoop(uint32_t tick)
             continue;
         if (DCTimeSliceAllocation[DcHeaterId] > 0) //heater active
         {
-            if (SliceCounter == 0)
+            if (SliceCounter == DcHeaterId)
             {
-                if (HeaterMaxTempFlag[DcHeaterId] == false)
+                if ((HeaterMaxTempFlag[DcHeaterId] == false) && (BlowerHeaterMaxTempFlag[DcHeaterId] == false))
                 {
                     ActivateHeater (DcHeaterId);
                 }
             }
-            else if (SliceCounter >= DCTimeSliceAllocation[DcHeaterId]) //turn off
+            else if (SliceCounter-DcHeaterId >= DCTimeSliceAllocation[DcHeaterId]) //turn off
             {
                 DeActivateHeater (DcHeaterId);
             }
         }
         else
         {
-            DeActivateHeater (DcHeaterId);
+            DeActivateHeater (DcHeaterId); 
         }
     }
     //handle the time sharing module
@@ -1747,3 +2020,5 @@ void HeatersControlTask(UArg arg0, UArg arg1)
         }
     }
 }
+
+
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index 41e729b9b..1c17c4f6b 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -13,6 +13,10 @@ extern double   DispenserPreparePressure ;
 extern uint32_t DispenserPrepareTimeout ;
 extern uint32_t DispenserPrepareTimeLag ;
 extern uint32_t InitialDispenserSpeed;
+extern double   InitialDispenserPressure;
+extern uint32_t InitialDispenserTimeout;
+
+
 
 extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 extern float DispenserPressure[MAX_SYSTEM_DISPENSERS];
@@ -28,6 +32,9 @@ extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 extern bool HomingActive[MAX_SYSTEM_DISPENSERS];
 extern bool PrimingActive[MAX_SYSTEM_DISPENSERS];
 
+extern uint32_t LeftRockerSpeed;
+extern uint32_t RightRockerSpeed;
+
 uint32_t IDS_Dispenser_EmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue);
 
 /*typedef struct
@@ -45,9 +52,12 @@ void IDS_Dispenser_RefillEnded (char DispenserId,char  MicroSteps);
 
 //uint32_t IDS_Dispenser_Build_Pressure(int DispenserId, callback_fptr callback);
 
-uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed);
-uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback);
+uint32_t IDS_Cleaning_Move_Actuators(void);
+//uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed);
+//uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback);
 uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr callback);
 uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
 
+void Init_CleaningStageCounter();
+extern int CleaningStageCounter;
 #endif  //MODULES_IDS_IDS_H_
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
index bdde05b43..0e28134c4 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
@@ -8,17 +8,106 @@
 #include "ids.h"
 #include "ids_ex.h"
 #include "../control/control.h"
+#include "modules/General/process.h"
 #include "../control/pidalgo.h"
 #include "../thread/thread.h"
 #include "PMR/Hardware/Hardwaremotor.pb-c.h"
 #include "PMR/Hardware/HardwareDispenser.pb-c.h"
 #include "StateMachines/Printing/printingSTM.h"
+#include <Drivers/I2C_Communication/I2C_Task.h>
+
 #include "drivers/motors/motor.h"
 #include "drivers/valves/valve.h"
+#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
 
 int SaveLeftRockerSpeed = 50, SaveRightRockerSpeed = 50;
+typedef enum
+{
+    CleaningStageIdle,
+    CleaningStageActuatorUp = 1,
+    CleaningStageDelay1,
+    CleaningStageActuatorDown,
+    CleaningStageDelay2,
+}CleaningStageEnum;
+TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DH_LID;
+
+/*
+ *Cleaning sequence:
+
+
+t up – time actuator goes up
+t delay1 – time actuator stays in position (up position – not limit switch)
+Down to limit -  actuator goes to lower limit switch
+t delay2 – time actuator stays in lower limit switch position
+
+Values for start:
+t up – 300 msec
+t delay1 – 500 msec
+t delay2 – 2 sec
+
+ */
+
+CleaningStageEnum CleaningStage = CleaningStageIdle;
+int Tup = 4,Tdelay1 = 9,Tdelay2 = 29;//set CleaningStageCounter to Tdelay1 - 1
+int CleaningStageCounter = 8;//Tdelay1 - 1 to start with stage moving down
 
-uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed)
+void Init_CleaningStageCounter()
+{
+    if(Head_Type == HEAD_TYPE_FLAT) {
+        CleaningStageCounter = Tdelay1 - 1;
+    } else {
+        CleaningStageCounter = 0;
+    }
+}
+
+uint32_t cleaningMotorCBFunction (uint32_t deviceID, uint32_t Parameter1)
+{
+    CleaningStageCounter = 0;
+    return 0;
+}
+
+uint32_t IDS_Cleaning_Move_Actuators()
+{
+   if((Head_Type != HEAD_TYPE_FLAT) && (Head_Type != HEAD_TYPE_ARC))
+       return OK;
+   if(Head_Type == HEAD_TYPE_FLAT) {
+       if (CleaningStageCounter == 1)
+       {
+           Trigger_Head_Actuators_Stub(ACTIN, ENABLE, UP);
+           //Trigger_Head_Actuators_Control(ACTIN, LOW,true);
+           ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Move_ActuatorUp", __FILE__, __LINE__, 1, RpWarning,   CleaningStageCounter, 0);
+       }
+       else if (CleaningStageCounter == Tup)
+       {
+           Trigger_Head_Actuators_Stub(ACTIN, DISABLE, DONTCARE);
+           //Trigger_Head_Actuators_Disable();
+           ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_Actuator", __FILE__, __LINE__, Tup, RpWarning,   CleaningStageCounter, 0);
+       }
+       else if (CleaningStageCounter == Tdelay1)
+       {
+           Trigger_Head_Actuators_Stub(ACTIN, ENABLE, DOWN);
+           //Trigger_Head_Actuators_Control(ACTIN, LOW,false);
+           ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_MoveDown", __FILE__, __LINE__, Tdelay1, RpWarning,   CleaningStageCounter, 0);
+       }
+       else if (CleaningStageCounter == Tdelay2)
+       {
+           CleaningStageCounter = 0;
+           Trigger_Head_Actuators_Stub(ACTIN, DISABLE, DONTCARE);
+           ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_delay", __FILE__, __LINE__, Tdelay2, RpWarning,   CleaningStageCounter, 0);
+       }
+   } else { //arc
+       if (CleaningStageCounter == 0) {
+           if (ArcCleaningMotorSpeed>1)
+               MotorSetSpeed(MotorId, ArcCleaningMotorSpeed);
+           else
+               MotorSetSpeed(MotorId, 750);
+           ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Motor_Run", __FILE__, __LINE__, 750, RpWarning,   (int)ArcCleaningMotorSpeed, 0);
+       }
+   }
+   CleaningStageCounter++;
+   return OK;
+}
+/*uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed)
 {
     uint32_t status = OK;
     SaveLeftRockerSpeed = LeftRockerSpeed;
@@ -27,24 +116,34 @@ uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed)
     status |= MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD, RightRockerSpeed);
     status |= MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH].directionthreadwize);
     status |= MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH, LeftRockerSpeed);
-    Report("IDS_Cleaning_Move_Rockers", __FILE__, __LINE__, LeftRockerSpeed, RpWarning,   RightRockerSpeed, 0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Move_Rockers", __FILE__, __LINE__, LeftRockerSpeed, RpWarning,   RightRockerSpeed, 0);
 
     return status;
 }
 uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback)
 {
     uint32_t status = OK;
-    status |= MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD].directionthreadwize, SaveRightRockerSpeed,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD], callback,timeout);
-    status |= MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH].directionthreadwize, SaveLeftRockerSpeed,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH], callback,timeout);
-    Report("IDS_Cleaning_Center_And_Stop_Rockers", __FILE__, __LINE__, timeout, RpWarning,   123456, 0);
+    //status |= MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD].directionthreadwize, SaveRightRockerSpeed,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD], callback,timeout);
+    //status |= MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH].directionthreadwize, SaveLeftRockerSpeed,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH], callback,timeout);
+    HeadCard_Actuators_Relocate();
+    //Trigger_Head_Actuators_Disable();
+    //Trigger_Head_Actuators_Control(ACTIN, LOW,false);
+    CleaningStageCounter = 0;
+    CleaningStage = CleaningStageIdle;
+    ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Center_And_Stop_Rockers actuator down", __FILE__, __LINE__, timeout, RpWarning,   123456, 0);
 
     return status;
-}
+}*/
 uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr callback)
 {
     uint32_t status = OK;
+    Tup = LeftRockerSpeed/100;
+    Tdelay1 = LeftRockerSpeed%100;
+    Tdelay2 = RightRockerSpeed;
     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);
+    Init_CleaningStageCounter();
+    ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Spray_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning,   dispenserSpeed, 0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Cleaning parameters", __FILE__, Tup*100, Tdelay1*100, RpWarning,   Tdelay2*100, 0);
 
     return status;
 
@@ -53,7 +152,20 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback)
 {
     uint32_t status = OK;
     status = IDS_Dispenser_Close_Valve_And_Stop_Motor(CLEANER_DISPENSER,callback);
-    Report("IDS_Cleaning_Stop_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning,   status, 0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning,   status, 0);
+    if(Head_Type == HEAD_TYPE_FLAT)
+    {
+        HeadCard_Actuators_Relocate();
+        Init_CleaningStageCounter();
+    }
+    if(Head_Type == HEAD_TYPE_ARC)
+    {
+        MotorMovetoLimitSwitch(MotorId,1-MotorsCfg[MotorId].directionthreadwize, 30,  Motor_Id_to_LS_IdDown[MotorId], cleaningMotorCBFunction,30000);
+    }
+
+    ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Motor_Homing", __FILE__, __LINE__, 1, RpWarning,   CleaningStageCounter, 0);
+    CleaningStage = CleaningStageIdle;
+    ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_Cleaning_Solution actuator relocate", __FILE__, __LINE__, CleaningStage, RpWarning,   CleaningStageCounter, 0);
 
     return status;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index bb9f0616e..c8f435cb9 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -49,8 +49,8 @@ void IDS_Dispenser_SetPrepareValues(    uint32_t DispenserBuildPressureSpeed,
      DispenserPreparePressure = DispenserBuildPressureLimit;
      DispenserPrepareTimeout = DispenserBuildPressureTimeout;
      DispenserPrepareTimeLag = DispenserBuildPressureLag;
-     Report("IDS_Dispenser_SetPrepareValues ",__FILE__,__LINE__,DispenserPrepareSpeed,RpWarning,(int)(DispenserPreparePressure*100),0);
-     Report("IDS_Dispenser_SetPrepareValues ",__FILE__,__LINE__,DispenserPrepareTimeout,RpWarning,(int)DispenserPrepareTimeLag,0);
+     ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetPrepareValues ",__FILE__,__LINE__,DispenserPrepareSpeed,RpWarning,(int)(DispenserPreparePressure*100),0);
+     ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetPrepareValues ",__FILE__,__LINE__,DispenserPrepareTimeout,RpWarning,(int)DispenserPrepareTimeLag,0);
 }
 void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout)
 {
@@ -59,7 +59,7 @@ void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout)
         CloseValveTimeout = CloseTimeout;
         OpenValveTimeout = OpenTimeout;
     }
-     Report("IDS_Dispenser_SetTimeOutValues ",__FILE__,__LINE__,OpenValveTimeout,RpWarning,(int)CloseValveTimeout,0);
+     ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetTimeOutValues ",__FILE__,__LINE__,OpenValveTimeout,RpWarning,(int)CloseValveTimeout,0);
 }
 
 //********************************************************************************************************************
@@ -89,7 +89,7 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
          if (SafeRemoveControlCallback(DispenserControlId[DispenserId], IDS_Dispenser_Build_Pressure_Callback )==OK)
              DispenserControlId[DispenserId] = 0xFF;
          else
-             Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+             ReportWithPackageFilter(IDSFilter,"Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
          TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
          MotorStop(HW_Motor_Id,Hard_Hiz);
          CurrentDispenserSpeed[DispenserId] = 0;
@@ -107,19 +107,19 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
  uint32_t IDS_Dispenser_Build_Pressure(int DispenserId, callback_fptr callback)
 {
     DispenserCallback[DispenserId] = callback;
-    Report("IDS_Dispenser_Build_Pressure called  ",__FILE__,__LINE__,(int)DispenserPrepareSpeed,RpWarning,DispenserPrepareTimeLag,0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Build_Pressure called  ",__FILE__,__LINE__,(int)DispenserPrepareSpeed,RpWarning,DispenserPrepareTimeLag,0);
 
     Control3WayValvesWithCallback ((Valves_t)DispenserId, CloseValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
     if (DispenserControlId[DispenserId] != 0xFF)
     {
-        Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
+        ReportWithPackageFilter(IDSFilter,"Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
     }
     DispenserControlId[DispenserId] = AddControlCallback(NULL, IDS_Dispenser_Build_Pressure_Callback, DispenserPrepareTimeLag,TemplateDataReadCBFunction ,DispenserId, DispenserId, 0 );
     if (DispenserControlId[DispenserId] == 0xFF)
-        Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+        ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
     else
     {
-        //Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+        //ReportWithPackageFilter(IDSFilter,"Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
         DispenserPrepareTime[DispenserId]=0;
         TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
         MotorSetDirection(HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize);
@@ -132,11 +132,11 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
 */
  uint32_t IDS_Dispenser_StopMotorCallback(uint32_t DispenserId, uint32_t ReadValue)
  {
-     Report("IDS_Dispenser_Close_Valve_And_Stop_Motor callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
+     ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Close_Valve_And_Stop_Motor callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
      if (SafeRemoveControlCallback(DispenserControlId[DispenserId], IDS_Dispenser_StopMotorCallback )==OK)
          DispenserControlId[DispenserId] = 0xFF;
      else
-         Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+         ReportWithPackageFilter(IDSFilter,"Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
 
      TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
      MotorStop(HW_Motor_Id,Hard_Hiz);
@@ -153,31 +153,31 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
  uint32_t IDS_Dispenser_Close_Valve_And_Stop_Motor(int DispenserId, callback_fptr callback)
 {
     DispenserCallback[DispenserId] = callback;
-    //Report("IDS_Dispenser_Close_Valve_And_Stop_Motor",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
+    //ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Close_Valve_And_Stop_Motor",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
 
     Control3WayValvesWithCallback ((Valves_t)DispenserId, CloseValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
     if (DispenserControlId[DispenserId] != 0xFF)
-        Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
+        ReportWithPackageFilter(IDSFilter,"Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
 
     DispenserControlId[DispenserId] = AddControlCallback(NULL, IDS_Dispenser_StopMotorCallback, CloseValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
     if (DispenserControlId[DispenserId] == 0xFF)
-        Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+        ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
     //else
-    //    Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+    //    ReportWithPackageFilter(IDSFilter,"Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
 
     return OK;
 }
 
 uint32_t IDS_Dispenser_OpenValveCallback(uint32_t DispenserId, uint32_t ReadValue)
 {
-    //Report("IDS_Dispenser_Start_Motor_and_Open_Valve Callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
+    //ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Start_Motor_and_Open_Valve Callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
 
     if (SafeRemoveControlCallback(DispenserControlId[DispenserId], IDS_Dispenser_OpenValveCallback )==OK)
         DispenserControlId[DispenserId] = 0xFF;
     else
-        Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+        ReportWithPackageFilter(IDSFilter,"Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
 
-    //Report("Control3WayValvesWithCallback called  ",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)0,0);
+    //ReportWithPackageFilter(IDSFilter,"Control3WayValvesWithCallback called  ",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)0,0);
     Control3WayValvesWithCallback (DispenserId, OpenValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
 
     if (DispenserCallback[DispenserId])
@@ -207,14 +207,14 @@ uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpee
         MotorSetSpeed(HW_Motor_Id, MotorSpeed);
         CurrentDispenserSpeed[DispenserId] = MotorSpeed;
         if (DispenserControlId[DispenserId] != 0xFF)
-            Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
-        //Report("IDS_Dispenser_Start_Motor_and_Open_Valve",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
+            ReportWithPackageFilter(IDSFilter,"Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
+        //ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Start_Motor_and_Open_Valve",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
 
         DispenserControlId[DispenserId] = AddControlCallback(NULL, IDS_Dispenser_OpenValveCallback, OpenValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
         if (DispenserControlId[DispenserId] == 0xFF)
-            Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+            ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
         //else
-        //    Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+        //    ReportWithPackageFilter(IDSFilter,"Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
     //}
 
     return OK;
@@ -289,11 +289,11 @@ void IDS_Dispenser_Content_Init (void)
             IDS_Dispenser_Data[i].microsteps = StoredDispenserData->dispenserinfo[i]->microsteps;
             IDS_Dispenser_Data[i].numberofrefills = StoredDispenserData->dispenserinfo[i]->numberofrefills;
             IDS_Dispenser_Data[i].nanolitterperpulse = StoredDispenserData->dispenserinfo[i]->nanolitterperpulse;
-            Report("IDS_Dispenser load data ",__FILE__,i,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].consumedinnanolitter,0);
+            ReportWithPackageFilter(IDSFilter,"IDS_Dispenser load data ",__FILE__,i,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].consumedinnanolitter,0);
         }
         dispenser_data__free_unpacked(StoredDispenserData,NULL);
     }
-    //Report("IDS_Dispenser load data ",__FILE__,__LINE__,(int)Bytes,RpWarning,(int)IDS_Dispenser_Data[0].nanolitterperpulse*100,0);
+    //ReportWithPackageFilter(IDSFilter,"IDS_Dispenser load data ",__FILE__,__LINE__,(int)Bytes,RpWarning,(int)IDS_Dispenser_Data[0].nanolitterperpulse*100,0);
     return;
 
     //==================================
@@ -314,11 +314,11 @@ uint32_t IDS_Dispenser_Store_Data (void)
     for(i=0;i<MAX_SYSTEM_DISPENSERS;i++)
     {
         StoreDispenserData.dispenserinfo[i] = &IDS_Dispenser_Data[i];
-        Report("IDS_Dispenser store data ",__FILE__,i,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].consumedinnanolitter,0);
+        ReportWithPackageFilter(IDSFilter,"IDS_Dispenser store data ",__FILE__,i,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].consumedinnanolitter,0);
     }
 
-//    Report("IDS_Dispenser_Store_Data 0",__FILE__,(int)IDS_Dispenser_Data[0].totalconsumedinnanolitter,(int)IDS_Dispenser_Data[0].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[0].microsteps,0);
-//    Report("IDS_Dispenser_Store_Data 4",__FILE__,(int)IDS_Dispenser_Data[4].totalconsumedinnanolitter,(int)IDS_Dispenser_Data[4].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[4].microsteps,0);
+//    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Store_Data 0",__FILE__,(int)IDS_Dispenser_Data[0].totalconsumedinnanolitter,(int)IDS_Dispenser_Data[0].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[0].microsteps,0);
+//    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Store_Data 4",__FILE__,(int)IDS_Dispenser_Data[4].totalconsumedinnanolitter,(int)IDS_Dispenser_Data[4].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[4].microsteps,0);
 
     if (JobIsActive()==false)
     {
@@ -326,7 +326,7 @@ uint32_t IDS_Dispenser_Store_Data (void)
         EraseFlashSection(DISPENSERS_SECTION_FLASH);
         ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH, 4,&response_size);
         ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH+4, response_size, dispensers_container_buffer);
-        //Report("IDS_Dispenser_Store ",__FILE__,__LINE__,(int)response_size,RpWarning,(int)StoreDispenserData.dispenserinfo[4]->nanolitterperpulse *100,0);
+        //ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Store ",__FILE__,__LINE__,(int)response_size,RpWarning,(int)StoreDispenserData.dispenserinfo[4]->nanolitterperpulse *100,0);
 
         /*Status = FileWrite(IDS_Dispenser_Data,response_size,DispenserStorePath,BIOS_NO_WAIT);
         if (Status == FR_OK)
@@ -347,26 +347,34 @@ void IDS_Dispenser_Content_Calculation (char DispenserId)
             != DispenserIdToMotorId[DispenserId])
         return;
 
+    /********* THIS FUNCTION IS NOW CALLED EVERY 400 MILISECONDS!!!!!!!!!! ***************************/
     //int dir = (IDS_Dispenser_Data[DispenserId].direction==1)?1:-1;
     //double consumedintimeframe = (double)(CurrentDispenserSpeed[DispenserId])*(double)(IDS_Dispenser_Data[DispenserId].microsteps)*
     //        IDS_Dispenser_Data[DispenserId].nanolitterperpulse ;//* dir;
     //double consumedintimeframe = (double)(CurrentDispenserSpeed[DispenserId]); //pulses only
     //consumedintimeframe = 10+DispenserId;
-    IDS_Dispenser_Data[DispenserId].consumedinnanolitter += (CurrentDispenserSpeed[DispenserId]/10);//100 milliseconds ==> speed/10
+    IDS_Dispenser_Data[DispenserId].consumedinnanolitter += (CurrentDispenserSpeed[DispenserId]*4/10);//400 milliseconds ==> speed*4/10
     if (IDS_Dispenser_Data[DispenserId].consumedinnanolitter<0)
         IDS_Dispenser_Data[DispenserId].consumedinnanolitter = 0;
-    if (CurrentDispenserSpeed[DispenserId]>0.1)
+    //if ((DispenserId == 2)&&(CurrentDispenserSpeed[DispenserId]>0))
+    //    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Data info",__FILE__,DispenserId,(int)IDS_Dispenser_Data[DispenserId].consumedinnanolitter,RpWarning,(int)CurrentDispenserSpeed[DispenserId],0);
+    //if ((DispenserId == 2)&&(CurrentDispenserSpeed[DispenserId]<0))
+    //    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Data fill",__FILE__,DispenserId,(int)IDS_Dispenser_Data[DispenserId].consumedinnanolitter,RpWarning,(int)(-1*CurrentDispenserSpeed[DispenserId]),0);
+
+    if (IDS_Dispenser_Data[DispenserId].consumedinnanolitter<0)
+        IDS_Dispenser_Data[DispenserId].consumedinnanolitter = 0;
+    if (abs(CurrentDispenserSpeed[DispenserId])>0)
     {
         DispenserDataUpdated = true;
         IDS_Dispenser_Data[DispenserId].totalconsumedinnanolitter += (CurrentDispenserSpeed[DispenserId]/10);
-        if (seconds_counter%6000 == 0)
+        if (seconds_counter%1500 == 0) //1500*400MILI = 600000
         {
-            Report("IDS_Dispenser_Data ",__FILE__,DispenserId,(int)IDS_Dispenser_Data[DispenserId].consumedinnanolitter,RpWarning,(int)CurrentDispenserSpeed[DispenserId],0);
+            ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Data ",__FILE__,DispenserId,(int)IDS_Dispenser_Data[DispenserId].consumedinnanolitter,RpWarning,(int)CurrentDispenserSpeed[DispenserId],0);
         }
     }
     if (DispenserId == 0)
     {
-        if ((seconds_counter++>=900)&&(DispenserDataUpdated == true))//9000)// - one hour)
+        if ((seconds_counter++>=9000)&&(DispenserDataUpdated == true))//9000)// - one hour)
         {
             seconds_counter = 0;
             if (IDS_Dispenser_Data[DispenserId].consumedinnanolitter)
@@ -393,7 +401,7 @@ void IDS_Dispenser_RefillStarted (char DispenserId,char  MicroSteps)
     IDS_Dispenser_Data[DispenserId].nanolitterperpulse = assumedFlow;
     IDS_Dispenser_Data[DispenserId].microsteps = 1;
     IDS_Dispenser_Data[DispenserId].direction = 0;*/
-    Report("IDS_Dispenser_RefillStarted",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)(CurrentDispenserSpeed[DispenserId]),0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_RefillStarted",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)(CurrentDispenserSpeed[DispenserId]),0);
 }
 void IDS_Dispenser_RefillEnded (char DispenserId,char  MicroSteps)
 {
@@ -402,7 +410,7 @@ void IDS_Dispenser_RefillEnded (char DispenserId,char  MicroSteps)
     IDS_Dispenser_Data[DispenserId].numberofrefills++;
     //IDS_Dispenser_Data[DispenserId].direction = 1;
     IDS_Dispenser_Data[DispenserId].consumedinnanolitter = 0;
-    Report("IDS_Dispenser_RefillEnded",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)IDS_Dispenser_Data[DispenserId].numberofrefills,0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_RefillEnded",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)IDS_Dispenser_Data[DispenserId].numberofrefills,0);
 }
 void DispenserDataRequestFunc(MessageContainer* requestContainer)
 {
@@ -417,7 +425,7 @@ void DispenserDataRequestFunc(MessageContainer* requestContainer)
     for(i=0;i<MAX_SYSTEM_DISPENSERS;i++)
     {
         response.dispenserinfo[i] = &IDS_Dispenser_Data[i];
-        Report("DispenserDataRequestFunc",__FILE__,__LINE__,(int)response.dispenserinfo[i]->totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,0);
+        ReportWithPackageFilter(IDSFilter,"DispenserDataRequestFunc",__FILE__,__LINE__,(int)response.dispenserinfo[i]->totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,0);
     }
     responseContainer = createContainer(MESSAGE_TYPE__DispenserDataResponse, requestContainer->token, true, &response, &dispenser_data_response__pack, &dispenser_data_response__get_packed_size);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index ad1d5b5c4..57d3ff5e2 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -12,7 +12,6 @@
 #include "PMR/EmbeddedParameters/DispenserRunningData.pb-c.h"
 #include "PMR/EmbeddedParameters/DispenserData.pb-c.h"
 
-#define MAX_SYSTEM_DISPENSERS 8
 typedef enum {
       LimitSwitchAlarmEmpty_1, //MOTO_DISPENSER_1 = 6,
       LimitSwitchAlarmEmpty_2, //MOTO_DISPENSER_2 = 7,
@@ -46,8 +45,11 @@ extern DispenserRunningData IDS_Dispenser_Data[MAX_SYSTEM_DISPENSERS];
 //extern DispenserData IDSDispenserData;
 extern DispenserRunningData **dispenserdata;
 
+extern bool ActuatorsCleaningSequence;
+
 extern bool         DispenserUsedInJob[MAX_SYSTEM_DISPENSERS];
 extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
+extern bool DispenserLastMovementDown[MAX_SYSTEM_DISPENSERS];
 
 bool IDS_MapDispenserUsedinJob(void *JobDetails);
 
@@ -115,5 +117,6 @@ void DispenserDataRequestFunc(MessageContainer* requestContainer);
 
 void IDS_Start_Pid_Testing(int DispenserId);
 void IDS_Stop_Pid_Testing(int DispenserId);
+uint32_t cleaningMotorCBFunction (uint32_t deviceID, uint32_t Parameter1);
 
 #endif /* MODULES_IDS_IDS_EX_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_init.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_init.c
index 4a4e42b41..8f1de2c1c 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_init.c
@@ -17,12 +17,10 @@
 
 #define MAX_CONTROL_SAMPLES 10
 
-HardwareDispenser DispensersCfg[ MAX_SYSTEM_DISPENSERS];
+//HardwareDispenser DispensersCfg[ MAX_SYSTEM_DISPENSERS];
 
 TimerMotors_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS] = {HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8};
 
-float DispenserPressure[MAX_SYSTEM_DISPENSERS] = {0};
-
 float GetDispenserPressure(int DispenserId)
 {
     return DispenserPressure[DispenserId];
@@ -37,59 +35,9 @@ bool isDispenserInConfig(int DispenserId)
         return true;
 
 }
-float Vlow,VHigh,Bits_0Pascal,Bits_1MPascal,a,b;
-void Calculateinit (void)
-{
-    Vlow = 0.004 * 130; // 4mA*130ohm  = 0.52 V(0 Pascal)
-    VHigh = 0.020 *130; // 20mA*130ohm  = 2.6V (1M Pascal)
-
-    Bits_0Pascal = Vlow * 4096 / 3; // Vlow * 4096bit / 3Vref = 709.973328 bits
-    Bits_1MPascal = VHigh * 4096 / 3; // VHigh * 4096bit / 3Vref = 3549.86646 bits
-
-    a = (1 - 0) / (Bits_1MPascal - Bits_0Pascal);// Mpascal/Bits = 0.000352125
-
-    b = 0 - (a * Bits_0Pascal ); // y = ax + b (x= Bits_0Pascal, y = 0)
-
-}
-float CalculateDispenserPressure (int DispenserId)
-{
-    unsigned short data = 0;
-    float temp = 0.0;
-
-/*
-    data = ADC_GetReading(DispenserIdToPressureSensorId[DispenserId]);
-    temp = 4096 - data;
-    temp *= 3;
-    temp *= 1000; //move to mv
-    temp /= 4096;
-    DispenserPressure[DispenserId] = 3000 - temp;
-    */
-    data = ADC_GetReading(DispenserIdToPressureSensorId[DispenserId]);
-
-    if(data<Bits_0Pascal)
-        data = Bits_0Pascal;//40mA 0Bar
-
-    temp = a * data + b;
-
-    DispenserPressure[DispenserId] = temp; // [Mpascal] ( 1 Mpascal = 10 Bar )
-
-    //unmark one of them to convert from Mpascal to :
-    //-----------------------------------
-    //DispenserPressure[DispenserId] /= 1000000; //Pascal
-    //DispenserPressure[DispenserId] *=10;        //Bar;
-    //DispenserPressure[DispenserId] *=10000000;        //uBar;
-    //DispenserPressure[DispenserId] *=145.0377;  //PSI;
-
-    DispenserPressure[DispenserId] *= 10; //MPascal -> Bar
-
-    //if(DispenserPressure[DispenserId] < 0 ) //why????
-    //    DispenserPressure[DispenserId] = 0;
-
-    return(DispenserPressure[DispenserId]);
-}
 
 
-uint32_t DispenserConfigMessage(HardwareDispenser * request)
+/*uint32_t DispenserConfigMessage(HardwareDispenser * request)
 {
     uint32_t status = PASSED;
     int Dispenser_i;
@@ -102,7 +50,7 @@ uint32_t DispenserConfigMessage(HardwareDispenser * request)
     }
     else return Dispenser_i;
 
-}
+}*/
 void IDS_ModuleInit(void)
 {
     Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 2ffce8e46..ab2062293 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -20,6 +20,7 @@
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "drivers/Motors/Motor.h"
 #include "drivers/Valves/Valve.h"
+#include "Modules/AlarmHandling/AlarmHandling.h"
 
 
 FPGA_GPI_ENUM     Dispenser_Id_to_LS_Id[MAX_SYSTEM_DISPENSERS] = {
@@ -72,8 +73,8 @@ bool PrimingActive[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false
 uint32_t DispenserHomingControlId[MAX_SYSTEM_DISPENSERS] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 uint32_t DispenserBacklashControlId[MAX_SYSTEM_DISPENSERS] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 uint32_t DispenserHomingTime[MAX_SYSTEM_DISPENSERS] = {0,0,0,0,0,0,0,0};
-#define INITIAL_DISPENSER_PRESSURE 2.10
-#define INITIAL_DISPENSER_TIMEOUT_LIMIT 60000
+#define INITIAL_DISPENSER_PRESSURE 3.85
+#define INITIAL_DISPENSER_TIMEOUT_LIMIT 120000
 #define INITIAL_DISPENSER_TIMEOUT 100
 #define INITIAL_DISPENSER_SPEED 1000
 
@@ -84,12 +85,12 @@ 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);
+//uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t deviceID);
 
 AutoHoming_Config_enum AutoHoming_Config = AutoHoming_off;
 void IDS_Dispenser_SetAutoHoming_Config(AutoHoming_Config_enum Config)
 {
-    Report("IDS_Dispenser_SetAutoHoming_Config ",__FILE__,__LINE__,Config,RpWarning,AutoHoming_Config,0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetAutoHoming_Config ",__FILE__,__LINE__,Config,RpWarning,AutoHoming_Config,0);
     if (Special_Dispensers == false)
     {
         AutoHoming_Config = Config;
@@ -98,16 +99,21 @@ void IDS_Dispenser_SetAutoHoming_Config(AutoHoming_Config_enum Config)
     {
         AutoHoming_Config = AutoHoming_off;
     }
+#ifdef DISPESER_TEST
+    AutoHoming_Config = AutoHoming_off;
+#endif
 }
 
 void IDS_Dispenser_SetBackLashValues(double   initialdispenserpressure,   uint32_t initialdispensertimeout,   uint32_t initialdispensertimelag,   uint32_t initialdispenserspeed)
 {
-    InitialDispenserPressure = initialdispenserpressure;
-    InitialDispenserTimeout = initialdispensertimeout;
+    //if (initialdispenserpressure>2)
+        InitialDispenserPressure = initialdispenserpressure;
+    //if (initialdispensertimeout>70000)
+        InitialDispenserTimeout = initialdispensertimeout;
     InitialDispenserTimeLag = initialdispensertimelag;
     InitialDispenserSpeed = initialdispenserspeed;
 
-    Report("IDS_Dispenser_SetBackLashValues ",__FILE__,InitialDispenserPressure*100,InitialDispenserTimeout,RpWarning,(int)InitialDispenserTimeLag,0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetBackLashValues ",__FILE__,InitialDispenserPressure*100,InitialDispenserTimeout,RpWarning,(int)InitialDispenserTimeLag,0);
 }
 uint32_t IDS_HomeDispenserWaitForHomingEndCallback(uint32_t DispenserId, uint32_t ReadValue)
 {
@@ -170,11 +176,11 @@ uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId,  uint32_t timeo
         Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
         Disable_MidTank_Pressure_Reading(DispenserId);
 
-        Report("End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+        ReportWithPackageFilter(IDSFilter,"End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
         if (SafeRemoveControlCallback(DispenserHomingControlId[DispenserId], IDS_HomeDispenserBackMoveCallback )==OK)
             DispenserHomingControlId[DispenserId] = 0xFF;
         else
-            Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserHomingControlId[DispenserId],0);
+            ReportWithPackageFilter(IDSFilter,"Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserHomingControlId[DispenserId],0);
         DispenserHomingTime[DispenserId]=0;
     }
     else
@@ -199,7 +205,7 @@ uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
     }
 //    HomingActive[DispenserId]= false;
     IDS_Dispenser_RefillEnded ( DispenserId, MotorsCfg[motorId].microstep);
-    Report("Homing ended",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+    ReportWithPackageFilter(IDSFilter,"Homing ended",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
 //    DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
     MotorSetDirection(motorId,MotorsCfg[motorId].directionthreadwize);
     Task_sleep(10);
@@ -212,6 +218,10 @@ uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
     HomingActive[DispenserId]= false;
     PrimingActive[DispenserId]= false;
     Control_TCA9534ByPass(DispenserId,DISABLE);// use ENABLE or DISABLE
+#ifdef DISPENSER_VALVES_OPEN
+    if (JobIsActive()==false)
+        Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+#endif
 
     //close dry air valve in the dispenser
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
@@ -233,25 +243,25 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
     double midTankContent = 0.0;
     if (FPGA_Read_limit_Switches(Dispenser_Id_to_LS_Id[DispenserId]) == LIMIT)
     {
-        Report("IDS_HomeDispenser - Disp is full",__FILE__,Dispenser_Id_to_LS_Id[DispenserId],(int)DispenserId,RpWarning,LIMIT,0);
+        ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Disp is full",__FILE__,Dispenser_Id_to_LS_Id[DispenserId],(int)DispenserId,RpWarning,LIMIT,0);
         return ERROR;
     }
     if (Get_MidTank_Pressure_Sensor(DispenserId)<0.2)
     {
-        Report("IDS_HomeDispenser - Midtank is empty",__FILE__,Get_MidTank_Int1000_Sensor(DispenserId),(int)DispenserId,RpWarning,LIMIT,0);
+        ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Midtank is empty",__FILE__,Get_MidTank_Int1000_Sensor(DispenserId),(int)DispenserId,RpWarning,LIMIT,0);
         return ERROR;
     }
     midTankContent = Read_MidTank_Pressure_Sensor(DispenserId);
     if (midTankContent < 0.2) //midtank is empty - abort!!!!
     {
-        Report("IDS_HomeDispenser - Mid Tank Empty!!! ",__FILE__,__LINE__,(int)(midTankContent * 1000),RpWarning,DispenserId,0);
+        ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Mid Tank Empty!!! ",__FILE__,__LINE__,(int)(midTankContent * 1000),RpWarning,DispenserId,0);
         return ERROR;
     }
     //if Safety is active
         //if safety is upper position or
     if ((HomingActive[DispenserId] == true)||(PrimingActive[DispenserId] == true))
     {
-        Report("IDS_HomeDispenser - Homing/priming already active",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
+        ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Homing/priming already active",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
         return ERROR;
     }
 
@@ -259,7 +269,7 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
     {
         if ((Get_Notification_Disp_UP(DispenserId) == false)||(Get_Notification_Over_Press(DispenserId) == false))
         {
-            Report("IDS_HomeDispenser - Bypassing safety",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
+            ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Bypassing safety",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
             Control_TCA9534ByPass(DispenserId,ENABLE);// use ENABLE or DISABLE
         }
     }
@@ -284,15 +294,17 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
         {
             MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed/4,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
             CurrentDispenserSpeed[DispenserId] = speed/4;
-            Report("IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed/4,0);
+            ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed/4,0);
         }
         else
         {
             MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
             CurrentDispenserSpeed[DispenserId] = speed;
-            Report("IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed,0);
+            ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed,0);
         }
         CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]);
+        DispenserLastMovementDown[DispenserId] = true;
+
         return OK;
     }
     return ERROR;
@@ -301,10 +313,10 @@ uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
 {
     assert(DispenserId < MAX_SYSTEM_DISPENSERS);
 
-    Report("IDS_StopHomeDispenser",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
+    ReportWithPackageFilter(IDSFilter,"IDS_StopHomeDispenser",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
     if ((HomingActive[DispenserId] == false)&&( PrimingActive[DispenserId] == false))
     {
-        LOG_ERROR (DispenserId,"Homing not active");
+        ReportWithPackageFilter(IDSFilter,"Homing not active",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
         return OK;
     }
 
@@ -329,20 +341,25 @@ uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
     HomingActive[DispenserId] = false;
     PrimingActive[DispenserId] = false;
     Control_TCA9534ByPass(DispenserId,DISABLE);// use ENABLE or DISABLE
+#ifdef DISPENSER_VALVES_OPEN
+    if (JobIsActive()==false)
+        Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+#endif
     if (Extended_Motor_Param[MotorId] == true)
         Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
     //MotorSetMicroStep(MotorId, KeepMicrostep[DispenserId]);
     CurrentDispenserSpeed[DispenserId] = 0;
     return OK;
 }
+/*
 uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t DispenserId)
 {
     assert(DispenserId < MAX_SYSTEM_DISPENSERS);
 
-    Report("IDS_StopHomeDispenser and build pressure",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
+    ReportWithPackageFilter(IDSFilter,"IDS_StopHomeDispenser and build pressure",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
     if (HomingActive[DispenserId] != true)
     {
-        LOG_ERROR (DispenserId,"Homing not active");
+        ReportWithPackageFilter(IDSFilter,"Homing not active",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
         return ERROR;
     }
     else
@@ -364,22 +381,22 @@ uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t DispenserId)
         HomingRequestCallback[DispenserId] = NULL;
     }
 //    HomingActive[DispenserId]= false;
-      Report("End homing for job start",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
-  /*  else
+      ReportWithPackageFilter(IDSFilter,"End homing for job start",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+  /`*  else
     {
-        Report("homing aborted,start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+        ReportWithPackageFilter(IDSFilter,"homing aborted,start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
         DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
         Task_sleep(10);
         MotorSetDirection(motorId,MotorsCfg[motorId].directionthreadwize);
         Task_sleep(10);
         MotorSetSpeed(motorId, 1000);
         CurrentDispenserSpeed[DispenserId] = 1000;
-    }*/
+    }*`/
     //IDS_Dispenser_RefillEnded ( DispenserId, MotorsCfg[motorId].microstep);
 
     return OK;
 }
-
+*/
 uint32_t IDS_CheckDispenserLimitSwitch (LimitSwitchAlarms LS_Id)
 {
     int DispenserId;
@@ -416,7 +433,7 @@ uint32_t IDS_EmptyDispenserCallback(uint32_t motorId, uint32_t ReadValue)
     {
         Lubricant_2Way_Valve (STOP);
     }
-    Report("End Priming",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+    ReportWithPackageFilter(IDSFilter,"End Priming",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
     //    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     if (HomingRequestCallback[DispenserId])
     {
@@ -434,14 +451,14 @@ uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fpt
     //    return ERROR;
     if ((HomingActive[DispenserId] == true)||(PrimingActive[DispenserId] == true))
     {
-        Report("IDS_HomeDispenser - Homing/priming already active",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
+        ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser - Homing/priming already active",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
         return ERROR;
     }
     if (Check_Disp_Safety_Stop_Indication(DispenserId) == true)
     {
         if ((Get_Notification_Disp_Down(DispenserId) == false)||(Get_Notification_Over_Press(DispenserId) == false))
         {
-            Report("IDS_EmptyDispenser - Bypassing safety",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
+            ReportWithPackageFilter(IDSFilter,"IDS_EmptyDispenser - Bypassing safety",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
             Control_TCA9534ByPass(DispenserId,ENABLE);// use ENABLE or DISABLE
         }
     }
@@ -473,7 +490,7 @@ uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fpt
 uint32_t IDS_Dispenser_Alarm_On (uint8_t DispenserId)
 {
     uint32_t status = OK;
-    Report("IDS_Dispenser_Alarm_On",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Alarm_On",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
     assert(DispenserId < MAX_SYSTEM_DISPENSERS);
     DispensersAlarmState[DispenserId] = true;
     TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
@@ -486,6 +503,7 @@ uint32_t IDS_Dispenser_Alarm_On (uint8_t DispenserId)
     status |= MotorStop(MotorId, Hard_Hiz);
     IDS_Dispenser_Init(DispenserId);
     JobEndReason = JOB_OUT_OF_DYE;
+    usnprintf(AlarmReasonStr, 100, "IDS_Dispenser_Alarm_On %d ",DispenserId);
     return status;
 }
 uint32_t IDS_Dispenser_Alarm_Off (uint8_t DispenserId)
@@ -493,12 +511,12 @@ uint32_t IDS_Dispenser_Alarm_Off (uint8_t DispenserId)
     uint32_t status = OK;
     assert(DispenserId < MAX_SYSTEM_DISPENSERS);
     DispensersAlarmState[DispenserId] = false;
-    Report("IDS_Dispenser_Alarm_Off",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Alarm_Off",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
     return status;
 }
 uint32_t IDS_ReCheck_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
 {
-    Report("Pulling dispenser down result",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
+    ReportWithPackageFilter(IDSFilter,"Pulling dispenser down result",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
     SafeRemoveControlCallback(GetControlLowDevice_i(), IDS_ReCheck_Pressure_Callback );
 
     return OK;
@@ -519,7 +537,6 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
     {
         if (DispenserUsedInJob[DispenserId] == true)
         {
-            //LOG_ERROR(DispenserId,"IDS_Check_Pressure_Callback active in a job");
             return ERROR;
         }
     }
@@ -528,14 +545,22 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
 
     if (GetDispenserPressure(DispenserId)>3.0)
     {
-        Report("Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
+        //10/8/2020 pulling down 2000 steps
+        ReportWithPackageFilter(IDSFilter,"Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,2000,0);
         if ((HomingActive[DispenserId] == true)||(PrimingActive[DispenserId] == true))
         {
-            Report("Dispenser in pressure but homing active",__FILE__,DispenserId,(int)HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
-            LOG_ERROR(DispenserId,"IDS_Check_Pressure_Callback homing active");
+            ReportWithPackageFilter(IDSFilter,"Dispenser in pressure but homing active",__FILE__,DispenserId,(int)HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
             return ERROR;
         }
-        MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,200*MotorsCfg[HW_Motor_Id].microstep);
+        if (GetDispenserPressure(DispenserId)>5.5)
+        {
+            //stop job on pressure rise above 5.5 bar
+            IDS_Dispenser_Alarm_On(DispenserId);
+            //open valve toward mixer on pressure rise above 5.5 bar
+            Task_sleep(100);
+            Control3WayValvesWithCallback ((Valves_t)DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+        }
+        MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,2000*MotorsCfg[HW_Motor_Id].microstep);
         AddControlCallback("IDS_ReCheck_Pressure", IDS_ReCheck_Pressure_Callback, eOneSecond*4,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
     }
     return OK;
@@ -545,13 +570,17 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
 void IDS_Dispenser_Init(uint8_t DispenserId)
 {
     assert(DispenserId < MAX_SYSTEM_DISPENSERS);
-    Report("IDS_Dispenser_Init",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Init",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
     CurrentDispenserSpeed[DispenserId] = 0;
     HomingActive[DispenserId]= false;
     PrimingActive[DispenserId]= false;
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
+/*#ifdef DISPENSER_VALVES_OPEN
+    Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+#else
     Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-    if (Special_Dispensers == true)
+#endif*/
+    //if (Special_Dispensers == true)
     {
         if (ControlIdtoInactiveDispenserId[DispenserId] == 0xFF)
             ControlIdtoInactiveDispenserId[DispenserId] = AddControlCallback("IDS_Check_Pressure", IDS_Check_Pressure_Callback, eOneMinute,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 32895f307..9f8491aa1 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -26,6 +26,7 @@
 #include "drivers/Flash_Memory/fatfs/ff.h"
 
 #include "modules/heaters/heaters.h"
+#include "../AlarmHandling/AlarmHandling.h"
 
 #include "drivers/Flash_ram/FlashProgram.h"
 
@@ -43,6 +44,10 @@ typedef struct
 HardwarePidControl *DispensersControl;
 HardwarePidControl DispensersCtrl[MAX_SYSTEM_DISPENSERS];
 #define MAX_DYE_DISPENSERS 6
+#define IDS_PRESEGMENT_TIME_STEP 50
+#define INITIAL_CLEANER_SPEED 300
+
+int32_t minimal_intersegment_length = 0;
 int32_t DispenserSamples[MAX_SYSTEM_DISPENSERS][MAX_CONTROL_SAMPLES] = {0};
 int DispenserSamplePointer[MAX_SYSTEM_DISPENSERS] = {0};
 double DispenserNormalizedErrorCoEfficient[MAX_SYSTEM_DISPENSERS] = {0};
@@ -51,6 +56,7 @@ HardwarePidControlType ThreadDispenserIdToControlId[MAX_SYSTEM_DISPENSERS] = {
 JobUploadStrategy uploadstrategy = JOB_UPLOAD_STRATEGY__Default;
 bool    DispenserReady[MAX_SYSTEM_DISPENSERS] = {true};
 bool IDS_Active = false;
+bool ActuatorsCleaningSequence = true;
 
 bool Special_Dispensers = false;
 /******************** STRUCTURES AND ENUMs  ********************************************/
@@ -59,7 +65,7 @@ uint32_t IDS_Valve_PresegmentReady(uint32_t deviceID, uint32_t ReadValue);
 uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue);
 //bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int SegmentId);
 /******************** GLOBAL PARAMETERS  ********************************************/
-DispenserControlConfig_t DispenserControlConfig[MAX_SYSTEM_DISPENSERS];
+//DispenserControlConfig_t DispenserControlConfig[MAX_SYSTEM_DISPENSERS];
 uint32_t    ControlIdtoDispenserId [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};
@@ -78,7 +84,7 @@ int lInterSegmentLength = 0;
  uint32_t InterSegmentStartRocking = 0;
  uint32_t InterSegmentCenterRockers = 0;
  uint32_t LeftRockerSpeed = 20;
- uint32_t RighttRockerSpeed = 20;
+ uint32_t RightRockerSpeed = 20;
  uint32_t CleaningDispenserSpeed = 40;
  uint32_t InterSegmentStartWFCFDispensers;
  uint32_t WFCF = 80;
@@ -98,7 +104,7 @@ void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, doubl
          InterSegmentStartWFCFDispensers = ids_presegment_wfcf_timebeforesegment;
      if (dispenserpresegmentwfcf)
          WFCF = dispenserpresegmentwfcf;
-     Report("IDS_Dispenser_SetPreSegmentWFCFValues ",__FILE__,__LINE__,dispenserpresegmentwfcf,RpWarning,(int)ids_presegment_wfcf_timebeforesegment,0);
+     ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetPreSegmentWFCFValues ",__FILE__,__LINE__,dispenserpresegmentwfcf,RpWarning,(int)ids_presegment_wfcf_timebeforesegment,0);
 
  }
  void IDS_Dispenser_SetPreSegmentCleaningValues(double ids_cleaningspeed,double ids_cleaningstartspraypresegmenttime ,double ids_cleaningstopbeforesegmenttime,double ids_leftcleaningmotorspeed,double ids_rightcleaningmotorspeed)
@@ -115,15 +121,16 @@ void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, doubl
      if ( ids_leftcleaningmotorspeed)
          LeftRockerSpeed = ids_leftcleaningmotorspeed;
      if ( ids_rightcleaningmotorspeed)
-         RighttRockerSpeed = ids_rightcleaningmotorspeed;
-     Report("IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,__LINE__,CleaningDispenserSpeed,RpWarning,(int)LeftRockerSpeed,0);
-     Report("IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,__LINE__,InterSegmentStartSprayCleaner,RpWarning,(int)InterSegmentCenterRockers,0);
-
+         RightRockerSpeed = ids_rightcleaningmotorspeed;
+     minimal_intersegment_length = ids_cleaningstopbeforesegmenttime+ids_cleaningstartspraypresegmenttime+2000;
+     ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,__LINE__,RightRockerSpeed,RpWarning,(int)LeftRockerSpeed,0);
+     ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,minimal_intersegment_length,InterSegmentStartSprayCleaner,RpWarning,(int)InterSegmentCenterRockers,0);
+     ReportWithPackageFilter(IDSFilter,"IDS_Dispenser actuator times ",__FILE__,(int)LeftRockerSpeed/100*IDS_PRESEGMENT_TIME_STEP,(int)LeftRockerSpeed%100*IDS_PRESEGMENT_TIME_STEP,RpWarning,(int)RightRockerSpeed*IDS_PRESEGMENT_TIME_STEP,0);
  }
 
  uint32_t DispenserPreSegmentControlId = 0xFF;
  uint32_t BrushStopControlId = 0xFF;
- uint32_t PreSegmentControlId = 0xFF;
+ //uint32_t PreSegmentControlId = 0xFF;
 
 /*uint32_t IDS_DispenserControlInit()
 {
@@ -136,7 +143,7 @@ void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, doubl
 
 uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request)
 {
-    int Dispenser_i,i;
+    /*int Dispenser_i,i;
     //int temp;
     for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
     {
@@ -171,11 +178,11 @@ uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request)
     DispenserControlConfig[Dispenser_i].m_preError = 0;
     DispenserControlConfig[Dispenser_i].m_SetParam = DispensersCtrl[Dispenser_i].outputproportionalcycletime;//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)
+/*uint32_t IDS_Pid_Testing_Func(uint32_t DispenserId, uint32_t ReadValue)
 {
     float calculated_speed;
     DispenserControlConfig[DispenserId].m_mesuredParam = MillisecGetPressures(DispenserId);
@@ -183,22 +190,22 @@ uint32_t IDS_Pid_Testing_Func(uint32_t DispenserId, uint32_t ReadValue)
                                                       &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);
+    ReportWithPackageFilter(IDSFilter,"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);
+    ReportWithPackageFilter(IDSFilter,"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);
-}
+    ReportWithPackageFilter(IDSFilter,"IDS_Stop_Pid_Testing ",__FILE__,__LINE__,DispenserId,RpWarning,(int)DispenserPidControlId[DispenserId],0);
+}*/
 /*
  * IDS Printing support
  * Prepare: build pressure in all participating dispensers
@@ -282,10 +289,10 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
                              SendJobProgress(0.0,0,false, "Processing file");
                              Control_WD(ENABLE,55);  //activate heaters/dispenser watchdog, 0.5 seconds
                          }
-                         if ((brushCounter % 1000)==0)
+                         if ((brushCounter % 1000)==900)
                          {
                              Task_sleep(200);
-                             Report("Sleep in file parsing",__FILE__, BrushStop->index, brushCounter, RpWarning,   Segment->brushstopscount, 0);
+                             ReportWithPackageFilter(IDSFilter,"Sleep in file parsing",__FILE__, BrushStop->index, brushCounter, RpWarning,   Segment->brushstopscount, 0);
                              Control_WD(ENABLE,55);  //activate heaters/dispenser watchdog, 0.5 seconds
                          }
                          brushCounter++;
@@ -323,7 +330,7 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
                          }//if dispensers
                          else
                          {
-                             LOG_ERROR (BrushStop->index, "no dispensers in brushstop");
+                             ReportWithPackageFilter(IDSFilter,"no dispensers in brushstop",__FILE__,__LINE__,(int)BrushStop->index,RpError,(int)BrushStop->n_dispensers,0);
                          }
                          if (FirstBrushStop!= BrushStop)
                              FreeBrushStopFileData(BrushStop);
@@ -331,7 +338,7 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
                      }
                      else
                      {
-                         LOG_ERROR (BrushStop, "malloc error");
+                         ReportWithPackageFilter(IDSFilter,"malloc error",__FILE__,__LINE__,(int)0,RpError,(int)0,0);
                          status = ERROR;
                      }
                  }//for brushstops
@@ -342,6 +349,11 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
          FreeSegmentFileData(Segment);
          CloseJobFile();
      }
+     else
+     {
+         ReportWithPackageFilter(IDSFilter,"Error Opening the file", __FILE__, __LINE__, Fresult, RpWarning,   0, 0);
+         return false;
+     }
      //GeneralHwReady = true;
      int ActiveDispensers = 0;
      for (Dispenser_i = 0; Dispenser_i < MAX_DYE_DISPENSERS; Dispenser_i++)
@@ -351,7 +363,7 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
              ActiveDispensers++;
          }
      }
-     Report("Finished checking the file", __FILE__, __LINE__, n_segments, RpWarning,   ActiveDispensers, 0);
+     ReportWithPackageFilter(IDSFilter,"Finished checking the file", __FILE__, __LINE__, n_segments, RpWarning,   ActiveDispensers, 0);
      return status;
 
  }
@@ -446,19 +458,24 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
  uint32_t DispenserPrepareControlId = 0xFF;
  int NumOfActiveDispensers = 0;
  int DispenserBuildTimeCounter = 0;
-#define PRESSURE_READ_TIME_GAP 100
+ double TargetNumberOfStepsPreRun,MaximalPressurePreRun;
+ int DispenserTotalPrepareSteps[MAX_SYSTEM_DISPENSERS];
+ bool DispenserLastMovementDown[MAX_SYSTEM_DISPENSERS];
+
+ #define PRESSURE_READ_TIME_GAP 100
+
 uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 {
     if (AutoHoming_Config >= AutoHoming_JobEnd_PowerOn_off)
     {
         if ((HomingActive[DispenserId] == false)&&(PrimingActive[DispenserId] == false))
         {
-            Report("Homing Inactive dispenser",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
+            ReportWithPackageFilter(IDSFilter,"Homing Inactive dispenser",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
             IDS_HomeDispenser (DispenserId, 1000 , NULL);
         }
         else
         {
-            Report("Inactive dispenser already homing",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
+            ReportWithPackageFilter(IDSFilter,"Inactive dispenser already homing",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
         }
     }
     return OK;
@@ -481,7 +498,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
          {
              if ((HomingActive[i] == false)&&(PrimingActive[i] == false))
              {
-                 Report("Inactive dispenser close valve",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+                 ReportWithPackageFilter(IDSFilter,"Inactive dispenser close valve",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
                  Control3WayValvesWithCallback (i, MidTank_Dispenser, InactiveDispenserHome); //direction: MidTank_Dispenser or Dispenser_Mixer
              }
          }
@@ -501,20 +518,54 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
       return OK; // all configured heaters are ready
   }
-  char IdsMessage[100];
+  //char IdsMessage[100];
+  char IdMessage[100];
   int SegmentPrepareWFCFCounter = 0;
   bool pressureReady = false,endOfPrepareWCF = false;
+
+bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,double pressure)
+{
+    TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[DispenserId];
+    float updatedSpeed,tempSpeed;
+
+    if (pressure > RefMaxPressure*1.03)
+    {
+            tempSpeed = CurrentDispenserSpeed[DispenserId];
+            //updatedSpeed = (tempSpeed * 0.992 > 100) ? tempSpeed * 0.992 : 100;
+            updatedSpeed = tempSpeed*0.98;
+            MotorSetSpeed(HW_Motor_Id, updatedSpeed);
+            CurrentDispenserSpeed[DispenserId] = updatedSpeed;
+            //ReportWithPackageFilter(IDSFilter,"IDS decrease speed",__FILE__,DispenserId,(int)updatedSpeed,RpWarning,(int)(pressure*100),0);
+            //return true; //ready
+    }
+    else if (pressure < RefMaxPressure*0.97)
+    {
+        tempSpeed = CurrentDispenserSpeed[DispenserId];
+        if (tempSpeed<50) tempSpeed = 50;
+        updatedSpeed = (tempSpeed * 1.02 < InitialDispenserSpeed) ? tempSpeed * 1.02 : InitialDispenserSpeed;
+        MotorSetSpeed(HW_Motor_Id, updatedSpeed);
+        CurrentDispenserSpeed[DispenserId] = updatedSpeed;
+        //ReportWithPackageFilter(IDSFilter,"IDS increase speed",__FILE__,DispenserId,(int)updatedSpeed,RpWarning,(int)(pressure*100),0);
+        //return false; //not ready
+    }
+    if ((pressure>RefMaxPressure)&&(pressure<(RefMaxPressure+0.1)))
+       return true;
+    return false;
+}
+
  //********************************************************************************************************************
  uint32_t IDS_Prepare_Callback(uint32_t DispenserId, uint32_t ReadValue)
  {
      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;
+     double pressure;
+     ModuleStateEnum result = ModuleDone;
+     bool DispenserReady[MAX_DYE_DISPENSERS] = {false,false,false,false,false,false};
 
      //REPORT_MSG((int)DispenserPrepareControlId, "Prepare Callback");
 
@@ -522,78 +573,93 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
      if (pressureReady == false)
      {
-         if (Special_Dispensers == false)
+         if (DispenserBuildTimeCounter<(2*eOneSecond))
          {
-             if (DispenserBuildTimeCounter<(2*eOneSecond))
+             for (i = 0; i < MAX_DYE_DISPENSERS; i++)
              {
-                 //REPORT_MSG(DispenserBuildTimeCounter,"waiting 2 seconds for pressure changes");
-                 return OK;
+                 DispenserTotalPrepareSteps[i]+=(CurrentDispenserSpeed[i]*PRESSURE_READ_TIME_GAP/eOneSecond);
+                 DispenserLastMovementDown[i] = false;
              }
+             //REPORT_MSG(DispenserBuildTimeCounter,"waiting 2 seconds for pressure changes");
+             return OK;
          }
          for (i = 0; i < MAX_DYE_DISPENSERS; i++)
          {
+             pressure = GetDispenserPressure(i);
              //IDS_StopHomeDispenser(i);
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
              {
+                 DispenserTotalPrepareSteps[i]+=(CurrentDispenserSpeed[i]*PRESSURE_READ_TIME_GAP/eOneSecond);
                  HW_Motor_Id = DispenserIdToMotorId[i];
-                 if (GetDispenserPressure(i) > DispenserPreparePressure*1.05)
+
+                 if (DispenserTotalPrepareSteps[i]<TargetNumberOfStepsPreRun)
                  {
-                     NumofReadyDispensers++;
-                     if (Special_Dispensers == true)
-                     {
-                         MotorStop(HW_Motor_Id, Hard_Hiz);
-                         CurrentDispenserSpeed[i] = 0;
-                     //Report("IDS stopped ready",__FILE__,i,(int)(DispenserPreparePressure*100),RpWarning,(int)NumofReadyDispensers,0);
-                     }
-                     else
-                     {
-                         tempSpeed = CurrentDispenserSpeed[i];
-                         updatedSpeed = (tempSpeed*0.992>100)?tempSpeed*0.992:100;
-                         MotorSetSpeed(HW_Motor_Id, updatedSpeed);
-                         CurrentDispenserSpeed[i] = updatedSpeed;
-                         //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
-                     }
+                     AdjustDispenserSpeedToPressure(i,MaximalPressurePreRun,pressure);
+                 }
+                 else if (pressure > DispenserPreparePressure*1.2)
+                 {
+                     MotorStop(HW_Motor_Id, Hard_Hiz);
+                     CurrentDispenserSpeed[i] = 1;
                  }
                  else
                  {
-                     if (Special_Dispensers == true)
+                     if (AdjustDispenserSpeedToPressure(i,DispenserPreparePressure,pressure) == true)
                      {
-                         tempSpeed = (DispenserPreparePressure-GetDispenserPressure(i))*InitialDispenserSpeed;
-                         if (tempSpeed<300)
-                             tempSpeed = 300;
+                         NumofReadyDispensers++;
+                         DispenserReady[i] = true;
                      }
-                     else
-                     {
-                         tempSpeed = CurrentDispenserSpeed[i];
-                     }
-                     updatedSpeed = (tempSpeed*1.03<InitialDispenserSpeed)?tempSpeed*1.03:InitialDispenserSpeed;
-                     MotorSetSpeed(HW_Motor_Id, updatedSpeed);
-                     CurrentDispenserSpeed[i] = updatedSpeed;
                  }
+                 //ReportWithPackageFilter(IDSFilter,"IDS prepare",__FILE__,i,(int)DispenserTotalPrepareSteps[i],RpWarning,(int)(CurrentDispenserSpeed[i]*100),0);
              }
+             else
+                 DispenserReady[i] = true;
+         }
+         pressure = GetDispenserPressure(CLEANER_DISPENSER);
+         if (pressure > 0.02)
+         {
+             HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
+             MotorStop(HW_Motor_Id, Hard_Hiz);
+             if (CurrentDispenserSpeed[CLEANER_DISPENSER])
+                 ReportWithPackageFilter(IDSFilter,"IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(pressure*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
+             CurrentDispenserSpeed[CLEANER_DISPENSER] = 0;
          }
 
          if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
          {
-             Report("IDS_Prepare_Callback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+             ReportWithPackageFilter(IDSFilter,"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);
+             ReportWithPackageFilter(IDSFilter,"pressureReady = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
          }
-         if ((DispenserBuildTimeCounter >= DispenserPrepareTimeout)||(pressureReady == true))
+         if (pressureReady == true)
          {
              DispenserBuildTimeCounter = 0;
+             ReportWithPackageFilter(IDSFilter,"pressureReady = true",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)(DispenserPreparePressure*100),0);
+         }
+         if (DispenserBuildTimeCounter >= DispenserPrepareTimeout)
+         {
+             endOfPrepareWCF = true;
+             result = ModuleFail;
+             JobEndReason = JOB_PRESSURE_ALARM;
+             usnprintf(AlarmReasonStr, 100, "IDS pressure timeout %d ",DispenserPrepareTimeout);
              pressureReady = true;
-             Report("pressureReady = true  or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+             ReportWithPackageFilter(IDSFilter,"pressure timeout!",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)(DispenserPreparePressure*100),0);
+             for (i = 0; i < MAX_DYE_DISPENSERS; i++)
+             {
+                 if (DispenserReady[i] == false) //we actually should check for all dispensers
+                 {
+                     AlarmHandlingSetAlarm (EVENT_TYPE__DISPENSER_1_UNDERPRESSURE+i,ON);  //handle alarm detection and operation
+                 }
+             }
          }
      }
      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);
+             ReportWithPackageFilter(IDSFilter,"start prepare dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
              if (FirstBrushStop)
              {
                  REPORT_MSG(FirstBrushStop->index,"WFCFBrushStopRead Index");
@@ -628,7 +694,6 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                          }
                          if (segmentfirst_speed > MINIMAL_MOTOR_SPEED)
                          {
-                             char IdMessage[100];
                              segmentfirst_speed *= (100+WFCF);
                              segmentfirst_speed /= 100;
                              DispenserSegmentReady[DispenserId] = false;
@@ -643,16 +708,16 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                              }
                              CurrentDispenserSpeed[Dispenser_i] = segmentfirst_speed;
 
-                             usnprintf(IdMessage, 80,
+                             /*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]->nanoliterperpulse*100),
                                        (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);
+                             ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
+                             //SendJobProgress(0.0, 0, false, IdsMessage);*/
                          }
                          else
                          {
@@ -660,11 +725,15 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                              {
                                  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);
+                                 //usnprintf(IdsMessage, 80,"WFCF Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
+                                 //ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
                              }
                          }
                      }//for
+                     usnprintf(IdMessage, 80,"WFCF %d D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",WFCF,CurrentDispenserSpeed[0],
+                               CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+                     ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, DispenserBuildTimeCounter, RpWarning,   WFCF, 0);
+
                  }//if n_dis
              }
          }
@@ -678,21 +747,28 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              endOfPrepareWCF = true;
              FreeBrushStopFileData(FirstBrushStop);
              FirstBrushStop =NULL;
-             Report("endOfPrepareWCF = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+             ReportWithPackageFilter(IDSFilter,"endOfPrepareWCF = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
 
          }
      }
      //start new stage
      if (endOfPrepareWCF == true)
      {
+         if (CurrentDispenserSpeed[CLEANER_DISPENSER])
+         {
+             HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
+             MotorStop(HW_Motor_Id, Hard_Hiz);
+             CurrentDispenserSpeed[CLEANER_DISPENSER] = 0;
+             ReportWithPackageFilter(IDSFilter,"IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(pressure*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
+         }
          SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
          DispenserPrepareControlId = 0xFF;
-         Report("IDS_Prepare_Callback SafeRemoveControlCallback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+         ReportWithPackageFilter(IDSFilter,"IDS_Prepare_Callback SafeRemoveControlCallback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
          setRapidPressureRead(false);
          pressureReady = false;
          endOfPrepareWCF = false;
          //DispenserPrepareReady();
-         PrepareReady(Module_IDS,ModuleDone);
+         PrepareReady(Module_IDS,result);
      }
      return OK;
  }
@@ -701,7 +777,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
  //********************************************************************************************************************
  uint32_t IDSPrepareState(void *JobDetails)
 {
-    int Motor_i, Pid_Id;
+    int Motor_i;
     //start IDS control for all motors
     IDS_Active = true;
     double cleanerFlow = 0;
@@ -710,45 +786,55 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
     JobTicket* JobTicket = JobDetails;
 
     JobEndSequence = false;
-    if ((pressurebuildup>0.1)&&(pressurebuildup<1.5))
+    if ((pressurebuildup>0.1)&&(pressurebuildup<4.5))
     {
-        Report("Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(pressurebuildup*100),RpWarning,(int)(DispenserPreparePressure*100),0);
+        ReportWithPackageFilter(IDSFilter,"Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(pressurebuildup*100),RpWarning,(int)(DispenserPreparePressure*100),0);
         DispenserPreparePressure = pressurebuildup;
     }
-    if (JobTicket->headcleaningparameters->has_cleanerflow)
-            cleanerFlow =  JobTicket->headcleaningparameters->cleanerflow;
+    if (JobTicket->headcleaningparameters)
+    {
+        if (JobTicket->headcleaningparameters->has_cleanerflow)
+                cleanerFlow =  JobTicket->headcleaningparameters->cleanerflow;
+    }
     if ((cleanerFlow>200)&&(cleanerFlow<1150))
     {
-        Report("Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(cleanerFlow),RpWarning,(int)CleaningDispenserSpeed,0);
+        ReportWithPackageFilter(IDSFilter,"Setting cleanerFlow from RML cleanerFlow",__FILE__,__LINE__,(int)(cleanerFlow),RpWarning,(int)CleaningDispenserSpeed,0);
         CleaningDispenserSpeed = cleanerFlow;
     }
+    else if (cleanerFlow <= 10)
+    {
+        CleaningDispenserSpeed = 0;
+        EnableCleaning = false;
+    }
+    TargetNumberOfStepsPreRun = InitialDispenserTimeout;
+    MaximalPressurePreRun = InitialDispenserPressure;
 
     for (Motor_i = 0;Motor_i < MAX_SYSTEM_DISPENSERS;Motor_i++)
     {
         TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[Motor_i];
-        Pid_Id = Motor_i;/*IDSMotorIdToControlId[Motor_i];*/
-            DispenserControlConfig[Motor_i].m_params.MAX = 1;
-            DispenserControlConfig[Motor_i].m_params.MIN = DispensersControl[Pid_Id].outputproportionalpowerlimit*-1;
-            DispenserControlConfig[Motor_i].m_params.Kd = DispensersControl[Pid_Id].derivativetime;
-            DispenserControlConfig[Motor_i].m_params.Kp = DispensersControl[Pid_Id].proportionalgain;
-            DispenserControlConfig[Motor_i].m_params.Ki = DispensersControl[Pid_Id].integraltime;
-            DispenserControlConfig[Motor_i].m_params.epsilon = 0.01;
-            DispenserControlConfig[Motor_i].m_params.dt = eHundredMillisecond;
-            DispenserControlConfig[Motor_i].m_calculatedError = 0;
-            DispenserControlConfig[Motor_i].m_integral = 0;
-            DispenserControlConfig[Motor_i].m_isEnabled = true;
-            DispenserControlConfig[Motor_i].m_isReady = true;
-            DispenserControlConfig[Motor_i].m_mesuredParam = 0;
-            DispenserControlConfig[Motor_i].m_preError = 0;
-            DispenserControlConfig[Motor_i].m_SetParam = 0;//need to update SetParams on presegment stage
-
-            MotorSetDirection((TimerMotors_t)HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize); //set the dispenser to the
-            /*Start the dispensers to build initial pressure
-             * check different handling for dispensers that participate in the first segment and idle dispensers
-             * start control for initial pressure
-             *
-             */
-            //ValveCommand (Enable,MixerDirection);
+        /*Pid_Id = Motor_i;//IDSMotorIdToControlId[Motor_i];
+        DispenserControlConfig[Motor_i].m_params.MAX = 1;
+        DispenserControlConfig[Motor_i].m_params.MIN = DispensersControl[Pid_Id].outputproportionalpowerlimit*-1;
+        DispenserControlConfig[Motor_i].m_params.Kd = DispensersControl[Pid_Id].derivativetime;
+        DispenserControlConfig[Motor_i].m_params.Kp = DispensersControl[Pid_Id].proportionalgain;
+        DispenserControlConfig[Motor_i].m_params.Ki = DispensersControl[Pid_Id].integraltime;
+        DispenserControlConfig[Motor_i].m_params.epsilon = 0.01;
+        DispenserControlConfig[Motor_i].m_params.dt = eHundredMillisecond;
+        DispenserControlConfig[Motor_i].m_calculatedError = 0;
+        DispenserControlConfig[Motor_i].m_integral = 0;
+        DispenserControlConfig[Motor_i].m_isEnabled = true;
+        DispenserControlConfig[Motor_i].m_isReady = true;
+        DispenserControlConfig[Motor_i].m_mesuredParam = 0;
+        DispenserControlConfig[Motor_i].m_preError = 0;
+        DispenserControlConfig[Motor_i].m_SetParam = 0;//need to update SetParams on presegment stage
+        */
+        MotorSetDirection((TimerMotors_t)HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize); //set the dispenser to the
+        /*Start the dispensers to build initial pressure
+         * check different handling for dispensers that participate in the first segment and idle dispensers
+         * start control for initial pressure
+         *
+         */
+        //ValveCommand (Enable,MixerDirection);
     }
 
     if (HeaterCheckReady() == true)
@@ -766,7 +852,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
      if (IDS_Active == false)
      {
-         LOG_ERROR(IDS_Active,"IDSPrepareStart Not in a job");
+         ReportWithPackageFilter(IDSFilter,"IDSPrepareStart Not in a job",__FILE__,__LINE__,(int)0,RpError,(int)0,0);
          return;
      }
 
@@ -782,9 +868,11 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              NumOfActiveDispensers++;
              if (HomingActive[i] == true)
              {
-                 Report("Stop active dispenser homing ",__FILE__,i,HomingActive[i],RpWarning,CurrentDispenserSpeed[i],0);
+                 ReportWithPackageFilter(IDSFilter,"Stop active dispenser homing ",__FILE__,i,HomingActive[i],RpWarning,CurrentDispenserSpeed[i],0);
                  IDS_StopHomeDispenser(i);
              }
+             DispenserTotalPrepareSteps[i] = 0;
+             ReportWithPackageFilter(IDSFilter,"Dispenser total prepare steps zero",__FILE__,i,DispenserTotalPrepareSteps[i],RpWarning,IDS_Dispenser_Data[i].consumedinnanolitter,0);
          }
          else
          {
@@ -792,14 +880,22 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              {
                  if ((HomingActive[i] == false)&&(PrimingActive[i] == false))
                  {
-                     Report("Homing Inactive dispenser",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
-                     IDS_HomeDispenser (i, 1000 , NULL);
+                     ReportWithPackageFilter(IDSFilter,"Homing Inactive dispenser",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+                     if (IDS_HomeDispenser (i, 1000 , NULL) == ERROR)
+                         Control3WayValvesWithCallback (i, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer;
                  }
                  else
                  {
-                     Report("Inactive dispenser already homing",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+                     ReportWithPackageFilter(IDSFilter,"Inactive dispenser already homing",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
                  }
              }
+#ifdef DISPENSER_VALVES_OPEN
+             else  // turn inactive dispenser valve toward the midtank during job
+             {
+                 if (HomingActive[i] == false)
+                     Control3WayValvesWithCallback ((Valves_t)i, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+             }
+#endif
          }
      }
      if (NumOfActiveDispensers)
@@ -818,7 +914,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              {
                  //if (HomingActive[i] == false)
                  {
-                     Report("Prepare Speed",__FILE__,HomingActive[i],i,RpWarning,(int)dispenserspeed,0);
+                     ReportWithPackageFilter(IDSFilter,"Prepare Speed",__FILE__,HomingActive[i],i,RpWarning,(int)dispenserspeed,0);
                      MotorSetDirection((TimerMotors_t)HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize); //set the dispenser to the
                      if (Special_Dispensers == true)
                      {
@@ -831,11 +927,17 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  }
                  /*else
                  {
-                     Report("IDSPrepare Stop Dispenser Homing",__FILE__,__LINE__,i,RpWarning,(int)HomingActive[i],0);
+                     ReportWithPackageFilter(IDSFilter,"IDSPrepare Stop Dispenser Homing",__FILE__,__LINE__,i,RpWarning,(int)HomingActive[i],0);
                      IDS_HomeDispenserWaitForHomingEnd(i,  DispenserPrepareTimeout/2 , IDSPrepareStartDispenserAfterHoming);
                  }*/
              }
          }
+         TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
+         MotorSetSpeed((TimerMotors_t)HW_Motor_Id,INITIAL_CLEANER_SPEED ); //set the dispenser to the
+         CurrentDispenserSpeed[CLEANER_DISPENSER] = INITIAL_CLEANER_SPEED;
+         ReportWithPackageFilter(IDSFilter,"IDS start cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
+
+
      }
      DispenserBuildTimeCounter = 0;
      DispenserPrepareControlId = AddControlCallback(NULL, IDS_Prepare_Callback, PRESSURE_READ_TIME_GAP,TemplateDataReadCBFunction ,0, 0, 0 );
@@ -847,7 +949,6 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
  //********************************************************************************************************************
 
  JobDescriptionFileBrushStop * FileBrushStop;
- char IdsMessage[100];
 
  //********************************************************************************************************************
   uint32_t IDS_PreSegmentPrepare_Callback(uint32_t DispenserId, uint32_t ReadValue)
@@ -859,7 +960,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
       float updatedSpeed,tempSpeed;
       //REPORT_MSG((int)DispenserPrepareControlId, "Prepare Callback");
 
-      DispenserBuildTimeCounter+=PRESSURE_READ_TIME_GAP;
+      DispenserBuildTimeCounter+=IDS_PRESEGMENT_TIME_STEP;
 
       if (DispenserBuildTimeCounter<(1*eOneSecond))
       {
@@ -886,7 +987,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                   updatedSpeed = (tempSpeed*0.98>100)?tempSpeed*0.98:100;
                   MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                   CurrentDispenserSpeed[i] = updatedSpeed;
-                  //Report("IDS PreSegment reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+                  //ReportWithPackageFilter(IDSFilter,"IDS PreSegment reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
               }
               else
               {
@@ -894,20 +995,20 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                   updatedSpeed = (tempSpeed*1.04<1100)?tempSpeed*1.04:1100;
                   MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                   CurrentDispenserSpeed[i] = updatedSpeed;
-                  //Report("IDS PreSegment accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+                  //ReportWithPackageFilter(IDSFilter,"IDS PreSegment accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
               }
           }
       }
 
       if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
-          Report("IDS_PreSegmentPrepare_Callback",__FILE__,DispenserBuildTimeCounter,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
+          ReportWithPackageFilter(IDSFilter,"IDS_PreSegmentPrepare_Callback",__FILE__,DispenserBuildTimeCounter,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
 
       if (NumofReadyDispensers>=NumOfActiveDispensers)
           pressureReady = true;
 
       if ((DispenserBuildTimeCounter >= DispenserPrepareTimeout)||(pressureReady == true))
       {
-          Report("IDS_PreSegmentPrepare_Callback SafeRemoveControlCallback",__FILE__,DispenserPrepareControlId,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
+          ReportWithPackageFilter(IDSFilter,"IDS_PreSegmentPrepare_Callback SafeRemoveControlCallback",__FILE__,DispenserPrepareControlId,InterSegmentStepsCount,RpWarning,(int)NumOfActiveDispensers,0);
           SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
           DispenserPrepareControlId = 0xFF;
           PreSegmentWCFStarted = true;
@@ -930,7 +1031,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
      }
      if (FileBrushStop)
      {
-         Report("start dispensers pre segment pressure build",__FILE__,__LINE__,FileBrushStop->index,RpWarning,(int)FileBrushStop->n_dispensers,0);
+         ReportWithPackageFilter(IDSFilter,"start dispensers pre segment pressure build",__FILE__,__LINE__,FileBrushStop->index,RpWarning,(int)FileBrushStop->n_dispensers,0);
          NumOfActiveDispensers = FileBrushStop->n_dispensers;
          Dispensers = FileBrushStop->dispensers;
          n_dispensers = FileBrushStop->n_dispensers;
@@ -955,9 +1056,9 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                      DispenserUsedInSegment[Dispenser_i] = true;
                      MotorSetSpeed(HW_Motor_Id, DispenserPrepareSpeed);
                      CurrentDispenserSpeed[Dispenser_i] = DispenserPrepareSpeed;
-                     usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d speed %d",DispenserId,(int) DispenserPrepareSpeed);
+                     //usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d speed %d",DispenserId,(int) DispenserPrepareSpeed);
                      //REPORT_MSG(segmentfirst_speed,IdsMessage);
-                     Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   DispenserPrepareSpeed, 0);
+                     //ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   DispenserPrepareSpeed, 0);
                      //SendJobProgress(0.0, 0, false, IdsMessage);
                  }
                  else
@@ -973,13 +1074,17 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                              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);
+                         //usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
+                         //ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
                      }
                  }
-             }
+             }//for
+             usnprintf(IdMessage, 80,"Presegment Prepare D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",CurrentDispenserSpeed[0],
+                       CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+             ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
+
              DispenserBuildTimeCounter = 0;
-             //DispenserPrepareControlId = AddControlCallback( IDS_PreSegmentPrepare_Callback, PRESSURE_READ_TIME_GAP,TemplateDataReadCBFunction ,0, 0, 0 );
+             //DispenserPrepareControlId = AddControlCallback( IDS_PreSegmentPrepare_Callback, IDS_PRESEGMENT_TIME_STEP,TemplateDataReadCBFunction ,0, 0, 0 );
              setRapidPressureRead(true);
 
          }
@@ -1018,7 +1123,6 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
 
 //********************************************************************************************************************
-
  uint32_t IDSPreSegmentStateCallbackRunner(uint32_t IfIndex, uint32_t ReadValue)
  {
      JobDispenser **Dispensers;
@@ -1056,34 +1160,47 @@ uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr
 uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
 */
      //InterSegmentStepsLimit = lInterSegmentLength*10;//100 millisec steps
-     InterSegmentStepsCount+=100;
+     InterSegmentStepsCount+=IDS_PRESEGMENT_TIME_STEP;
      if (InterSegmentStepsCount >= lInterSegmentLength)
      {
          //IDS_Valve_PresegmentReady(1,0);
-         Report("End of Pre-segment Handling",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+         ReportWithPackageFilter(IDSFilter,"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 (JobEndSequence == true)
-             DistanceToSpoolReady(Module_IDS,ModuleDone);
+         //if (JobEndSequence == true)
+         //    DistanceToSpoolReady(Module_IDS,ModuleDone);
      }
      if (EnableCleaning == true)
      {
          if (( InterSegmentStartSprayCleaner )&&(InterSegmentStartSprayCleaner == InterSegmentStepsCount))
          {
-             Report("Start Spray Cleaner",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+             ReportWithPackageFilter(IDSFilter,"Start Spray Cleaner",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
              IDS_Cleaning_Spray_Cleaning_Solution (CleaningDispenserSpeed,NULL);
          }
          /*if (InterSegmentStartRocking == InterSegmentStepsCount)
          {
-             Report("Start cleaning rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+             ReportWithPackageFilter(IDSFilter,"Start cleaning rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
              //IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed);
          }*/
+         if (( InterSegmentStartSprayCleaner )&&
+            ((InterSegmentStepsCount>InterSegmentStartSprayCleaner)&&(InterSegmentStepsCount<(lInterSegmentLength-InterSegmentCenterRockers) )))
+         {
+             if (ActuatorsCleaningSequence)
+                 IDS_Cleaning_Move_Actuators();
+         }
+         if (( InterSegmentCenterRockers)&&(InterSegmentCenterRockers == (lInterSegmentLength-InterSegmentStepsCount-2000)))
+         {
+             if(Head_Type == HEAD_TYPE_ARC)
+             {
+                 MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DH_LID,Soft_Stop);
+             }
+         }
          if (( InterSegmentCenterRockers)&&(InterSegmentCenterRockers == (lInterSegmentLength-InterSegmentStepsCount)))
          {
-             Report("Stop spray and center rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+             ReportWithPackageFilter(IDSFilter,"Stop spray and center rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
              IDS_Cleaning_Stop_Cleaning_Solution (NULL);
              //IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback);
          }
@@ -1105,7 +1222,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
      }
      if ((InterSegmentStartWFCFDispensers > 0)&&(InterSegmentStartWFCFDispensers == InterSegmentStepsCount))
      {
-         Report("start dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+         ReportWithPackageFilter(IDSFilter,"start dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
          PreSegmentWCFStarted = true; // stop any presegment prepare stages, if still exist
          PreSegmentPrepareStarted = false;
          setRapidPressureRead(false);
@@ -1143,7 +1260,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                      }
                      if (segmentfirst_speed > MINIMAL_MOTOR_SPEED)
                      {
-                         char IdMessage[100];
+                         //char IdMessage[100];
                          segmentfirst_speed *= (100+WFCF);
                          segmentfirst_speed /= 100;
                          DispenserSegmentReady[DispenserId] = false;
@@ -1152,7 +1269,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                          MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
                          CurrentDispenserSpeed[Dispenser_i] = segmentfirst_speed;
 
-                         usnprintf(IdMessage, 80,
+                         /*usnprintf(IdMessage, 80,
                                    "WFCF Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d",
                                    DispenserId,
                                    (int) Dispensers[Dispenser_i]->nanolitterpersecond,
@@ -1160,10 +1277,13 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                                    (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);
+                         ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
+                         //SendJobProgress(0.0, 0, false, IdsMessage);*/
                      }
-                 }
+                 }//for
+                 usnprintf(IdMessage, 80,"Presegment WFCF %d D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",WFCF,CurrentDispenserSpeed[0],
+                           CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+                 ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, FileBrushStop->index, RpWarning,   lInterSegmentLength, 0);
              }
          }
          //startDispensersAtSegmentSpeed*1=WFCFClenerSpray(speed);
@@ -1181,14 +1301,18 @@ uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
     uint32_t status = OK;
     JobDescriptionFileBrushStop * tFileBrushStop;
     int Brush_i;
+    Task_Stat statbuf;
 
 //check and close previous segment
+    RemoveControlCallback(BrushStopControlId,IDSBrushStopRestartCallback);
+    BrushStopControlId = 0xFF;
     if (PrevSegment)
     {
         if (JobBrushStopId<PrevSegment->brushstopscount) //we did not finish reading the brushstops of the previous segment
         {
-            Report("Unhandled brushstops remained",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)PrevSegment->brushstopscount,0);
+            ReportWithPackageFilter(IDSFilter,"Unhandled brushstops remained",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)PrevSegment->brushstopscount,0);
             //REPORT_MSG (Segment->brushstopscount, "Segment->brushstopscount");
+            //for (Brush_i=JobBrushStopId;Brush_i<PrevSegment->brushstopscount;Brush_i++) #bug 3348 - unhandled jobstops stops too soon
             for (Brush_i=JobBrushStopId;Brush_i<PrevSegment->brushstopscount;Brush_i++)
             {
                 if (status == ERROR)
@@ -1197,17 +1321,23 @@ uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
                 if (tFileBrushStop)
                 {
                     FreeBrushStopFileData(tFileBrushStop);
-                    Report("Unhandled brushstops handled",__FILE__,__LINE__,(int)Brush_i,RpWarning,(int)PrevSegment->brushstopscount,0);
+                    ReportWithPackageFilter(IDSFilter,"Unhandled brushstops handled",__FILE__,__LINE__,(int)Brush_i,RpWarning,(int)PrevSegment->brushstopscount,0);
                 }
                 else
                 {
+                    Task_stat(Task_self(),&statbuf);
+                    ReportWithPackageFilter(IDSFilter,"Unhandled BrushStopRead Error",__FILE__,statbuf.used,(int)statbuf.stackSize,RpWarning,(int)statbuf.stackHeap,0);
+                    //JobEndReason = JOB_OUT_OF_DYE;
+                    //SegmentReady(Module_IDS,ModuleFail);
+                    ReportWithPackageFilter(IDSFilter,"Unhandled brushstops ERROR",__FILE__,__LINE__,(int)tFileBrushStop,RpWarning,(int)PrevSegment->brushstopscount,0);
                     status = ERROR;
                     break;
                 }
             }//for brushstops
         }
     }
-    return status;
+    ReportWithPackageFilter(IDSFilter,"Unhandled brushstops result",__FILE__,__LINE__,(int)Brush_i,RpWarning,(int)PrevSegment->brushstopscount,0);
+    return OK;
 }
 uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
 {
@@ -1223,11 +1353,12 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
     /* wait for all dispensers  to get to the required pressure
      * move the presegment ready when all dispensers are ready.
      */
-    REPORT_MSG(Segment->n_brushstops,"IDSPreSegmentState");
+    ReportWithPackageFilter(IDSFilter,"IDSPreSegmentState",__FILE__,__LINE__,(int)Segment->n_brushstops,RpError,(int)SegmentId,0);
     if (JobBrushStopId>=Segment->n_brushstops)
     {
-        LOG_ERROR(Segment->n_brushstops,"Error JobBrushStopId");
+        ReportWithPackageFilter(IDSFilter,"Error JobBrushStopId",__FILE__,__LINE__,(int)Segment->n_brushstops,RpError,(int)0,0);
         JobEndReason = JOB_OUT_OF_DYE;
+        usnprintf(AlarmReasonStr, 100, "IDS brushstop error %d above %d ",JobBrushStopId,Segment->n_brushstops);
         PreSegmentReady(Module_IDS,ModuleFail);
         return ERROR;
     }
@@ -1242,15 +1373,19 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
         if (SegmentId>0)
         {
             lInterSegmentLength = ((IntersegmentLength*100)*1000/dyeingspeed);
+
             lInterSegmentLength-=(lInterSegmentLength%100);   //round to a 100 multiplication
             InterSegmentStepsCount = 0;
-            DispenserPreSegmentControlId = AddControlCallback(NULL,IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
-            if (DispenserPreSegmentControlId == 0xFF)
+            if (minimal_intersegment_length<((IntersegmentLength*100)*1000/dyeingspeed))
             {
-                Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
-                return ERROR;
+                DispenserPreSegmentControlId = AddControlCallback(NULL,IDSPreSegmentStateCallbackRunner, IDS_PRESEGMENT_TIME_STEP,TemplateDataReadCBFunction ,0, 0, 0 );
+                if (DispenserPreSegmentControlId == 0xFF)
+                {
+                    ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
+                    return ERROR;
+                }
+                ReportWithPackageFilter(IDSFilter,"Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
             }
-            Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
             /*if (EnableCleaning == true)
             {
                 InterSegmentStartSprayCleaner = 500;
@@ -1277,13 +1412,13 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
         lInterSegmentLength = (dryerbufferCentimeters*1000/dyeingspeed);
         lInterSegmentLength-=(lInterSegmentLength%100);   //round to a 100 multiplication
         InterSegmentStepsCount = 0;
-        DispenserPreSegmentControlId = AddControlCallback( IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
+        DispenserPreSegmentControlId = AddControlCallback( IDSPreSegmentStateCallbackRunner, IDS_PRESEGMENT_TIME_STEP,TemplateDataReadCBFunction ,0, 0, 0 );
         if (DispenserPreSegmentControlId == 0xFF)
         {
-            Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
+            ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
             return ERROR;
         }
-        Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
+        ReportWithPackageFilter(IDSFilter,"Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
         if (EnableCleaning == true)
         {
             InterSegmentStartSprayCleaner = 500;
@@ -1314,8 +1449,9 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
         }
         else
         {
-            LOG_ERROR(FileBrushStop,"End run - BrushStopReadError");
+            ReportWithPackageFilter(IDSFilter,"End run - BrushStopReadError",__FILE__,__LINE__,(int)FileBrushStop,RpError,(int)0,0);
             JobEndReason = JOB_OUT_OF_DYE;
+            usnprintf(AlarmReasonStr, 100, "IDS brushstop read error");
             PreSegmentReady(Module_IDS,ModuleFail);
         }
     }
@@ -1396,7 +1532,7 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
     int Dispenser_i,DispenserId;
     TimerMotors_t HW_Motor_Id;
     double segmentfirst_speed;
-    Report("IDS_StartBrushStop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)0,0);
+    //ReportWithPackageFilter(IDSFilter,"IDS_StartBrushStop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)0,0);
 
     if (n_dispensers)
     {
@@ -1441,7 +1577,7 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                     MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
                 }
                 CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
-                usnprintf(IdsMessage, 80,
+                /*usnprintf(IdsMessage, 80,
                           "Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d steps %d/%d",
                           DispenserId,
                           (int) Dispensers[Dispenser_i]->nanolitterpersecond,
@@ -1449,8 +1585,8 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                           (int) Dispensers[Dispenser_i]->pulsepersecond*1000,
                           (int) (segmentfirst_speed*1000),Dispensers[Dispenser_i]->dispenserstepdivision,MotorsCfg[HW_Motor_Id].microstep);
                 //REPORT_MSG(segmentfirst_speed,IdsMessage);
-                Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
-                //SendJobProgress(0.0, 0, false, IdsMessage);
+                ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
+                //SendJobProgress(0.0, 0, false, IdsMessage);*/
             }
             else
             {
@@ -1468,10 +1604,14 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                     }
                     CurrentDispenserSpeed[DispenserId] = 0;
                 }
-                //Report("inActive dispenser stopped", __FILE__, __LINE__, DispenserId, RpWarning,   segmentfirst_speed, 0);
+                //ReportWithPackageFilter(IDSFilter,"inActive dispenser stopped", __FILE__, __LINE__, DispenserId, RpWarning,   segmentfirst_speed, 0);
             }
-        }
+        } //for
     }
+    usnprintf(IdMessage, 80,"IDS_StartBrushStop %d D1 %d,D2 %d,D3 %d,D4 %d,D5 %d",WFCF,CurrentDispenserSpeed[0],
+              CurrentDispenserSpeed[1],CurrentDispenserSpeed[2],CurrentDispenserSpeed[3],CurrentDispenserSpeed[4]);
+    ReportWithPackageFilter(IDSFilter,IdMessage, __FILE__, __LINE__, FileBrushStop->index, RpWarning,n_dispensers, 0);
+
 }
 uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
 {
@@ -1481,20 +1621,25 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
     Task_Stat statbuf;
     if(BrushStopStartTime+BrushStopLength+100 < msec_millisecondCounter   )
     {
-        Report("!!!!!!!!!!!!Overtime!",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
+       ReportWithPackageFilter(IDSFilter,"!!!!!!!!!!!!Overtime!",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
     }
 
-    if(BrushStopCounter++ <  BrushStopTime)
+    if(++BrushStopCounter <  BrushStopTime)
     {
         return OK;
     }
     BrushStopCounter = 0;
     BrushStopStartTime = msec_millisecondCounter;
 
+    if (BrushStopControlId == 0xFF)
+    {
+        ReportWithPackageFilter(IDSFilter,"!!!BrushStopControlId = 0xFF",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
+        return OK;
+    }
 
     if (JobEndSequence == true)
     {
-        Report("JobEndSequence",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0);
+        ReportWithPackageFilter(IDSFilter,"JobEndSequence",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0);
         SafeRemoveControlCallback(BrushStopControlId,IDSBrushStopRestartCallback);
         BrushStopControlId = 0Xff;
         return OK;
@@ -1513,13 +1658,15 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
         {
             Task_stat(Control_Task_Handle,&statbuf);
             //REPORT_MSG(FileBrushStop->index,"BrushStopRead Index");
-            Report("BrushStopRead Index",__FILE__,BrushStopTime,(int)FileBrushStop->index,RpWarning,(int)BrushStopStartTime,0);
+            //ReportWithPackageFilter(IDSFilter,"BrushStopRead Index",__FILE__,BrushStopTime,(int)FileBrushStop->index,RpWarning,(int)BrushStopStartTime,0);
             Dispensers = FileBrushStop->dispensers;
             n_dispensers = FileBrushStop->n_dispensers;
         }
         else
         {
-            LOG_ERROR(FileBrushStop,"BrushStopReadError");
+            Task_stat(Task_self(),&statbuf);
+            ReportWithPackageFilter(IDSFilter,"BrushStopRead Error",__FILE__,statbuf.used,(int)statbuf.stackSize,RpWarning,(int)statbuf.stackHeap,0);
+            usnprintf(AlarmReasonStr, 100, "IDS brushstop error");
             JobEndReason = JOB_OUT_OF_DYE;
             SegmentReady(Module_IDS,ModuleFail);
         }
@@ -1529,10 +1676,10 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
         IDS_StartBrushStop(n_dispensers, Dispensers);
     }
     JobBrushStopId++;
-    Report("brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0);
+    ReportWithPackageFilter(IDSFilter,"brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpMessage,(int)SegmentNumOfBrushStops,0);
     if (JobBrushStopId >= SegmentNumOfBrushStops)
     {
-        Report("last brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0);
+        ReportWithPackageFilter(IDSFilter,"last brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0);
         SafeRemoveControlCallback(BrushStopControlId,IDSBrushStopRestartCallback);
         BrushStopControlId = 0Xff;
     }
@@ -1546,7 +1693,7 @@ 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);
+    ReportWithPackageFilter(IDSFilter,"IDSSegmentState set valve after 1 second",__FILE__,__LINE__,(int)0,RpWarning,(int)0,0);
     return OK;
 }
 #endif
@@ -1562,12 +1709,13 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
 #else
      Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
 #endif
-     IDS_Cleaning_Stop_Cleaning_Solution(NULL);
+     if (CurrentDispenserSpeed[CLEANER_DISPENSER]>0)
+         IDS_Cleaning_Stop_Cleaning_Solution(NULL);
      SegmentNumOfBrushStops = Segment->n_brushstops;
      BrushStopTime = Segment->length*1000/(double)SegmentNumOfBrushStops;  //brushstop in meters //brushstop in millisecond
      BrushStopTime = ((BrushStopTime*100)/dyeingspeed);//brushstop in seconds
      //BrushStopTime *= 1000;
-     Report("IDSSegmentState bss time, num of bss",__FILE__,__LINE__,(int)(BrushStopTime),RpWarning,(int)SegmentNumOfBrushStops,0);
+     ReportWithPackageFilter(IDSFilter,"IDSSegmentState bss time, num of bss",__FILE__,__LINE__,(int)(BrushStopTime),RpWarning,(int)SegmentNumOfBrushStops,0);
      if (uploadstrategy == JOB_UPLOAD_STRATEGY__Default)
      {
          Dispensers = Segment->brushstops[JobBrushStopId]->dispensers;
@@ -1582,14 +1730,13 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          }
          else
          {
-             LOG_ERROR(FileBrushStop,"BrushStopReadError");
+             ReportWithPackageFilter(IDSFilter,"BrushStopRead Error",__FILE__,__LINE__,(int)FileBrushStop,RpError,(int)0,0);
          }
      }
 //handle ending of presegment
     if (DispenserPreSegmentControlId != 0xFF)
     {
-        Report("IDS presegment not yet ended!!",__FILE__,__LINE__,(int)InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
-        //IDS_Cleaning_Stop_Cleaning_Solution (NULL);
+        ReportWithPackageFilter(IDSFilter,"IDS presegment not yet ended!!",__FILE__,DispenserPreSegmentControlId,(int)InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
         RemoveControlCallback(DispenserPreSegmentControlId, IDSPreSegmentStateCallbackRunner );
         DispenserPreSegmentControlId = 0xFF;
     }
@@ -1598,16 +1745,16 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
     JobBrushStopId++;
     if ((BrushStopTime)&&(SegmentNumOfBrushStops > 1))
     {
-        BrushStopCounter = BrushStopTime+3; //move the IDS brush stop handling to highest priority in timing
+        //BrushStopCounter = BrushStopTime+3; //move the IDS brush stop handling to highest priority in timing
         BrushStopControlId = AddControlCallback(NULL, IDSBrushStopRestartCallback, eOneMillisecond,TemplateDataReadCBFunction ,SegmentDetails, 0, 0 );
         BrushStopStartTime = msec_millisecondCounter;
         BrushStopLength = BrushStopTime;
         if (BrushStopControlId == 0xFF)
         {
-            Report("Add control callback failed",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)0,0);
+            ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)0,0);
             return ERROR;
         }
-        Report("Add control callback ",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)n_dispensers,0);
+        ReportWithPackageFilter(IDSFilter,"Add control callback ",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)n_dispensers,0);
 
     }
     else
@@ -1648,7 +1795,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
  //********************************************************************************************************************
  uint32_t IDSDistanceToSpoolState(void)
  {
-     int Dispenser_i;
+     int Dispenser_i, dispenserCount = 0 ;
 
      REPORT_MSG(NumOfActiveDispensers,"Dispenser DTS");
      Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste);  //#bug 323
@@ -1658,6 +1805,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
              if (DispenserUsedInJob[Dispenser_i]==true)//unconfigured dispenser
              {
                  DispenserDistanceToSpoolReady[Dispenser_i] = false;
+                 dispenserCount++;
                  if (Special_Dispensers == true)
                  {
                      IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
@@ -1671,6 +1819,9 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
                  //IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_DistanceToSpoolValveReady);
              }
          }
+         if (dispenserCount == 0)
+             DistanceToSpoolReady(Module_IDS,ModuleDone);
+
 
          //cleaning
          if (FileBrushStop)
@@ -1680,13 +1831,13 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          lInterSegmentLength = (dryerbufferCentimeters*1000/dyeingspeed);
          lInterSegmentLength-=(lInterSegmentLength%100);   //round to a 100 multiplication
          InterSegmentStepsCount = 0;
-         DispenserPreSegmentControlId = AddControlCallback("IDS DTS", IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
+         DispenserPreSegmentControlId = AddControlCallback("IDS DTS", IDSPreSegmentStateCallbackRunner, IDS_PRESEGMENT_TIME_STEP,TemplateDataReadCBFunction ,0, 0, 0 );
          if (DispenserPreSegmentControlId == 0xFF)
          {
-             Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
+             ReportWithPackageFilter(IDSFilter,"Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
              return ERROR;
          }
-         Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
+         ReportWithPackageFilter(IDSFilter,"Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
          /*if (EnableCleaning == true)
          {
              InterSegmentStartSprayCleaner = 500;
@@ -1706,10 +1857,11 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      //MotorStop(HW_Motor_Id,Hard_Hiz);
      if (AutoHoming_Config >= AutoHoming_JobEnd_PowerOn_off)
      {
-         Report("IDS_Valve_EndValveReady start homing",__FILE__,deviceID,(int)AutoHoming_Config,RpWarning,(int)AutoHoming_JobEnd_PowerOn_off,0);
-
-         //if (deviceID!=LUBRICANT_DISPENSER)
-         IDS_HomeDispenser (deviceID, 1000 , NULL);
+         if (deviceID!=LUBRICANT_DISPENSER)
+         {
+             ReportWithPackageFilter(IDSFilter,"IDS_Valve_EndValveReady start homing",__FILE__,deviceID,(int)AutoHoming_Config,RpWarning,(int)AutoHoming_JobEnd_PowerOn_off,0);
+             IDS_HomeDispenser (deviceID, 1000 , NULL);
+         }
      }
      return OK;
  }
@@ -1740,12 +1892,13 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          DispenserPreSegmentControlId = 0xFF;
      }
 
-     IDS_Dispenser_Store_Data ();
+     //IDS_Dispenser_Store_Data ();
 
      for ( Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
      {
          if (DispenserUsedInJob[Dispenser_i] == true)
          {
+             AlarmHandlingSetAlarm (EVENT_TYPE__DISPENSER_1_UNDERPRESSURE+Dispenser_i,OFF);  //handle alarm detection and operation
              if (Special_Dispensers == true)
              {
                  IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
@@ -1754,7 +1907,11 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
              {
                  MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
              }
-            Control3WayValvesWithCallback (Dispenser_i, MidTank_Dispenser, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
+#ifdef DISPENSER_VALVES_OPEN
+             Control3WayValvesWithCallback (Dispenser_i, Dispenser_Mixer, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
+#else
+             Control3WayValvesWithCallback (Dispenser_i, MidTank_Dispenser, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
+#endif
             CurrentDispenserSpeed[Dispenser_i] = 0;
 
             //IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_EndValveReady);
@@ -1763,12 +1920,17 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          {
 //             RemoveControlCallback(ControlIdtoInactiveDispenserId[Dispenser_i], IDS_Check_Pressure_Callback );
 //             ControlIdtoInactiveDispenserId[Dispenser_i] = 0xFF;
+#ifdef DISPENSER_VALVES_OPEN
+             Control3WayValvesWithCallback (Dispenser_i, Dispenser_Mixer, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
+#endif
              IDS_Valve_EndValveReady(Dispenser_i,false);
          }
 
      }
 	IDS_StopLubrication();
-    return OK;
+	Init_CleaningStageCounter();//set the counter before relocating
+	HeadCard_Actuators_Relocate();
+	return OK;
 }
 uint32_t IDS_StartLubrication(void)
 {
@@ -1780,9 +1942,12 @@ uint32_t IDS_StartLubrication(void)
 }
 uint32_t IDS_StopLubrication(void)
 {
+    REPORT_MSG (lubricant_speed, "IDS_StopLubrication and home dispenser");
     Lubricant_2Way_Valve (STOP);
-    IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady);
+    //IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady);
+    TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[LUBRICANT_DISPENSER];
+    MotorStop(HW_Motor_Id,Hard_Hiz);
     CurrentDispenserSpeed[LUBRICANT_DISPENSER] = 0;
-    REPORT_MSG (lubricant_speed, "IDS_StopLubrication");
+    IDS_HomeDispenser (LUBRICANT_DISPENSER, 1000 , NULL);
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
index 572d16bb4..b2498ee7f 100644
--- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
@@ -8,274 +8,177 @@
  *  @author Shai
  */
 
+#include <DataDef.h>
 #include "PMR/Diagnostics/CartridgeSlot.pb-c.h"
 #include "PMR/Diagnostics/CartridgeTagContent.pb-c.h"
-#include "common/utilities/RfidTagContent.h"
+#include  <PMR/Diagnostics/EventType.pb-c.h>
+#include "PMR/IFS/CartridgeState.pb-c.h"
 #include <Drivers/I2C_Communication/RFID_NFC/RFIDTagInfo.h>
-#include <Utilities/RfidTagContent.h>
-
-#include <DataDef.h>
+#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"//#include "FPGA_GPIO.h"  //  use for FPGA IO
+#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
+#include "StateMachines/Initialization/PowerOffSequence.h"
+#include <Utilities/RfidTagHandling.h>
 #include "include.h"
 
-#include "Modules/Waste/Waste.h"
 #include "Modules/IDS/ids_ex.h"
 #include "Modules/IFS/ifs.h"
 #include "Modules/AlarmHandling/AlarmHandling.h"
 #include "CartridgeValidationRequest.pb-c.h"
 #include "CartridgeValidationResponse.pb-c.h"
-#include  <PMR/Diagnostics/EventType.pb-c.h>
 #include "drivers/Valves/Valve.h"
-#include "Modules/Waste/Waste.h"
 #include "../control/control.h"
+#include "Modules/General/buttons.h"
+#include "Modules/General/MachineStatus.h"
+
+#define CARTRIDGE_EMPTY_QUANTITY_LIMIT 10
+#define CARTRIDGE_EMPTY_CALCULATION_TIME 12
+#define FIVE_SECONDS 5
+
+//#define IFS_DEBUG
+
+int CartridgeInkTimeout = CARTRIDGE_INK_TIMEOUT;
+int CartridgeCheckTime = FIVE_SECONDS;
 
-bool IFS_TimeOutAlarm(bool status);
-bool ColorMatch();
-bool MidTankValvesAction(bool action);
+double midTankCapacity;
+MidTank_t midTankCartColor;
+bool prevDoorState;
+bool doorState;
+uint8_t inkAuthenticationPass;
+uint32_t midTankTimeoutCounter = 0;
+double MidTankEmptyLimit = MidTank_Pressure_EMPTY;
+MidTankStateEnum midTankState = 0;
+
+char CartridgeRequestToken[36+1];
+int  CartridgeRequestId = 0x01010101;
+
+bool RdInkCartridgeSensor()
+{
+    return Is_Cartridge_Present(CART_1);
+}
+
+bool IFS_CartridgeLowerPresent()
+{
+    return RdInkCartridgeSensor();
+}
 
 bool IFS_MidTankFilling(void)
 {
-    return (IFS_info.Ink.time_out > 0);
+    return (midTankTimeoutCounter > 0);
 }
+
 MidTank_t IFS_MidTankIsActive(void)
 {
-    return (IFS_info.Ink.cart_color);
+    return midTankCartColor;
 }
 
-//RfidTagContent TagContent[MAX_CARTRIDGES];
-NFC_Tag NFCTag[MAX_CARTRIDGES];
-//void TagInitialize(RfidTagContent* TagContent);
+uint32_t MidTankReading(void)
+{
+    if (midTankTimeoutCounter > 0)
+        return ERROR;
+    return OK;
+}
 
-void IFS_Init(void)
+bool MidTankValvesAction(bool action)
 {
-    int i;
-    for (i=0;i<MAX_CARTRIDGES;i++)
-    {
-        //TagInitialize(&TagContent[i]);
-        memset(NFCTag[i].Buf,0,sizeof(NFCTag[i]));
+    bool ret =  true;
+    if (action == Cartridge_MidTank_ON) {
+        Enable_MidTank_Pressure_Reading(midTankCartColor);
+    } else {
+        Disable_MidTank_Pressure_Reading(midTankCartColor);
+    }
+    if (IDS_IsHomingActive(midTankCartColor)==false) {
+        Valve_Set(IDS_Id_to_AirValve[midTankCartColor], action);
     }
+    Valve_Set(IDS_Id_to_CartrideValve[midTankCartColor], action);
+    return ret;
 }
-/*void TagInitialize(RfidTagContent* TagContent)
-{
 
-}*/
-
-/**
- *
- * @brief detect cartridge INK Empty
- *  this function detect changes in IFS INK cartridge
- *  when MidTank average is bigger the 98% of midtank pressure
- *  the INK cartridge is empty
- * @return bool ret OK = 0 , CartridgeFinished = 1
- */
-#define CARTRIDGE_EMPTY_QUANTITY_LIMIT 10
-#define CARTRIDGE_EMPTY_CALCULATION_TIME 6
 bool DetectIfCartridgeFinished(int int_MidTank_Pressure_1000)
 {
-
-#define CartridgeFinished 1
-
-    bool ret = OK;
+    bool ret = false;
     static int measure_midtank[CARTRIDGE_EMPTY_CALCULATION_TIME] ;
     static int count_measure_midtank = 0;
     int i=0;
     int sum = 0;
     int average = 0;
 
-    if ( count_measure_midtank == CARTRIDGE_EMPTY_CALCULATION_TIME)
+    if (count_measure_midtank == CARTRIDGE_EMPTY_CALCULATION_TIME)
         count_measure_midtank = 0;
     measure_midtank[count_measure_midtank] = int_MidTank_Pressure_1000;
     count_measure_midtank += 1;
     for (i=0;i<CARTRIDGE_EMPTY_CALCULATION_TIME;i++)
         sum += measure_midtank[i];
     average = sum/CARTRIDGE_EMPTY_CALCULATION_TIME;
-    if (abs(average - int_MidTank_Pressure_1000)<CARTRIDGE_EMPTY_QUANTITY_LIMIT)  ret = CartridgeFinished;
-    //if (average > (int_MidTank_Pressure_1000 * 0.98) )  ret = CartridgeFinished;
-
+    if (abs(average - int_MidTank_Pressure_1000)<CARTRIDGE_EMPTY_QUANTITY_LIMIT)
+        ret = true;
     return ret;
 }
 
-
-
-/**
- *
- * @brief detect changes in cartridge INK presence
- *  this function detect changes in IFS presence cartridge
- *  when changes are happens it update the presence status
- *  and the correct event
- * @return IFS_INK_presence_sensor or WHS_no_event event
- */
-
-WHS_sensor CartridgeInkCallBackFunction()
+#ifdef IFS_DEBUG
+bool CartridgeInkFull()
 {
-     WHS_sensor ret = WHS_no_event;
-
-    if (IFS_info.IFS_Ink_precense_sensor != RdInkCartridgeSensor())
-    {
-        WHS_info.event = IFS_INK_presence_sensor;
-        IFS_info.IFS_Ink_precense_sensor = !IFS_info.IFS_Ink_precense_sensor;
-        Report("------------ find  : IFS_Ink_presence_sensor event  -----------------", __FILE__,__LINE__, IFS_info.IFS_Ink_precense_sensor, RpMessage, 0, 0);
-        ret = IFS_INK_presence_sensor;
+    static int count = 1;
+    if((count++ % 60) == 0) {
+        return true;
+    } else {
+        return false;
     }
-    return ret;
 }
+#else
+int CartridgeFinishedCount = 0;
 
-/**
- *
- * @brief detect TimeOut
- * we have 2 way to stop filling:
- * 1. time out
- * 2. detect Midtank is full.
- *
- * 1. time out process is:
- *      1. detect timeout after 5 minutes
- *      2. close and open the valves
- *      3. count 5 minutes again
- *2. measure MidTank capacity
- *  if MidTank is full stop count
- *
- * @return IFS_INK_presence_sensor or WHS_no_event event
- */
-WHS_sensor CartridgeInkTimeOutCallBackFunction()
+bool CartridgeInkFull()
 {
-    WHS_sensor ret = WHS_no_event;
     double MidTank_Pressure = 0;
     int int_MidTank_Pressure_1000 = 0;
 
-
-    //Enable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
-    MidTank_Pressure = Read_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);// Get_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);
-    //Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
+    MidTank_Pressure = Read_MidTank_Pressure_Sensor(midTankCartColor);
     int_MidTank_Pressure_1000 =  ((int)(MidTank_Pressure*1000));
-    Report("------------ IFS_info.Ink.time_out and Pressure  -----------------", __FILE__,__LINE__,(IFS_info.Ink.time_out * SECONDS_5), RpMessage, (int_MidTank_Pressure_1000), 0);
-
-    if (IFS_info.Ink.time_out) IFS_info.Ink.time_out += 1; /*** counter  ***/
-
 
     /*** detect the MidTank capacity is full  ***/
-    //Read_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);
-    if (MidTank_Pressure >= IFS_info.MidTank_capacity  + CARTRIDGE_CAPATICY)
-    {
-        IFS_info.Ink.time_out = 0;
-        WHS_info.event = IFS_MidTankFull;
-        return IFS_MidTankFull;
-    }
-
-    /**** detect if the MidTank_Pressure is the same, 5 times   ****/
-    if (DetectIfCartridgeFinished(int_MidTank_Pressure_1000))
-    {
-        Report("------------ INK Cartrigde is empty (by average)  -----------------", __FILE__,__LINE__,(IFS_info.Ink.time_out * SECONDS_5), RpMessage, (int_MidTank_Pressure_1000), 0);
-        IFS_info.Ink.time_out = 0;
-        WHS_info.event = IFS_MidTankFull;
-        return IFS_MidTankFull;
-    }
-
+    //Read_MidTank_Pressure_Sensor(IFS_info.Ink.midTankCartColor);
+    if (MidTank_Pressure >= midTankCapacity  + CARTRIDGE_CAPATICY)
+        return true;
 
-    int timeout = CARTRIDGE_INK_TIMEOUT;
-    int secondtimeout = CARTRIDGE_INK_TIMEOUTx2;
-    if (IFS_info.Ink.cart_color == MIDTANK_8)//lubricant
-    {
-        timeout = CARTRIDGE_INK_TIMEOUT*3;
-        secondtimeout = CARTRIDGE_INK_TIMEOUTx2 * 3;
-    }
-    /*** first TimeOut  ***/
-    if (IFS_info.Ink.time_out == timeout)
-    {
-        Report("------------ first IFS_info.Ink.time_out, close valves  -----------------", __FILE__, __LINE__, (IFS_info.Ink.time_out * SECONDS_5), RpMessage, (int_MidTank_Pressure_1000), 0);
-        //IFS_info.Ink.time_out = 0;
-        //return IFS_info.event = IFS_Timeout;
-
-        // try again :
-        // start timeout
-        // close and open the correct valves
-
-        IFS_info.Ink.time_out = 0;
-        MidTankValvesAction(Cartridge_MidTank_OFF);
-        IFS_info.Ink.time_out = timeout;
-    }
-
-    if (IFS_info.Ink.time_out == (timeout + 1)) //need to open the valve for second chance
-        {
-        Report("------------ IFS_Timeout open valves for second timeout  -----------------", __FILE__, __LINE__, (IFS_info.Ink.time_out * SECONDS_5), RpMessage, (int_MidTank_Pressure_1000), 0);
-        MidTankValvesAction(Cartridge_MidTank_ON);
-        IFS_info.Ink.time_out = timeout;
+    if (CartridgeFinishedCount++>=CartridgeCheckTime ) {
+        CartridgeFinishedCount = 0;
+        Report("IFS_filling ", __FILE__,__LINE__,int_MidTank_Pressure_1000, RpMessage, int_MidTank_Pressure_1000, 0);
+        /**** detect if the MidTank_Pressure is the same, 5 times   ****/
+        if (DetectIfCartridgeFinished(int_MidTank_Pressure_1000)) {
+            //currently sensor work properly only until 1.6 - 1.8 Liter (TBD)
+            Report("DetectIfCartridgeFinished", __FILE__,__LINE__,int_MidTank_Pressure_1000, RpMessage, int_MidTank_Pressure_1000, 0);
+            //return true;
         }
-
-    if (IFS_info.Ink.time_out >= (secondtimeout + 1))
-        {
-            Report("------------ IFS_Timeout_Second_Time  -----------------", __FILE__, __LINE__, (IFS_info.Ink.time_out * SECONDS_5), RpMessage, (int_MidTank_Pressure_1000), 0);
-            IFS_info.Ink.time_out = 0;
-            MidTankValvesAction(Cartridge_MidTank_OFF);
-            WHS_info.event = IFS_Timeout_Second;
-            return IFS_Timeout_Second;
-        }
-    return ret;
+    }
+    return false;
 }
+#endif
 
-/**
- *
- * @brief IFS Time Out Alarm
- *
- * @return OK
- */
-bool IFS_TimeOutAlarm(bool status)
+int GetCartridgeFillPercent()
 {
-    bool ret =  OK;
-
-        AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT+IFS_info.Ink.cart_color,  status);
-
+    double MidTank_Pressure = 0;
 
-        return ret;
+    MidTank_Pressure = Read_MidTank_Pressure_Sensor(midTankCartColor);
+    return (((MidTank_Pressure - midTankCapacity)* 100) / CARTRIDGE_CAPATICY);
 }
 
-/**
- *
- * @brief MidTank Valves Action
- * the MidTank have 2 Valves:
- * 1. Ink Color Valve to get INK from the INK Cartridge to Midtank
- * 2. Air valve to get INK in the Midtank we have to open the Air valve so the air can go out
- *
- * @return action to open the Valve use: Cartridge_MidTank_ON/Atm_MidTank_ON
- *                to close the Valve use : Cartridge_MidTank_OFF/Atm_MidTank_OFF
- */
-bool MidTankValvesAction(bool action) //Cartridge_MidTank_ON of Cartridge_MidTank_OFF
+bool midTankCart_door()
 {
-    bool ret =  false;
-    if (action == Cartridge_MidTank_ON)
+    bool door;
+
+    if(Get_COVER_1_State(CartridgesDoor))//to check the polarity
     {
-        Enable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
+        door = OPEN;
     }
     else
     {
-        Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
+        door = CLOSE;
     }
-    if (IDS_IsHomingActive(IFS_info.Ink.cart_color)==false)
-        Valve_Set(IDS_Id_to_AirValve[IFS_info.Ink.cart_color], action );   //Atm_MidTank_OFF/ON
-    Valve_Set(IDS_Id_to_CartrideValve[IFS_info.Ink.cart_color], action );   //Atm_MidTank_OFF/ON
-
-    ret = true;
-    return ret;
-}
-
-bool ColorMatch()
-{
-    bool ret =  false;
-
-    ret = true;
-    return ret;
+    return door;
 }
 
-char CartridgeRequestToken[36+1];
-int  CartridgeRequestId = 0x01010101;
-
 
-/**
- *
- * @brief create message to PPC
- *  temporary message RFID will replace that message.
- *  send a request to PPC to know the MidTank number
- * @return OK
- */
-uint32_t ReadCartridgeData(cartridge_name cart_name)
+uint32_t ReadInkCartridgeData()
 {
     //this function triggers reading and validation of the cartridge information
     // for now it sends a request to the tablet to inquire for the ink color/midtank id
@@ -309,16 +212,9 @@ uint32_t ReadCartridgeData(cartridge_name cart_name)
     return OK;
 }
 
-/**
- *
- * @brief PPC answers the MidTank number and call WasteTankCBFunction() function.
- *  temporary message RFID will replace that message.
- *
- * @return OK
- */
 bool CartridgeValidationResponseFunc(MessageContainer* requestContainer)
 {
-    bool ret = notOK;
+    bool ret = ERROR;
 
     CartridgeValidationResponse* response = cartridge_validation_response__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
@@ -327,118 +223,165 @@ bool CartridgeValidationResponseFunc(MessageContainer* requestContainer)
     // 2. the index is out of rang
     if (response == NULL)
     {
-        ReportWithPackageFilter(WHS_filling,"------------ IFS_filling message from PPC is null!!! -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+        Report("IFS_filling message from PPC is null!!!", __FILE__,__LINE__,0, RpMessage, 0, 0);
         return ret;
     }
 
     if (response->index < NUM_OF_MIDTANKS)
     {
-        IFS_info.Ink.cart_color = response->index; // midtank 1-8
-        ReportWithPackageFilter(WHS_filling,"------------ IFS get message response->index is  -----------------", __FILE__, __LINE__, response->index, RpMessage, 0, 0);
-        WHS_info.event = IFS_INK_authentication_pass;
+        midTankCartColor = response->index; // midtank 1-8
+        Report("IFS get message response->index is", __FILE__, __LINE__, response->index, RpMessage, 0, 0);
+        inkAuthenticationPass = true;
     }
     else
     {
-        ReportWithPackageFilter(WHS_filling,"------------ IFS get message response->index is out of rang -----------------", __FILE__, __LINE__, response->index, RpMessage, 0, 0);
-        WHS_info.event = IFS_INK_authentication_fail;
+        Report("IFS get message response->index is out of rang", __FILE__, __LINE__, response->index, RpMessage, 0, 0);
+        inkAuthenticationPass = false;
     }
-
-    WasteTankCBFunction();//call cart is ok
-    ret = OK;
-
-return ret;
+    return OK;
 }
-
-
-/**
- *
- * @brief that response is from STUB. replace the PPC
- *  use stub : Poweroff_progress.cs from P:\Users - Public\Shai_Frieder
- *  ProgressRequest progressRequest = new ProgressRequest();
- *  progressRequest.Amount = 0xCC; //porgress id is 0xCC
- *  progressRequest.Delay = 1; //midtank number from 0-7
- *
- *
- * @return OK
- */
 void ResponseDemo(int MidtankId)
 {
-    WHS_info.event = IFS_INK_authentication_pass;
-    //global mid tank id = MidtankId;
-    IFS_info.Ink.cart_color = MidtankId;
-    WasteTankCBFunction();//call cart is ok
+    inkAuthenticationPass = true;
+    midTankCartColor = MidtankId;
 }
-uint32_t MidTankReadControlId = 0xFF;
-int MidTankCounter = 0;
-uint32_t MidTankCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+
+void midTankStateMachine(void)
 {
-    int MidTankOpenAir = 8;
-    int MidTankReadPressure = 16;
-    int MidTankCloseAir = 40;
-    int MidTankEnd = 48;
-    int portId;
+    static int init = 1;
+    static int authenticationTimeOutCounter = 0;
 
-    if (MidTankCounter >= MidTankEnd)
-    {
-        SafeRemoveControlCallback(MidTankReadControlId, MidTankCallBackFunction);
-    }
-    else if (MidTankCounter >= MidTankCloseAir)
-    {
-        //close air valve for midtank (MidTankCounter-MidTankCloseAir)
-        portId = (MidTankCounter - MidTankCloseAir) ; //0-7
-        if (IDS_IsHomingActive(portId) == false)
-        {
-            Disable_MidTank_Pressure_Reading(portId);
-            Valve_Set(IDS_Id_to_AirValve[portId], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
-        }
+    if (init) {
+        doorState = midTankCart_door();
+        prevDoorState = doorState;
+        init = 0;
+    } else {
+#ifndef IFS_DEBUG
+        doorState = midTankCart_door();
+#endif
     }
-    else if (MidTankCounter >= MidTankReadPressure)
-    {
-        //read pressure for midtank (MidTankCounter-MidTankCloseAir)
-        for (portId = 0;portId < MAX_SYSTEM_DISPENSERS;portId++)
-        {
-            Read_MidTank_Pressure_Sensor(portId);
+    if (!RdInkCartridgeSensor()) { // cartridge not presence
+        Pannel_Leds( CART_1,  MODE_OFF);
+        cart1.color = colorOFF;
+    } else { // cartridge presence
+        if (cart1.color == colorOFF) {
+            Pannel_Leds( CART_1,  MODE_ON);
+            cart1.color = colorON;
         }
     }
-    else if (MidTankCounter >= MidTankOpenAir)
+    switch (midTankState)
     {
-        //open air valve for midtank (MidTankCounter-MidTankOpenAir)
-        portId = (MidTankCounter - MidTankOpenAir) ; //0-7
-        Enable_MidTank_Pressure_Reading(portId);
-        Valve_Set(IDS_Id_to_AirValve[portId], Atm_MidTank_ON );   //Atm_MidTank_OFF/ON
-    }
-    MidTankCounter++;
-    return OK;
-}
+        case MidTankStateIdle:
+            if ((doorState == CLOSE) && (prevDoorState == OPEN)) {
+                //check if power down in process
+                if (PowerOffInProcessGetState()) {
+                    Report("Power-down in process", __FILE__, __LINE__, 0, RpMessage, 0, 0);
+                    break;
+                }
 
-uint32_t MidTankReading(void)
-{
-    MidTankCounter = 0;
-    if (IFS_info.Ink.time_out > 0)
-        return ERROR;
-    MidTankReadControlId = AddControlCallback("MidTankReading", MidTankCallBackFunction, 300/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
+                // check if cartridge presence
+                if (!RdInkCartridgeSensor()) {
+                    break;
+                }
+                //check RFID - check cartridge OK
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Inserted, 0);
 
-    return OK;
-}
+                // send request for validation to ppc
+                inkAuthenticationPass = 2; //not defined
+                authenticationTimeOutCounter = 0;
+                ReadInkCartridgeData();
 
-bool  INKCartridgeAuthentication(cartridge_name cart_name)
-{
-    bool ret = notOK;
-    // TBD;
-    switch (cart_name)
-    {
-        case INK_cartridge:
-            IFS_info.Ink.autheticate = PASSED;  //todo
-            //Pannel_Leds(CART_1, MODE_ON);
+                //move to next state
+                midTankState = MidTankStateWait;
+                Report("move to midTankStateWait", __FILE__, prevDoorState, doorState, RpMessage, midTankState, 0);
+            }
+            if (doorState != prevDoorState) {
+                prevDoorState = doorState;
+                Report("Door state change", __FILE__, __LINE__, doorState, RpMessage, prevDoorState, 0);
+            }
             break;
+        case MidTankStateWait:
+            if (inkAuthenticationPass == 2) {
+                authenticationTimeOutCounter++;
+                Report("MidTank Cartridge authentication wait...", __FILE__, __LINE__, authenticationTimeOutCounter, RpMessage, 0, 0);
+                if (authenticationTimeOutCounter > 60) {
+                    midTankState = MidTankStateIdle;
+                    CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Error, 0);
+                }
+                break;
+            }
+            if (inkAuthenticationPass == false) {
+                Report("MidTank Cartridge authentication fail", __FILE__, __LINE__, 0, RpMessage, 0, 0);
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Error, 0);
+                midTankState = MidTankStateIdle;
+                break;
+            }
+            // Cartridge status received from user - assume cartridge is full
+
+            midTankCapacity = Get_MidTank_Pressure_Sensor(midTankCartColor);
+            if ((midTankCapacity > MidTankEmptyLimit)&&(midTankCartColor!=MIDTANK_8))//enable lubricant filling in two stages
+            {
+                Pannel_Leds(CART_1, MODE_ON);
+                cart1.color = fastBILNK;
+                Report("Mid-tank not empty", __FILE__, __LINE__, midTankCapacity, RpMessage, MidTankEmptyLimit, 0);
+                midTankState = MidTankStateIdle;
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Error, 0);
+                break;
+            }
+            Report("Mid-tank filling in process", __FILE__,__LINE__,(int)(MidTankEmptyLimit*1000), RpMessage, (int)(midTankCapacity*1000), 0);
+            Pannel_Leds(CART_1, MODE_ON);
+            cart1.color  = BLINK;
+            CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Filling, 0);
+
+            if (midTankCartColor == MIDTANK_8)
+            {
+                CartridgeInkTimeout = CARTRIDGE_INK_TIMEOUT*4;
+                CartridgeCheckTime = FIVE_SECONDS*3;
+            }
+            // set valve selection
+            MidTankValvesAction(Cartridge_MidTank_ON);
+            Report("midTankStateWait set valve", __FILE__, __LINE__, 0, RpMessage, 0, 0);
+
+            // RFID change status - inkUsed, inkFill
 
+            // set count down
+            midTankTimeoutCounter = 1;
+
+            //start  filling
+            midTankState = MidTankStateFilling;
+            break;
+        case MidTankStateFilling:
+            if (!RdInkCartridgeSensor()) { // cartridge not presence
+                MidTankValvesAction(Cartridge_MidTank_OFF);
+                Report("Cartridge extracted during filling!!!", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
+                Report("Mid-tank # filling fail", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
+                midTankState = MidTankStateIdle;
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Absent, GetCartridgeFillPercent());
+            }
+            // if time out or emptying done - idle
+            if (midTankTimeoutCounter++ > CartridgeInkTimeout) {
+                midTankTimeoutCounter = 0;
+                Pannel_Leds(CART_1, MODE_ON);
+                cart1.color = fastBILNK;
+                MidTankValvesAction(Cartridge_MidTank_OFF);
+                Report("Mid-tank # filling fail", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
+                Report("Call customer support", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Error, GetCartridgeFillPercent());
+                midTankState = MidTankStateIdle;
+            } else if (CartridgeInkFull()) {
+                midTankTimeoutCounter = 0;
+                Pannel_Leds(CART_1, MODE_OFF);
+                cart1.color = colorOFF;
+                MidTankValvesAction(Cartridge_MidTank_OFF);
+                Report("Mid-tank # filling done", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
+                midTankState = MidTankStateIdle;
+                // RFID change status - inkEmpty
+                CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__FillingCompleted, 100.0);
+            }
+            CartridgeStateUpdate(CARTRIDGE_SLOT__Ink, CARTRIDGE_STATE__Filling, GetCartridgeFillPercent());
+            break;
         default:
-            //WHS_info.cartridge_1.autheticate = FAILED; //todo
-           // WHS_info.cartridge_2.autheticate = FAILED; //todo
-            //Pannel_Leds(CART_2, MODE_OFF);
-            //Pannel_Leds(CART_3, MODE_OFF);
+            Report("wrong state", __FILE__, __LINE__, midTankState, RpMessage, 0, 0);
             break;
     }
-    ret = OK;
-    return ret;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
index 5304edd93..0f95fb2e2 100644
--- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
@@ -11,52 +11,22 @@
 #ifndef MODULES_IFS_IFS_H_
 #define MODULES_IFS_IFS_H_
 
-#include "Modules/Waste/Waste.h"
+#define CARTRIDGE_INK_TIMEOUT           420
+#define MidTank_Pressure_EMPTY          0.3
+#define CARTRIDGE_CAPATICY              1500
 
-//void IFS_Init(void)
-#define SECONDS_5                       5               /**<  5seconds  */
-#define SECONDS_300                     300             /**<  300 seconds = 5 minutes  */
-#define SECONDS_420                     (7*60)          /**<  420 seconds = 7 minutes  */
-#define SECONDS_600                     600             /**<  600 seconds = 10 minutes  */
-#define SECONDS_2_DLY                   0               /**< dly 0 seconds  */
-#define CARTRIDGE_INK_TIMEOUT           (SECONDS_420 / SECONDS_5)             /**< TimeOut (7 minutes) for finishing transfer the Ink from Ink cartridge to MidTank  */
-#define CARTRIDGE_INK_TIMEOUTx2         (CARTRIDGE_INK_TIMEOUT * 2)           /**< TimeOut (7 minutes) for second try finishing transfer the Ink from Ink cartridge to MidTank  */
-#define CartridgeInkTimeOutCallBackTime (eOneSecond * SECONDS_5)
-#define CartridgeInkCallBackTime        eOneSecond
-#define MidTank_Pressure_EMPTY          0.3  //todo get from Moti the correct number  (Oleg -> 300cc)
-#define CARTRIDGE_CAPATICY 1500 //todo get from Moti the correct number
-#define FULL 1000   //todo get from Moti the correct number
+typedef enum{
+    MidTankStateIdle,
+    MidTankStateWait,
+    MidTankStateFilling
+}MidTankStateEnum;
 
-
-
-/**
- *  A structure to represent IFS_information
- */
-struct IFS_information
-{
-    struct cartridge_params Ink;                                /**< cartridge_params */
-    CarteidgPrecenseSensorStatus IFS_Ink_precense_sensor;       /**< INK cartridge presence(1) or not_precense(0) */
-    uint32_t Cartridge_Ink_device_Id;                           /**< INK device_Id number for callback */
-    uint32_t Cartridge_Ink_TimeOut_device_Id;                   /**< INK device_Id number for TimeOut callback */
-    uint32_t INK_isOK_flag ;                                    /**< INK cartridge pass authentication (from PPC) */
-    double MidTank_capacity;                                    /**< MidTank current capacity  */
-};
-
-struct IFS_information IFS_info;
-
-WHS_sensor CartridgeInkCallBackFunction();
-WHS_sensor CartridgeInkTimeOutCallBackFunction();
-uint32_t ReadCartridgeData(cartridge_name cart_name);
-bool INKCartridgeAuthentication(cartridge_name cart_name);
-bool MidTankValvesAction(bool action); //Cartridge_MidTank_ON of Cartridge_MidTank_OFF
-bool ColorMatch();
-bool IFS_TimeOutAlarm(bool status);
+void midTankStateMachine(void);
+uint32_t MidTankReading(void);
 void ResponseDemo(int MidtankId);
 bool IFS_MidTankFilling(void);
 MidTank_t IFS_MidTankIsActive(void);
-
+bool IFS_CartridgeLowerPresent();
 bool CartridgeValidationResponseFunc(MessageContainer* requestContainer);
 
-uint32_t MidTankReading(void);
-
 #endif /* MODULES_IFS_IFS_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index fa8bb1459..a3a0ff38e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -25,12 +25,15 @@
 #include "Drivers/I2C_Communication/Head_Card/Fan/fan_click.h"
 #include "Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h"
 #include "drivers/Motors/Motor.h"
+#include "drivers/Valves/Valve.h"
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "Modules/IFS/ifs.h"
 #include "Modules/IDS/ids_ex.h"
+#include "Modules/IDS/ids.h"
 #include "Modules/Control/MillisecTask.h"
 #include "modules/thread/thread_ex.h"
 #include "modules/heaters/heaters_ex.h"
+#include "modules/waste/waste_ex.h"
 #include <Drivers/I2C_Communication/I2C.h>
 #include <Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.h>
 #include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
@@ -49,7 +52,10 @@
 #include "drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.h"
 #include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
 
+#include "drivers/Heater/TemperatureSensor.h"
+#include "Drivers/I2C_Communication/Head_Card/PT100/ADS122X04.h"
 
+extern HeadBoardTempSensConfigStruc  HeadTempSensConfig[MAX_HEAD_CARD_TEMP_SENS_ID];
 extern float NumberOfRotationPerPassage;  // how many rotations per spool passage
 extern void HeaterSafetyTestSetLimits(int limit);
 
@@ -59,6 +65,10 @@ extern uint8_t Test_Read_Buf[4];
 
 extern uint8_t Head_Fan_PWM_Command[2];
 extern uint16_t Head_Fan_Tach[2];
+extern bool doorState;
+
+bool RestartNeeded = false;
+uint32_t temp1,temp2;
 
 void Stub_ProgressRequest(MessageContainer* requestContainer)
 {
@@ -77,13 +87,133 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     uint8_t port = 0;
     uint8_t pin  = 0;
     uint8_t value= 0;
+    uint32_t enable;
+
+    uint8_t ReadBackReg[1];
+
 
+    if(request->amount == 0xacc1e)
+    {
+        response.progress = IDS_Cleaning_Move_Actuators();
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xacc1ea)
+    {
+        response.progress = HeadCard_Actuators_Relocate();
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xC04f)
+    {
+
+        switch(request->delay)
+        {
+            case 0x8400:
+                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_5_0X84_0, ADS122X_CONFIG_0_REG, &ReadBackReg[0]);
+                    response.progress = ReadBackReg[0];
+                    //response.progress = HeadTempSensConfig[14].Reg0.Byte;
+                break;
+            case 0x8401:
+                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_5_0X84_0, ADS122X_CONFIG_1_REG, &ReadBackReg[0]);
+                    response.progress = ReadBackReg[0];
+                    //response.progress = HeadTempSensConfig[14].Reg1.Byte;
+                break;
+            case 0x8402:
+                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_5_0X84_0, ADS122X_CONFIG_2_REG, &ReadBackReg[0]);
+                    response.progress = ReadBackReg[0];
+                    //response.progress = HeadTempSensConfig[14].Reg2.Byte;
+                break;
+            case 0x8403:
+                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_5_0X84_0, ADS122X_CONFIG_3_REG, &ReadBackReg[0]);
+                    response.progress = ReadBackReg[0];
+                    //response.progress = HeadTempSensConfig[14].Reg3.Byte;
+                break;
+            case 0x8600:
+                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_7_0X86_0, ADS122X_CONFIG_0_REG, &ReadBackReg[0]);
+                    response.progress = ReadBackReg[0];
+                    //response.progress = HeadTempSensConfig[15].Reg0.Byte;
+                break;
+            case 0x8601:
+                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_7_0X86_0, ADS122X_CONFIG_1_REG, &ReadBackReg[0]);
+                    response.progress = ReadBackReg[0];
+                    //response.progress = HeadTempSensConfig[15].Reg1.Byte;
+                break;
+            case 0x8602:
+                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_7_0X86_0, ADS122X_CONFIG_2_REG, &ReadBackReg[0]);
+                    response.progress = ReadBackReg[0];
+                    //response.progress = HeadTempSensConfig[15].Reg2.Byte;
+                break;
+            case 0x8603:
+                    HeadADCPT100_ReadReg(HEAD_PT100_ZONE_7_0X86_0, ADS122X_CONFIG_3_REG, &ReadBackReg[0]);
+                    response.progress = ReadBackReg[0];
+                    //response.progress = HeadTempSensConfig[15].Reg3.Byte;
+                break;
+
+            default:
+                    if((request->delay >= HEAD_PT100_ZONE_1_0X80_0) && (request->delay <= HEAD_PT100_RESERVE_0X8E_1))
+                    {
+                        response.progress = TempSensorResponse[request->delay].PT100_ADC_Reading_Bits;
+                    }
+                break;
+        }
+
+        response.has_progress = true;
+    }
+    else
     if(request->amount == 0xb05)
     {
-        response.progress = Test_Uart3(request->delay);
+        response.progress = Test_Uart3(request->delay);//test Shinko
         response.has_progress = true;
     }
     else
+    if(request->amount == 0xdace)//test_dancer_responce_RTFU
+        //in order to use it unmark the define test_RTFU_dancer !!!!!!!!!!!
+    {
+        test_dancer_flag = true;
+
+        if(request->delay == 0x01)
+        {
+            test_dancer_direction  = true;
+        }
+        else
+        if(request->delay == 0x00)
+        {
+            test_dancer_direction  = false;
+        }
+
+        response.progress = 0xdace;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xb10) //S.S Head Sensor board
+        {
+            if(request->delay == 0x01)
+            {
+                response.progress = HeadCard_ActivateHeadPressureArcBlowers();
+            }
+            else if(request->delay == 0x00)
+            {
+                response.progress = HeadCard_DeActivateHeadPressureArcBlowers();
+            }
+            response.has_progress = true;
+        }
+
+    else
+        if(request->amount == 0x3EC)
+        {
+            if(request->delay == 0x01)
+            {
+                uint16_t Vm_mv = 0;
+
+                Trigger_WHS_MAX11614_Read_allADC();
+
+                get_vlev1(&Vm_mv);
+                response.progress = Vm_mv;
+                response.has_progress = true;
+            }
+        }
+    else
        if(request->amount == 0x3EB) //whs valves
        {
            if (WHS_Type == WHS_TYPE_NEW)
@@ -112,7 +242,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
            }
        }
     else
-       if(request->amount == 0x3EA) //whs pump
+       if(request->amount == 0x3EE) //whs pump
        {
            if (WHS_Type == WHS_TYPE_NEW)
            {
@@ -208,32 +338,32 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
             if (WHS_Type == WHS_TYPE_NEW)
             {
-                display_byte = ((request->delay & 0x3000)>>12);
+                /*display_byte = ((request->delay & 0x3000)>>12);
                 switch (display_byte)
                 {
                 case 0:
-                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x0000); //
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x0000); //
                     SetLeftDisplayView (HeadAVERAGE);
                     SetWriteDisplayView(DrierAVERAGE);
                     SetDisplayView (AVERAGE);
                     break;
                 case 1:
-                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x1000); //
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x1000); //
                     SetLeftDisplayView (HeadAVERAGE);
                     SetWriteDisplayView(HeadCURRENT);
                     break;
                 case 2:
-                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x2000); //
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x2000); //
                     SetLeftDisplayView (DrierAVERAGE);
                     SetWriteDisplayView(DrierCURRENT);
                     break;
                 case 3:
-                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x3000); //
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x3000); //
                     SetLeftDisplayView (HeadCURRENT);
                     SetWriteDisplayView(DrierCURRENT);
                     SetDisplayView (CURRENT);
                     break;
-                }
+                }*/
 
                 A2D_data = (request->delay & 0x0FFF);
                 switch(A2D_data )// get A2D
@@ -268,14 +398,17 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                     case 10:
                         temp_double = get_Q(HEAD_FLOW_METER);
                         break;
+                    case 11:
+                        temp_double = get_Q(NU_FLOW_METER);
+                        break;
                     case 12:
                         temp_double = get_Q(DRIER_FLOW_METER);
                         break;
-                    case 20:
-                        temp_double = get_average_Q(HEAD_FLOW_METER); //HEAD
+                    /*case 20:
+                        //temp_double = get_average_Q(HEAD_FLOW_METER); //HEAD
                         break;
                     case 22:
-                        temp_double = get_average_Q(DRIER_FLOW_METER); //Drier
+                        //temp_double = get_average_Q(DRIER_FLOW_METER); //Drier
                         break;
 
                     case 11:
@@ -298,7 +431,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                         break;
                     case 18:
                         //tempu16 = 0;  //get_cur_vlv2(&tempu16);
-                        break;
+                        break;*/
                     default :
                         tempu16 = 0x500;  //get_cur_vlv2(&tempu16);
                         break;
@@ -315,7 +448,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
        response.has_progress = true;
     }
     else //
-    if(request->amount == 0x3EB)
+    if(request->amount == 0x3ED)
     {
         uint16_t tempu16 = 0;
         if (WHS_Type == WHS_TYPE_NEW)
@@ -323,12 +456,17 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
             if (request->delay <= 0x03FF)
             {
                 Trigger_WHS_Set_RDAC(request->delay);  // 0 -> 0x03FF
+                get_gas_out(&tempu16);
             }
-            else
+            else if (request->delay == 0x0FFF)
             {
-                //Trigger_WHS_set_Rheostat_to_CLEAN_AIR();
+                Trigger_WHS_set_Rheostat_to_CLEAN_AIR();
+
+                //Search_Rheostat_Value_for_Air_clibration();
+                get_gas_out(&tempu16);
             }
-            get_gas_out(&tempu16);
+            else if (request->delay == 0x04FF)
+                get_gas_out(&tempu16);
         }
         response.progress = (double)tempu16;
         response.has_progress = true;
@@ -376,12 +514,52 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
+    if(request->amount == 0xAD5) //Set SecondFeederCorrection
+    {
+        LOG_ERROR(request->delay,"Set SecondFeederCorrection");
+        SecondFeederCorrection = request->delay;
+        response.progress = SecondFeederCorrection;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xAD6) //Set skip open lids
+    {
+        LOG_ERROR(request->delay,"Set SkipOpenLids");
+        SkipOpenLids = request->delay;
+        response.progress = SkipOpenLids;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xAD7) //Set actuators cleaning sequence
+    {
+        LOG_ERROR(request->delay,"Set actuators cleaning sequence");
+        ActuatorsCleaningSequence = request->delay;
+        response.progress = ActuatorsCleaningSequence;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xAD8) //Set ignore cone missing
+    {
+        LOG_ERROR(request->delay,"Set ignore cone missing");
+        IgnoreConeMissing = request->delay;
+        response.progress = IgnoreConeMissing;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xAD9) //halt
+    {
+        LOG_ERROR(request->delay,"halt");
+        memset (0,0,100000);
+        response.progress = IgnoreConeMissing;
+        response.has_progress = true;
+    }
+    else
     if((request->amount == 0x01) && ((request->delay &0x010000) == 0x010000)) //change mode powerset01
     {
         response.progress = Power_Step_01_Mode(((request->delay &0x00FF00)>>8), request->delay &0x0000FF);
         response.has_progress = true;
     }
-    else
+    /*else
     if((request->amount == 0xAB) && (request->delay == 0xAB)) //Get pressure with flow (orifice flow meter)
     {
         response.progress = Calculate_Pitot_Pressure(true);
@@ -394,7 +572,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.progress = Calculate_Pitot_Pressure(false);
         response.has_progress = true;
 
-    }
+    }*/
     else
     if((request->amount == 0xAC) && (request->delay == 0xAC)) //VAC
     {
@@ -571,9 +749,46 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
         if((request -> delay & 0xFFF000) == 0xCAF000)//Actuator
         {
-            //HeadCard_Actuators_Control((ACTUATORS)(((request -> delay) & 0x100)>>8), /*(bool)((request -> delay & 0x10)>>4), */(bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
-            Trigger_Head_Actuators_Control((ACTUATORS)(((request -> delay) & 0x100)>>8), (bool)((request -> delay & 0x10)>>4), (bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
-            //response.progress = HeadCard_Actuators_Status((ACTUATORS)((request -> delay) & 0x100)>>8);
+            if((request -> delay & 0x00000F) >1)
+            {
+                if((request -> delay & 0xFFFFFF) == 0xCAF002)//ACTUATOR-IN down without delay and without stop the actuator
+                {
+                    Trigger_Head_Actuators_Stub(ACTIN, true, false);
+                }
+                else
+                if((request -> delay & 0xFFFFFF) == 0xCAF003)//ACTUATOR-IN up without delay and without stop the actuator
+                {
+                    Trigger_Head_Actuators_Stub(ACTIN, true, true);
+                }
+                else
+                if((request -> delay & 0xFFFFFF) == 0xCAF008)//Stop  ACTUATOR-IN
+                {
+                    Trigger_Head_Actuators_Stub(ACTIN, false, true);
+                }
+                else
+                if((request -> delay & 0xFFFFFF) == 0xCAF102)//ACTUATOR-OUT  down without delay and without stop the actuator
+                {
+                    Trigger_Head_Actuators_Stub(ACTOT, true, false);
+                }
+                else
+                if((request -> delay & 0xFFFFFF) == 0xCAF103)//ACTUATOR-OUT  up without delay and without stop the actuator
+                {
+                    Trigger_Head_Actuators_Stub(ACTOT, true, true);
+                }
+                else
+                if((request -> delay & 0xFFFFFF) == 0xCAF108)//Stop  ACTUATOR-OUT
+                {
+                    Trigger_Head_Actuators_Stub(ACTOT, false, true);
+                }
+            }
+            else
+            {
+               // STUB: stubManager.Run<ProgressResponse>("ProgressRequest" ,0xFEAD, 0xCAF201);//Actuators: ID, power, Direction
+
+                //HeadCard_Actuators_Control((ACTUATORS)(((request -> delay) & 0x100)>>8), /*(bool)((request -> delay & 0x10)>>4), */(bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
+                Trigger_Head_Actuators_Control((ACTUATORS)(((request -> delay) & 0xF00)>>8), (bool)((request -> delay & 0x10)>>4), (bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
+                //response.progress = HeadCard_Actuators_Status((ACTUATORS)((request -> delay) & 0x100)>>8);
+            }
             response.has_progress = true;
         }
         else
@@ -601,21 +816,32 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     {
         //Head_Fan_PWM_Command[0] = (request->delay & 0xFF) ;
         //Test_Head_fan_Click();
-
-        Trigger_Head_Fan_Control(HEAD_FAN_RIGHT, request->delay & 0xFF);
-        Task_sleep(2000);
+        if(request->delay <= 0xFF)
+        {
+            Trigger_Head_Fan_Control(HEAD_FAN_RIGHT, request->delay & 0xFF);
+            response.progress = 7864320/Head_Fan_Tach[0];
+        }
+        else
+        {
+            response.progress = 7864320/Head_Fan_Tach[0];
+        }
 
         //response.progress = Fan_Click_Info.Product_ID;
-        response.progress = Head_Fan_Tach[0];
         response.has_progress = true;
 
     }
     else
     if((request->amount == 0xFAC1) /*&& (request->delay == 0xFAC)*/) //Head Fan control
     {
-        Trigger_Head_Fan_Control(HEAD_FAN_LEFT, request->delay & 0xFF);
-        Task_sleep(2000);
-        response.progress = Head_Fan_Tach[1];
+        if(request->delay <= 0xFF)
+        {
+            Trigger_Head_Fan_Control(HEAD_FAN_LEFT, request->delay & 0xFF);
+            response.progress = 7864320/Head_Fan_Tach[1];
+        }
+        else
+        {
+            response.progress = 7864320/Head_Fan_Tach[1];
+        }
         response.has_progress = true;
     }
     else
@@ -625,9 +851,16 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
         if (WHS_Type == WHS_TYPE_NEW)
         {
-            Trigger_SetWHSFanSpeed(((request->amount & 0x0000000F)-1) , request->delay & 0x000000FF);
-            Task_sleep(2000);
-            fan_tacho = WHS_Get_fan_tach( (request->amount & 0x0000000F)-1);
+            if(request->delay <= 0xFF)
+            {
+                Trigger_SetWHSFanSpeed(((request->amount & 0x0000000F)-2) , request->delay & 0x000000FF);
+                fan_tacho = WHS_Fan_Tach_RPM[(request->amount & 0x0000000F)-2];
+            }
+            else
+            {
+                //reading the tacho in msectask
+                fan_tacho = WHS_Fan_Tach_RPM[(request->amount & 0x0000000F)-2];//WHS_Get_fan_tach( (request->amount & 0x0000000F)-2);
+            }
         }
         response.progress = fan_tacho;
         response.has_progress = true;
@@ -672,6 +905,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         uint32_t timeout = 0xFFFFFFFFU;
         ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
 #endif
+        HeatersEnd();
         FRESULT iFResult = Init_Flash_File_System(true);
         if(iFResult != FR_OK)
         {
@@ -684,13 +918,13 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         ROM_WatchdogReloadSet(WATCHDOG0_BASE, timeout);
 #endif
     }
-    else
+    /*else
     if((request->amount == 0x0C) && (request->delay == 0x0C)) //Get Gas Sensor
     {
         response.progress = (double)Calculate_Gas_Power_Consumption();
         response.has_progress = true;
 
-    }
+    }*/
     else
     if((request->amount == 0xDD) && (request->delay == 0xDD)) //Read Input Voltage
     {
@@ -704,9 +938,23 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     if((request->amount == 0x0CE) && (request->delay == 0x0CE)) //Get Gas Sensor
     {
         LOG_ERROR(request->delay,"FlashInit");
+        HeatersEnd();
         FlashInit();
         response.progress = (double)OK;
         response.has_progress = true;
+        RestartNeeded = true;
+    }
+    else
+    if((request->amount == 0x0CD) && (request->delay == 0x0CD)) //Get Gas Sensor
+    {
+        LOG_ERROR(request->delay,"Load embedded parameters from file and restart");
+        base_flashErased = false;
+        LoadConfigurationParamsFromFile(true);
+        LOG_ERROR(255,"Update successful, Rebooting in 5 seconds");
+        Task_sleep (eOneSecond*5);
+        Power_Reset();
+        response.progress = (double)OK;
+        response.has_progress = true;
 
     }
     else
@@ -725,7 +973,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.progress = (double)OK;
         response.has_progress = true;
     }
-    else
+    /*else
     if(request->amount == 0xE1)  //fast refresh for pressure
     {
         LOG_ERROR(request->delay,"Starting Dispenser PID");
@@ -740,7 +988,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         IDS_Stop_Pid_Testing(request->delay);
         response.progress = (double)OK;
         response.has_progress = true;
-    }
+    }*/
     else
     if(request->amount == 0xE3)  //fast refresh for pressure
     {
@@ -797,7 +1045,6 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.progress = (double)MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,request->delay);
         response.has_progress = true;
     }
-
     else
     if(request->amount == 0xB3)  //fast refresh for pressure
     {
@@ -838,7 +1085,146 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
     }
 #endif
+    else
+    if(request->amount == 0xB7)  //fast refresh for pressure
+    {
+        specialHeaterState = request->delay?true:false;
+        LOG_ERROR(specialHeaterState,"set specialHeaterState");
+        response.progress = specialHeaterState;
+        response.has_progress = true;
 
+    }
+    else
+    if(request->amount == 0xB8)  //fast refresh for pressure
+        {
+            if (request->delay == 1) {//init waste
+                Waste_Init();
+                LOG_ERROR(request->delay,"Waste_Init");
+            }
+            response.progress = request->delay;
+            response.has_progress = true;
+        }
+    else
+    if(request->amount == 0xB9)  //fast refresh for pressure
+    {
+        if ((request->delay == 0) || (request->delay == 1)) {
+            doorState = request->delay;
+            LOG_ERROR(request->delay,"door");
+        }
+        response.progress = request->delay;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB11)  //fast refresh for pressure
+    {
+        temp1 = Read_Dryer_ENC_Position();
+        temp2 = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius/4;
+
+           MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Hiz);
+        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,200);
+        //6 seconds per round
+        Report("Arm movement test",__FILE__,request->delay,request->delay/2*2,RpWarning,(int)request->delay%2,0);
+
+        //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
+        MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, request->delay%2,request->delay/2*2,    NULL, 12000);
+
+        response.progress = temp2;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB12)  //fast refresh for pressure
+    {
+
+        temp2 = Calculate_Arm_Distance(temp1,Read_Dryer_ENC_Position());
+        Report("Arm movement test calc",__FILE__,temp2,temp1,RpWarning,Read_Dryer_ENC_Position(),0);
+
+        response.progress = temp2;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB13)  //TryThreadLoadingRequest
+    {
+        TryThreadLoadingFunc(NULL);
+        Report("TryThreadLoadingFunc",__FILE__,temp2,temp1,RpWarning,Read_Dryer_ENC_Position(),0);
+
+        response.progress = 0xB13;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB14)
+    {
+        LOG_ERROR(request->amount,"IDS_Cleaning_Move_Actuators");
+        Init_CleaningStageCounter();
+        IDS_Cleaning_Move_Actuators();
+
+        response.progress = 0xB14;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB15)
+    {
+        TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DH_LID;
+        LOG_ERROR(request->amount,"Motor soft stop");
+        MotorStop(MotorId,Soft_Stop);
+
+        response.progress = 0xB15;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB16)
+    {
+        TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DH_LID;
+        LOG_ERROR(request->amount,"MotorMovetoLimitSwitch");
+        MotorMovetoLimitSwitch(MotorId,1 - MotorsCfg[MotorId].directionthreadwize, 50,  Motor_Id_to_LS_IdDown[MotorId], cleaningMotorCBFunction,30000);
+        ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Motor_Homing", __FILE__, __LINE__, 1, RpWarning, 0, 0);
+
+        response.progress = 0xB16;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB17)
+    {
+        LOG_ERROR(request->delay,"HeadBlowersOff");
+        HeadBlowersOff(request->delay);
+
+        response.progress = 0xB17;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB18)
+    {
+        enable = HeadBlowersOffGet();
+        LOG_ERROR(enable, "HeadBlowersOffGet");
+
+        response.progress = 0xB18;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB19)
+    {
+        LOG_ERROR(request->amount,"ThreadCheckArcHeadCovers");
+        ThreadCheckArcHeadCovers();
+        ReportWithPackageFilter(IDSFilter,"ThreadCheckArcHeadCovers", __FILE__, __LINE__, 1, RpWarning, 0, 0);
+
+        response.progress = 0xB19;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB20)  //Set loading arm cycles
+    {
+        LOG_ERROR(request->delay,"Set winding calibration data");
+
+        response.progress = (double)MCU_E2PromProgram(EEPROM_STORAGE_WINDER_CALIBRATION,request->delay);
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB21)  //Set loading arm cycles
+    {
+        LOG_ERROR(request->delay,"Set screw max speed");
+
+        response.progress = (double)MotorSetMaxSpeed(HARDWARE_MOTOR_TYPE__MOTO_SCREW,request->delay);
+        response.has_progress = true;
+    }
     else
     if(request->amount == 0xC3)  //suspend I2C task
     {
@@ -852,12 +1238,50 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         else
         {
             LOG_ERROR(request->delay,"Resume");
-            Task_setPri (I2C_Task_Handle,8);
+            Task_setPri (I2C_Task_Handle,17);
         }
         response.progress = request->delay;
         response.has_progress = true;
 
     }
+    else
+    if(request->amount == 0xC11)
+    {
+        IgnoreMidTank = request->delay;
+        LOG_ERROR(IgnoreMidTank, "IgnoreMidTank");
+
+        response.progress = request->delay;
+        response.has_progress = true;
+    }
+#ifdef MIDTANK_MITIGATION
+    else
+    if(request->amount == 0xC12)
+    {
+        MidTankMitigation = request->delay;
+        LOG_ERROR(MidTankMitigation, "MidTankMitigation");
+
+        response.progress = request->delay;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xC13)
+    {
+        MidTankMitigationOff = request->delay;
+        LOG_ERROR(MidTankMitigationOff, "MidTankMitigationOff");
+
+        response.progress = request->delay;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xC14)
+    {
+        MidTankMitigationOn = request->delay;
+        LOG_ERROR(MidTankMitigationOn, "MidTankMitigationOn");
+
+        response.progress = request->delay;
+        response.has_progress = true;
+    }
+#endif
     else     
 	if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
     {
@@ -895,9 +1319,18 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
     free(responseContainer.data.data);
+    if (request)
+        progress_request__free_unpacked(request,NULL);
     //writeLine("Progress Completed!");
     SendChars((char*)container_buffer, container_size);
     //free(container_buffer);
+    if (RestartNeeded == true)
+    {
+        LOG_ERROR(255,"Update successful, Rebooting in 5 seconds");
+        Task_sleep (eOneSecond*5);
+        Power_Reset();
+        RestartNeeded = false;
+    }
 
     return;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
index 132d46fb7..63c7b6963 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
@@ -10,49 +10,65 @@
 #include "inc/hw_uart.h"
 #include "driverlib/gpio.h"
 
-#include "Drivers/USB_Communication/USBCDCD.h"
 #include "Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h"
+#include <Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.h>
 #include "Drivers/I2C_Communication/RFID_NFC/NFC.h"
+#include <Utilities/RfidTagHandling.h>
+#include <Drivers/I2C_Communication/RFID_NFC/RFIDTagInfo.h>
+#include <Drivers/I2C_Communication/I2C.h>
+#include <Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h>
+
 
 #include "Stub_Status.h"
 
 void Stub_CartridgeReadRequest(MessageContainer* requestContainer)
 {
-    uint32_t status = PASSED;
+    //uint32_t status = PASSED;
     MessageContainer responseContainer;
 
+    static bool first_time = true;
+
     StubCartridgeReadRequest* request = stub_cartridge_read_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
-    Init_RFID_Reader();
-    uint8_t readerID = request->cartridgeid;
-    Connect_to_RFID_Reder(readerID);//2
+    Cartridge CartridgeRead = CARTRIDGE__INIT;
+    CartridgeTagContent TagRead = CARTRIDGE_TAG_CONTENT__INIT;
+    NFC_Tag NFC_TagRead;
 
     StubCartridgeReadResponse response =   STUB_CARTRIDGE_READ_RESPONSE__INIT;
 
-    response.cartridgeid = request->cartridgeid;
-    response.has_cartridgeid = true;
-
-    response.cartridgecolor = (uid[6] << 24) | (uid[5] << 16) | (uid[4] << 8) | uid[3];
-    //response.cartridgecolor
-    response.has_cartridgecolor = true;
-
-    response.cartridgeversion = (uid[2] << 16) | (uid[1] << 8) | uid[0];
-    //response.cartridgeversion
-    response.has_cartridgeversion = true;
+    uint8_t readerID = request->cartridgeid >> 8;
 
-    response.cartridgedata = RFID_Status;
-    //response.cartridgedata
-    response.has_cartridgedata = false;
+    /*if(request->cartridgeid == 0x0100)
+    {
+        Init_RFID_Reader(readerID);//0-2
+    }
+    else if(request->cartridgeid == 0x0101)
+    {
+        Connect_to_RFID_Reder(readerID);//0-2 - conect the card and get tag id
+    }
+    else if(request->cartridgeid == 0x0102)
+    {
+        Active_RFID_Reader = readerID + 1;
+        if(first_time == true)
+        {
+            TagStage =  Tag_PrepareForDiscovery;
+            first_time = false;
+        }
 
-    //response.cartridgeused
-    response.has_cartridgeused = false;
+        RFIDTagComm_StateMachine(Auto);
+    }
+    */
+    response.cartridge = &CartridgeRead;
+    CartridgeRead.has_index = false;
+    CartridgeRead.has_slot = true;
+    CartridgeRead.slot = request->cartridgeid;
+    CartridgeRead.tag = &TagRead;
 
-    status_response(status,&response.status, &response.statusword ,&response.has_statusword);
-
-
-    Write_status_response(status);
 
     responseContainer = createContainer(MESSAGE_TYPE__StubCartridgeReadResponse, requestContainer->token, true, &response, &stub_cartridge_read_response__pack, &stub_cartridge_read_response__get_packed_size);
+    responseContainer.has_error = false;
+    responseContainer.error = ERROR_CODE__NONE;
+    responseContainer.errormessage = "PASSED";
 
     //-------------------------------------------------------------------------------------------
     uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
@@ -66,7 +82,7 @@ void Stub_CartridgeReadRequest(MessageContainer* requestContainer)
 
 void Stub_CartridgeWriteRequest(MessageContainer* requestContainer)
 {
-    uint32_t status = NOT_SUPPORTED;
+    //uint32_t status = NOT_SUPPORTED;
     MessageContainer responseContainer;
 
     StubCartridgeWriteRequest* request = stub_cartridge_write_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
@@ -80,19 +96,19 @@ void Stub_CartridgeWriteRequest(MessageContainer* requestContainer)
 	
     StubCartridgeWriteResponse response =   STUB_CARTRIDGE_WRITE_RESPONSE__INIT;
 	
-	response.cartridgeid = request->cartridgeid;
+	response.cartridgeid = request->cartridge->slot;
 	response.has_cartridgeid = true;
 	
 //    char temp[7] = "PASSED";
 //    response.status = temp;
 //    response.statusword = OK;
 //    response.has_statusword = true;
-	status_response(status,&response.status, &response.statusword ,&response.has_statusword);
 
-    Write_status_response(status);
 
     responseContainer = createContainer(MESSAGE_TYPE__StubCartridgeWriteResponse, requestContainer->token, true, &response, &stub_cartridge_write_response__pack, &stub_cartridge_write_response__get_packed_size);
-
+    responseContainer.has_error = false;
+    responseContainer.error = ERROR_CODE__NONE;
+    responseContainer.errormessage = "PASSED";
     //-------------------------------------------------------------------------------------------
     uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c
index 213902038..3d2db071e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c
@@ -52,7 +52,11 @@ void Stub_DancerPositionRequest(MessageContainer* requestContainer)
     response.dancer_id = request->dancer_id;
     response.has_dancer_id = true;
 
+    #ifdef FOUR_WINDERS
+    Dancers_4_Winders Dancer_Id = (Dancers_4_Winders)request->dancer_id;//to remove warning
+    #else
     HardwareDancerType Dancer_Id = (HardwareDancerType)request->dancer_id;//to remove warning
+    #endif
 
     if(Dancer_Id < NUM_OF_ROTENC)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_IntADC.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_IntADC.c
index 5e4b9fd85..737116907 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_IntADC.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_IntADC.c
@@ -67,20 +67,21 @@ void Stub_IntADCReadRequest(MessageContainer* requestContainer)
     }
     else
     {
-        ADCAcquireInit();
-        //SysCtlDelay(10000);
-        delayUs(500);
-        ADCAcquireStart(0,1);
-        //SysCtlDelay(10000);
-        delayUs(500);
-        ADC_TriggerCollection();
-        //SysCtlDelay(10000);
-        delayUs(500);
-
-        ADC0SS0Handler();
-        //SysCtlDelay(100000);
-        delayms(1);
+        #ifndef RUN_AS_MAIN_JIG
+                ADCAcquireInit();
+                //SysCtlDelay(10000);
+                delayUs(500);
+                ADCAcquireStart(0,1);
+                //SysCtlDelay(10000);
+                delayUs(500);
+                ADC_TriggerCollection();
+                //SysCtlDelay(10000);
+                delayUs(500);
 
+                ADC0SS0Handler();
+                //SysCtlDelay(100000);
+                delayms(1);
+        #endif
 
         request->adc_device  = (request->adc_device & 0x1F) ;//the max id is 0x14
 
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 1663219bd..e527e3c0b 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
@@ -190,9 +190,7 @@ void Stub_MotorRunRequest(MessageContainer* requestContainer)
     Run_Value = /*SpdCalc*/(temp);
     Direction = request->direction;
 
-    /*#ifdef TEST_POWERSTEP01
-        Direction = Direction^1;
-    #endif*/
+
 
 #ifdef EVALUATION_BOARD
     //SPI_Control(SKIP_INIT);
@@ -379,7 +377,10 @@ void Stub_MotorStatusRequest(MessageContainer* requestContainer)
            }
            else
            {
-                 read_status = Get_Param(x_STATUS);
+               #ifdef EVALUATION_BOARD
+                   read_status = Get_Param(x_STATUS);// Function only for evaluation board !!!!!
+                   //if needed use Motor_Get_Param_Horizontal_Printing_powerstep01_rev10.cs
+               #endif
            }
 
 
@@ -554,9 +555,7 @@ void Stub_MotorMovRequest(MessageContainer* requestContainer)
     Pos_Value = request->position;
     Direction = request->direction;
 
-/*    #ifdef TEST_POWERSTEP01
-        Direction = Direction^1;
-    #endif*/
+
 
     MotorGetnBusyFromFPGA(); //temporary -
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c
index f4384ab94..bd9b18ab9 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c
@@ -40,6 +40,7 @@
 #include "Modules/thread/thread.h"
 #include "Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h"
 #include "Drivers/I2C_Communication/Head_Card/PT100/ADS122X04.h"
+#include "Modules/Control/MillisecTask.h"
 
 void Stub_TempSensorRequest(MessageContainer* requestContainer)
 {
@@ -149,6 +150,7 @@ void Stub_TempSensorRequest(MessageContainer* requestContainer)
             response.temperature_c_mult_by_100 = TempSensorResponse[request->stemp_sensor_id].Temperature_C_mult_by_100;
         }
 
+        response.temperature_c_mult_by_100 = MillisecGetTemperatures(request->stemp_sensor_id);
 
 
     /*
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
index d1d23598f..13032f49d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
@@ -17,6 +17,7 @@
 #include "../control/pidalgo.h"
 
 #include "thread_ex.h"
+#include "drivers/SSI_Comm/SSI_Comm.h"
 
 #define NORMAL_COEF_DIVIDER 100
 typedef struct
@@ -42,12 +43,27 @@ typedef struct
     PID_Config_Params   m_params;
 }MotorControlConfig_t;
 
+#ifdef FOUR_WINDERS
+#define SCREW_2_Motor  HARDWARE_MOTOR_TYPE__MOTO_SPARE2_1
+#define SCREW_3_Motor  HARDWARE_MOTOR_TYPE__MOTO_SPARE1_1
+#define SCREW_4_Motor  HARDWARE_MOTOR_TYPE__MOTO_RDANCER
+#define Winder_2_Motor HARDWARE_MOTOR_TYPE__MOTO_SPARE2_2
+#define Winder_3_Motor HARDWARE_MOTOR_TYPE__MOTO_SPARE1_2
+#define Winder_4_Motor HARDWARE_MOTOR_TYPE__MOTO_RLOADARM
+#endif
+
 
 #define MAX_THREAD_FEED_MOTORS (WINDER_MOTOR+1)
-#define MAX_SYSTEM_DANCERS (HARDWARE_DANCER_TYPE__RightDancer+1)
+#define MAX_SYSTEM_DANCERS NUM_OF_ROTENC
 
 extern TimerMotors_t ThreadMotorIdToMotorId[MAX_THREAD_MOTORS_NUM];
+
+#ifdef FOUR_WINDERS
+extern Dancers_4_Winders ThreadMotorIdToDancerId[MAX_THREAD_MOTORS_NUM];
+#else
 extern HardwareDancerType ThreadMotorIdToDancerId[MAX_THREAD_MOTORS_NUM];
+#endif
+
 extern HardwarePidControlType ThreadMotorIdToControlId[MAX_THREAD_MOTORS_NUM];
 
 extern bool BreakSensorenabled;
@@ -76,7 +92,6 @@ extern int MotorSpeedSamplePointer[MAX_THREAD_MOTORS_NUM];
 uint32_t InternalWinderConfigMessage(HardwareWinder* request);
 uint32_t MotorsConfigMessage( HardwareConfiguration* HW_request);
 uint32_t InternalWindingConfigMessage(JobSpool* request);
-uint32_t ThreadInitialTestStub(HardwareMotor * request);
 uint32_t MotorPidRequestMessage(HardwarePidControl* request);
 void     SetKeepWindingCone(bool value);
 void SetWinderBackToBaseTime(uint32_t value);
@@ -85,6 +100,10 @@ uint32_t DancerConfigMessage(HardwareDancer * request);
 uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Read);
 
 void SetOriginMotorSpeed(float process_speed);
+uint32_t UpdatePidDuringRun(HardwarePidControl *hardwarepidcontrol);
+
+uint32_t ThreadPrepare_Tension (int DancerId, double tension);
+
 
 #endif //MODULES_THREAD_THREAD_H_
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 19392c754..63072e4d8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -16,7 +16,7 @@
 #include "Modules/Control/control.h"
 #include "Modules/General/process.h"
 #include "Modules/control/pidalgo.h"
-
+#include "Modules/AlarmHandling/AlarmHandling.h"
 #include "Modules/heaters/heaters_ex.h"
 #include "Modules/General/buttons.h"
 #include "StateMachines/Initialization/InitSequence.h"
@@ -35,6 +35,7 @@
 #include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
 #include <Drivers/I2C_Communication/I2C_Task.h>
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
+#include "drivers/FPGA/Full_Vme/FPGA_Programming_Up.h"
 
 #include "PMR/Stubs/StubHeatingTestRequest.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestResponse.pb-c.h"
@@ -44,26 +45,28 @@
 #include "PMR/ThreadLoading/StartThreadLoadingResponse.pb-c.h"
 #include "PMR/ThreadLoading/ContinueThreadLoadingRequest.pb-c.h"
 #include "PMR/ThreadLoading/ContinueThreadLoadingResponse.pb-c.h"
+#include "PMR/ThreadLoading/TryThreadLoadingRequest.pb-c.h"
+#include "PMR/ThreadLoading/TryThreadLoadingResponse.pb-c.h"
 #include "PMR/ThreadLoading/StopThreadLoadingRequest.pb-c.h"
 #include "PMR/ThreadLoading/StopThreadLoadingResponse.pb-c.h"
 
 //#include <stdint.h>
 //#include <stdbool.h>
     static char* LoadStagesStr[15] = {
-    /*00*/ "INIT",
-    /*01*/ "REDUCE_HEAT",
-    /*02*/ "LIFT_ROCKERS",
-    /*03*/ "SET_LOAD_ARM",
-    /*04*/ "OPEN_COVERS",
-    /*05*/ "LIFT_DANCERS",
-    /*06*/ "INITIAL_TENSION",
-    /*07*/ "CLOSE_ROCKERS",
-    /*08*/ "CLOSE_DANCERS",
-    /*09*/ "CLOSE_LIDS",
-    /*10*/ "JOG_FEEDER",
-    /*11*/ "DRYER_LOADING",
-    /*12*/ "RESUME_HEATING",
-    /*13*/ "JOG_THREAD" ,
+    /*00*/ "Initialization",
+    /*01*/ "Heating stop",
+    /*02*/ "Rockers opening",
+    /*03*/ "Dryer unloading",
+    /*04*/ "Lids opening",
+    /*05*/ "Dancers opening",
+    /*06*/ "Initial tension building",
+    /*07*/ "Rockers closing",
+    /*08*/ "Dancers closing",
+    /*09*/ "Lids closing",
+    /*10*/ "Feeder jogging",
+    /*11*/ "Dryer loading",
+    /*12*/ "Heating resuming",
+    /*13*/ "Thread jogging" ,
     /*14*/ "END"};
 
 /*    typedef enum
@@ -91,7 +94,7 @@
     uint32_t LoadStatus = OK;
     char LoadErrorMsg[100];
     int32_t keepmicrostep;
-    int32_t keepkvalrun,keepkvalhold;
+    int32_t keepkvalrun,keepkvalhold,kval_upperValue;
     uint8_t CallbackCounter = 0;
     uint8_t TimeoutsCounter = 0;
     bool SecondTry = false,TryAgain = false;
@@ -100,7 +103,7 @@
     uint32_t UnloadingStart = 0;
     uint8_t NumberOfDrierLoaderCycles = 0;
     uint32_t status = OK;
-    uint32_t LoadingControlId = 0xFF,PullerControlId = 0xFF,WinderControlId = 0xFF, SpeedTControlId = 0xFF;
+    uint32_t LoadingControlId = 0xFF,PullerControlId = 0xFF,WinderControlId = 0xFF, SpeedTControlId = 0xFF,ThreadLoadControlId = 0xFF;
     uint32_t previousPosition = 0, currentPosition = 0,Tinitialpos = 0xFFFF;
     uint32_t LoadCounter = 0;
     double TotalLoadedLen = 0.0;
@@ -108,16 +111,22 @@
     float numberOfSteps = 0;
     float numberOfCycles = 0;
     double DrierPrevLocation = 0;
-    FPGA_GPI_ENUM screw[2] = {GPI_LS_SCREW_LEFT,GPI_LS_SCREW_RIGHT};
+    int DrierCenterLocation = 0;
+    FPGA_GPI_ENUM screw[2] = {GPI_LS_SCREW_RIGHT,GPI_LS_SCREW_LEFT};
     int Screw_Dir = false;
     bool InitCalled = false;
     uint32_t LoadArmRounds;
 
+    int CurrentlyLoaded = 0;
     uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM LoadStages);
     uint32_t ThreadLoadControlCBFunction(uint32_t index, uint32_t ReadValue);
     uint32_t ThreadLoadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue);
+    uint32_t ThreadUpdateCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
+
+
     uint32_t Thread_Load_Dryer_UnLoading(void);
     uint32_t ThreadLoadingReport(void);
+    uint32_t ThreadLoadingRestartReport(void); //sending after a failure in the finalizing stage
     bool ThreadLoaded(void);
     bool ThreadLoadingActive(void)
     {
@@ -138,12 +147,8 @@
         //EEPROM_STORAGE_DRYER_CYCLES
         MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
 
+        Report("Read_Dryer_ENC_Position()",__FILE__,__LINE__,LoadArmRounds,RpWarning,Read_Dryer_ENC_Position(),0);
 
-        Report("Read_Dryer_ENC_Position()",__FILE__,__LINE__,0,RpWarning,Read_Dryer_ENC_Position(),0);
-
-        Report("MotorMovetoEncoderPosition",__FILE__,__LINE__,LoadArmRounds,RpWarning,0,0);
-
-        Report("Thread_Load_Init",__FILE__,__LINE__,LoadArmRounds,RpMessage,LoadArmRounds,0);
         StopInitSequence();
         memcpy (&ProcessParametersRecover,&ProcessParametersKeep,sizeof(ProcessParameters));
         //NumberOfDrierLoaderCycles = loadLoadArmParameters();
@@ -163,6 +168,11 @@
     uint32_t Thread_Load_Reduce_Heat(void)
     {
 
+        if (Is_PP_Machine())
+            kval_upperValue = 28;
+        else
+            kval_upperValue = 70;
+
         //Heaters Off, Dryer Blower Off, Blower Low,
         REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Reduce_Heat");
         memcpy (&ProcessParametersClear,&ProcessParametersKeep,sizeof(ProcessParameters));
@@ -188,18 +198,23 @@
         ProcessParametersClear.lblowerflow  = 0;
         ProcessParametersClear.dyeingspeed = 40;
         ProcessParametersClear.dryerbufferlength = ProcessParametersKeep.dryerbufferlength;
+        ProcessParametersClear.pullertension = ProcessParametersKeep.pullertension;
+        ProcessParametersClear.windertension = ProcessParametersKeep.windertension;
+
         if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
         {
             LOG_ERROR (LoadStages, "Thread_Load_Reduce_Heat failed");
             strcpy(LoadErrorMsg,"Thread_Load_Reduce_Heat failed");
+            load.color = fastBILNK;
             LoadStatus = ERROR;
             TryAgain = true;
+            //ThreadLoadButton(LoadStages);
         }
         else
         {
-            if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+            if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
             {
-                WHS_Set_SetPoint_Q_value(headairflow/2);
+                WHS_Set_SetPoint_Q_value(headairflow);
             }
             else
             {
@@ -215,40 +230,57 @@
         }
         return OK;
     }
+    uint32_t Thread_Load_Set_Load_Arm_To_Stopper_OnError_Callback(uint32_t deviceID, uint32_t BusyFlag)
+    {
+
+        Report("Thread_Load_Set_Load_Arm_To_Stopper_OnError_Callback time",__FILE__,msec_millisecondCounter - UnloadingStart,msec_millisecondCounter,RpMessage,UnloadingStart,0);
+
+        Report("Thread_Load_Set_Load_Arm_To_Stopper_OnError_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+        NumberOfDrierLoaderCycles=0;
+        //storeLoadArmParameters();
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Stop);
+        SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
+        MotorAbortMovetoLimitSwitch(HARDWARE_MOTOR_TYPE__MOTO_SCREW);
+
+        return OK;
+    }
     uint32_t Thread_Load_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_t BusyFlag)
     {
+        uint32_t angle, temp = Read_Dryer_ENC_Position();
 
-        /*if(PullerControlId != 0xFF)
-        {
-            MotorStop(ThreadMotorIdToMotorId[POOLER_MOTOR],Hard_Hiz);
-            RemoveControlCallback(PullerControlId, ThreadLoadControlCBFunction );
-            PullerControlId = 0xFF;
-        }*/
-        if(WinderControlId != 0xFF)
+        ReportWithPackageFilter(DiagnosticsFilter,"Thread_Load_Set_Load_Arm_To_Stopper_Callback",__FILE__,(int)numberOfCycles,(int)DrierPrevLocation,RpMessage,temp,0);
+
+        angle = Calculate_Arm_Distance(DrierPrevLocation,temp);
+
+        DrierPrevLocation = temp;
+        if (CallbackCounter)
         {
-            MotorStop(ThreadMotorIdToMotorId[WINDER_MOTOR],Hard_Hiz);
-            RemoveControlCallback(WinderControlId, ThreadLoadControlCBFunction );
-            WinderControlId = 0xFF;
+            CallbackCounter--;
         }
+        if ((angle>14000  )&&(BusyFlag == NOTBUSY)) // OK - take another round
+        {
+            Report("Thread_Load_Set_Load_Arm_To_Stopper time",__FILE__,msec_millisecondCounter - UnloadingStart,msec_millisecondCounter,RpMessage,UnloadingStart,0);
 
-        MotorAbortMovetoLimitSwitch(HARDWARE_MOTOR_TYPE__MOTO_SCREW);
-        /*Task_sleep(5)
-        MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);
-        MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);*/
+            Report("Thread_Load_Set_Load_Arm_To_Stopper_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+            NumberOfDrierLoaderCycles=0;
+            //storeLoadArmParameters();
+            LoadStages++;
+
+            ThreadLoadStateMachine(LoadStages);
+        }
+        else
+        {
+            load.color = fastBILNK;
+            usnprintf(LoadErrorMsg, 100, "Stage %s - %s timeout",LoadStagesStr[LoadStages], MotorStr[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM]);
+            Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
 
-        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,Hard_Hiz);
+            LoadStatus = ERROR;
+            ThreadLoadingReport();
+            TryAgain = true;
+            //ThreadLoadButton(LoadStages);
+        }
 //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();
-        LoadStages++;
-        SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
-
-        ThreadLoadStateMachine(LoadStages);
         return OK;
     }
     uint32_t Thread_Load_HomingCallback(uint32_t MotorId, uint32_t ReadValue)
@@ -284,12 +316,13 @@
                 {
                     TimeoutsCounter = 0;
                     load.color = fastBILNK;
-                    usnprintf(LoadErrorMsg, 100, "Load sequence timeout %s motor %d",LoadStagesStr[LoadStages], MotorId);
+                    usnprintf(LoadErrorMsg, 100, "Stage %s - %s timeout",LoadStagesStr[LoadStages], MotorStr[MotorId]);
                     Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
 
                     LoadStatus = ERROR;
                     ThreadLoadingReport();
                     TryAgain = true;
+                    //ThreadLoadButton(LoadStages);
                 }
                 else
                 {
@@ -306,6 +339,7 @@
                     else
                     {
                         load.color = colorON;
+                        Pannel_Leds(THREAD_LOAD, MODE_ON);
                         ThreadLoadingReport();
                     }
                 }
@@ -323,13 +357,30 @@
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
         //DeActivateHeadMagnet();
         CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
-        CallbackCounter++;
         //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 0, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        Report("Thread_Load_Lift_actuators",__FILE__,__LINE__,LOW,RpMessage,false,0);
-        Trigger_Head_Actuators_Control(ACTOT, LOW,false);
-        Trigger_Head_Actuators_Control(ACTIN, LOW,false);
+        int direction;
+        if (MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType == CombinrdMotDriver)//reverse direction for powerstep
+        {
+            direction = DRIER_LID_CLOSE;
+        }
+        else
+        {
+            direction = DRIER_LID_OPEN;
+        }
+        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
+        if (Head_Type != HEAD_TYPE_ARC)
+        {
+            CallbackCounter++;
+            if (MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 300,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,20000)==ERROR)
+            {
+                Thread_Load_HomingCallback(HARDWARE_MOTOR_TYPE__MOTO_DH_LID,NO_LIMIT);
+            }
+        }
+        if (Head_Type == HEAD_TYPE_FLAT)
+        {
+            Report("Thread_Load_Lift right actuator",__FILE__,__LINE__,LOW,RpMessage,false,0);
+            Trigger_Head_Actuators_Control(ACTIN, LOW,true);//UP
+        }
         return OK;
     }
     uint32_t Thread_Load_Lift_Dancers(void)
@@ -349,6 +400,12 @@
             status |= MCU_E2PromProgram(EEPROM_PULLER_TENSION_POSITION,1);
 
         }
+        if (Head_Type == HEAD_TYPE_FLAT)
+        {
+            Report("Thread_Load_Lift left actuator",__FILE__,__LINE__,LOW,RpMessage,false,0);
+            Trigger_Head_Actuators_Stub(ACTOT, ENABLE, UP);
+        }
+
         return OK;
     }
     uint32_t Thread_Load_Lift_Rockers(void)
@@ -356,8 +413,8 @@
     {
         keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
         keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
-        if (keepkvalrun>=25)
-            keepkvalrun = 25;
+        /*if (keepkvalrun>=25)
+            keepkvalrun = 25;*/
 
         Report("Read_Dryer_ENC_Position()",__FILE__,__LINE__,0,RpWarning,Read_Dryer_ENC_Position(),0);
 
@@ -372,8 +429,8 @@
         REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Lift_Rockers");
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 8);
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 8);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, kval_upperValue);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, kval_upperValue);
         Task_sleep(10);
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 250,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,35000);
@@ -389,6 +446,7 @@
         if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
         {
             REPORT_MSG(LIMIT, "No cone in winder");
+            Thread_Load_HomingCallback(HARDWARE_MOTOR_TYPE__MOTO_WINDER,NO_LIMIT);
             //return ERROR;
         }
         CallbackCounter++;
@@ -401,43 +459,67 @@
     {
         keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
         keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
-        if (keepkvalrun>=25)
-            keepkvalrun = 25;
+        /*if (keepkvalrun>=25)
+            keepkvalrun = 25;*/
         Report("Thread_Load_Close_Rockers",__FILE__,__LINE__,keepkvalrun,RpMessage,keepmicrostep,0);
 
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 8);
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 8);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, kval_upperValue);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, kval_upperValue);
 
         REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Close_Rockers");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 250,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,25000);
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize, 250,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LLOADING], Thread_Load_HomingCallback,25000);
+        if (Head_Type == HEAD_TYPE_FLAT)
+        {
+            Report("Thread_Load_Close left actuator",__FILE__,__LINE__,LOW,RpMessage,true,0);
+            Trigger_Head_Actuators_Stub(ACTOT, ENABLE, DOWN);
+        }
 
         return OK;
     }
     uint32_t Thread_Load_Close_Dancers(void)
     //Send Dancer Motors To Preset Location, Check That The Dancers Are On The Thread
     {
+        uint32_t  current = 1;
         REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Close_Dancers");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 15,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,10000);
-        CallbackCounter++;
-        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1, 500);
+
+        Report("Thread_Load_Close dancers tension",__FILE__,__LINE__,(int)windertension,RpMessage,(int)pullertension,0);
 
 //        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 500,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
-        MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, ((int)windertension*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].microstep), Thread_Load_HomingCallback,20000);
-        status |= MCU_E2PromProgram(EEPROM_WINDER_TENSION_POSITION,(int)windertension);
-        if (Is_PP_Machine() == true) //PP machine - new LTFU
+        status |= MCU_E2PromRead(EEPROM_WINDER_TENSION_POSITION,&current);
+
+        ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__LeftDancer, windertension);
+/*        if (current!=windertension)
         {
             CallbackCounter++;
-            MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, 500);
-            MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].directionthreadwize, ((int)pullertension*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].microstep), Thread_Load_HomingCallback,20000);
-            status |= MCU_E2PromProgram(EEPROM_PULLER_TENSION_POSITION,(int)pullertension);
-        }
+            MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1, 500);
+            MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, ((int)windertension*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].microstep), Thread_Load_HomingCallback,20000);
+            status |= MCU_E2PromProgram(EEPROM_WINDER_TENSION_POSITION,(int)windertension);
+        }*/
+        if (Is_PP_Machine() == true) //PP machine - new LTFU
+        {
+            ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__MiddleDancer, pullertension);
+            /*status |= MCU_E2PromRead(EEPROM_PULLER_TENSION_POSITION,&current);
+            if (current!=pullertension)
+            {
+                CallbackCounter++;
+                MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, 500);
+                MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].directionthreadwize, ((int)pullertension*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].microstep), Thread_Load_HomingCallback,20000);
+                status |= MCU_E2PromProgram(EEPROM_PULLER_TENSION_POSITION,(int)pullertension);
+            }*/
 
+        }
+        if (Head_Type == HEAD_TYPE_FLAT)
+        {
+            Report("Thread_Load_Close right actuators",__FILE__,__LINE__,LOW,RpMessage,true,0);
+            HeadCard_Actuators_Relocate();
+        }
         return OK;
     }
     uint32_t Thread_Load_Close_Lids(void)
@@ -447,23 +529,37 @@
         //HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2,
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
         CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
-        CallbackCounter++;
 //        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 2, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        Report("Thread_Load_Close_actuators",__FILE__,__LINE__,LOW,RpMessage,true,0);
-        Trigger_Head_Actuators_Control(ACTOT, LOW,true);
-        Trigger_Head_Actuators_Control(ACTIN, LOW,true);
+        int direction;
+        if (MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType == CombinrdMotDriver)//reverse direction for powerstep
+        {
+            direction = DRIER_LID_OPEN;
+        }
+        else
+        {
+            direction = DRIER_LID_CLOSE;
+        }
+        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
+        if (Head_Type != HEAD_TYPE_ARC)
+        {
+            CallbackCounter++;
+            if(MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 300,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,20000)==ERROR)
+            {
+                Thread_Load_HomingCallback(HARDWARE_MOTOR_TYPE__MOTO_DH_LID,NO_LIMIT);
+            }
+        }
+
         return OK;
     }
     uint32_t Thread_Load_Resume_Heating(void)
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Resume_Heating");
         ActivateHeadMagnet();
+        HeadCard_Actuators_Relocate();
 
         if (HandleProcessParameters(&ProcessParametersRecover,false)!= OK)
         {
-            usnprintf(LoadErrorMsg, 100, "Load sequence error %d",LoadStagesStr[LoadStages]);
+            usnprintf(LoadErrorMsg, 100, "Stage %s error",LoadStagesStr[LoadStages]);
             Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
         }
         else
@@ -504,6 +600,7 @@
                 LoadStatus = ERROR;
                 ThreadLoadingReport();
                 TryAgain = true;
+                //ThreadLoadButton(LoadStages);
             }
         }
 
@@ -557,7 +654,7 @@
     {
         numberOfCycles++;
 
-        Report("Thread_Load_Dryer_Loading_Callback",__FILE__,(int)TotalLoadedLen,(int)DrierPrevLocation,RpMessage,ReadValue,0);
+        Report("Thread_Load_Dryer_Loading_Callback",__FILE__,(int)TotalLoadedLen,(int)DrierPrevLocation,RpMessage,numberOfCycles,0);
 
         if ((fabs (TotalLoadedLen  -DrierPrevLocation)>50  )&&(ReadValue == NOTBUSY))
         {
@@ -568,6 +665,7 @@
             {
                 return OK;
             }
+            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,numberOfCycles+CurrentlyLoaded);
             if (numberOfCycles<LoadArmRounds)
             {
                 MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
@@ -575,20 +673,20 @@
             }
             else
             {
-                MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Thread_Load_Dryer_MovetoEncoderPosition_Callback,10000);
-                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,numberOfCycles);
-                Report("Store Number of cycles in drier",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
+                MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Thread_Load_Dryer_MovetoEncoderPosition_Callback,30000,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,40);
+                Report("Store Number of cycles in dryer",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
             }
         }
         else
         {
             TryAgain = true;
             SecondTry = false;
-            Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
-            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,numberOfCycles);
+            Report("Loading dryer - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
+            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,numberOfCycles+CurrentlyLoaded);
             TimeoutsCounter = 0;
+            CallbackCounter = 0;
             load.color = fastBILNK;
-            usnprintf(LoadErrorMsg, 100, "Load sequence timeout %s motor %d",LoadStagesStr[LoadStages], HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);
+            usnprintf(LoadErrorMsg, 100, "Stage %s - Dryer load arm timeout",LoadStagesStr[LoadStages]);
             Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
             LoadStatus = ERROR;
             MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
@@ -606,6 +704,7 @@
             Report("Total Feeder load",__FILE__,__LINE__,dryerbufferCentimeters,RpMessage,TotalLoadedLen,0);
 
             ThreadLoadingReport();
+            //ThreadLoadButton(LoadStages);
         }
         return OK;
     }
@@ -623,7 +722,12 @@
 //        OriginalMotorSpd_2PPS[FEEDER_MOTOR] = 1000;
 //        CurrentControlledSpeed[FEEDER_MOTOR] = 1000;
 
-        //MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds);
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&CurrentlyLoaded);
+        Report("Thread_Load_Dryer_Loading cycles",__FILE__,LoadArmRounds,CurrentlyLoaded,RpMessage,LoadArmRounds-CurrentlyLoaded,0);
+        if (CurrentlyLoaded)
+        {
+            LoadArmRounds -= CurrentlyLoaded;
+        }
         ThreadMotorIdToMotorId[FEEDER_MOTOR] = HARDWARE_MOTOR_TYPE__MOTO_RDRIVING ;
         ThreadMotorIdToMotorId[DRYER_MOTOR] = HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING;
 
@@ -637,7 +741,7 @@
         MotorControlConfig[FEEDER_MOTOR].m_params.MIN = MotorsControl[FEEDER_MOTOR].outputproportionalpowerlimit*-1;
         MotorControlConfig[FEEDER_MOTOR].m_params.Kd = MotorsControl[FEEDER_MOTOR].derivativetime;
         MotorControlConfig[FEEDER_MOTOR].m_params.Kp = MotorsControl[FEEDER_MOTOR].proportionalgain;
-        MotorControlConfig[FEEDER_MOTOR].m_params.Ki = MotorsControl[FEEDER_MOTOR].integraltime;
+        MotorControlConfig[FEEDER_MOTOR].m_params.Ki = 0;//MotorsControl[FEEDER_MOTOR].integraltime;
         MotorControlConfig[FEEDER_MOTOR].m_params.IntegralErrorMultiplier = MotorsControl[FEEDER_MOTOR].setpointramprateorsoftstartramp;
         MotorControlConfig[FEEDER_MOTOR].m_params.ProportionalErrorMultiplier = MotorsControl[FEEDER_MOTOR].outputonoffhysteresisvalue;
         MotorControlConfig[FEEDER_MOTOR].m_params.epsilon = MotorsControl[FEEDER_MOTOR].epsilon;
@@ -652,7 +756,8 @@
         MotorControlConfig[FEEDER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage
         MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize);
 
-        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
+        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
+        //6 seconds per round
 
         LoadingControlId = AddControlCallback(NULL,ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
         Report("AddControlCallback feeder",__FILE__,__LINE__,LoadingControlId,RpMessage,IfTypeThread*0x100+FEEDER_MOTOR,0);
@@ -670,9 +775,10 @@
         CallbackCounter++;
         Report("Thread_Load_Dryer_Loading",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
         MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
-                               numberOfSteps-400,    Thread_Load_Dryer_Loading_Callback, 10000);
+                               numberOfSteps-800,    Thread_Load_Dryer_Loading_Callback, 10000);
         return OK;
     }
+    double keepfeedertension = 0;
     uint32_t Thread_Load_Jog_ThreadStop(uint32_t index, uint32_t ReadValue)
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Jog_ThreadStop");
@@ -680,6 +786,7 @@
         LoadingControlId = 0xFF;
         ThreadAbortJoggingFunc();
         LoadStages++;
+        ProcessParametersKeep.feedertension = keepfeedertension;
         ThreadLoadStateMachine(LoadStages);
         return OK;
     }
@@ -687,6 +794,8 @@
     //Jog Thread Shortly To Make Sure Spool Is Running. Report End Of Loading
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Jog_Thread");
+        keepfeedertension = feedertension;
+        ProcessParametersKeep.feedertension = 0.0;
         ThreadJoggingFunc(20);
         LoadingControlId = AddControlCallback("Load jog",Thread_Load_Jog_ThreadStop, eOneSecond*25,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
         return OK;
@@ -718,7 +827,13 @@
            RemoveControlCallback(SpeedTControlId, ThreadLoadLengthCBFunction );
            SpeedTControlId = 0xFF;
         }
+        if (ThreadLoadControlId != 0xFF)
+        {
+           RemoveControlCallback(ThreadLoadControlId, ThreadUpdateCallBackFunction );
+           ThreadLoadControlId = 0xFF;
+        }
 
+        LoadingStopArmReset();
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_RLOADING);
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_LLOADING);
@@ -726,7 +841,10 @@
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_LDANCER1);
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID);
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_DH_LID);
-        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Stop);
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,Hard_Stop);
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_WINDER,Hard_Hiz);
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_SCREW,Hard_Hiz);
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,Hard_Hiz);
         if (LoadStages!=THREAD_LOAD_END)
         {
             usnprintf(LoadErrorMsg, 100, "Load sequence stopped by user on stage %d",LoadStages);
@@ -735,6 +853,7 @@
 
         LoadStages = THREAD_LOAD_INIT;
         load.color = colorON;
+        Pannel_Leds(THREAD_LOAD, MODE_ON);
         return OK;
     }
     uint32_t Thread_Load_switchCallback(uint32_t deviceID, uint32_t BusyFlag)
@@ -745,49 +864,62 @@
         }
         Screw_Dir = 1-Screw_Dir;
         // movement of the screw while unloading the thread from the dryer to the spool
-        status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,Screw_Dir, 80, screw[Screw_Dir], Thread_Load_switchCallback,13000);
+        AlarmHandlingSetAlarm (EVENT_TYPE__SCREW_MOTOR_LIMIT_TIMEOUT,OFF);  //handle alarm detection and operation
+        status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,Screw_Dir, 80, screw[Screw_Dir], Thread_Load_switchCallback,20000);
 
         return OK;
     }
-    uint32_t Thread_Load_Dryer_UnLoading_Callback(uint32_t MotorId, uint32_t ReadValue)
+    /*uint32_t Thread_Load_Dryer_UnLoading_Callback(uint32_t MotorId, uint32_t ReadValue)
     {
+        bool direction;
         numberOfCycles++;
         uint32_t temp = Read_Dryer_ENC_Position();
-        Report("Thread_Load_Dryer_UnLoading_Callback",__FILE__,ReadValue,temp,RpMessage,DrierPrevLocation,0);
+        Report("Thread_Load_Dryer_UnLoading_Callback",__FILE__,AccumulatedArmMovement,temp,RpMessage,DrierPrevLocation,0);
         //Report("Thread_Load_Dryer_UnLoading_Callback details",__FILE__,(int)(TotalLoadedLen),numberOfCycles,RpMessage,CallbackCounter,0);
         if (LoadStages != THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION)
         {
             Report("Thread_Load_Dryer_UnLoading_Callback wrong state",__FILE__,__LINE__,LoadStages,RpMessage,DrierPrevLocation,0);
             return OK;
         }
-        if ((abs (temp -DrierPrevLocation)>1000  )&&(ReadValue == NOTBUSY)) // OK - take another round
+        if ((AccumulatedArmMovement>8000  )&&(ReadValue == NOTBUSY)) // OK - take another round
         {
             DrierPrevLocation = temp;
             Report("Thread_Load_Dryer_UnLoading cycles",__FILE__,numberOfCycles,LoadArmRounds,RpMessage,0,0);
             if (numberOfCycles<LoadArmRounds)
             {
+                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-numberOfCycles);
                 MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
-                                       numberOfSteps,    Thread_Load_Dryer_UnLoading_Callback, 30000);
+                                       numberOfSteps,    Thread_Load_Dryer_UnLoading_Callback, 10000);
             }
             else //done enough cycles, go to the center point
             {
-                MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Thread_Load_Set_Load_Arm_To_Stopper_Callback,10000);
-                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-numberOfCycles);
-                Report("Store Number of cycles in drier",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
+                MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Thread_Load_Set_Load_Arm_To_Stopper_Callback,30000,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,40);
+                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,0);
+                Report("Store Number of cycles in dryer",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
             }
         }
         else  //timeout or no movement
         {
-            Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
-            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-(numberOfCycles-2));//it takes two cycles to identify a stop of the arm
+            Report("Unloading dryer - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
+            if (SecondTry == true)
+                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,0);
+            else
+                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-numberOfCycles);
+            if (abs(temp -DrierCenterLocation)<200)
+            {
+                if (temp<DrierCenterLocation)
+                    direction = 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize;
+                else
+                    direction = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize;
+                MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Thread_Load_Set_Load_Arm_To_Stopper_OnError_Callback,3000,direction,10);
+
+            }
+            else
+                MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Stop);
+
+
             TimeoutsCounter = 0;
             CallbackCounter = 0;
-            /*if(PullerControlId != 0xFF)
-            {
-                MotorStop(ThreadMotorIdToMotorId[POOLER_MOTOR],Hard_Hiz);
-                RemoveControlCallback(PullerControlId, ThreadLoadControlCBFunction );
-                PullerControlId = 0xFF;
-            }*/
             if(WinderControlId != 0xFF)
             {
                 MotorStop(ThreadMotorIdToMotorId[WINDER_MOTOR],Hard_Hiz);
@@ -796,109 +928,61 @@
             }
 
             MotorAbortMovetoLimitSwitch(HARDWARE_MOTOR_TYPE__MOTO_SCREW);
-            /*Task_sleep(5)
-            MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);
-            MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);*/
 
             MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,Hard_Hiz);
-            MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Stop);
             load.color = fastBILNK;
-            usnprintf(LoadErrorMsg, 100, "Load sequence timeout %s motor %d",LoadStagesStr[LoadStages], HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);
+            usnprintf(LoadErrorMsg, 100, "Stage %s - Dryer load arm timeout",LoadStagesStr[LoadStages]);
             Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
-            Report("Drier unloading timeout(1) or no movement",__FILE__,temp,DrierPrevLocation,RpWarning,ReadValue,0);
+            Report("Dryer unloading timeout(1) or no movement",__FILE__,temp,DrierPrevLocation,RpWarning,ReadValue,0);
             LoadStatus = ERROR;
             TryAgain = true;
             ThreadLoadingReport();
+            //ThreadLoadButton(LoadStages);
         }
         return OK;
-    }
+    }*/
     uint32_t Thread_Load_Dryer_UnLoading(void)
     {
         uint32_t temp;
-        REPORT_MSG(LoadStages, "Thread UnLoad State Machine step");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Dryer Unloading");
         //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(22);
-//        OriginalMotorSpd_2PPS[FEEDER_MOTOR] = 1000;
-//        CurrentControlledSpeed[FEEDER_MOTOR] = 1000;
-
-// Rockers are up already, so puller handling is not needed
-        //numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
-        /*MotorControlConfig[POOLER_MOTOR].m_params.MAX = 1;
-        MotorControlConfig[POOLER_MOTOR].m_params.MIN = MotorsControl[POOLER_MOTOR].outputproportionalpowerlimit*-1;
-        MotorControlConfig[POOLER_MOTOR].m_params.Kd = MotorsControl[POOLER_MOTOR].derivativetime;
-        MotorControlConfig[POOLER_MOTOR].m_params.Kp = MotorsControl[POOLER_MOTOR].proportionalgain;
-        MotorControlConfig[POOLER_MOTOR].m_params.Ki = 0;//MotorsControl[POOLER_MOTOR].integraltime;
-        MotorControlConfig[POOLER_MOTOR].m_params.IntegralErrorMultiplier = MotorsControl[POOLER_MOTOR].setpointramprateorsoftstartramp;
-        MotorControlConfig[POOLER_MOTOR].m_params.ProportionalErrorMultiplier = MotorsControl[POOLER_MOTOR].outputonoffhysteresisvalue;
-        MotorControlConfig[POOLER_MOTOR].m_params.epsilon = MotorsControl[POOLER_MOTOR].epsilon;
-        MotorControlConfig[POOLER_MOTOR].m_params.dt = MotorsControl[POOLER_MOTOR].controloutputtype;
-        MotorControlConfig[POOLER_MOTOR].m_ingnoreValue =  MotorsControl[POOLER_MOTOR].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
-        MotorControlConfig[POOLER_MOTOR].m_calculatedError = 0;
-        MotorControlConfig[POOLER_MOTOR].m_integral = 0;
-        MotorControlConfig[POOLER_MOTOR].m_isEnabled = true;
-        MotorControlConfig[POOLER_MOTOR].m_isReady = true;
-        MotorControlConfig[POOLER_MOTOR].m_mesuredParam = 0;
-        MotorControlConfig[POOLER_MOTOR].m_preError = 0;
-        MotorControlConfig[POOLER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage
-        MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDRIVING].directionthreadwize);
-
-        PullerControlId = AddControlCallback(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+POOLER_MOTOR),POOLER_DANCER,POOLER_MOTOR);
-        Report("AddControlCallback Puller",__FILE__,__LINE__,PullerControlId,RpMessage,IfTypeThread*0x100+POOLER_MOTOR,0);*/
-////////////////////////
-        MotorControlConfig[WINDER_MOTOR].m_params.MAX = 1;
-        MotorControlConfig[WINDER_MOTOR].m_params.MIN = MotorsControl[WINDER_MOTOR].outputproportionalpowerlimit*-1;
-        MotorControlConfig[WINDER_MOTOR].m_params.Kd = MotorsControl[WINDER_MOTOR].derivativetime;
-        MotorControlConfig[WINDER_MOTOR].m_params.Kp = MotorsControl[WINDER_MOTOR].proportionalgain;
-        MotorControlConfig[WINDER_MOTOR].m_params.Ki = 0;//MotorsControl[WINDER_MOTOR].integraltime;
-        MotorControlConfig[WINDER_MOTOR].m_params.IntegralErrorMultiplier = MotorsControl[WINDER_MOTOR].setpointramprateorsoftstartramp;
-        MotorControlConfig[WINDER_MOTOR].m_params.ProportionalErrorMultiplier = MotorsControl[WINDER_MOTOR].outputonoffhysteresisvalue;
-        MotorControlConfig[WINDER_MOTOR].m_params.epsilon = MotorsControl[WINDER_MOTOR].epsilon;
-        MotorControlConfig[WINDER_MOTOR].m_params.dt = MotorsControl[WINDER_MOTOR].controloutputtype;
-        MotorControlConfig[WINDER_MOTOR].m_ingnoreValue =  MotorsControl[WINDER_MOTOR].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
-        MotorControlConfig[WINDER_MOTOR].m_calculatedError = 0;
-        MotorControlConfig[WINDER_MOTOR].m_integral = 0;
-        MotorControlConfig[WINDER_MOTOR].m_isEnabled = true;
-        MotorControlConfig[WINDER_MOTOR].m_isReady = true;
-        MotorControlConfig[WINDER_MOTOR].m_mesuredParam = 0;
-        MotorControlConfig[WINDER_MOTOR].m_preError = 0;
-        MotorControlConfig[WINDER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage
-        MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_WINDER,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].directionthreadwize);
-
-        WinderControlId = AddControlCallback(NULL,ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+WINDER_MOTOR),WINDER_DANCER,WINDER_MOTOR);
-        Report("AddControlCallback Winder",__FILE__,__LINE__,WinderControlId,RpMessage,IfTypeThread*0x100+WINDER_MOTOR,0);
-
-////////////////////////
-        MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING].directionthreadwize);
-        MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING, OriginalMotorSpd_2PPS[DRYER_MOTOR]);
 
         CallbackCounter++;
-        //MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
-        //                       numberOfSteps,    Thread_Load_Dryer_Loading_Callback, 100000);
-        //Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
-        //MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,numberOfCycles);
-//shlomo
-        UnloadingStart = msec_millisecondCounter;
-        numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/**LoadArmRounds*/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
-        numberOfCycles = 0;
 
-        if (SecondTry == true)
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&temp);
+        DrierCenterLocation = DrierPrevLocation;
+        DrierPrevLocation = temp;
+        UnloadingStart = msec_millisecondCounter;
+        //numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/**LoadArmRounds*/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
+        //numberOfCycles = 0;
+        LoadingArmReset(Thread_Load_Set_Load_Arm_To_Stopper_Callback,300000);
+        /*if (SecondTry == true)
         {
-            LoadArmRounds = 30;
+            MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
+            if (LoadArmRounds == 0) //prev trial stopped
+            {
+                LoadArmRounds = (int)dryerbufferlength;
+            }
+            //LoadArmRounds = 30;
         }
         else
         {
             MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
-        }
-        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&temp);
+            if (LoadArmRounds == 0) //prev trial stopped
+            {
+                LoadArmRounds = (int)dryerbufferlength;
+            }
+        }*/
+        /*MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&temp);
+        DrierCenterLocation = DrierPrevLocation;
         DrierPrevLocation = temp;
         Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,UnloadingStart,DrierPrevLocation,RpMessage, LoadArmRounds,0);
-        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
+        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
 //        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,0,1000);
         MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
-                               numberOfSteps-400,    Thread_Load_Dryer_UnLoading_Callback, 30000);
+                               numberOfSteps-800,    Thread_Load_Dryer_UnLoading_Callback, 10000);
 
         Screw_Dir = 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize;
 
@@ -907,14 +991,20 @@
 
         //Keep Notation How Many Rotations In The Dryer
         //LoadArmRounds = (int)dryerbufferlength;
+         *
+         */
         load.color = BLINK;
         return OK;
     }
 
+    double percentage;
     uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM ReadValue)
     {
         REPORT_MSG(ReadValue,"ThreadLoadStateMachine");
-        ThreadLoaded();
+        //ThreadLoaded();
+        percentage = ReadValue*7;
+        ThreadLoadingReport();
+
         if (LoadStages!=ReadValue)
             LoadStages = ReadValue;
         switch (ReadValue)
@@ -997,17 +1087,19 @@
             break;
         case THREAD_LOAD_END:
             LoadStages = THREAD_LOAD_END;
+            percentage = 100.0;
             Thread_Load_End();
             break;
         default:
             LOG_ERROR(LoadStages,"ERROR IN LOAD STATE MACHINE");
             break;
     }
+
     return OK;
 }
 uint32_t ThreadLoadButton(THREAD_LOAD_STAGES_ENUM ReadValue)
 {
-    if (JobIsActive())
+    if (JobIsActive()||(MachineReadyForHeating == false)||(FPGABurningActive==true))
     {
         Report("ThreadLoadButton called on job",__FILE__,__LINE__,LoadStages,RpMessage,ReadValue,0);
         return ERROR;
@@ -1019,26 +1111,43 @@ uint32_t ThreadLoadButton(THREAD_LOAD_STAGES_ENUM ReadValue)
     }
     Report("ThreadLoadButton",__FILE__,__LINE__,LoadStages,RpMessage,ReadValue,0);
     Report("ThreadLoadButton params",__FILE__,LoadStatus,TryAgain,RpMessage,SecondTry,0);
+    if (LoadStages == THREAD_LOAD_INITIAL_TENSION) //on this satge we should wait for user call
+        MessageState = 2;
+    ThreadLoadingReport();
     if (LoadStatus == ERROR)
     {
         if ((SecondTry == false)&&(TryAgain == true))
         {
             LoadStatus = OK;
             SecondTry = true;
-            Report("Calling State machine",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
+            load.color = BLINK;
+            //if (LoadStages > THREAD_LOAD_INITIAL_TENSION)
+            //    ThreadLoadingRestartReport();
+            Report("Calling State machine retry",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
             ThreadLoadStateMachine(LoadStages);
         }
-        else
+        else if (SecondTry == true)
         {
             SecondTry = false;
-            Report("Calling State machine",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
+            Report("Calling State machine  2nd try",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
+            load.color = BLINK;
+            //if (LoadStages > THREAD_LOAD_INITIAL_TENSION)
+            //    ThreadLoadingRestartReport();
             ThreadLoadStateMachine(LoadStages+1);
         }
+        else //((SecondTry == false)&&(TryAgain == false))???????
+        {
+            Report("State ERROR with wrong parameters",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
+            SecondTry = false;
+        }
     }
     else
     {
         Report("Calling State machine status OK",__FILE__,ReadValue,LoadStatus,RpMessage,SecondTry,0);
+        //if (LoadStages > THREAD_LOAD_INITIAL_TENSION)
+        //    ThreadLoadingRestartReport();
         ThreadLoadStateMachine(LoadStages);
+        SecondTry = false;
     }
     return OK;
 }
@@ -1118,11 +1227,11 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     index = IfIndex&0xFF;
 
     DancerId = ThreadMotorIdToDancerId[index];
-    if (ReadValue < 10)
+    /*if (ReadValue < 10)
     {
         Report("Dancer value read too small.",__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
         return OK;
-    }
+    }*/
     if (ReadValue == 0x3FFF)
     {
         return OK;
@@ -1133,6 +1242,11 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         //pooler dancer is right sided: data is opposite
         TranslatedReadValue = (-1*TranslatedReadValue);
     }
+    if (abs(TranslatedReadValue) > 0x2000)
+    {
+        TranslatedReadValue = 0x3FFF- TranslatedReadValue; //overcome zero environment
+    }
+
     //TranslatedReadValue = 0;//test
     MotorSamples[index][MotorSamplePointer[index]] = TranslatedReadValue;//(-1 * TranslatedReadValue);
     MotorSamplePointer[index]++;
@@ -1197,29 +1311,29 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 }
 bool ThreadLoaded(void)
 {
-    uint32_t ReadValue;
+   /* uint32_t ReadValue;
 
     int32_t PoolerValue,WinderValue,FeederValue;
     //this function tests if there is a thread in the machine. all dancers are in lowermost position then there is no thread.
 
     ReadValue = Control_Read_Dancer_Position(FEEDER_DANCER,0);
     FeederValue = ReadValue - DancersCfg[FEEDER_DANCER].zeropoint;
-    Report("Feeder out",__FILE__,FeederValue,ReadValue,RpWarning,(int)DancersCfg[FEEDER_DANCER].zeropoint,0);
+    Report("Feeder out",__FILE__,abs(FeederValue),ReadValue,RpWarning,(int)DancersCfg[FEEDER_DANCER].zeropoint,0);
     ReadValue = Control_Read_Dancer_Position(WINDER_DANCER,0);
     WinderValue = ReadValue - DancersCfg[WINDER_DANCER].zeropoint;
-    Report("Winder out",__FILE__,WinderValue,ReadValue,RpWarning,(int)DancersCfg[WINDER_DANCER].zeropoint,0);
+    Report("Winder out",__FILE__,abs(WinderValue),ReadValue,RpWarning,(int)DancersCfg[WINDER_DANCER].zeropoint,0);
     ReadValue = Control_Read_Dancer_Position(POOLER_DANCER,0);
     PoolerValue = ReadValue - DancersCfg[POOLER_DANCER].zeropoint;
         //pooler dancer is right sided: data is opposite
     PoolerValue = (-1*PoolerValue);
-    Report("Puller out",__FILE__,PoolerValue,ReadValue,RpWarning,(int)DancersCfg[POOLER_DANCER].zeropoint,0);
+    Report("Puller out",__FILE__,abs(PoolerValue),ReadValue,RpWarning,(int)DancersCfg[POOLER_DANCER].zeropoint,0);
 
     if (((PoolerValue)<(-1200))&&((WinderValue)<(-1200))&&((FeederValue)<(-1200)))
     {
         Report("Thread is out",__FILE__,(-1*PoolerValue),(-1*WinderValue),RpWarning,(-1*FeederValue),0);
         return true;
     }
-    else
+    else*/
         return false;
 }
 void ThreadLoadRequest(MessageContainer* requestContainer)
@@ -1235,10 +1349,16 @@ void ThreadLoadRequest(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__StubHeatingTestResponse, requestContainer->token, false, &response, &stub_heating_test_response__pack, &stub_heating_test_response__get_packed_size);
     container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
 
-
     int LoadStage = (int)request->dryerzone1temp;
-    LoadStages = LoadStage;
-    ThreadLoadStateMachine(LoadStage);
+    if (request->hardwarepidcontrol1!=NULL)
+    {
+        UpdatePidDuringRun(request->hardwarepidcontrol1);
+    }
+    else
+    {
+        LoadStages = LoadStage;
+        ThreadLoadStateMachine(LoadStage);
+    }
 
     /*if (status)
     {
@@ -1336,9 +1456,14 @@ uint32_t ThreadLoadingReport(void)
             response.errorreason = LoadErrorMsg;
         }
     }
-    else return ERROR;
+    else
+    {
+        Report("ThreadLoadingReport ERROR",__FILE__,MessageState,response.state,RpWarning,(int)LoadStages,0);
+        return ERROR;
+    }
     Report("ThreadLoadingReport",__FILE__,MessageState,response.state,RpWarning,(int)LoadStages,0);
-
+    response.has_progresspercentage = true;
+    response.progresspercentage =  percentage;
     //-------------------------------------------------------------------------------------------
     responseContainer = createContainer(MESSAGE_TYPE__StartThreadLoadingResponse, ThreadLoadingToken, last, &response, &start_thread_loading_response__pack, &start_thread_loading_response__get_packed_size);
     responseContainer.has_continuous = true;
@@ -1351,12 +1476,68 @@ uint32_t ThreadLoadingReport(void)
     return OK;
 
 }
+bool ThreadLoadingRestartFlag = false;
+uint32_t ThreadLoadingRestartReport(void) //sending after a failure in the finalizing stage
+{
+    MessageContainer responseContainer;
+    StartThreadLoadingResponse response = START_THREAD_LOADING_RESPONSE__INIT;
+
+    if (ThreadLoadingToken[0] == 0)
+        return OK;
+    ThreadLoadingRestartFlag = true;
+
+    response.has_state = true;
+    response.state = THREAD_LOADING_STATE__ReadyForLoading;
+    response.errorreason = DefaultErrSrt;
+    Report("ThreadLoadingRestartReport",__FILE__,MessageState,response.state,RpWarning,(int)LoadStages,0);
+    //-------------------------------------------------------------------------------------------
+    responseContainer = createContainer(MESSAGE_TYPE__StartThreadLoadingResponse, ThreadLoadingToken, false, &response, &start_thread_loading_response__pack, &start_thread_loading_response__get_packed_size);
+    responseContainer.has_continuous = true;
+    responseContainer.continuous = true;
+    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);
+    SendChars((char*)container_buffer, container_size);
+
+    return OK;
+
+}
+
+uint32_t TryThreadLoadingFunc(MessageContainer* requestContainer)
+{
+    TryThreadLoadingResponse Cresponse = TRY_THREAD_LOADING_RESPONSE__INIT;
+    MessageContainer responseContainer;
+    //MessageState = 2;
+    ThreadLoadingReport();
+    Report("TryThreadLoadingFunc",__FILE__,__LINE__,MESSAGE_TYPE__TryThreadLoadingResponse,RpWarning,(int)LoadStages,0);
+
+    if (requestContainer)
+    {
+        responseContainer = createContainer(MESSAGE_TYPE__TryThreadLoadingResponse, requestContainer->token, true, &Cresponse, &try_thread_loading_response__pack, &try_thread_loading_response__get_packed_size);
+        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);
+        SendChars((char*)container_buffer, container_size);
+    }
+
+    ThreadLoadButton(LoadStages);
+    return OK;
+}
+uint32_t ThreadUpdateCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+{
+
+    if(ThreadLoadingActive())
+        ThreadLoadingReport();
+    return OK;
+}
 
 uint32_t StartThreadLoadingFunc(MessageContainer* requestContainer)
 {
     StartThreadLoadingRequest *request = start_thread_loading_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
     ustrncpy (ThreadLoadingToken, requestContainer->token,36);
     //MessageState = 1;
+    ThreadLoadControlId = AddControlCallback("ThreadLoad", ThreadUpdateCallBackFunction, 4* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
     Report("StartThreadLoadingFunc",__FILE__,__LINE__,0,RpWarning,(int)LoadStages,0);
     ThreadLoadingReport();
     return OK;
@@ -1370,13 +1551,19 @@ uint32_t ContinueThreadLoadingFunc(MessageContainer* requestContainer)
     MessageContainer responseContainer;
     MessageState = 2;
     ThreadLoadingReport();
-    if (request->processparameters)
+    if (ThreadLoadingRestartFlag == false)
     {
-        dryerbufferlength = request->processparameters->dryerbufferlength;
-        LoadArmRounds = (int)(request->processparameters->dryerbufferlength);
+        if (request->processparameters)
+        {
+            dryerbufferlength = request->processparameters->dryerbufferlength;
+            LoadArmRounds = (int)(request->processparameters->dryerbufferlength);
+            windertension = request->processparameters->windertension;
+            pullertension = request->processparameters->pullertension;
+            memcpy (&ProcessParametersRecover,request->processparameters,sizeof(ProcessParameters));
 
+        }
+        Report("ContinueThreadLoadingFunc",__FILE__,__LINE__,(int)(request->processparameters->dryerbufferlength),RpWarning,(int)LoadStages,0);
     }
-    Report("ContinueThreadLoadingFunc",__FILE__,__LINE__,(int)(request->processparameters->dryerbufferlength),RpWarning,(int)LoadStages,0);
 
     responseContainer = createContainer(MESSAGE_TYPE__ContinueThreadLoadingResponse, requestContainer->token, true, &Cresponse, &continue_thread_loading_response__pack, &continue_thread_loading_response__get_packed_size);
     responseContainer.continuous = false;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 41ef9e480..a6cb25c45 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -17,7 +17,7 @@
 #include "Common/report/report.h"
 
 #include "drivers/FPGA/FPGA.h"
-
+#include "drivers/Flash_ram/MCU_E2Prom.h"
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 
@@ -54,7 +54,7 @@ double   ScrewRunningTime = 0;
 uint32_t ScrewNumberOfSteps = 0;     //holds the current number of steps for the next screw run - will be used to build the cone
 bool     SCREW_TimerActivated = false;
 uint32_t ScrewControlId = 0xFF;
-
+bool IgnoreConeMissing = false;
 
 
 static bool KeepWindingCone = false;
@@ -89,26 +89,38 @@ void SetWinderBackToBaseTime(uint32_t value)
     ReportWithPackageFilter(ThreadFilter,"Set WinderBackToBaseTime",__FILE__,__LINE__,WinderBackToBaseTime,RpWarning,KeepWindingCone, 0);
 }
 
-uint32_t InternalWinderConfigMessage(HardwareWinder* request)
+/*uint32_t InternalWinderConfigMessage(HardwareWinder* request)
 {
     uint32_t status = PASSED;
 
     InternalWinderCfg.milimetersperrotation = request->millimeterperrotation;
 
     return status;
-}
+}*/
 char ScrewStr[150];
 
 uint32_t InternalWindingConfigMessage(JobSpool* request)
 {
     uint32_t status = PASSED;
+    int limitswitchstartpointoffset = 0;
 
     InternalWinderCfg.segmentoffsetpulses = request->segmentoffsetpulses;
     InternalWinderCfg.spoolbackingrate = request->backingrate;
     InternalWinderCfg.startoffsetpulses = request->startoffsetpulses;
+    if (request->has_limitswitchstartpointoffset)
+    {
+        //InternalWinderCfg.startoffsetpulses += request->limitswitchstartpointoffset;
+        Report("limit switch start point offset",__FILE__,__LINE__,(int)(request->startoffsetpulses),RpWarning,(int)(request->limitswitchstartpointoffset), 0);
+    }
+    status |= MCU_E2PromRead(EEPROM_STORAGE_WINDER_CALIBRATION,&limitswitchstartpointoffset);
+    if ((status!= OK )||(limitswitchstartpointoffset == 0xFFFF))
+        limitswitchstartpointoffset = 0;
+    Report("limit switch start point offset",__FILE__,(int)(request->startoffsetpulses),(int)(limitswitchstartpointoffset),RpWarning,status, 0);
+    InternalWinderCfg.startoffsetpulses += limitswitchstartpointoffset;
+
     InternalWinderCfg.SpoolBottomBackingRate =  request->bottombackingrate;
     InternalWinderCfg.NumberOfRotationPerPassage = 3.1415926*3;//request->rotationsperpassage;
-    if (request->rotationsperpassage > 6.1)
+    if (request->rotationsperpassage > 5.1)
         InternalWinderCfg.NumberOfRotationPerPassage = request->rotationsperpassage;
     if (NumberOfRotationPerPassage > 1)
     {
@@ -118,7 +130,7 @@ uint32_t InternalWindingConfigMessage(JobSpool* request)
     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,(int)(InternalWinderCfg.NumberOfRotationPerPassage*1000));
-    Report(ScrewStr,__FILE__,__LINE__,(int)InternalWinderCfg.diameter,RpWarning,(int)(InternalWinderCfg.NumberOfRotationPerPassage*1000), 0);
+    Report(ScrewStr,__FILE__,__LINE__,(int)InternalWinderCfg.startoffsetpulses,RpWarning,(int)(InternalWinderCfg.NumberOfRotationPerPassage*1000), 0);
 
     return status;
 }
@@ -128,6 +140,7 @@ uint32_t InternalWindingConfigMessage(JobSpool* request)
  * 1. move home to the limit switch (check that the cart is clear from the limit switch, start moving, with acceleration to maximal speed. enable interrupt on the limit switch, upon interrupt stop.
  * report ready to the job STM
  */
+int Screw_wait_counter;
 uint32_t Winder_Prepare(void *JobDetails)
 {
     JobTicket* JobTicket = JobDetails;
@@ -149,9 +162,17 @@ uint32_t Winder_Prepare(void *JobDetails)
     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;
+        if (Is_PP_Machine())
+        {
+            if (IgnoreConeMissing == false)
+            {
+                JobEndReason = JOB_THREAD_BREAK;
+                usnprintf(AlarmReasonStr, 100, "No cone in winder");
+                PrepareReady(Module_Winder,ModuleFail);
+                AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
+                return ERROR;
+            }
+        }
     }
 
 #ifdef READ_SCREW_ENCODER
@@ -187,7 +208,16 @@ uint32_t Winder_Prepare(void *JobDetails)
         //REPORT_MSG(ScrewSpeed, "Winder_Prepare");
         Winder_ScrewHoming = true;
         //REPORT_MSG(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, "Winder_Prepare move to limit");
+        Screw_wait_counter=1;
         status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, ScrewSpeed, GPI_LS_SCREW_RIGHT, Winder_PrepareStage2,2000);
+#ifdef FOUR_WINDERS
+        Screw_wait_counter++;
+        status = MotorMovetoLimitSwitch (SCREW_2_Motor,MotorsCfg[SCREW_2_Motor].directionthreadwize, ScrewSpeed, GPI_LS_SPARE2_2, Winder_PrepareStage2,2000);
+        Screw_wait_counter++;
+        status = MotorMovetoLimitSwitch (SCREW_3_Motor,MotorsCfg[SCREW_3_Motor].directionthreadwize, ScrewSpeed, GPI_LS_SPARE1_2, Winder_PrepareStage2,2000);
+        Screw_wait_counter++;
+        status = MotorMovetoLimitSwitch (SCREW_4_Motor,MotorsCfg[SCREW_4_Motor].directionthreadwize, ScrewSpeed, GPI_LS_RDANCER_UP, Winder_PrepareStage2,2000);
+#endif
     }
     return status;
 }
@@ -202,7 +232,7 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
     uint32_t status=OK;
     uint32_t numOfSteps = WindingConeLocation*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep;
 
-    //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,InternalWinderCfg.segmentoffsetpulses);
+        //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,InternalWinderCfg.segmentoffsetpulses);
     //REPORT_MSG(numOfSteps, "Winder_PrepareStage2");
 #ifdef READ_SCREW_ENCODER
     Read_Screw_Encoder();
@@ -211,13 +241,15 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
 #endif
 
     REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2");
+    Screw_wait_counter--;
     if (ReadValue != LIMIT)
     {
         if (JobIsActive()==true)
         {
-            LOG_ERROR(ReadValue,"Screw failed to reach the limit switch!!");
+            LOG_ERROR(deviceID,"Screw failed to reach the limit switch!!");
             //returned with a timeout
             Winder_ScrewAtOffsetCallback(0,0);
+            PrepareReady(Module_Winder, ModuleFail);
         }
         else //short jog, etc
         {
@@ -226,18 +258,39 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
     }
     else
     {
+        if (Screw_wait_counter!=0)
+        {
+            ReportWithPackageFilter(ThreadFilter,"waiting for winders",__FILE__,__LINE__,Screw_wait_counter,RpWarning,deviceID, 0);
+            return status;
+        }
+        Screw_wait_counter++;
         status |= MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_SCREW, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize),numOfSteps, Winder_ScrewAtOffsetCallback,1000);
+#ifdef FOUR_WINDERS
+        Screw_wait_counter++;
+        status |= MotorMoveWithCallback (SCREW_2_Motor,(1-MotorsCfg[SCREW_2_Motor].directionthreadwize), numOfSteps,  Winder_ScrewAtOffsetCallback,1000);
+        Screw_wait_counter++;
+        status |= MotorMoveWithCallback (SCREW_3_Motor,(1-MotorsCfg[SCREW_3_Motor].directionthreadwize), numOfSteps,  Winder_ScrewAtOffsetCallback,1000);
+        Screw_wait_counter++;
+        status |= MotorMoveWithCallback (SCREW_4_Motor,(1-MotorsCfg[SCREW_4_Motor].directionthreadwize), numOfSteps,  Winder_ScrewAtOffsetCallback,1000);
+#endif
     }
      //set motor location 0 here
         return status;
 
 }
 
-uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
+uint32_t Winder_ScrewAtOffsetCallback(uint32_t MotorId, uint32_t BusyFlag)
 {
     //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,temp_MaxFrequency);
+    if (Screw_wait_counter)
+        Screw_wait_counter--;
 
-    MotorStop (HARDWARE_MOTOR_TYPE__MOTO_SCREW,Soft_Hiz); //per L6470 errata between mov and run commands
+    MotorStop (MotorId,Soft_Hiz); //per L6470 errata between mov and run commands
+/*#ifdef FOUR_WINDERS
+    MotorStop(SCREW_2_Motor, Hard_Hiz);
+    MotorStop(SCREW_3_Motor, Hard_Hiz);
+    MotorStop(SCREW_4_Motor, Hard_Hiz);
+#endif*/
     Task_sleep(5);
 #ifdef READ_SCREW_ENCODER
     Reset_Screw_Encoder();
@@ -248,7 +301,12 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
 
     REPORT_MSG(ScrewLocationStart, "Winder_ScrewAtOffsetCallback Encoder Location");
 #endif
-    SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_SCREW);  //set this point as the spool home
+    SetMotHome(MotorId);  //set this point as the spool home
+/*#ifdef FOUR_WINDERS
+    SetMotHome(SCREW_2_Motor);
+    SetMotHome(SCREW_3_Motor);
+    SetMotHome(SCREW_4_Motor);
+#endif*/
 
     ScrewCurrentDirection = false;
 #ifdef READ_SCREW_ENCODER
@@ -257,8 +315,9 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
     ScrewSpeed = 0;
     ScrewControlId = 0xFF;
     ScrewNumberOfSteps = 0;
-    REPORT_MSG(millisecondCounter, "Winder_ScrewAtOffsetCallback");
-    PrepareReady(Module_Winder, ModuleDone);
+    ReportWithPackageFilter(ThreadFilter,"Winder_ScrewAtOffsetCallback",__FILE__,millisecondCounter,Screw_wait_counter,RpWarning,MotorId, 0);
+    if (Screw_wait_counter == 0)
+        PrepareReady(Module_Winder, ModuleDone);
     return OK;
 }
 
@@ -298,10 +357,17 @@ int flipflop = 0;
 uint32_t motspeed;
 float speedf;
 int WinderCalculation = 0;
+#ifdef FOUR_WINDERS
+int MotorOrder[4] = {HARDWARE_MOTOR_TYPE__MOTO_SCREW,SCREW_2_Motor,SCREW_3_Motor,SCREW_4_Motor};
+#endif
+
 uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 {
     //uint32_t Steps;
     double temp,tempScrewSpeed;
+#ifdef FOUR_WINDERS
+    int tempmot;
+#endif
     //double screw_horizontal_speed = 0;
     //double RotationsPerSecond;
         if (WinderMotorSpeedCounter++>=MAX_WINDER_SPEED_CALCULATION)
@@ -320,6 +386,14 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 
     ScrewCurrentDirection = 1-ScrewCurrentDirection;
     CalculationDirectionChangeCounter++;
+#ifdef FOUR_WINDERS
+    tempmot = MotorOrder[0];
+    MotorOrder[0] = MotorOrder[1];
+    MotorOrder[1] = MotorOrder[2];
+    MotorOrder[2] = MotorOrder[3];
+    MotorOrder[3] = tempmot;
+    //Report("order change" ,__FILE__,MotorOrder[0],MotorOrder[1],RpWarning,MotorOrder[2], 0);
+#endif
     if (SampleWinding)
         return OK;
     //double calcsteps = (ScrewRunningTime/SYS_CLK_FREQ)*ScrewSpeed;
@@ -539,7 +613,7 @@ uint32_t WinderDistanceToSpoolEnded(uint32_t deviceID, uint32_t ReadValue)
 }
 uint32_t ScrewDTSCallback(uint32_t deviceID, uint32_t BusyFlag)
 {
-    REPORT_MSG ((int)msec_millisecondCounter,"ScrewDTSCallback called");
+    Report("ScrewDTSCallback called", __FILE__,__LINE__,msec_millisecondCounter, RpMessage, ScrewSpeed, 0);
     SafeRemoveControlCallback(ScrewDTSControlId, ScrewDTSCallback);
 
     if (ScrewControlId != 0xFF)
@@ -553,6 +627,11 @@ uint32_t ScrewDTSCallback(uint32_t deviceID, uint32_t BusyFlag)
     //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, 1000, GPI_LS_SCREW_RIGHT, NULL,0);
     //MotorStop(HARDWARE_MOTOR_TYPE__MOTO_SCREW,Hard_Hiz);
     MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, ScrewSpeed, GPI_LS_SCREW_RIGHT, WinderDistanceToSpoolEnded,2000);
+#ifdef FOUR_WINDERS
+    MotorMovetoLimitSwitch (SCREW_2_Motor,MotorsCfg[SCREW_2_Motor].directionthreadwize, ScrewSpeed, GPI_LS_SPARE2_2, NULL,2000);
+    MotorMovetoLimitSwitch (SCREW_3_Motor,MotorsCfg[SCREW_3_Motor].directionthreadwize, ScrewSpeed, GPI_LS_SPARE1_2, NULL,2000);
+    MotorMovetoLimitSwitch (SCREW_4_Motor,MotorsCfg[SCREW_4_Motor].directionthreadwize, ScrewSpeed, GPI_LS_RDANCER_UP, NULL,2000);
+#endif
 
     return OK;
 }
@@ -562,7 +641,7 @@ uint32_t WinderDistanceToSpoolState(void )
     REPORT_MSG ((int)DTS_Time,"WinderDistanceToSpoolState");
 
     ScrewDTSControlId = AddControlCallback("screw DTS",ScrewDTSCallback, DTS_Time-WinderBackToBaseTime,TemplateDataReadCBFunction,0,0,0);
-    REPORT_MSG ((int)msec_millisecondCounter,"ScrewDTSCallback start");
+    Report("ScrewDTSCallback start", __FILE__,DTS_Time,msec_millisecondCounter, RpMessage, WinderBackToBaseTime, 0);
 
     return OK;
 }
@@ -582,9 +661,14 @@ uint32_t Winder_End(void)
     //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, 1000, GPI_LS_SCREW_RIGHT, NULL,0);
     //MotorStop(HARDWARE_MOTOR_TYPE__MOTO_SCREW,Hard_Hiz);
     MotorAbortMovetoLimitSwitch(HARDWARE_MOTOR_TYPE__MOTO_SCREW); //bug #2709
+#ifdef FOUR_WINDERS
+    MotorAbortMovetoLimitSwitch (SCREW_2_Motor);
+    MotorAbortMovetoLimitSwitch (SCREW_3_Motor);
+    MotorAbortMovetoLimitSwitch (SCREW_4_Motor);
+#endif
     return OK;
 }
-void Winder_ScrewHomeLimitSwitchInterrupt(void)
+/*void Winder_ScrewHomeLimitSwitchInterrupt(void)
 {
     //uint32_t status;
     //handle glitch - send information to the next time that the motor stops
@@ -599,7 +683,7 @@ void Winder_ScrewOutLimitSwitchInterrupt(void)
     //handle glitch - send information to the next time that the motor stops
     //uint32_t status;
     MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_SCREW,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize);//make sure to move the cart out
-}
+}*/
 
 uint32_t  Screw_timerBase = TIMER3_BASE;        //Timer handle
 
@@ -643,7 +727,19 @@ void ScrewTimerInterrupt(int ARG0)
     {
         ROM_TimerLoadSet(Screw_timerBase, TIMER_A,(int)ScrewRunningTime);
         MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection);
+#ifdef FOUR_WINDERS
+        MotorSetDirection (SCREW_2_Motor, ScrewCurrentDirection);
+        MotorSetDirection (SCREW_3_Motor, ScrewCurrentDirection);
+        MotorSetDirection (SCREW_4_Motor, ScrewCurrentDirection);
+#endif
+#ifdef FOUR_WINDERS
+        MotorSetSpeedDirect(MotorOrder[0],ScrewSpeed);
+        MotorSetSpeedDirect (MotorOrder[1], ScrewSpeed);
+        MotorSetSpeedDirect (MotorOrder[2], ScrewSpeed);
+        MotorSetSpeedDirect (MotorOrder[3], ScrewSpeed);
+#else
         MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed);
+#endif
 #ifdef READ_SCREW_ENCODER
         Read_Screw_Encoder();
         ScrewLocationRun[ScrewCurrentDirection] = Screw_RotEnc.Position;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 1e730e252..5d69e2980 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -9,7 +9,7 @@
 #define WINDER_DANCER HARDWARE_DANCER_TYPE__LeftDancer
 #define POOLER_DANCER HARDWARE_DANCER_TYPE__MiddleDancer
 #define FEEDER_DANCER HARDWARE_DANCER_TYPE__RightDancer
-#define NUM_OF_DANCERS (HARDWARE_DANCER_TYPE__RightDancer+1)
+#define NUM_OF_DANCERS NUM_OF_ROTENC
 //} DANCER_ENUM;
 typedef enum threadMotorsEnum
 {
@@ -17,12 +17,19 @@ typedef enum threadMotorsEnum
     DRYER_MOTOR,
     POOLER_MOTOR,
     WINDER_MOTOR,
+#ifdef FOUR_WINDERS
+    WINDER_2_MOTOR,
+    WINDER_3_MOTOR,
+    WINDER_4_MOTOR,
+#endif
     SCREW_MOTOR,
     MAX_THREAD_MOTORS_NUM
 }threadMotorsEnum;
 
 extern double TotalProcessedLength;
 extern double PoolerTotalProcessedLength;
+extern int SecondFeederCorrection;
+extern bool SkipOpenLids,IgnoreConeMissing;
 
 void ThreadSetBreakSensorLimit(int limit);
 
@@ -36,7 +43,6 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId);
 uint32_t ThreadSegmentState(void *SegmentDetails, int SegmentId);
 uint32_t ThreadDistanceToSpoolState(void);
 uint32_t ThreadEndState();
-uint32_t ThreadInitialTestStub();
 
 bool Set_Thread_Rockers_Bypass (int value);
 
@@ -81,7 +87,8 @@ void ThreadLoadRequest(MessageContainer* requestContainer);
 uint32_t StartThreadLoadingFunc(MessageContainer* requestContainer);
 uint32_t ContinueThreadLoadingFunc(MessageContainer* requestContainer);
 uint32_t StopThreadLoadingFunc(MessageContainer* requestContainer);
-
+uint32_t TryThreadLoadingFunc(MessageContainer* requestContainer);
+void ThreadCheckArcHeadCovers(void);
 uint32_t Thread_Load_End(void);
 
 #endif
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index fb3b78752..1920db03a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -104,14 +104,14 @@ uint32_t MotorsConfigMessage(HardwareConfiguration * HWrequest)
         MotorsCfg[Motor_i].tfast    = request->tfast   ;
         MotorsCfg[Motor_i].tonmin   = request->tonmin  ;
         MotorsCfg[Motor_i].toffmin  = request->toffmin ;
+        MotorsCfg[Motor_i].has_p01configword  = (bool)(request->has_p01configword) ;//needed for backward compatibility
+        MotorsCfg[Motor_i].p01configword  = request->p01configword ;
 
             status = MotorConfig( Motor_i,  &MotorsCfg[Motor_i]);
             if ((Motor_i >= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)&&(Motor_i <= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8))
             {
                 IDS_Dispenser_Init(Motor_i-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
             }
-//        if (Motor_i == MOTOR_RDRIVING)
-//            ThreadInitialTestStub(request);
     }
         return status;
 
@@ -145,8 +145,45 @@ uint32_t MotorPidRequestMessage(HardwarePidControl* request)
     NormalizedErrorCoEfficient[Motor_i] = NormalizedErrorCoEfficient[Motor_i] / temp;
 //    uint32_t MotorSamples[MAX_THREAD_MOTORS_NUM][MAX_CONTROL_SAMPLES];
     temp = 1<<(DancersCfg[ThreadMotorIdToDancerId[Motor_i]].resolutionbits);
-    temp = (temp*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].maximalmovementmm*3/2);
+    temp = (temp*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].maximalmovementmm);//*3/2);
+    if (Motor_i == WINDER_MOTOR)
+    {
+        temp = temp*3/2;
+    }
     DancerStopActivityLimit[Motor_i] = temp/(2*PI*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].armlength);
+#ifdef FOUR_WINDERS
+    if (Motor_i == WINDER_MOTOR)
+    {
+        int j,winderMotorId;
+        for (j=0;j<3;j++)
+        {
+            winderMotorId = j+WINDER_2_MOTOR;
+            memcpy (&MotorsControl[winderMotorId],request,sizeof(HardwarePidControl));
+            if (MotorsControl[winderMotorId].pvinputfilterfactormode > MAX_CONTROL_SAMPLES)
+                MotorsControl[winderMotorId].pvinputfilterfactormode = MAX_CONTROL_SAMPLES;
+        #ifdef TEST_LONGER_PID_THREAD
+            MotorsControl[Motor_i].pvinputfilterfactormode = 10; //test longer control
+        #endif
+            for (i = 0;i < (int)MotorsControl[winderMotorId].pvinputfilterfactormode; i++)
+            {
+                MotorSamples[winderMotorId][i] = 0;  //reset the samples value for control beginning
+                MotorSpeedSamples[winderMotorId][i] = 0;
+            }
+            NormalizedErrorCoEfficient[winderMotorId] = (2*PI*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].armlength);
+            temp = 1<<(DancersCfg[ThreadMotorIdToDancerId[Motor_i]].resolutionbits);
+            temp=(NORMAL_COEF_DIVIDER*(temp-1)*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].maximalmovementmm);
+            NormalizedErrorCoEfficient[winderMotorId] = NormalizedErrorCoEfficient[winderMotorId] / temp;
+        //    uint32_t MotorSamples[MAX_THREAD_MOTORS_NUM][MAX_CONTROL_SAMPLES];
+            temp = 1<<(DancersCfg[ThreadMotorIdToDancerId[Motor_i]].resolutionbits);
+            temp = (temp*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].maximalmovementmm);//*3/2);
+            if (Motor_i == WINDER_MOTOR)
+            {
+                temp = temp*3/2;
+            }
+            DancerStopActivityLimit[winderMotorId] = temp/(2*PI*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].armlength);
+        }
+    }
+#endif
     return OK;
 }
 char DancerConfigPath[50] = "0://SysInfo//DancCfg.cfg";
@@ -155,31 +192,37 @@ uint32_t StoreDancerConfigMessage()
 {
     uint32_t status = OK;
   //  FRESULT Fresult = FR_OK;
-    HardwareConfiguration DancerConfig;
+    //HardwareConfiguration DancerConfig;
     HardwareDancer Dancers[MAX_SYSTEM_DANCERS];
   //  uint8_t* response_buffer;
   //  size_t response_size = 0;
     int Dancer_i;
 
-    hardware_configuration__init(&DancerConfig);
-    DancerConfig.dancers = (HardwareDancer**)my_malloc(sizeof(HardwareDancer*)*MAX_SYSTEM_DANCERS);
+    //hardware_configuration__init(&DancerConfig);
+    //DancerConfig.dancers = (HardwareDancer**)my_malloc(sizeof(HardwareDancer*)*MAX_SYSTEM_DANCERS);
     for (Dancer_i = 0; Dancer_i < MAX_SYSTEM_DANCERS; Dancer_i++)
     {
         hardware_dancer__init(&Dancers[Dancer_i]);
-        DancerConfig.dancers[Dancer_i] = &Dancers[Dancer_i];
+        //DancerConfig.dancers[Dancer_i] = &Dancers[Dancer_i];
         Dancers[Dancer_i].has_zeropoint = true;
         Dancers[Dancer_i].hardwaredancertype = Dancer_i;
         Dancers[Dancer_i].has_hardwaredancertype = true;
-        DancerConfig.dancers[Dancer_i]->zeropoint=Control_Read_Dancer_Position(Dancer_i,0);
-        DancerConfig.n_dancers++;
-        DancersCfg[Dancer_i].zeropoint = DancerConfig.dancers[Dancer_i]->zeropoint;
+        Dancers[Dancer_i].zeropoint=Control_Read_Dancer_Position(Dancer_i,0);
+        //DancerConfig.n_dancers++;
+        DancersCfg[Dancer_i].zeropoint = Dancers[Dancer_i].zeropoint;
+        DancersCfg[Dancer_i].zeropoint = Control_Read_Dancer_Position(Dancer_i,0);
     }
 
     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);
     Report("~~~~~~Store eeprom 0",__FILE__,DancersCfg[0].zeropoint,(int)DancersCfg[1].zeropoint,RpWarning,(int)DancersCfg[2].zeropoint,0);
-/*
+#ifdef FOUR_WINDERS
+    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_3,DancersCfg[HARDWARE_DANCER_3].zeropoint);
+    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_4,DancersCfg[HARDWARE_DANCER_4].zeropoint);
+    Report("~~~~~~Store eeprom 1",__FILE__,__LINE__,(int)DancersCfg[HARDWARE_DANCER_3].zeropoint,RpWarning,(int)DancersCfg[HARDWARE_DANCER_4].zeropoint,0);
+#endif
+    /*
     response_buffer = my_malloc(hardware_configuration__get_packed_size(&DancerConfig));
     if (response_buffer)
     {
@@ -204,11 +247,18 @@ uint32_t LoadDancerConfigMessage()
     MCU_E2PromRead(EEPROM_STORAGE_DANCER_0,&DancersCfg[0].zeropoint);
     MCU_E2PromRead(EEPROM_STORAGE_DANCER_1,&DancersCfg[1].zeropoint);
     MCU_E2PromRead(EEPROM_STORAGE_DANCER_2,&DancersCfg[2].zeropoint);
-
+#ifdef FOUR_WINDERS
+    MCU_E2PromRead(EEPROM_STORAGE_DANCER_3,&DancersCfg[3].zeropoint);
+    MCU_E2PromRead(EEPROM_STORAGE_DANCER_4,&DancersCfg[4].zeropoint);
+#endif
 
     status |= Report("Dancer 0 Store data eeprom ",__FILE__,__LINE__,0,RpWarning,(int)DancersCfg[0].zeropoint,0);
     status |= Report("Dancer 1 Store data eeprom ",__FILE__,__LINE__,1,RpWarning,(int)DancersCfg[1].zeropoint,0);
     status |= Report("Dancer 2 Store data eeprom ",__FILE__,__LINE__,2,RpWarning,(int)DancersCfg[2].zeropoint,0);
+#ifdef FOUR_WINDERS
+    status |= Report("Dancer 3 Store data eeprom ",__FILE__,__LINE__,3,RpWarning,(int)DancersCfg[3].zeropoint,0);
+    status |= Report("Dancer 4 Store data eeprom ",__FILE__,__LINE__,4,RpWarning,(int)DancersCfg[4].zeropoint,0);
+#endif
 
     return status;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 69f640c45..bc4e6cb8f 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -37,6 +37,8 @@
 #include "Control/MillisecTask.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
 
+#include "drivers/SSI_Comm/SSI_Comm.h"
+
 ////////////////////////////////State machine operation////////////////////////////////////
 //the state machine operation is used to operate in runtime correct profile flow execution
 //by recieved esign flow of the user from the UI
@@ -44,9 +46,15 @@
 
 double CurrentControlledSpeed[MAX_THREAD_MOTORS_NUM] = {0};
 
+#ifdef FOUR_WINDERS
+TimerMotors_t ThreadMotorIdToMotorId[MAX_THREAD_MOTORS_NUM] = {HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,HARDWARE_MOTOR_TYPE__MOTO_WINDER,Winder_2_Motor,Winder_3_Motor,Winder_4_Motor,HARDWARE_MOTOR_TYPE__MOTO_SCREW};
+Dancers_4_Winders ThreadMotorIdToDancerId[MAX_THREAD_MOTORS_NUM] = {NUM_OF_DANCERS,NUM_OF_DANCERS,HARDWARE_DANCER_1,HARDWARE_DANCER_0,HARDWARE_DANCER_4,HARDWARE_DANCER_3,HARDWARE_DANCER_2,NUM_OF_DANCERS};
+uint32_t    ControlIdtoMotorId [MAX_THREAD_MOTORS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+#else
 TimerMotors_t ThreadMotorIdToMotorId[MAX_THREAD_MOTORS_NUM] = {HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,HARDWARE_MOTOR_TYPE__MOTO_WINDER,HARDWARE_MOTOR_TYPE__MOTO_SCREW};
 HardwareDancerType ThreadMotorIdToDancerId[MAX_THREAD_MOTORS_NUM] = {FEEDER_DANCER,NUM_OF_DANCERS,POOLER_DANCER,WINDER_DANCER,NUM_OF_DANCERS};
 uint32_t    ControlIdtoMotorId [MAX_THREAD_MOTORS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF};
+#endif
 uint32_t    SpeedControlId=0xFF;
 uint32_t    PoolerSpeedControlId=0xFF;
 
@@ -58,6 +66,10 @@ uint32_t JobCounter = 0;
 MotorControlConfig_t MotorControlConfig[MAX_THREAD_MOTORS_NUM];
 uint32_t DeviceId2Motor[MAX_THREAD_MOTORS_NUM];
 
+int MotorTiming[MAX_THREAD_MOTORS_NUM];
+int MotorTimer[MAX_THREAD_MOTORS_NUM];
+
+
 uint32_t PreviousPosition = 0, CurrentPosition = 0;
 double CurrentRequestedLength = 0.0;
 double CurrentProcessedLength = 0.0;
@@ -140,15 +152,22 @@ uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Rea
  * **************************************************************************************/
 uint32_t initialpos = 0xFFFF;
 uint32_t Poolerinitialpos = 0xFFFF;
+#define SPEED_STORE_SIZE 20
+float PullerSpeedStore[SPEED_STORE_SIZE];
+float PullerSpeedAverage;
+int PullerSpeedIndex = 0;
+float FeederSpeedStore[SPEED_STORE_SIZE];
+float FeederSpeedAverage;
+int FeederSpeedIndex = 0,Speed_i;
 
 void ThreadUpdateProcessLength (double length, void *Funcptr)
 {
-    REPORT_MSG(length,"ThreadUpdateProcessLength");
+    ReportWithPackageFilter(ThreadFilter,"ThreadUpdateProcessLength.",__FILE__,__LINE__,(int)length,RpMessage,(int)dyeingspeed,0);
     CurrentRequestedLength = length*100;//Centimetres
     CurrentProcessedLength = 0;
     ProcessedLengthFuncPtr = (ProcessedLengthFunc)Funcptr;
 }
-char Lenstr[160];
+char Lenstr[190];
 uint32_t ThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
     uint32_t positionDiff = 0,prevprev;
@@ -206,6 +225,16 @@ uint32_t ThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         }
 
     }
+    /*FeederSpeedStore[FeederSpeedIndex++] = length;
+    if (FeederSpeedIndex>=SPEED_STORE_SIZE)
+    {
+        FeederSpeedIndex = 0;
+        FeederSpeedAverage = 0;
+        for (Speed_i = 0;Speed_i<SPEED_STORE_SIZE;Speed_i++)
+            FeederSpeedAverage+=FeederSpeedStore[Speed_i];
+        FeederSpeedAverage = FeederSpeedAverage/SPEED_STORE_SIZE;
+        ReportWithPackageFilter(ThreadFilter,"Avg len 100ms last 2 sec",__FILE__,(int)PoolerTotalProcessedLength,(int)(FeederSpeedAverage*1000),RpWarning,(int)(PullerSpeedAverage*1000),0);
+    }*/
     TotalProcessedLength += (length/100);
     TempTotalProcessedLength = TotalProcessedLength;
 #ifdef FEEDER_LENGTH_CALCULATION
@@ -242,7 +271,6 @@ uint32_t ThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 
     return OK;
 }
-
 uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
     uint32_t positionDiff = 0,prevprev;
@@ -297,9 +325,22 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             length = 0;
 
         }
+        /*PullerSpeedStore[PullerSpeedIndex++] = length;
+        if (PullerSpeedIndex>=SPEED_STORE_SIZE)
+        {
+            PullerSpeedIndex = 0;
+            PullerSpeedAverage = 0;
+            for (Speed_i = 0;Speed_i<SPEED_STORE_SIZE;Speed_i++)
+                PullerSpeedAverage+=PullerSpeedStore[Speed_i];
+            PullerSpeedAverage = PullerSpeedAverage/SPEED_STORE_SIZE;
+            //ReportWithPackageFilter(ThreadFilter,"Average Speed 2 second",__FILE__,__LINE__,(int)(FeederSpeedAverage*100),RpWarning,(int)(PullerSpeedAverage*100),0);
+        }**/
 
     //}
-
+#ifdef BTSR_NO_TFU
+        if (CurrentControlledSpeed[WINDER_MOTOR]>100)
+            length = dyeingspeed/10;
+#endif
     PoolerTotalProcessedLength+= (length/100);
     TempPoolerTotalProcessedLength = PoolerTotalProcessedLength;
 #ifndef FEEDER_LENGTH_CALCULATION
@@ -322,9 +363,9 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     }
     if ((CurrentProcessedLength>=CurrentRequestedLength )&&(CurrentRequestedLength > 0.0))
     {
-        usnprintf(Lenstr, 100, "Total processed length: Feeder: %d Pooler %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
+        usnprintf(Lenstr, 100, "Total processed length: Feeder: %d Puller %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
         SendJobProgress(0.0,0,false, Lenstr);
-        ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+        ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)(TotalProcessedLength*100),RpWarning,(int)(PoolerTotalProcessedLength*100),0);
         // segment/intersegment/distance to spool finished
         if (ProcessedLengthFuncPtr)
             ProcessedLengthFuncPtr();
@@ -393,7 +434,72 @@ uint32_t ThreadControlSpeedReadFunction(uint32_t IfIndex, uint32_t ReadValue)
     }
     return OK;
 }
+uint16_t BreakSensorCounter = 0;
+uint16_t BreakSensorLatchCounter = 0;
+char TMessage[150];
+#ifdef FOUR_WINDERS
+char ATMessage[MAX_THREAD_MOTORS_NUM][150];
+int c = 0;
+#endif
+uint32_t checkBreakSensor(uint32_t index)
+{
+    if (BreakSensorenabled == true)
+    {
+        if (JobCounter > eOneSecond)
+        {
+            if (ReadBreakSensor()==ERROR)
+            {
+                BreakSensorCounter++;
+                BreakSensorLatchCounter++;
+                if (BreakSensorCounter>=BreakSensordebouncetimemilli)
+                {
+                    //consider applying the debouce parameters later
+                    usnprintf(TMessage, 60, "ReadBreakSensor Error");
+                    //BreakSensordebouncetimemilli
+                    JobEndReason = JOB_THREAD_BREAK;
+                    ThreadControlActive = false;
+                    SendJobProgress(0.0,0,false, TMessage);
+                    strcpy(AlarmReasonStr,TMessage);
+                    SendSegmentFail();
+                    //AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true);
+                    //EndState(CurrentJob,"ReadBreakSensor Error" );
+                    ReportWithPackageFilter(ThreadFilter,"ReadBreakSensor Error",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
+                    return ERROR;
+                } //passed limit
+            }//ReadBreakSensor()==ERROR
+            else //reset counter - we are looking for consequent calls
+            {
+                if (BreakSensorCounter)
+                {
+                    ReportWithPackageFilter(ThreadFilter,"ReadBreakSensor Spike",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
+                }
+                BreakSensorCounter = 0;
+            }
+            if (CurrentControlledSpeed[index] < (OriginalMotorSpd_2PPS[index]/3))
+            {
+                BreakSensorCounter++;
+                BreakSensorLatchCounter++;
+                if (BreakSensorCounter>=BreakSensordebouncetimemilli)
+                {
+                    //consider applying the debouce parameters later
+                    usnprintf(TMessage, 60, "thread speed too low");
+                    strcpy(AlarmReasonStr,TMessage);
+                    JobEndReason = JOB_THREAD_BREAK;
+                    ThreadControlActive = false;
+                    SendJobProgress(0.0,0,false, TMessage);
+                    SendSegmentFail();
+                    //AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true);
+                    //EndState(CurrentJob,"ReadBreakSensor Error" );
+                    ReportWithPackageFilter(ThreadFilter,"thread speed too low Error",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
+                    return ERROR;
+                }
+            }
 
+        }
+    }
+    return OK;
+
+}
 int controlIndex = 0;
 bool keepdata = true;
 int32_t KeepReadValue = 0;
@@ -447,20 +553,15 @@ void testDancersControl()
 }
 #endif
 int MotorFailedSample[MAX_THREAD_MOTORS_NUM] = {0,0,0,0,0};
-char TMessage[150];
 //char time[150];
-uint16_t BreakSensorCounter = 0;
-uint16_t BreakSensorLatchCounter = 0;
 bool FirstCalcInJob = true;
 uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
 //#define MAX_CONTROL_SAMPLES 6
 //extern uint32_t MotorSamples[MAX_THREAD_MOTORS_NUM][MAX_CONTROL_SAMPLES];
 //extern int MotorSamplePointer[MAX_THREAD_MOTORS_NUM];
-
     //read value is the dancer angle
     int i,index=MAX_THREAD_MOTORS_NUM;
-    int len;
     int DancerId;
     int32_t TranslatedReadValue, avreageSampleValue = 0;//,avreageMotorSampleValue = 0;
     //double tempcalcspeed = 0;
@@ -480,6 +581,23 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     }
     index = IfIndex&0xFF;
 
+    if (index == POOLER_MOTOR) //move break sensor handling up to ensure handling even if tiing control is > 1 msec
+    {
+        if (checkBreakSensor(index) == ERROR)
+            return OK;
+    }
+    if (MotorTiming[index]>1)
+    {
+        MotorTimer[index]++;
+        if (MotorTimer[index]>=MotorTiming[index])
+        {
+            MotorTimer[index]=0;
+        }
+        else
+        {
+            return OK;
+        }
+    }
     if(MotorControlConfig[index].m_isEnabled )
     {
         //if (MotorDriverResponse[ThreadMotorIdToMotorId[index]].Busy == true)
@@ -511,6 +629,30 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 			//pooler dancer is right sided: data is opposite
             TranslatedReadValue = (-1*TranslatedReadValue);
         }
+#ifdef FOUR_WINDERS
+        if (index == WINDER_MOTOR)
+        {
+            c++;
+        }
+        if (index == WINDER_2_MOTOR)
+        {
+            c++;
+        }
+        if (index == WINDER_3_MOTOR)
+        {
+            c++;
+        }
+        if (index == WINDER_4_MOTOR)
+        {
+            c++;
+        }
+        //if ((index == WINDER_2_MOTOR)||(index == WINDER_3_MOTOR)||(index == WINDER_4_MOTOR))
+        /*if (index >= WINDER_MOTOR)
+        {
+            //pooler dancer is right sided: data is opposite
+            TranslatedReadValue = (-1*TranslatedReadValue);
+        }*/
+#endif
         if (index == POOLER_MOTOR)
         {
             //pooler dancer is right sided: data is opposite
@@ -529,61 +671,6 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             avreageSampleValue += MotorSamples[index][i];
         avreageSampleValue = avreageSampleValue / (int)MotorsControl[index].pvinputfilterfactormode;
 
-        if (BreakSensorenabled == true)
-        {
-            if (index == POOLER_MOTOR)
-            {
-                if (JobCounter > eOneSecond)
-                {
-                    if (ReadBreakSensor()==ERROR)
-                    {
-                        BreakSensorCounter++;
-                        BreakSensorLatchCounter++;
-                        if (BreakSensorCounter>=BreakSensordebouncetimemilli)
-                        {
-                            //consider applying the debouce parameters later
-                            usnprintf(TMessage, 60, "ReadBreakSensor Error");
-                            //BreakSensordebouncetimemilli
-                            JobEndReason = JOB_THREAD_BREAK;
-                            ThreadControlActive = false;
-                            SendJobProgress(0.0,0,false, TMessage);
-                            SendSegmentFail();
-                            //AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true);
-                            //EndState(CurrentJob,"ReadBreakSensor Error" );
-                            ReportWithPackageFilter(ThreadFilter,"ReadBreakSensor Error",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
-                            return OK;
-                        } //passed limit
-                    }//ReadBreakSensor()==ERROR
-                    else //reset counter - we are looking for consequent calls
-                    {
-                        if (BreakSensorCounter)
-                        {
-                            ReportWithPackageFilter(ThreadFilter,"ReadBreakSensor Spike",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
-                        }
-                        BreakSensorCounter = 0;
-                    }
-                    if (CurrentControlledSpeed[index] < (OriginalMotorSpd_2PPS[index]/3))
-                    {
-                        BreakSensorCounter++;
-                        BreakSensorLatchCounter++;
-                        if (BreakSensorCounter>=BreakSensordebouncetimemilli)
-                        {
-	                        //consider applying the debouce parameters later
-	                        usnprintf(TMessage, 60, "thread speed too low");
-	                        JobEndReason = JOB_THREAD_BREAK;
-	                        ThreadControlActive = false;
-	                        SendJobProgress(0.0,0,false, TMessage);
-	                        SendSegmentFail();
-	                        //AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true);
-	                        //EndState(CurrentJob,"ReadBreakSensor Error" );
-                            ReportWithPackageFilter(ThreadFilter,"thread speed too low Error",__FILE__,BreakSensorCounter,(int)index,RpError,(int)JobCounter,0);
-	                        return OK;
-						}
-                    }
-
-                }
-            }
-        }
 
         //Stop Execution if the dancer moves too much
         if ((abs(avreageSampleValue)> DancerStopActivityLimit[index])&&(JobCounter > eOneSecond))
@@ -595,7 +682,12 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             ThreadControlActive = false;
             //MotorGetStatusFromFPGA(ThreadMotorIdToMotorId[index]);
             JobEndReason = JOB_WINDER_DANCER_FAIL+DancerId;
+#ifdef FOUR_WINDERS
+            if (DancerId>HARDWARE_DANCER_2)
+                JobEndReason = JOB_WINDER_DANCER_FAIL+HARDWARE_DANCER_0;
+#endif
             SendJobProgress(0.0,0,false, TMessage);
+            strcpy(AlarmReasonStr,TMessage);
             //EndState(CurrentJob,TMessage );
             SendSegmentFail();
             /*switch (index)
@@ -647,21 +739,26 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             }*`/
         }*/
         calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*OriginalMotorSpd_2PPS[index];
+        if (index < WINDER_MOTOR)
+            calculated_speed = calculated_speed*InitialDryerSpeed/OriginalMotorSpd_2PPS[DRYER_MOTOR];
         //calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*CurrentControlledSpeed[index];
-        if (FirstCalcInJob == true)
+        //if (0)//(JobCounter % 1000 == 0)
+#ifdef FOUR_WINDERS
+        if (0)//(JobCounter % 500 < 7)//(FirstCalcInJob == true)
         {
-            if (index == FEEDER_MOTOR)
+            if (index >= WINDER_MOTOR)
             {
-                FirstCalcInJob = false;
-                len = usnprintf(TMessage, 150, "read %d avg %d error(6) %d integral(9) %d,delta(9) %d, calc(3) %d speed %d",
-                                ReadValue,avreageSampleValue,(int)(MotorControlConfig[index].m_mesuredParam*1000000),
+           //     FirstCalcInJob = false;
+                usnprintf(ATMessage[index], 150, "index %d read %d avg %d error(6) %d integral(9) %d,delta(9) %d, calc(3) %d speed %d %d",index-WINDER_MOTOR+1,
+                                TranslatedReadValue,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);
-                ReportWithPackageFilter(ThreadFilter,TMessage,__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
+                                (int)(MotorControlConfig[index].m_calculatedError*1000),(int)calculated_speed, (int)(InitialDryerSpeed*100/OriginalMotorSpd_2PPS[DRYER_MOTOR]));
+                ReportWithPackageFilter(ThreadFilter,ATMessage[index],__FILE__,MotorSamplePointer[index],JobCounter,RpError,ReadValue,0);
 
             }
+            JobCounter++;
         }
-
+#endif
 #ifndef TEST_PID_THREAD
         if (fabs(calculated_speed-CurrentControlledSpeed[index])> MotorControlConfig[index].m_ingnoreValue)
 #else
@@ -670,6 +767,11 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             if (calculated_speed>5.0)
             {
+                /*if (calculated_speed>(CurrentControlledSpeed[index]+100))
+                {
+                        ReportWithPackageFilter(ThreadFilter,"limit acceleration",__FILE__,calculated_speed,CurrentControlledSpeed[index],RpError,index,0);
+                        calculated_speed=CurrentControlledSpeed[index]+100;
+                }*/
                 CurrentControlledSpeed[index] = calculated_speed;
                 MotorSetSpeed(ThreadMotorIdToMotorId[index], calculated_speed);
             }
@@ -684,7 +786,6 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                 ReportWithPackageFilter(ThreadFilter,"MotorSpeedUpdated",__FILE__,index,(int)OriginalMotorSpd_2PPS[index],RpWarning,(int)CurrentControlledSpeed[index],0);
             }*/
 #ifdef TEST_PID_THREAD
-            int len;
             if ((JobCounter % 2000) == index*100)
              //if (keepdata == true)
             {
@@ -696,7 +797,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                 NormError[controlIndex] = MotorControlConfig[index].m_mesuredParam;
                 mIntegral[controlIndex] = MotorControlConfig[index].m_integral;
                 timestamp[controlIndex] = msec_millisecondCounter;*/
-                len = usnprintf(TMessage, 150, "read %d avg %d error(6) %d integral(9) %d,delta(9) %d, calc(3) %d speed %d",
+                usnprintf(TMessage, 150, "read %d avg %d error(6) %d integral(9) %d,delta(9) %d, calc(3) %d speed %d",
                                 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);
@@ -740,64 +841,166 @@ double ThreadGetMotorCalculatedError(int DancerId)
 }
 
 //********************************************************************************************************************
-uint32_t ThreadInitialTestStub(HardwareMotor * request)
-{
-
-
-    //MotorsConfigMessage(request);
-     ThreadPrepareState(request);
-     ThreadPreSegmentState(request,0);
-    return OK;
-}
 uint32_t HandleJobThreadControlParameters(ThreadParameters* ThreadParams)
 {
-    /*
-         FEEDER_MOTOR,
-    DRYER_MOTOR,
-    POOLER_MOTOR,
-    WINDER_MOTOR,
-    MotorControlConfig[Motor_i].m_params.Kd = MotorsControl[Pid_Id].derivativetime;
-    MotorControlConfig[Motor_i].m_params.Kp = MotorsControl[Pid_Id].proportionalgain;
-    MotorControlConfig[Motor_i].m_params.Ki = MotorsControl[Pid_Id].integraltime;
-
-     */
     if (ThreadParams == NULL)
     {
         return OK;
     }
+    if((ThreadParams->bypassrockers != true)&&(ThreadParams->bypassrockers != false))
+    {
+        ReportWithPackageFilter(ThreadFilter,"incorrect Thread parameters ",__FILE__,__LINE__,(int)ThreadParams->feederp,RpWarning,(int)ThreadParams->bypassrockers,0);
+        return OK;
+    }
+    if ((ThreadParams->feederp>100000)||(ThreadParams->feederi>100000))
+    {
+        ReportWithPackageFilter(ThreadFilter,"incorrect Thread parameters ",__FILE__,__LINE__,(int)ThreadParams->feederp,RpWarning,(int)ThreadParams->bypassrockers,0);
+        return OK;
+    }
     if(ThreadParams->feederp)
-        MotorControlConfig[FEEDER_MOTOR].m_params.Kd = ThreadParams->feederp;
+        MotorControlConfig[FEEDER_MOTOR].m_params.Kp = ThreadParams->feederp;
     if(ThreadParams->feederi)
         MotorControlConfig[FEEDER_MOTOR].m_params.Ki = ThreadParams->feederi;
     if(ThreadParams->feederd)
         MotorControlConfig[FEEDER_MOTOR].m_params.Kd = ThreadParams->feederd;
 
     if(ThreadParams->pullerp)
-        MotorControlConfig[POOLER_MOTOR].m_params.Kd = ThreadParams->pullerp;
+        MotorControlConfig[POOLER_MOTOR].m_params.Kp = ThreadParams->pullerp;
     if(ThreadParams->pulleri)
         MotorControlConfig[POOLER_MOTOR].m_params.Ki = ThreadParams->pulleri;
     if(ThreadParams->pullerd)
         MotorControlConfig[POOLER_MOTOR].m_params.Kd = ThreadParams->pullerd;
 
     if(ThreadParams->winderp)
-        MotorControlConfig[WINDER_MOTOR].m_params.Kd = ThreadParams->winderp;
+    {
+        MotorControlConfig[WINDER_MOTOR].m_params.Kp = ThreadParams->winderp;
+#ifdef FOUR_WINDERS
+        MotorControlConfig[WINDER_2_MOTOR].m_params.Kp = ThreadParams->winderp;
+        MotorControlConfig[WINDER_3_MOTOR].m_params.Kp = ThreadParams->winderp;
+        MotorControlConfig[WINDER_4_MOTOR].m_params.Kp = ThreadParams->winderp;
+#endif
+    }
     if(ThreadParams->winderi)
+    {
         MotorControlConfig[WINDER_MOTOR].m_params.Ki = ThreadParams->winderi;
+#ifdef FOUR_WINDERS
+        MotorControlConfig[WINDER_2_MOTOR].m_params.Ki = ThreadParams->winderi;
+        MotorControlConfig[WINDER_3_MOTOR].m_params.Ki = ThreadParams->winderi;
+        MotorControlConfig[WINDER_4_MOTOR].m_params.Ki = ThreadParams->winderi;
+#endif
+    }
     if(ThreadParams->winderd)
+    {
         MotorControlConfig[WINDER_MOTOR].m_params.Kd = ThreadParams->winderd;
+#ifdef FOUR_WINDERS
+        MotorControlConfig[WINDER_2_MOTOR].m_params.Kd = ThreadParams->winderd;
+        MotorControlConfig[WINDER_3_MOTOR].m_params.Kd = ThreadParams->winderd;
+        MotorControlConfig[WINDER_4_MOTOR].m_params.Kd = ThreadParams->winderd;
+#endif
+    }
+    ReportWithPackageFilter(ThreadFilter,"Rockers activity",__FILE__,__LINE__,(int)Thread_Rockers_Bypass,RpWarning,(int)ThreadParams->bypassrockers,0);
     if(ThreadParams->bypassrockers)
         Thread_Rockers_Bypass = true;
 
     return OK;
 }
+bool RTFU_Up = false;
+
+uint32_t Release_Right_TFU_TensionCallback(uint32_t deviceID, uint32_t BusyFlag)
+{
+    //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,temp_MaxFrequency);
+    Report("Release_Right_TFU_TensionCallback",__FILE__,deviceID,0,RpMessage,0,0);
+
+    MotorStop (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,Soft_Hiz); //per L6470 errata between mov and run commands
+    return OK;
+}
+uint32_t Release_Right_TFU_Tension()
+{
+    uint32_t status = OK;
+#ifndef BTSR_NO_TFU
+    if (RTFU_Up == true)
+    {
+        Report("Release_Right_TFU_Tension",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_RDANCER,RpMessage,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].pulseperround/4,0);
+        RTFU_Up = false;
+        status = MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].pulseperround/4* MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].microstep, Release_Right_TFU_TensionCallback,1000);
+    }
+#endif
+    return status;
+}
+int SecondFeederCorrection = 4;
+int PrepareWaitCount = 0;
+uint32_t Adjust_Right_TFU_Tension_2nd_Callback(uint32_t MotorId, uint32_t ReadValue)
+{
+#ifndef BTSR_NO_TFU
+    MotorStop (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,Soft_Stop); //per L6470 errata between mov and run commands
+    Report("Adjust_Right_TFU_Tension_2ndCallback x more steps",__FILE__,__LINE__,MotorId,RpMessage,SecondFeederCorrection,0);
+    if (JobIsActive()==false)
+    {
+        Report("release tension - job aborted",__FILE__,__LINE__,MotorId,RpMessage,0,0);
+        Release_Right_TFU_Tension();
+    }
+    if (PrepareWaitCount)
+    {
+        ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_TensionCallback",__FILE__,__LINE__,2,RpWarning,PrepareWaitCount,0);
+        PrepareWaitCount--;
+    }
+    if ((PrepareWaitCount == 0)&&(PrepareState == true))
+    {
+        PrepareState = false;
+        ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_TensionCallback  Prepare Ready",__FILE__,__LINE__,2,RpWarning,PrepareWaitCount,0);
+        PrepareReady(Module_Thread,ModuleDone);
+    }
+#endif
+    return OK;
+}
+uint32_t Adjust_Right_TFU_Tension_Callback(uint32_t MotorId, uint32_t ReadValue)
+{
+#ifndef BTSR_NO_TFU
+    Report("Adjust_Right_TFU_Tension_Callback",__FILE__,__LINE__,MotorId,RpMessage,0,0);
+    MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize,SecondFeederCorrection* MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].microstep, Adjust_Right_TFU_Tension_2nd_Callback,1000);
+    RTFU_Up = true;
+#endif
+    return OK;
+}
+
+uint32_t Adjust_Right_TFU_Tension(double tension)
+{
+    uint32_t status = OK;
+#ifndef BTSR_NO_TFU
+    if (tension > 0.5) //0 = lower position, 1 = high position
+    {
+        if (FPGA_Read_limit_Switches(GPI_LS_RDANCER_UP) == NO_LIMIT)
+        {
+            PrepareWaitCount++;
+            MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 15,  GPI_LS_RDANCER_UP, Adjust_Right_TFU_Tension_Callback,15000);
+            Report("Adjust_Right_TFU_Tension",__FILE__,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize,HARDWARE_MOTOR_TYPE__MOTO_RDANCER,RpMessage,PrepareWaitCount,0);
+        }
+    }
+#endif
+    return status;
+}
+uint32_t ThreadPrepare_TensionCallback (int MotorId, double tension)
+{
+    //MotorStop(MotorId,Hard_Hiz);
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_TensionCallback",__FILE__,__LINE__,MotorId,RpWarning,PrepareWaitCount,0);
+    if (PrepareWaitCount)
+    {
+        PrepareWaitCount--;
+    }
+    if ((PrepareWaitCount == 0)&&(PrepareState == true))
+    {
+        PrepareState = false;
+        ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_TensionCallback  Prepare Ready",__FILE__,__LINE__,MotorId,RpWarning,PrepareWaitCount,0);
+        PrepareReady(Module_Thread,ModuleDone);
+    }
+    return OK;
+}
 uint32_t ThreadPrepare_Tension (int DancerId, double tension)
 {
     int current, request = (int)tension,movement;
     int HW_Motor_Id;
     bool direction;
     uint32_t status = OK, address = 0;
-    if (tension < 100)
-        return OK; //do not handle tension of zero
     switch (DancerId)
     {
     case HARDWARE_DANCER_TYPE__LeftDancer:
@@ -811,10 +1014,13 @@ uint32_t ThreadPrepare_Tension (int DancerId, double tension)
         HW_Motor_Id = HARDWARE_MOTOR_TYPE__MOTO_LDANCER2;
         break;
     case HARDWARE_DANCER_TYPE__RightDancer:
-        return ERROR;
+        return Adjust_Right_TFU_Tension(tension);
+        //break;
     default:
         return ERROR;
     }
+    if (tension < 100)
+        return OK; //do not handle tension of zero
     status |= MCU_E2PromRead(address,&current);
     if ((status!= OK )||(current == 0xFFFF))
         return status;
@@ -832,24 +1038,37 @@ uint32_t ThreadPrepare_Tension (int DancerId, double tension)
             direction = 1-MotorsCfg[HW_Motor_Id].directionthreadwize;
             movement = current - request;
         }
-        MotorSetMaxSpeed (HW_Motor_Id, 500);
-        MotorMoveWithCallback (HW_Motor_Id, direction, (movement*MotorsCfg[HW_Motor_Id].microstep), NULL,20000);
+        MotorSetMaxSpeed (HW_Motor_Id, 800);
+        MotorMoveWithCallback (HW_Motor_Id, direction, (movement*MotorsCfg[HW_Motor_Id].microstep), ThreadPrepare_TensionCallback,20000);
+        PrepareWaitCount++;
+        ReportWithPackageFilter(ThreadFilter,"PrepareWaitCount",__FILE__,PrepareWaitCount,current,RpWarning,request,0);
         status |= MCU_E2PromProgram(address,request);
     }
-    usnprintf(Lenstr, 100, "ThreadPrepare_Tension Dancer %d Request: %d Current %d movement %d dir %d motor %d address %d",
-              DancerId,request,current,movement,direction,HW_Motor_Id,address);
-    ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,address,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpFatalError,LIMIT,0);
+    if (DancerId == HARDWARE_DANCER_TYPE__LeftDancer)
+    {
+        usnprintf(Lenstr, 100, "ThreadPrepare_Tension Dancer %d Request: %d Current %d movement %d dir %d motor %d address %d call %d",
+                  DancerId,request,current,movement,direction,HW_Motor_Id,address,PrepareWaitCount);
+        ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,address,current,RpWarning,request,0);
 
+    }
+    else
+    {
+        usnprintf(TMessage, 100, "ThreadPrepare_Tension Dancer %d Request: %d Current %d movement %d dir %d motor %d address %d call %d",
+                  DancerId,request,current,movement,direction,HW_Motor_Id,address,PrepareWaitCount);
+        ReportWithPackageFilter(ThreadFilter,TMessage,__FILE__,address,current,RpWarning,request,0);
+
+    }
     return status;
 }
 //********************************************************************************************************************
- uint32_t ThreadPrepareState(void *JobDetails)
+bool SkipOpenLids = true;
+uint32_t ThreadPrepareState(void *JobDetails)
 {
     int Motor_i,i, HW_Motor_Id, Pid_Id;
     JobTicket* JobTicket = JobDetails;
     uint32_t status = OK;
     CurrentSegmentId = 0;
-
+    float temp_dt = 0;
     JobCounter = 0;
     TotalProcessedLength = 0.0;
     PoolerTotalProcessedLength = 0.0;
@@ -873,13 +1092,15 @@ uint32_t ThreadPrepare_Tension (int DancerId, double tension)
     EnableIntersegment = JobTicket->enableintersegment;
     IntersegmentLength = JobTicket->intersegmentlength;
 
+    PrepareWaitCount = 0;
+#ifndef BTSR_NO_TFU
     status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__LeftDancer, windertension);
-    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension",__FILE__,HARDWARE_DANCER_TYPE__LeftDancer,status,RpFatalError,(int)windertension,0);
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Winder",__FILE__,HARDWARE_DANCER_TYPE__LeftDancer,PrepareWaitCount,RpWarning,(int)windertension,0);
     status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__MiddleDancer, pullertension);
-    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension",__FILE__,HARDWARE_DANCER_TYPE__MiddleDancer,status,RpFatalError,(int)pullertension,0);
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Puller",__FILE__,HARDWARE_DANCER_TYPE__MiddleDancer,PrepareWaitCount,RpWarning,(int)pullertension,0);
     status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__RightDancer, feedertension);
-    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension",__FILE__,HARDWARE_DANCER_TYPE__RightDancer,status,RpFatalError,(int)feedertension,0);
-
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Feeder",__FILE__,HARDWARE_DANCER_TYPE__RightDancer,PrepareWaitCount,RpWarning,(int)feedertension,0);
+#endif
     FirstCalcInJob = true;
     if(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].speedmaster == false)
     {
@@ -893,19 +1114,57 @@ uint32_t ThreadPrepare_Tension (int DancerId, double tension)
     }
     MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, Hard_Stop);
 
-    if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) != LIMIT)
+    /*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);
+        ReportWithPackageFilter(ThreadFilter,"Dyeing head is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpWarning,LIMIT,0);
         //JobEndReason = JOB_LIDS_OPEN;
+        // usnprintf(AlarmReasonStr, 100, "Dyeing head is 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);
+        ReportWithPackageFilter(ThreadFilter,"Dryer lid is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,RpWarning,LIMIT,0);
         //JobEndReason = JOB_LIDS_OPEN;
+        // usnprintf(AlarmReasonStr, 100, "Dyeing head is open!!!");
         //PrepareReady(Module_Thread,ModuleFail);
         //return ERROR;
+    }*/
+
+//    if ((FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) == LIMIT)&&(JoggingJobActive == false))
+    if ((FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) != LIMIT)&&(JoggingJobActive == false))
+    {
+        if(Head_Type != HEAD_TYPE_ARC)
+        {
+            ReportWithPackageFilter(ThreadFilter,"Dyeing head is wide open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpError,LIMIT,0);
+            if (SkipOpenLids == false)
+            {
+                JobEndReason = JOB_LIDS_OPEN;
+                usnprintf(AlarmReasonStr, 100, "Dyeing head is open!!!");
+                PrepareReady(Module_Thread,ModuleFail);
+                return ERROR;
+            }
+        }
+    }
+    if ((Head_Type == HEAD_TYPE_ARC) && (JoggingJobActive == false)) {
+        if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_ARC) != LIMIT) {
+            ReportWithPackageFilter(ThreadFilter,"Dyeing head arc is open!!!",__FILE__,__LINE__,0,RpError,LIMIT,0);
+        }
+        if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_TUNNEL_ARC) != LIMIT) {
+            ReportWithPackageFilter(ThreadFilter,"Dyeing head arc tunnel is open!!!",__FILE__,__LINE__,0,RpError,LIMIT,0);
+        }
+    }
+//    if ((FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID]) == LIMIT)&&(JoggingJobActive == false))
+    if ((FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID]) != LIMIT)&&(JoggingJobActive == false))
+    {
+        ReportWithPackageFilter(ThreadFilter,"Dryer lid is wide open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,RpError,LIMIT,0);
+        if (SkipOpenLids == false)
+        {
+            JobEndReason = JOB_LIDS_OPEN;
+            usnprintf(AlarmReasonStr, 100, "Dryer lid is open!!!");
+            PrepareReady(Module_Thread,ModuleFail);
+            return ERROR;
+        }
     }
 
     //start thread control for all motors
@@ -913,61 +1172,81 @@ uint32_t ThreadPrepare_Tension (int DancerId, double tension)
     {
         HW_Motor_Id = ThreadMotorIdToMotorId[Motor_i];
         Pid_Id = Motor_i;/*ThreadMotorIdToControlId[Motor_i];*/
-            MotorControlConfig[Motor_i].m_params.MAX = 1;
-            MotorControlConfig[Motor_i].m_params.MIN = MotorsControl[Pid_Id].outputproportionalpowerlimit*-1;
-            MotorControlConfig[Motor_i].m_params.Kd = MotorsControl[Pid_Id].derivativetime;
-            MotorControlConfig[Motor_i].m_params.Kp = MotorsControl[Pid_Id].proportionalgain;
-            MotorControlConfig[Motor_i].m_params.Ki = MotorsControl[Pid_Id].integraltime;
-            MotorControlConfig[Motor_i].m_params.IntegralErrorMultiplier = MotorsControl[Pid_Id].setpointramprateorsoftstartramp;
-            MotorControlConfig[Motor_i].m_params.ProportionalErrorMultiplier = MotorsControl[Pid_Id].outputonoffhysteresisvalue;
-            MotorControlConfig[Motor_i].m_params.epsilon = MotorsControl[Pid_Id].epsilon;
-            MotorControlConfig[Motor_i].m_params.dt = MotorsControl[Pid_Id].controloutputtype;
-            MotorControlConfig[Motor_i].m_ingnoreValue =  MotorsControl[Pid_Id].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
-            MotorControlConfig[Motor_i].m_calculatedError = 0;
-            MotorControlConfig[Motor_i].m_integral = 0;
-            MotorControlConfig[Motor_i].m_isEnabled = true;
-            MotorControlConfig[Motor_i].m_isReady = true;
-            MotorControlConfig[Motor_i].m_mesuredParam = 0;
-            MotorControlConfig[Motor_i].m_preError = 0;
-            MotorControlConfig[Motor_i].m_SetParam = 0;//need to update SetParams on presegment stage
+#ifdef FOUR_WINDERS
+        if (Motor_i == WINDER_2_MOTOR) Pid_Id = WINDER_MOTOR;
+        if (Motor_i == WINDER_3_MOTOR) Pid_Id = WINDER_MOTOR;
+        if (Motor_i == WINDER_4_MOTOR) Pid_Id = WINDER_MOTOR;
+#endif
+        MotorControlConfig[Motor_i].m_params.MAX = 1;
+        MotorControlConfig[Motor_i].m_params.MIN = MotorsControl[Pid_Id].outputproportionalpowerlimit*-1;
+        MotorControlConfig[Motor_i].m_params.Kd = MotorsControl[Pid_Id].derivativetime;
+        MotorControlConfig[Motor_i].m_params.Kp = MotorsControl[Pid_Id].proportionalgain;
+        MotorControlConfig[Motor_i].m_params.Ki = MotorsControl[Pid_Id].integraltime;
+        MotorControlConfig[Motor_i].m_params.IntegralErrorMultiplier = MotorsControl[Pid_Id].setpointramprateorsoftstartramp;
+        MotorControlConfig[Motor_i].m_params.ProportionalErrorMultiplier = MotorsControl[Pid_Id].outputonoffhysteresisvalue;
+        MotorControlConfig[Motor_i].m_params.epsilon = MotorsControl[Pid_Id].epsilon;
+        MotorControlConfig[Motor_i].m_params.dt = MotorsControl[Pid_Id].controloutputtype;
+        MotorControlConfig[Motor_i].m_ingnoreValue =  MotorsControl[Pid_Id].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
+        MotorControlConfig[Motor_i].m_calculatedError = 0;
+        MotorControlConfig[Motor_i].m_integral = 0;
+        MotorControlConfig[Motor_i].m_isEnabled = true;
+        MotorControlConfig[Motor_i].m_isReady = true;
+        MotorControlConfig[Motor_i].m_mesuredParam = 0;
+        MotorControlConfig[Motor_i].m_preError = 0;
+        MotorControlConfig[Motor_i].m_SetParam = 0;//need to update SetParams on presegment stage
+
+        HandleJobThreadControlParameters(JobTicket->threadparameters);  //OVERRIDES CONFIGURATION PARAMETERS!!!
+
+        temp_dt = MotorControlConfig[Motor_i].m_params.dt/0.001;
+        MotorTiming[Motor_i] = (int)temp_dt;
+        if (MotorTiming[Motor_i])
+        {
+            MotorTimer[Motor_i] = MotorTiming[Motor_i]-1;
+            ReportWithPackageFilter(ThreadFilter,"MotorTiming",__FILE__,Motor_i,MotorTiming[Motor_i],RpWarning,MotorTimer[Motor_i],0);
+        }
 //////////////////////////////////////////////////
-            for (i = 0;i < (int)MotorsControl[Motor_i].pvinputfilterfactormode; i++)
-            {
-                //if (Motor_i == DRYER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
-                    MotorSamples[Motor_i][i] = Control_Read_Dancer_Position(ThreadMotorIdToDancerId[Motor_i],0);  //reset the samples value for control beginning
-               // else if ((Motor_i == POOLER_MOTOR)||(Motor_i == FEEDER_MOTOR))
-                //    MotorSamples[Motor_i][i] = DancersCfg[ThreadMotorIdToDancerId[Motor_i]].zeropoint;
-                //MotorSpeedSamples[Motor_i][i] = 0;
-            }
-            MotorSamplePointer[Motor_i] = 0;
+        for (i = 0;i < (int)MotorsControl[Motor_i].pvinputfilterfactormode; i++)
+        {
+            //if (Motor_i == DRYER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
+                MotorSamples[Motor_i][i] = 0;
+                if (Motor_i == FEEDER_MOTOR)
+                    MotorSamples[Motor_i][i] = -500;
+           // else if ((Motor_i == POOLER_MOTOR)||(Motor_i == FEEDER_MOTOR))
+            //    MotorSamples[Motor_i][i] = DancersCfg[ThreadMotorIdToDancerId[Motor_i]].zeropoint;
+            //MotorSpeedSamples[Motor_i][i] = 0;
+        }
+        MotorSamplePointer[Motor_i] = 0;
 /////////////////////////////////////////////////////
-            MotorSetDirection((TimerMotors_t)HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize);
+        MotorSetDirection((TimerMotors_t)HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize);
 
-            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
+#ifndef BTSR_NO_TFU
+        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
+        {
+            ReportWithPackageFilter(ThreadFilter,"Feeder Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
+            if (SpeedControlId != 0xFF)
             {
-                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);
-                    SpeedControlId = 0xFF;
-                }
-                //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
-                LengthCalculationMultiplier = (MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulleyradius*2*PI)/(MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulseperround*MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].microstep);
-                SpeedControlId = AddControlCallback(NULL,ThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
+                RemoveControlCallback(SpeedControlId,ThreadLengthCBFunction);
+                SpeedControlId = 0xFF;
             }
-            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
+            //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
+            LengthCalculationMultiplier = (MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulleyradius*2*PI)/(MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulseperround*MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].microstep);
+            SpeedControlId = AddControlCallback(NULL,ThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
+        }
+#endif
+        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
+        {
+            ReportWithPackageFilter(ThreadFilter,"Puller Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
+            if (PoolerSpeedControlId != 0xFF)
             {
-                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)
-                        ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)PoolerSpeedControlId,0);
-                     PoolerSpeedControlId = 0xFF;
-                }
-                //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
-                PoolerLengthCalculationMultiplier = (MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulleyradius*2*PI)/(MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulseperround*MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].microstep);
-                PoolerSpeedControlId = AddControlCallback(NULL,PoolerThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
+                if (RemoveControlCallback(PoolerSpeedControlId,PoolerThreadLengthCBFunction)!=OK)
+                    ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)PoolerSpeedControlId,0);
+                 PoolerSpeedControlId = 0xFF;
             }
+            //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
+            PoolerLengthCalculationMultiplier = (MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulleyradius*2*PI)/(MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulseperround*MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].microstep);
+            PoolerSpeedControlId = AddControlCallback(NULL,PoolerThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
+        }
+#ifndef BTSR_NO_TFU
             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
             {
                 if (ControlIdtoMotorId[Motor_i] != 0xFF)
@@ -995,6 +1274,7 @@ uint32_t ThreadPrepare_Tension (int DancerId, double tension)
                 ControlIdtoMotorId[Motor_i] = AddControlCallback(NULL,ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
 #endif
             }
+#endif
             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
             {
                 ReportWithPackageFilter(ThreadFilter,"Winder Control",__FILE__,Motor_i,MotorControlConfig[Motor_i].m_params.Kp,RpWarning,MotorControlConfig[Motor_i].m_params.Ki,0);
@@ -1009,25 +1289,87 @@ uint32_t ThreadPrepare_Tension (int DancerId, double tension)
                 ControlIdtoMotorId[Motor_i] = AddControlCallback(NULL,ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
 #endif
             }
-//            if (HW_Motor_Id == HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
-//                AddControlCallback(ThreadSpeedControlCBFunction, eOneMillisecond,TemplateDataReadCBFunction,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],0);
-            if (Motor_i == ThreadMotorIdToMotorId[DRYER_MOTOR]) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
-                continue;
+#ifdef FOUR_WINDERS
+            if ((Motor_i == WINDER_2_MOTOR)||(Motor_i == WINDER_3_MOTOR)||(Motor_i == WINDER_4_MOTOR)) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will n//ot be controlled
+            {
+                ReportWithPackageFilter(ThreadFilter,"Winder 2/3/4 Control",__FILE__,Motor_i,MotorControlConfig[WINDER_MOTOR].m_params.Kp,RpWarning,MotorControlConfig[WINDER_MOTOR].m_params.Ki,0);
+                if (ControlIdtoMotorId[Motor_i] != 0xFF)
+                {
+                    if(RemoveControlCallback(ControlIdtoMotorId[Motor_i],ThreadControlCBFunction)!=OK)
+                        ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)PoolerSpeedControlId,0);
+                    CurrentControlledSpeed[Motor_i] = 0;
+                    ControlIdtoMotorId[Motor_i] = 0xFF;
+                }
+#ifndef TEST_PID_THREAD
+                ControlIdtoMotorId[Motor_i] = AddControlCallback(NULL,ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
+#endif
+            }
+#endif
     }
-    HandleJobThreadControlParameters(JobTicket->threadparameters);  //OVERRIDES CONFIGURATION PARAMETERS!!!
 
 #ifdef TEST_PID_THREAD
     testDancersControl();
 #endif
-    PrepareReady(Module_Thread,ModuleDone);
+    if (PrepareWaitCount == 0)
+        PrepareReady(Module_Thread,ModuleDone);
     //set 3 dancers to the profile positions
-    return OK;
+    return status;
 }
+uint32_t UpdatePidDuringRun(HardwarePidControl *request)
+{
+    int Motor_i = MAX_THREAD_MOTORS_NUM,i;
+    double temp_dt;
+
+    for (i=0;i<MAX_THREAD_MOTORS_NUM;i++)
+    {
+        if (ThreadMotorIdToControlId[i] == request->hardwarepidcontroltype)
+        {
+            Motor_i = i;
+            break;
+        }
+    }
+    if (Motor_i == MAX_THREAD_MOTORS_NUM)
+        return ERROR;
 
+
+    if (request->derivativetime == true)
+    {
+        MotorControlConfig[Motor_i].m_params.Kd = request->derivativetime;
+        ReportWithPackageFilter(ThreadFilter,"UpdatePidDuringRun Kd",__FILE__,Motor_i,(int)(request->derivativetime),RpWarning,0,0);
+    }
+    if (request->proportionalgain == true)
+    {
+        MotorControlConfig[Motor_i].m_params.Kp = request->proportionalgain;
+        ReportWithPackageFilter(ThreadFilter,"UpdatePidDuringRun Kp",__FILE__,Motor_i,(int)(request->proportionalgain),RpWarning,0,0);
+    }
+    if (request->integraltime == true)
+    {
+        MotorControlConfig[Motor_i].m_params.Ki = request->integraltime;
+        ReportWithPackageFilter(ThreadFilter,"UpdatePidDuringRun Ki",__FILE__,Motor_i,(int)(request->integraltime),RpWarning,0,0);
+    }
+    if (request->epsilon == true)
+    {
+        MotorControlConfig[Motor_i].m_params.epsilon = request->epsilon;
+        ReportWithPackageFilter(ThreadFilter,"UpdatePidDuringRun epsilon",__FILE__,Motor_i,(int)(request->epsilon*10000),RpWarning,0,0);
+    }
+    if (request->has_controloutputtype == true)
+    {
+        MotorControlConfig[Motor_i].m_params.dt = request->controloutputtype;
+        temp_dt = MotorControlConfig[Motor_i].m_params.dt/0.001;
+        MotorTiming[Motor_i] = (int)temp_dt;
+        if (MotorTiming[Motor_i])
+        {
+            MotorTimer[Motor_i] = MotorTiming[Motor_i]-1;
+        }
+        ReportWithPackageFilter(ThreadFilter,"UpdatePidDuringRun dt",__FILE__,Motor_i,(int)(request->controloutputtype*1000),RpWarning,temp_dt,0);
+    }
+//////////////////////////////////////////////////
+    return OK;
+}
 void SetOriginMotorSpeed(float process_speed)
 {
     int Motor_i, HW_Motor_Id;
-    for (Motor_i = 0; Motor_i <= WINDER_MOTOR; Motor_i++)
+    for (Motor_i = 0; Motor_i < SCREW_MOTOR; Motor_i++)
     {
         HW_Motor_Id = ThreadMotorIdToMotorId[Motor_i];
         //(Speed*uStep*PPR)/((2*PI*motor_Radius)
@@ -1100,7 +1442,11 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
     {
         SetOriginMotorSpeed(process_speed);
         ThreadControlActive = true;
-        PrepareState = false;
+        if (PrepareWaitCount == 0)
+            PrepareState = false;
+        PullerSpeedIndex = 0;
+        FeederSpeedIndex = 0;
+
 #ifndef TEST_PID_THREAD
         // set the new speed in the dryer motor to the speed of the new segment
         if(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].speedmaster == false)
@@ -1111,7 +1457,7 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
         {
             DrierDivider = dyeingspeed/5;  //ramp up drier in 5 cm/sec steps
         }
-        ReportWithPackageFilter(ThreadFilter,"Drier ramp up",__FILE__,__LINE__,(int)dyeingspeed,RpWarning,(int)DrierDivider,0);
+        ReportWithPackageFilter(ThreadFilter,"Dryer ramp up",__FILE__,__LINE__,(int)dyeingspeed,RpWarning,(int)DrierDivider,0);
         InitialDryerSpeed = OriginalMotorSpd_2PPS[DRYER_MOTOR]/DrierDivider;
         MotorSetSpeed(ThreadMotorIdToMotorId[DRYER_MOTOR],InitialDryerSpeed );
         ControlIdtoMotorId[DRYER_MOTOR] = AddControlCallback("DryerRampUp",ThreadDryerRampUp, 200,TemplateDataReadCBFunction,0,0,0);
@@ -1235,7 +1581,7 @@ char Endstr[150];
      int Motor_i;
      ThreadControlActive = false;
      uint32_t status = OK;
-     usnprintf(Endstr, 100, "Total _processed length: Feeder: %d Pooler %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
+     usnprintf(Endstr, 100, "Total _processed length: Feeder: %d Puller %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
      SendJobProgress(0.0,0,false, Endstr);
      ReportWithPackageFilter(ThreadFilter,Endstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
 
@@ -1258,7 +1604,7 @@ char Endstr[150];
          PoolerSpeedControlId = 0xFF;
      }
 
-     for ( Motor_i = 0;Motor_i <= WINDER_MOTOR;Motor_i++)
+     for ( Motor_i = 0;Motor_i < SCREW_MOTOR;Motor_i++)
      {
          if (ControlIdtoMotorId[Motor_i] != 0xFF)
          {
@@ -1271,18 +1617,29 @@ char Endstr[150];
 
      }
 	 Task_sleep(100);
-     for ( Motor_i = 0;Motor_i <= WINDER_MOTOR;Motor_i++)
+     for ( Motor_i = 0;Motor_i < SCREW_MOTOR;Motor_i++)
      {
         MotorStop(ThreadMotorIdToMotorId[Motor_i],Hard_Hiz);
+
      }
      MotorStop(HARDWARE_MOTOR_TYPE__MOTO_RLOADING,Hard_Hiz);
      MotorStop(HARDWARE_MOTOR_TYPE__MOTO_LLOADING,Hard_Hiz);
+     Release_Right_TFU_Tension();
      IDS_StopLubrication();
     return OK;
 }
 
-
-
+void ThreadCheckArcHeadCovers(void)
+{
+    if ((Head_Type == HEAD_TYPE_ARC) && (JoggingJobActive == false)) {
+         if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_ARC) != LIMIT) {
+             ReportWithPackageFilter(ThreadFilter,"Dyeing head arc is open!!!",__FILE__,__LINE__,0,RpError,LIMIT,0);
+         }
+         if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_TUNNEL_ARC) != LIMIT) {
+             ReportWithPackageFilter(ThreadFilter,"Dyeing head arc tunnel is open!!!",__FILE__,__LINE__,0,RpError,LIMIT,0);
+         }
+     }
+}
 //********************************************************************************************************************
 
 void ThreadStartPrinting(void)
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
index 4518f0ded..e69de29bb 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
@@ -1,207 +0,0 @@
-#ifndef WASTE_H
-#define WASTE_H
-
-#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
-
-
-#define temp_funcion  0
-#define notOK 1
-
-
-/*
-#define SENSORFULL 1
-#define SENSOROVERFLOW 1
-#define SENSOREMPTY 0
-
-
-#define SENSORnotFULL 0
-#define SENSORnotOVERFLOW 0
-#define SENSORnotEMPTY 1
-*/
-#define PUMPON 1
-#define PUMPOFF 0
-
-#define PRECENSE 1
-#define NOTPRECENSE 0
-
-
-
-typedef unsigned char U8;
-
-
-typedef enum
-{
-    BLACK,
-    CYAN,
-    MAGENTA,
-    YELLOW,
-    TRANSPARENT,
-    SP_1,
-    CLEANER,
-    LUBRICANT
-} CMYK_color;
-
-typedef enum
-{
-    CarteidgeNotPrecense = 0,
-    CarteidgePrecense
-} CarteidgPrecenseSensorStatus; //WHS_CarteidgPrecenseSensorStatus;
-
-typedef enum
-{
-    WHS_CartridgeCoverCLOSE = 0,
-    WHS_CartridgeCoverOPEN
-} WHS_CarteidgeCoverSensorStatus;
-
-typedef enum
-{
-    SENSORFULL = 0,
-    SENSORnotFULL
-} WHS_FullSensorStatus;
-
-typedef enum
-{
-    SENSORnotEMPTY = 0,
-    SENSOREMPTY
-} WHS_EmptySensorStatus;
-
-typedef enum
-{
-    WHS_empty = 0,
-    WHS_filling,
-    WHS_emptying,
-    WHS_full,
-    WHS_overflow,
-    WHS_sttError
-} WHS_sttMachin;
-
-typedef enum
-{
-    WHS_no_event = 0,
-    WHS_overflow_sensor,
-    WHS_full_sensor,
-    WHS_empty_sensor,
-    IFS_INK_presence_sensor,
-    IFS_INK_authentication_pass,
-    IFS_INK_authentication_fail,
-    WHS_waste1_presence_sensor,
-    WHS_waste2_presence_sensor,
-    WHS_filter_sensor,
-    WHS_cartridge_cover_sensor,
-    WHS_Timeout,
-    IFS_Timeout,
-    IFS_Timeout_Second,
-    IFS_MidTankFull
-} WHS_sensor;
-
-typedef enum
-{
-   // WasteEmpty = 0,
-   // WasteFilling,
-   // WasteFail,
-    ColorFull = 0,
-    ColorUsed,
-    WasteEmpty,
-    WasteFilling,
-    WasteFull,
-    WasteFail
-} cartridge_status;
-
-
-typedef enum
-{
-    led_on = 0,
-    led_off,
-    led_blink,
-    led_panic
-} led_status;
-
-typedef enum
-{
-    no_waste_cartridge = 0,
-    INK_cartridge    ,
-    waste_cartridge1 ,
-    waste_cartridge2
-} cartridge_name;
-
-typedef enum
-{
-    VALVE_DIR_WASTE_CARTRIDGE1 = 0,
-    VALVE_DIR_WASTE_CARTRIDGE2
-} valve_cartridge_name;
-
-
-struct WHS_sensors_status
-{
-    WHS_CarteidgeCoverSensorStatus cartridge_cover;                       /*open(1)          ,close(0)           */
-//    WHS_CarteidgPrecenseSensorStatus IFS_Ink_precense_sensor;      /*presence(1)      ,not_precense(0)    */
-//    bool IFS_Ink_precense_sensor_flag; /* 1=event          0=no enent */
-    CarteidgPrecenseSensorStatus waste_cartridge1_precense_sensor;      /*presence(1)      ,not_precense(0)    */
-    bool waste_cartridge1_precense_sensor_flag; /* 1=event          0=no enent */
-    CarteidgPrecenseSensorStatus waste_cartridge2_precense_sensor;      /*presence(1)      ,not_precense(0)    */
-    bool waste_cartridge2_precense_sensor_flag; /* 1=event           0=no enent */
-    bool waste_tank_filter_sensor;              /*presence(1)      ,not_precense(0)    */
-    WHS_EmptySensorStatus waste_tank_empty_sensor; /*enpty(1)         ,not_empty(0)       */
-    WHS_FullSensorStatus waste_tank_full_sensor;   /*full(1)          ,not_full(0)        */
-    bool waste_tank_over_flow_sensor;           /*over_flow(1)     ,not_over_flow(0)   */
-};
-
-struct cartridge_params
-{
-    uint32_t serial_number;
-    cartridge_status status;  /*WasteEmpty, WasteFilling, WasteFail, WasteFull.......  */
-    MidTank_t cart_color;
-    bool autheticate;
-    uint32_t time_out;
-};
-
-struct pump_params
-{
-    bool status;
-    uint32_t time;
-};
-
-struct WHS_information
-{
-    WHS_sttMachin sttMachine;
-    struct cartridge_params cartridge_1, cartridge_2;
-    struct WHS_sensors_status WHS_sensors;
-    struct pump_params WHS_pump;
-    valve_cartridge_name WHS_valve;
-    WHS_sensor event;
-    cartridge_name active_cartridge;
-    uint32_t Cartridge_Ink_device_Id;
-    uint32_t Cartridge_Ink_TimeOut_device_Id;
-    uint32_t Cartridge_Waste1_device_Id;
-    uint32_t Cartridge_Waste2_device_Id;
-    uint32_t Cartridge_Cover_device_Id;
-    //PBcolor Ink_Led, cartridge_1_Led, cartridge_2_Led;
-    double MidTank_capacity;
-};
-struct WHS_information WHS_info;
-
-U8 WHS_init(void);
-U8 WHS_HW_test(void);
-bool WHS_IsEmptying();
-
-bool WHS_IsContainerFull();
-bool WHS_IsContainerEmpty();
-bool WHS_IsContainerOverflow();
-bool WHS_WasteCartridgeLowerPresent();
-bool WHS_WasteCartridgeMiddlePresent();
-bool WHS_IsPumpActive();
-bool WHS_IsValveOpen();
-
-bool SetWastePump( bool power);
-
-void midtanktest6_ON();
-void midtanktest6_OFF();
-
-//bool CartridgeValidationResponseFunc(MessageContainer* requestContainer);
-//void ResponseDemo(int MidtankId);
-
-bool RdInkCartridgeSensor();
-bool WasteTankCBFunction();
-
-#endif
-
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h
index 8b1378917..db15a9ffd 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h
@@ -1 +1,56 @@
+#ifndef WASTE_EX_H
+#define WASTE_EX_H
+
+typedef enum {
+    CartridgeStateOUT,
+    CartridgeStateIN,
+    CartridgeStateSELECTED,
+    CartridgeStateACTIVE,
+    CartridgeStateFULL
+}CartridgeStateEnum;
+
+typedef enum {
+    WasteCartridge_upper,
+    WasteCartridge_middle,
+    WasteCartridge_lower,
+    MaxWasteCartridges
+}WasteCartridgeEnum;
+
+typedef enum{
+    WasteTankStateIdle,
+    WasteTankStateFull,
+    WasteTankStateEmptying,
+    WasteTankStatePaused
+}WasteTankStateEnum;
+
+extern bool DoorState;
+/////////////////////////////// Cartridges  //////////////////////////////////////
+void cartCART_INSERTED (WasteCartridgeEnum); //{called from polling function. validate, set state to IN)
+void cartCART_EXTRACTED(WasteCartridgeEnum); //{called from polling function. set state to out, if was ACTIVE – notify waste module)
+WasteCartridgeEnum cartSELECT_CART(void); //{ if there is no SELECTED cartridge select the first cartridge in IN state. If there is none, return -1}
+void cartFILLING_START(void); //{set state of SELECTED to ACTIVE}
+void cartFILLING_END(void); //{set state of ACTIVE to FULL}
+CartridgeStateEnum cartGetState (WasteCartridgeEnum);
+bool cartGetPresence (WasteCartridgeEnum CartId);
+bool cartCart_door();//Polled by polling function. Notify waste. Poll each 1 second. During active filling poll each 100msec
+bool NoCartAvailable();
+
+void Waste_Init();
+void Waste_StateMachine(void);
+void Waste_StateMachine_OneSecond_Call(void);
+bool SetWastePump( bool power);
+bool WHS_IsContainerEmpty();
+bool WHS_IsContainerFull();
+bool WHS_WasteCartridgeLowerPresent();
+bool WHS_WasteCartridgeMiddlePresent();
+bool WHS_IsEmptying();
+uint32_t Waste_CheckState(int *AlarmId);
+uint32_t Waste_Prepare(void);
+bool WHS_IsVocPpmOverAlarmLimit();
+void setWastePrepareValues(float HeadLimit,float WasteLimit);
+
+
+extern bool ReadingVocEverySec;
+
+#endif
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index 922da21b1..e69de29bb 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -1,1410 +0,0 @@
-/*   ----  WHS      */
-#include <Container.h>
-#include <DataDef.h>
-#include "include.h"
-#include "Modules/Control/control.h" //  use for FPGA IO
-#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"//#include "FPGA_GPIO.h"  //  use for FPGA IO
-#include "drivers/Valves/Valve.h"
-#include "Common/report/report.h"
-#include "Modules/Waste/Waste.h"
-#include "common/utilities/RfidTagContent.h"
-
-#include  <PMR/Diagnostics/EventType.pb-c.h>
-#include "Modules/AlarmHandling/AlarmHandling.h"
-#include "StateMachines/Initialization/PowerOffSequence.h"
-#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
-#include "CartridgeValidationRequest.pb-c.h"
-#include "CartridgeValidationResponse.pb-c.h"
-#include "Modules/General/buttons.h"
-#include "Modules/IFS/ifs.h"
-#include <Drivers/I2C_Communication/I2C_Task.h>
-#include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
-//
-//#define CARTRIDGE_INK_TIMEOUT           60
-//#define CARTRIDGE_INK_TIMEOUTx2         120
-//#define CartridgeInkTimeOutCallBackTime eOneSecond
-//#define MidTank_Pressure_EMPTY 1000  //todo get from Moti the correct number
-//#define CARTRIDGE_CAPATICY 1500 //liters
-//#define FULL 1000
-
-#define WasteTankCallBackTime           eOneSecond
-#define CartridgeCoverCallBackTime      eOneSecond
-#define CartridgeCoverCallBackFastTime  eTenMillisecond
-#define CartridgeWaste1CallBackTime     eOneSecond
-#define CartridgeWaste2CallBackTime     eOneSecond
-//#define CartridgeInkCallBackTime        eOneSecond
-#define STARTCOUNT  1
-#define STOPCOUNT   0
-#define PUMPTIMEOUT 1200 //  seconds; 20 minutes, per Moty,  15/4/19
-
-
-/*------------Waste Tank function-----------------------*/
-bool initWHS_WasteTank();
-bool InitCartStatus();
-
-//bool CartridgeCoverCBFunction();
-U8 CartridgeCoverCallBackFunction();
-// WHS_sensor CartridgeInkCallBackFunction();
-WHS_sensor CartridgeWaste1CallBackFunction();
-WHS_sensor CartridgeWaste2CallBackFunction();
-WHS_sensor WasteTankCallBackFunction();
-U8 CartridgeWasteFilling(bool status);
-//bool WasteTankCBFunction();
-//WHS_sensor CartridgeInkTimeOutCallBackFunction();
-
-
-U8 CartridgePrecenceCBFunction();
-//U8 SetCartridgeLED(cartridge_name name,led_status led);
-
-bool SetWastePump( bool power);
-bool SetValveDirection();
-bool RdCartridgeCoverSensor();
-
-bool RdWasteCartridge1Sensor();
-bool RdWasteCartridge2Sensor();
-bool RdWasteTankFilterSensor();
-bool RdWasteTankOverFlowSensor();
-bool RdWasteTankFullSensor();
-bool RdWasteTankEmptySensor();
-bool RdCartridgeParam(cartridge_name cart_name);
-bool CartridgeAuthentication(cartridge_name cart_name);
-bool SetActiveWastCartridge();
-void SetWasteLevelEmptyingLimit(double value);
-
-
-
-RfidTagContent cartridge_info;
-
-// function for RFID:
-bool WrRFIDStatus(cartridge_name active_cartridge, cartridge_status status);
-cartridge_status RdRFIDStatus (cartridge_name active_cartridge);
-bool RD_MID_TANK_Level();
-
-//bool PowerOffInProcessGetState() {return OK;}; //todo
-bool WrRFIDStatus(cartridge_name active_cartridge, cartridge_status status)  { return OK;} //todo
-cartridge_status RdRFIDStatus (cartridge_name active_cartridge)  { return WasteEmpty; }  //todo
-
-bool WHS_IsContainerFull(){return WHS_info.WHS_sensors.waste_tank_full_sensor;}
-bool WHS_IsContainerEmpty(){return WHS_info.WHS_sensors.waste_tank_empty_sensor;}
-
-bool WHS_IsContainerOverflow(){return WHS_info.WHS_sensors.waste_tank_over_flow_sensor;}
-bool WHS_WasteCartridgeLowerPresent(){return WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;}
-bool WHS_WasteCartridgeMiddlePresent(){return WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;}
-bool WHS_IsPumpActive(){return WHS_info.WHS_pump.status;}
-bool WHS_IsValveOpen(){return WHS_info.WHS_valve;}
-bool RD_MID_TANK_Level(){return 0 /* FULL*/ ;}
-//bool ColorMatch();
-//bool MidTankValvesAction(bool action);
-
-
-
-//bool MidTankValvesAction(bool action) //Cartridge_MidTank_ON of Cartridge_MidTank_OFF
-//{
-//    bool ret =  false;
-//
-//    Valve_Set(IDS_Id_to_AirValve[WHS_info.Ink.cart_color], action );   //Atm_MidTank_OFF/ON
-//    Valve_Set(IDS_Id_to_CartrideValve[WHS_info.Ink.cart_color], action );   //Atm_MidTank_OFF/ON
-//
-//    ret = true;
-//    return ret;
-//}
-//
-//bool ColorMatch()
-//{
-//    bool ret =  false;
-//
-//    ret = true;
-//    return ret;
-//}
-
-bool WHS_IsEmptying()
-{
-    bool ret =  false;
-    if ( WHS_info.sttMachine == WHS_emptying )
-    {
-        ret = true;
-    }
-    return ret;
-}
-
-//char CartridgeRequestToken[36+1];
-//int  CartridgeRequestId = 0x01010101;
-///* --------    cartridge function  ----*/
-//uint32_t ReadCartridgeData(cartridge_name cart_name)
-//{
-//    //this function triggers reading and validation of the cartridge information
-//    // for now it sends a request to the tablet to inquire for the ink color/midtank id
-//    MessageContainer responseContainer;
-//    CartridgeValidationRequest ValidationReq = CARTRIDGE_VALIDATION_REQUEST__INIT;
-//    Cartridge CartridgeData;
-//
-//    strcpy(CartridgeRequestToken,"Happy days are coming to us, soon");
-//    memcpy(&CartridgeRequestToken[32],&CartridgeRequestId,sizeof(CartridgeRequestId));
-//    CartridgeRequestId++;
-//
-//    cartridge__init(&CartridgeData);
-//    CartridgeData.has_slot = true;
-//    CartridgeData.slot = CARTRIDGE_SLOT__Ink;
-//    CartridgeData.tag = 0;
-//    CartridgeData.has_index = false;
-//
-//    ValidationReq.has_action = true;
-//    ValidationReq.action = CARTRIDGE_ACTION__Inserted;
-//
-//    ValidationReq.cartridge = &CartridgeData;
-//
-//    responseContainer = createContainer(MESSAGE_TYPE__CartridgeValidationRequest, CartridgeRequestToken, true, &ValidationReq, &cartridge_validation_request__pack, &cartridge_validation_request__get_packed_size);
-//    //-------------------------------------------------------------------------------------------
-//    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);
-//    //SendChars((char*)container_buffer, container_size);
-//
-//    return OK;
-//}
-//void ResponseDemo(int MidtankId)
-//{
-//    WHS_info.event = IFS_INK_authentication_pass;
-//    //global mid tank id = MidtankId;
-//    WHS_info.Ink.cart_color = MidtankId;
-//    WasteTankCBFunction();//call cart is ok
-//}
-//bool CartridgeValidationResponseFunc(MessageContainer* requestContainer)
-//{
-//    bool ret = notOK;
-//    CartridgeValidationResponse* response = cartridge_validation_response__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
-//
-//    Cartridge *cartridge;
-//    uint32_t midtankId;
-//    cartridge_name cart_name;
-//
-//    // chack the massege:
-//    // 1. the cartridge is valid ( autantication)
-//    // 2. the pointer is not 0 !!!
-//    if (response->cartridge == 0 )
-//    {
-//        REPORT_MSG(WHS_filling," ------------ IFS_filling message from PPC is null!!! ----------------- "); // write to log error
-//        return ret;
-//    }
-//
-//    if (response->isvalid == true)
-//    {
-//        REPORT_MSG(WHS_filling," ------------ IFS_filling INK cartridge is valid ----------------- "); // write to log error
-//        cartridge = response->cartridge;
-//        midtankId = cartridge->index; // midtank 1-8
-//        cart_name = cartridge->slot;    //cart1(INK),cart2(WASTE1),cart3(WASTE1)
-//        if (cartridge->slot == INK_cartridge)
-//        {
-//            WHS_info.Ink.cart_color = cartridge->index; // midtank 1-8
-//            WHS_info.event = IFS_INK_authentication_pass;
-//        }
-//        WasteTankCBFunction();//call cart is ok
-//        ret = OK;
-//    }
-//    else
-//    {
-//        REPORT_MSG(WHS_filling," ------------ IFS_filling INK cartridge is not valid !!!----------------- "); // write to log error
-////        cartridge = response->cartridge;
-////        mimidtankId = cartridge->index;
-////        cart_name = cartridge->slot;
-//        WHS_info.event = IFS_INK_authentication_fail;
-//        WasteTankCBFunction();// call cart is INVALID
-//        ret = OK;
-//    }
-//return ret;
-//}
-
-
-
-bool RdCartridgeParam(cartridge_name cart_name)
-{
-    /*
-    read all parameters from RFid cartridge:
-    serial number, cartridge_status...
-    waste_cartridge 1 or 1
-    update waste_cartridge struct
-    */
-    bool ret = notOK;
-    switch (cart_name)
-    {
-    case waste_cartridge1:
-        WHS_info.cartridge_1.serial_number = temp_funcion; //to do
-        WHS_info.cartridge_1.status = temp_funcion; // to do
-        break;
-    case waste_cartridge2:
-        WHS_info.cartridge_2.serial_number = temp_funcion;
-        WHS_info.cartridge_2.status = temp_funcion;
-        break;
-    case INK_cartridge:
-        ReadCartridgeData(cart_name);
-        //memcpy(cartridge_info.ColorName,RED);
-//        add call back!!  WasteTankCallBackTime
-//        state - wait for cartridge validation
-//        //WHS_info.Ink.serial_number = temp_funcion;
-        //WHS_info.Ink.status = temp_funcion;
-        break;
-    default:
-        break;
-    }
-    ret = OK;
-    return ret;
-}
-
-bool  CartridgeAuthentication(cartridge_name cart_name)
-{
-    bool ret = notOK;
-    // TBD;
-    switch (cart_name)
-    {
-//        case INK_cartridge:
-//            WHS_info.Ink.autheticate = PASSED;  //todo
-//            //Pannel_Leds(CART_1, MODE_ON);
-//            break;
-        case waste_cartridge1:
-            WHS_info.cartridge_1.autheticate = PASSED;  //todo
-            //Pannel_Leds(CART_2, MODE_ON);
-            break;
-        case waste_cartridge2:
-            WHS_info.cartridge_2.autheticate = PASSED; //todo
-            //Pannel_Leds(CART_3, MODE_ON);
-            break;
-        default:
-            WHS_info.cartridge_1.autheticate = FAILED; //todo
-            WHS_info.cartridge_2.autheticate = FAILED; //todo
-            //Pannel_Leds(CART_2, MODE_OFF);
-            //Pannel_Leds(CART_3, MODE_OFF);
-            break;
-    }
-    ret = OK;
-    return ret;
-}
-
-/*
-bool check_RFID_authentication()
-{
-    bool ret = notOK;
- //   rd_waste_cartridge_param();
-    if ( 1 )
-        ret = OK;
-    return ret;
-}
-
-
-U8 Wr_cartridge_RFid(cartridge_name cartridge, cartridge_status status)
-{
-    bool ret = notOK;
-    // TBD;
-    ret = OK;
-    return ret;
-}
-
-U8 set_cartridge_2(U8 cartridge_status)
-{
-    bool ret = notOK;
-    WHS_info.cartridge_2.status = temp_funcion;
-    return ret;
-}
-*/
-
-/* ------------------------------*/
-
-
-bool SetWastePump( bool power)
-{
-    /*
-    set the waste pump on/off
-    off - :
-        1. when waste tank is empty
-        2. when empting is time out
-        3. cartrigde cover is open
-        4. when waste1 is not precense AND valve3way==1
-        5. when waste2 is not precense AND valve3way==2
-        6. when autentication with waste cartige is disable
-    on :
-        1. when waste_tank_full
-
-        void Pumps_Control(PUMPS_ENUM Pump_Id, bool Direction) //1 - OPEN, 0 - CLOSE ?? WHS_WTANKPUMP2 or WASTECH_PUMP2
-    */
-    bool ret = notOK;
-//    if (( power == OPEN ) && (WHS_info.WHS_sensors.cartridge_cover == CLOSE))
-    if ( power == OPEN )
-    {
-        if (WHS_Type == WHS_TYPE_UNKNOWN)
-        {
-		    Pumps_Control(WHS_WTANKPUMP2, OPEN); //waste_pump_power_on();
-        }
-		else //new WHS
-        {
-		    Trigger_SetWHSPump(OPEN);
-		}
-        WHS_info.WHS_pump.status = OPEN;
-        ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_empty start PUMP -----------------", __FILE__, __LINE__, WHS_info.WHS_pump.status, RpMessage, 0, 0);
-        WHS_info.WHS_pump.time = STARTCOUNT;
-        ret = OPEN;
-    }
-    else
-    {
-        if (WHS_Type == WHS_TYPE_UNKNOWN)
-        {
-		    Pumps_Control(WHS_WTANKPUMP2, CLOSE); //waste_pump_power_on();
-        }
-		else //new WHS
-        {
-		    Trigger_SetWHSPump(CLOSE);
-        }
-		WHS_info.WHS_pump.status = CLOSE;
-        ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_empty stop PUMP -----------------", __FILE__, __LINE__, WHS_info.WHS_pump.status, RpMessage, 0, 0);
-        WHS_info.WHS_pump.time = STOPCOUNT;
-        ret = CLOSE;
-    }
-    return ret;
-}
-
-
-
-
-bool SetValveDirection()
-{
-    /*
-     * waste_cartridge = 1- OPEN, 0 - CLOSE
-     *   VALVE_WASTE_TANK
-     *
-     * */
-    bool ret = OK;
-    //if (WHS_info.WHS_valve != no_waste_cartridge)
-    if (WHS_info.active_cartridge == waste_cartridge1)
-    {
-        WHS_info.WHS_valve = VALVE_DIR_WASTE_CARTRIDGE1;
-        ReportWithPackageFilter(WasteFilter,"------------WHS_info.WHS_valve VALVE_DIR_WASTE_CARTRIDGE1  -----------------", __FILE__, __LINE__, WHS_info.WHS_valve, RpMessage, 0 ,0);
-}
-    else
-    {
-        WHS_info.WHS_valve = VALVE_DIR_WASTE_CARTRIDGE2;
-        ReportWithPackageFilter(WasteFilter,"------------WHS_info.WHS_valve VALVE_DIR_WASTE_CARTRIDGE2   -----------------", __FILE__, __LINE__, WHS_info.WHS_valve, RpMessage, 0 ,0);
-    }
-
-
-    if (WHS_Type == WHS_TYPE_UNKNOWN)
-        Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
-    else //new WHS
-        Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
-
-    //ret = OK;
-
-    return ret;
-}
-
-
-/*--------------------------    function for  WHS  -------------------------------   */
-
-U8 CartridgeWasteFilling(bool status)
-{
-    bool ret = notOK;
-    //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
-        //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;
-        AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  false);
-        if (WHS_Type == WHS_TYPE_NEW)
-        {
-            SetWasteLevelEmptyingLimit(GetWHSWasteTankLevelMiliLiter());
-            waste_seq_step1_cont();
-        }
-        ret=OK;
-    }
-    else // stop Waste cartridge filling
-    {
-        SetWastePump(CLOSE);
-        WHS_info.WHS_valve = VALVE_DIR_WASTE_CARTRIDGE1;
-        if (WHS_Type == WHS_TYPE_UNKNOWN)
-            Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
-        else //new WHS
-        {
-            Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
-            waste_seq_cont_stop();
-        }
-
-        AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  true);
-
-        switch (WHS_info.active_cartridge)
-           {
-              case waste_cartridge1:
-                  Pannel_Leds( CART_2,  MODE_OFF);                //set led color
-                  cart2.color = colorOFF;
-                  ReportWithPackageFilter(WasteFilter,"------------ WHS  waste_cartridge1 is used please replace it -----------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
-                  break;
-              case waste_cartridge2:
-                  Pannel_Leds( CART_3,  MODE_OFF);                //set led color
-                  cart3.color = colorOFF;
-                  ReportWithPackageFilter(WasteFilter,"------------ WHS  waste_cartridge2 is used please replace it -----------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
-                  break;
-              case no_waste_cartridge:
-                  ReportWithPackageFilter(WasteFilter,"------------ !!!!!WHS  No waste cartridge !!!!! -----------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
-                  ReportWithPackageFilter(WasteFilter,"------------ !!!! WHS  insert cartridge!!!! -----------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
-                  ret = ERROR;
-                  break;
-              default:
-                  break;
-           }
-
-
-        //write RFID status
-    }
-    return ret;
-}
-
-/* ------read waste tank sensors -----------  */
-#define WASTE_CARTRIDGE_SIZE 1.5
-#define WASTE_LEVEL_OVERFLOW 4.0
-#define WASTE_LEVEL_FULL 3.5
-#define WASTE_LEVEL_EMPTY 2.10
-double WasteLevelOverflow = WASTE_LEVEL_OVERFLOW;
-double WasteLevelFull = WASTE_LEVEL_FULL;
-double WasteLevelEmpty = WASTE_LEVEL_EMPTY;
-void SetWasteLevelEmptyingLimit(double value)
-{
-    WasteLevelEmpty = value - WASTE_CARTRIDGE_SIZE;
-    ReportWithPackageFilter(WasteFilter,"------------ SetWasteLevelEmptyingLimit -----------------", __FILE__, __LINE__, (int)(value*100), RpMessage, (int)(WasteLevelEmpty*100), 0);
-}
-bool RdWasteTankEmptySensor()
-{
-    double WasteLevel = 0.0;
-    bool ret = notOK;
-    //WHS_Read_GPI_Registers();
-    //WHS_info.WHS_sensors.waste_tank_empty_sensor = WHS_GPI_WCONTAINER_WARN();
-    //ret = WHS_info.WHS_sensors.waste_tank_empty_sensor;
-     if (WHS_Type == WHS_TYPE_UNKNOWN)
-     {
-         ret = WHS_GPI_WCONTAINER_WARN();
-     }
-     else //new WHS
-     {
-         WasteLevel = GetWHSWasteTankLevelMiliLiter();
-         if (WasteLevel < WasteLevelEmpty)
-             ret = OK;
-     }
-     return ret;
-}
-
-bool RdWasteTankFullSensor()
-{
-    double WasteLevel = 0.0;
-    bool ret = notOK;
-    //WHS_Read_GPI_Registers();
-    //WHS_info.WHS_sensors.waste_tank_full_sensor =  WHS_GPI_WCONTAINER_FULL();
-    //ret = WHS_info.WHS_sensors.waste_tank_full_sensor;
-    if (WHS_Type == WHS_TYPE_UNKNOWN)
-    {
-        ret = WHS_GPI_WCONTAINER_FULL();
-    }
-    else //new WHS
-    {
-        WasteLevel = GetWHSWasteTankLevelMiliLiter();
-        if (WasteLevel < WasteLevelFull)
-            ret = OK;
-    }
-    return ret;
-}
-
-bool RdWasteTankOverFlowSensor()
-{
-    bool ret = notOK;
-    double WasteLevel = 0.0;
-    //WHS_Read_GPI_Registers();
-    //WHS_info.WHS_sensors.waste_tank_over_flow_sensor =  WHS_GPI_WASTE_OVERFULL();
-    //ret = WHS_info.WHS_sensors.waste_tank_over_flow_sensor;
-    if (WHS_Type == WHS_TYPE_UNKNOWN)
-    {
-        ret = WHS_GPI_WASTE_OVERFULL();
-    }
-    else //new WHS
-    {
-        WasteLevel = GetWHSWasteTankLevelMiliLiter();
-        if (WasteLevel > WasteLevelOverflow)
-            ret = OK;
-    }
-    return ret;
-}
-
-/*-------------*/
-
-
-WHS_sttMachin UpdateStateMachine()
-{
-    //WHS_sttMachin ret = WHS_sttError  ;
-
-    if ( WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORnotFULL)
-    {
-        WHS_info.sttMachine = WHS_empty  ;
-        ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_empty -----------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_tank_full_sensor, RpMessage, WHS_info.WHS_sensors.waste_tank_empty_sensor, 0);
-    }
-    else if ((WHS_info.WHS_sensors.waste_tank_full_sensor   == SENSORFULL) &&
-             (WHS_info.WHS_sensors.waste_tank_empty_sensor  == SENSORnotEMPTY))
-    {
-        WHS_info.sttMachine =  WHS_full  ;
-        ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_full -----------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_tank_full_sensor, RpMessage, WHS_info.WHS_sensors.waste_tank_empty_sensor, 0);
-    }
-    else
-    {
-        WHS_info.sttMachine =  WHS_sttError  ;
-        ReportWithPackageFilter(WasteFilter,"------------ WHS sensor Error -----------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_tank_full_sensor, RpMessage, WHS_info.WHS_sensors.waste_tank_empty_sensor, 0);
-    }
-    return WHS_info.sttMachine;
-}
-
-
-bool initWHS_WasteTank()
-{
-    WHS_info.WHS_sensors.waste_tank_empty_sensor = RdWasteTankEmptySensor();
-    WHS_info.WHS_sensors.waste_tank_full_sensor =  SENSORnotFULL;
-    Task_sleep(15);
-    UpdateStateMachine();
-    AddControlCallback("Waste tank",WasteTankCBFunction, WasteTankCallBackTime , WasteTankCallBackFunction, 0,0,0);//eOneMinute
-    return OK;
-}
-
-
-WHS_sensor EmptySensorEvent()
-{
-    WHS_sensor ret = WHS_no_event;
-    if (RdWasteTankEmptySensor() != WHS_info.WHS_sensors.waste_tank_empty_sensor)
-    {
-        WHS_info.event =  WHS_empty_sensor;
-        ret = WHS_empty_sensor;
-        WHS_info.WHS_sensors.waste_tank_empty_sensor = !WHS_info.WHS_sensors.waste_tank_empty_sensor;
-        ReportWithPackageFilter(WasteFilter,"------------ WHS EmptySensorEvent (status) -----------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_tank_full_sensor, RpMessage, WHS_info.WHS_sensors.waste_tank_empty_sensor, 0);
-    }
-    return ret;
-}
-
-WHS_sensor FullSensorEvent()
-{
-    WHS_sensor ret = WHS_no_event;
-    if ( RdWasteTankFullSensor() != WHS_info.WHS_sensors.waste_tank_full_sensor )
-    {
-        WHS_info.event =  WHS_full_sensor;
-        ret = WHS_full_sensor;
-        WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor;
-        ReportWithPackageFilter(WasteFilter,"------------ WHS FullSensorEvent (status) -----------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_tank_full_sensor, RpMessage, WHS_info.WHS_sensors.waste_tank_empty_sensor, 0);
-    }
-    return ret;
-}
-
-WHS_sensor WasteTankCallBackFunction()
-{
-    /* detect waste tank sensor event */
-    WHS_sensor ret = WHS_no_event;
-/*    if ( OverflowSensorEvent())
-        {
-         return WHS_info.event;
-        }
-    else */
-    if (WHS_info.WHS_pump.time) WHS_info.WHS_pump.time += 1;
-    if (WHS_info.WHS_pump.time == PUMPTIMEOUT)
-    {
-        WHS_info.WHS_pump.time = 0;
-        AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  false);
-        ReportWithPackageFilter(WasteFilter,"------------ WHS PUMPTIMEOUT -----------------", __FILE__, __LINE__, PUMPTIMEOUT, RpMessage, 0, 0);
-        return WHS_info.event = WHS_Timeout;
-    }
-    if ( FullSensorEvent())
-         {
-             return WHS_info.event;
-         }
-    else if ( EmptySensorEvent())
-         {
-            return WHS_info.event;
-         }
-
-    return ret;
-}
-
-bool WasteTankCBFunction()
-{
-
-    bool ret = notOK;
-    static bool pump_on_flag = CLOSE;
-    //uint32_t Cartridge_Cover_device_Id = 0;
-    double MidTank_Pressure = 0;
-
-    switch (WHS_info.event)
-    {
-        case WHS_empty_sensor:
-            if (WHS_info.WHS_sensors.waste_tank_empty_sensor == SENSORnotEMPTY)
-            {
-                if (WHS_info.sttMachine == WHS_empty)
-                {
-                    WHS_info.sttMachine = WHS_filling;
-                    ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_filling ------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
-                }
-                else
-                {
-                    ReportWithPackageFilter(WasteFilter,"------------ WHS WHS EMPTY sensor failed !!!!!!! ------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
-                }
-            }
-            else //SENSOREMPTY
-            {
-                if (WHS_info.sttMachine == WHS_emptying)
-                {
-                    WHS_info.sttMachine = WHS_empty;
-                    ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_empty -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
-                    ret = CartridgeWasteFilling(OFF);
-                    WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
-                    WHS_info.Cartridge_Cover_device_Id = AddControlCallback("Cartridge Cover Door", WasteTankCBFunction, CartridgeCoverCallBackTime, CartridgeCoverCallBackFunction, 0,0,0 );//eOneSecond
-                    WrRFIDStatus(WHS_info.active_cartridge, WasteFull);//write RFID status todo
-                }
-                else
-                {
-                    ReportWithPackageFilter(WasteFilter,"------------ WHS WHS EMPTY sensor failed !!!!!!! -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
-                }
-            }
-            break;
-        case WHS_full_sensor:
-            /* if the machine status is power down : don't start the waste emptying sequence !!!*/
-            if ( PowerOffInProcessGetState() )
-                break;
-            if ((WHS_info.WHS_sensors.cartridge_cover == OPEN) && (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL))
-            {
-                ReportWithPackageFilter(WasteFilter,"------------ WHS_full , cartridge cover is open cant start the pump!!!! -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.cartridge_cover, 0);
-                ReportWithPackageFilter(WasteFilter,"------------ WHS, close the cartridge cover to start the pump!!!! -------------"      , __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.cartridge_cover, 0);
-
-                AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  true);
-
-                WHS_info.WHS_sensors.waste_tank_full_sensor = SENSORnotFULL;
-                break;
-            }
-            if (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL)
-            {
-                WHS_info.sttMachine = WHS_full;
-                ReportWithPackageFilter(WasteFilter,"------------ WHS, WHS_full -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.waste_tank_full_sensor, 0);
-                WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
-                WHS_info.Cartridge_Cover_device_Id = AddControlCallback("Cartridge Cover Door", WasteTankCBFunction, CartridgeCoverCallBackFastTime , CartridgeCoverCallBackFunction, 0,0,0 );//eTenMillisecond
-                if (RdRFIDStatus (WHS_info.active_cartridge) == WasteEmpty)
-                {
-                    ret = WrRFIDStatus(WHS_info.active_cartridge, WasteFilling);//write RFID status todo
-                    if (ret == OK)
-                    {
-                        ret = CartridgeWasteFilling(ON);
-                    }
-                    else
-                    {
-                        WrRFIDStatus(WHS_info.active_cartridge,  WasteFail);//write RFID status todo
-                    }
-                }
-
-                if (ret != OK)
-                {
-                    //recreate the full event until cartridge is inserted or authentication
-                    WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor;
-                }
-
-                // cant start a new Job
-            }
-            else
-            {
-                if (WHS_info.sttMachine == WHS_full)
-                {
-                    WHS_info.sttMachine = WHS_emptying;
-                    ReportWithPackageFilter(WasteFilter,"------------ WHS, WHS_emptying -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.waste_tank_full_sensor, 0);
-                    // can start a new JOB
-                }
-                else
-                {
-                    ReportWithPackageFilter(WasteFilter,"------------ WHS, WHS FULL sensor failed !!!!!!! -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.waste_tank_full_sensor, 0);
-                }
-            }
-            break;
-
-        case WHS_cartridge_cover_sensor:
-
-            if ( WHS_info.WHS_sensors.cartridge_cover == OPEN )
-            {
-                ReportWithPackageFilter(WasteFilter,"------------ WHS, Cartridge cover open -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.cartridge_cover, 0);//popup message :"Cartridge cover open"  //todo
-                if ( WHS_info.WHS_pump.status == OPEN)
-                {
-                    CartridgeWasteFilling(CLOSE);
-                    pump_on_flag = OPEN;
-                }
-
-//                if (cart1.color != colorOFF)
-//                {
-//
-//                }
-
-                if ( !PowerOffInProcessGetState() )
-                {
-                    IFS_info.Cartridge_Ink_device_Id    = AddControlCallback("Ink_Cartridge", WasteTankCBFunction, CartridgeInkCallBackTime   , CartridgeInkCallBackFunction   , 0,0,0 ); //eOneSecond
-                    WHS_info.Cartridge_Waste1_device_Id = AddControlCallback("Waste1 Cartridge", WasteTankCBFunction, CartridgeWaste1CallBackTime, CartridgeWaste1CallBackFunction, 0,0,0 ); //eOneSecond
-                    WHS_info.Cartridge_Waste2_device_Id = AddControlCallback("Waste2 Cartridge", WasteTankCBFunction, CartridgeWaste2CallBackTime, CartridgeWaste2CallBackFunction, 0,0,0 ); //eOneSecond
-                }
-                else
-                {
-                    ReportWithPackageFilter(WasteFilter,"------------ WHS, Power down in process -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.cartridge_cover, 0);//popup message :"Cartridge cover open"  //todo
-                }
-
-
-
-                //if (WHS_info.WHS_pump == ON)
-                //{
-                //    SetWastePump(OFF); //pump OFF
-                //}
-                // prevent NEW Job
-                // Display "Close cartridge cover"
-                // pop up message in GUI
-            }
-            else // CLOSE
-            {
-                //if (WHS_info.sttMachine == WHS_full) CartridgeWasteFilling(OPEN);
-                SetActiveWastCartridge();
-                if (pump_on_flag == OPEN )
-                {
-                    WHS_info.WHS_sensors.waste_tank_full_sensor =  SENSORnotFULL;  // todo
-                    //                    CartridgeWasteFilling(OPEN);
-                    pump_on_flag = CLOSE;
-                }
-                IFS_info.Cartridge_Ink_device_Id    = RemoveControlCallback(IFS_info.Cartridge_Ink_device_Id   , WasteTankCBFunction );
-                WHS_info.Cartridge_Waste1_device_Id = RemoveControlCallback(WHS_info.Cartridge_Waste1_device_Id, WasteTankCBFunction );
-                WHS_info.Cartridge_Waste2_device_Id = RemoveControlCallback(WHS_info.Cartridge_Waste2_device_Id, WasteTankCBFunction );
-                if ( IFS_info.INK_isOK_flag )
-                {
-                    IFS_info.INK_isOK_flag = false;//0
-                    ReportWithPackageFilter(WasteFilter,"------------ WHS, change INK cartridge status to color Used -------------", __FILE__, __LINE__, IFS_info.INK_isOK_flag, RpMessage, 0, 0);
-                    // test the Mid-tank capacity is not at Nadav sequence
-                    MidTank_Pressure = Get_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);
-                    if ( MidTank_Pressure > MidTank_Pressure_EMPTY )
-                    {
-                        ReportWithPackageFilter(WasteFilter,"------------ close door  MidTank_Pressure > MidTank_Pressure_EMPTY -----------------", __FILE__,__LINE__,(int)(MidTank_Pressure_EMPTY*1000), RpMessage, (int)(MidTank_Pressure*1000), 0);
-                        MidTankValvesAction(Cartridge_MidTank_OFF);
-                        //Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
-                        ReportWithPackageFilter(WasteFilter,"------------ WHS, Mid-tank not empty -------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
-                        break;
-                    }
-                    IFS_info.MidTank_capacity = MidTank_Pressure;
-                    ReportWithPackageFilter(WasteFilter,"------------ Mid-tank filling in process -----------------", __FILE__,__LINE__,(int)(MidTank_Pressure_EMPTY*1000), RpMessage, (int)(MidTank_Pressure*1000), 0);
-                    Pannel_Leds(CART_1, MODE_ON);
-                    cart1.color  = BLINK;
-                    MidTankValvesAction(Cartridge_MidTank_ON);
-                    //add timeout
-                    IFS_TimeOutAlarm(false);
-                    IFS_info.Ink.time_out = 1;
-                    IFS_info.Cartridge_Ink_TimeOut_device_Id = AddControlCallback("Ink Cartridge TimeOut", WasteTankCBFunction, CartridgeInkTimeOutCallBackTime, CartridgeInkTimeOutCallBackFunction, 0,0,0 ); //eOneSecond
-
-
-//                    //add callback for midtank status is full
-//                    IFS_info.Cartridge_Ink_TimeOut_device_Id = AddControlCallback(NULL, WasteTankCBFunction, CartridgeInkTimeOutCallBackTime, CartridgeInkTimeOutCallBackFunction, 0,0,0 ); //eOneSecond
-//                    Enable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
-//                    Read_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);
-//                    if ( Get_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color) > MidTank_Pressure_FULL )
-//                    {
-//                        Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
-//                        REPORT_MSG(WHS_full," ------------ Mid-tank not empty ----------------- ");
-//                        break;
-//                    }
-
-                }
-            }
-            break;
-
-        case IFS_INK_presence_sensor:
-            if (IFS_info.IFS_Ink_precense_sensor == CarteidgePrecense)
-            {
-                // is power down in process??  //todo
-                if ( !PowerOffInProcessGetState() ) // not in power down process
-                {
-                    Pannel_Leds(CART_1, MODE_ON);
-                    cart1.color = colorON;
-                    RdCartridgeParam(INK_cartridge); //todo
-                }
-                else
-                {
-                    //  print: "power down in process";
-                    ReportWithPackageFilter(WasteFilter,"------------ WHS, Power down in process -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, IFS_info.IFS_Ink_precense_sensor, 0);
-                }
-            }
-            else // Cartridge is out
-            {
-                IFS_info.INK_isOK_flag = false;//0
-                Pannel_Leds(CART_1, MODE_OFF);
-                cart1.color = colorOFF;
-                if (IFS_info.Ink.time_out != 0)
-                {
-                    MidTankValvesAction(Cartridge_MidTank_OFF);
-                    IFS_info.Ink.time_out = 0;
-                    IFS_info.Cartridge_Ink_TimeOut_device_Id = RemoveControlCallback(IFS_info.Cartridge_Ink_TimeOut_device_Id, WasteTankCBFunction );
-                }
-            }
-            break;
-
-        case IFS_INK_authentication_pass:
-            if (!ColorMatch())
-            {
-                    ReportWithPackageFilter(WasteFilter,"------------ WHS, cartridge color does not match -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
-                    Pannel_Leds(CART_1, MODE_ON);
-                    cart1.color  = BLINK;
-                    break;
-            }
-#warning The messege removed (close cartridge cover)
-            //REPORT_MSG(WHS_full," ------------ close cartridge cover ----------------- ");
-            IFS_info.INK_isOK_flag = true; // 1
-
-            break;
-
-        case IFS_INK_authentication_fail:
-            break;
-
-
-        case WHS_waste1_presence_sensor :
-                    if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == CarteidgePrecense ) // waste cartridge 1 is inserted .
-                    {
-                        //SetCartridgeLED(waste_cartridge1, led_on);
-                        Pannel_Leds(CART_2, MODE_ON);
-                        cart2.color = colorON;
-                        RdCartridgeParam(waste_cartridge1);
-//                        SetActiveWastCartridge();
-//                        SetValveDirection();
-                        if ( CartridgeAuthentication(waste_cartridge1) == PASSED) // to define authentication
-                        {
-                            //WHS_info.cartridge_1.autheticate = PASSED; //='0'
-                            //???WHS_info.WHS_valve = waste_cartridge1; // or we should do it only before pumping????
-                            AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  false);
-                        }
-                        else
-                        {
-                            //WHS_info.cartridge_1.autheticate = FAILED; //='1'
-                            //SetCartridgeLED(waste_cartridge1, led_off);
-                            Pannel_Leds(CART_2, MODE_OFF);
-                            cart2.color = colorOFF;
-                        }
-                    }
-                    else    // waste cartridge 1 take out
-                    {
-                        Pannel_Leds(CART_2, MODE_OFF);
-                        cart2.color = colorOFF;
-                        WHS_info.cartridge_1.autheticate = FAILED;
-                    }
-                    //SetActiveWastCartridge();
-                    break;
-        case WHS_waste2_presence_sensor :
-                    if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == CarteidgePrecense ) // waste cartridge  is inserted .
-                    {
-                       Pannel_Leds(CART_3, MODE_ON);//SetCartridgeLED(waste_cartridge2, led_on);
-                       cart3.color = colorON;
-                       RdCartridgeParam(waste_cartridge2);
-                       if ( CartridgeAuthentication(waste_cartridge2) == PASSED) // to define authentication
-                       {
-                           //WHS_info.cartridge_2.autheticate = PASSED; //='0'
-                           //???WHS_info.WHS_valve = waste_cartridge2; // or we should do it only before pumping????
-                           //???SetValveDirection();    // or we should do it only before pumping????
-                           AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  false);
-                       }
-                       else
-                       {
-                           //WHS_info.cartridge_2.autheticate = FAILED; //='1'
-                           Pannel_Leds(CART_3, MODE_OFF);//SetCartridgeLED(waste_cartridge2, led_off);
-                           cart3.color = colorON;
-                       }
-                    }
-                    else    // waste cartridge 2 take out
-                    {
-                        Pannel_Leds(CART_3, MODE_OFF);
-                        cart3.color = colorOFF;
-                        WHS_info.cartridge_2.autheticate = FAILED;
-                        /*
-                          if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping????
-                          {
-                            WHS_info.WHS_valve = waste_cartridge;
-                            SetValveDirection();
-                            }
-                       else
-                        {
-
-                        }
-                        RdCartridgeParam(waste_cartridge2);
-                       WHS_info.WHS_valve = waste_cartridge1;
-                       */
-                    }
-                    //SetActiveWastCartridge();
-                    break;
-
-        case WHS_Timeout:
-            ReportWithPackageFilter(WasteFilter,"------------ WHS, WHS_Timeout -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
-            AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  true);
-            CartridgeWasteFilling(OFF);
-            break;
-
-//        case IFS_Timeout:
-//            REPORT_MSG(WHS_emptying," ------------ IFS_Timeout ----------------- ");
-//            // try again :
-//            // start timeout
-//            // close and open the correct valves
-//            REPORT_MSG(WHS_full," ------------ IFS_Timeout_Second_Time ----------------- ");
-//            MidTankValvesAction(Cartridge_MidTank_OFF);
-//            MidTankValvesAction(Cartridge_MidTank_ON);
-//
-//            IFS_TimeOutAlarm();
-//
-//            break;
-        case IFS_Timeout_Second:
-//            Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
-            IFS_info.Cartridge_Ink_TimeOut_device_Id = RemoveControlCallback(IFS_info.Cartridge_Ink_TimeOut_device_Id, WasteTankCBFunction );
-            ReportWithPackageFilter(WasteFilter,"------------ WHS, Change cartridge status to Fail -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
-
-            MidTankValvesAction(Cartridge_MidTank_OFF);
-            cart1.color = fastBILNK;
-            ReportWithPackageFilter(WasteFilter,"------------ Display Mid-tank # filling fail -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
-            ReportWithPackageFilter(WasteFilter,"------------ call customer support -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
-            Pannel_Leds(CART_1, MODE_ON);
-            cart1.color = fastBILNK;
-            IFS_TimeOutAlarm(true);
-            break;
-
-        case IFS_MidTankFull:
-//            Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
-            IFS_info.Cartridge_Ink_TimeOut_device_Id = RemoveControlCallback(IFS_info.Cartridge_Ink_TimeOut_device_Id, WasteTankCBFunction );
-            ReportWithPackageFilter(WasteFilter,"------------ Change cartridge status to Waste Empty -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
-            Pannel_Leds(CART_1, MODE_OFF);
-            cart1.color = colorOFF;
-            MidTankValvesAction(Cartridge_MidTank_OFF);
-            ReportWithPackageFilter(WasteFilter,"------------ Display Mid-tank # filling done -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
-            break;
-
-
-
-        case WHS_no_event:
-            break;
-        default: //error state
-            break;
-    }
-    WHS_info.event = WHS_no_event;
-    return ret;
-}
-
-
-
-
-/*------------------------------- Cartridge  Cover       -----------------------------------------*/
-
-bool RdCartridgeCoverSensor()
-{
-
-    //REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor    ----------------- ");
-    bool ret = notOK;
-    //WHS_Read_GPI_Registers();
-   // WHS_info.WHS_sensors.cartridge_cover = Get_COVER_1_State(CartridgesDoor);
-   // ret = WHS_info.WHS_sensors.cartridge_cover;
-    ret = Get_COVER_1_State(CartridgesDoor);
-    if ((ret == OPEN ) && (ret != WHS_info.WHS_sensors.cartridge_cover))
-    {
-        ReportWithPackageFilter(WasteFilter,"------------ RD Cartridge Cover Sensor is = OPEN(1) -------------", __FILE__, __LINE__, ret, RpMessage, 0, 0);
-    }
-    if ((ret == CLOSE ) && (ret != WHS_info.WHS_sensors.cartridge_cover))
-    {
-        ReportWithPackageFilter(WasteFilter,"------------ RD Cartridge Cover Sensor is = CLOSE(0) -------------", __FILE__, __LINE__, ret, RpMessage, 0, 0);
-    }
-    return ret;
-}
-
-
-
-
-WHS_sensor CartridgeCoverCallBackFunction()
-{
-    WHS_sensor ret = WHS_no_event;
-   //ret = RdCartridgeCoverSensor();
-    if ( WHS_info.WHS_sensors.cartridge_cover != RdCartridgeCoverSensor() )
-    {
-        WHS_info.event = WHS_cartridge_cover_sensor;
-        WHS_info.WHS_sensors.cartridge_cover = !WHS_info.WHS_sensors.cartridge_cover;
-        ReportWithPackageFilter(WasteFilter,"------------ find  :  WHS_cartridge_cover_sensor event -------------", __FILE__, __LINE__, WHS_info.WHS_sensors.cartridge_cover, RpMessage, 0, 0);
-        ret = WHS_cartridge_cover_sensor; //todo
-    }
-    else if (( IFS_info.INK_isOK_flag ) && ( WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN))// for Mid-tank filling
-    {
-        ReportWithPackageFilter(WasteFilter,"------------ Mid-tank Filling  :  Close cartridge cover -------------", __FILE__, __LINE__, WHS_info.WHS_sensors.cartridge_cover, RpMessage, 0, 0);
-    }
-    /*else if(WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN)
-    {
-        REPORT_MSG(parameter," ------------ Mid-tank Filling  :  Cartridge door open    ----------------- ");
-    }*/
-    return ret;
-}
-
-
-
-//WHS_sensor CartridgeInkTimeOutCallBackFunction()
-//{
-//    WHS_sensor ret = WHS_no_event;
-////    uint32_t time_out_second = 0 ;
-//
-//    if (WHS_info.Ink.time_out) WHS_info.Ink.time_out += 1;
-//    Read_MidTank_Pressure_Sensor(WHS_info.Ink.cart_color);
-//    if (Get_MidTank_Pressure_Sensor(WHS_info.Ink.cart_color) >= WHS_info.MidTank_capacity  + CARTRIDGE_CAPATICY)
-//    {
-//        WHS_info.Ink.time_out = 0;
-//        WHS_info.event = IFS_MidTankFull;
-//        return IFS_MidTankFull;
-//    }
-//    if (WHS_info.Ink.time_out == CARTRIDGE_INK_TIMEOUT)
-//    {
-//        //WHS_info.Ink.time_out = 0;
-//        //return WHS_info.event = IFS_Timeout;
-//
-//        REPORT_MSG(WHS_emptying," ------------ IFS_Timeout ----------------- ");
-//        // try again :
-//        // start timeout
-//        // close and open the correct valves
-//        REPORT_MSG(WHS_full," ------------ IFS_Timeout_Second_Time ----------------- ");
-//        MidTankValvesAction(Cartridge_MidTank_OFF);
-//    }
-//
-//    if (WHS_info.Ink.time_out == (CARTRIDGE_INK_TIMEOUT+1)) //need to open the valve for second chance
-//        {
-//            MidTankValvesAction(Cartridge_MidTank_ON);
-//        }
-//
-//    if (WHS_info.Ink.time_out == CARTRIDGE_INK_TIMEOUTx2)
-//        {
-//            WHS_info.Ink.time_out = 0;
-//            WHS_info.event = IFS_Timeout_Second;
-//            return IFS_Timeout_Second;
-//        }
-//    return ret;
-//}
-
-
-
-//WHS_sensor CartridgeInkCallBackFunction()
-//{
-//    uint32_t parameter = 6 ;
-//
-//    WHS_sensor ret = WHS_no_event;
-//    if (WHS_info.WHS_sensors.IFS_Ink_precense_sensor != RdInkCartridgeSensor())
-//    {
-//        REPORT_MSG(parameter," ------------ find  : IFS_Ink_presence_sensor event   ----------------- ");
-//        WHS_info.event = IFS_INK_presence_sensor;
-//        WHS_info.WHS_sensors.IFS_Ink_precense_sensor = !WHS_info.WHS_sensors.IFS_Ink_precense_sensor;
-//        ret = IFS_INK_presence_sensor;
-//    }
-//    return ret;
-//}
-
-
-
-WHS_sensor CartridgeWaste1CallBackFunction()
-{
-    WHS_sensor ret = WHS_no_event;
-    //ret = RdCartridgeCoverSensor();
-    if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor != RdWasteCartridge1Sensor())
-    {
-        WHS_info.event = WHS_waste1_presence_sensor;
-        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;
-        ReportWithPackageFilter(WasteFilter,"------------ find  : WHS_waste1_presence_sensor event -------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_cartridge1_precense_sensor, RpMessage, 0, 0);
-        ret = WHS_waste1_presence_sensor;
-    }
-    return ret;
-}
-
-WHS_sensor CartridgeWaste2CallBackFunction()
-{
-    WHS_sensor ret = WHS_no_event;
-
-    if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor != RdWasteCartridge2Sensor())
-    {
-        WHS_info.event = WHS_waste2_presence_sensor;
-        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;
-        ReportWithPackageFilter(WasteFilter,"------------ find  : WHS_waste2_presence_sensor event -------------", __FILE__, __LINE__, WHS_info.WHS_sensors.waste_cartridge2_precense_sensor, RpMessage, 0, 0);
-        ret = WHS_waste2_presence_sensor;
-    }
-    return ret;
-}
-
-/*------------------------------- Waste Cartridge + IFS Cartridge    -----------------------------------------*/
-bool InitCartStatus()
-{
-    WHS_info.WHS_sensors.cartridge_cover = RdCartridgeCoverSensor();
-
-    /* INK =>  CART_1 */
-    ReportWithPackageFilter(WasteFilter,"------------------------------------------------------------------------------------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-    ReportWithPackageFilter(WasteFilter,"------------ !!!!!!!  at INIT what to do if IFS_INK is presence  !!!!!!! -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-    ReportWithPackageFilter(WasteFilter,"------------------------------------------------------------------------------------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-
-    if (RdInkCartridgeSensor())
-    {
-        IFS_info.IFS_Ink_precense_sensor = CarteidgePrecense;
-        ReportWithPackageFilter(WasteFilter,"------------ INIT : IFS_INK is presence -----------------", __FILE__,__LINE__, IFS_info.IFS_Ink_precense_sensor, RpMessage, 0, 0);
-        Pannel_Leds( CART_1,  MODE_ON);
-        cart1.color = colorON;
-    }
-    else
-    {
-        IFS_info.IFS_Ink_precense_sensor = CarteidgeNotPrecense;
-        ReportWithPackageFilter(WasteFilter,"------------ INIT : IFS_INK is NOT presence -----------------", __FILE__,__LINE__, IFS_info.IFS_Ink_precense_sensor, RpMessage, 0, 0);
-        Pannel_Leds( CART_1,  MODE_OFF);
-        cart1.color = colorOFF;
-    }
-
-    /* waste_cartridge1 => CART_2  */
-    if (RdWasteCartridge1Sensor())
-    {
-        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = CarteidgePrecense;
-        ReportWithPackageFilter(WasteFilter,"------------ INIT : WHS_waste1 cart is presence -----------------", __FILE__,__LINE__, WHS_info.WHS_sensors.waste_cartridge1_precense_sensor, RpMessage, 0, 0);
-        Pannel_Leds( CART_2,  MODE_ON);
-        cart2.color = colorON;
-    }
-    else
-    {
-        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = CarteidgeNotPrecense;
-        ReportWithPackageFilter(WasteFilter,"------------ INIT : WHS_waste1 cart is NOT presence !!! -----------------", __FILE__,__LINE__,WHS_info.WHS_sensors.waste_cartridge1_precense_sensor, RpMessage, 0, 0);
-        Pannel_Leds( CART_2,  MODE_OFF);
-        cart2.color = colorOFF;
-    }
-
-    /* waste_cartridge2 => CART_3  */
-    if (RdWasteCartridge2Sensor())
-    {
-        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = CarteidgePrecense;
-        ReportWithPackageFilter(WasteFilter,"------------ INIT : WHS_waste2 cart is presence -----------------", __FILE__,__LINE__, WHS_info.WHS_sensors.waste_cartridge2_precense_sensor, RpMessage, 0, 0);
-        Pannel_Leds( CART_3,  MODE_ON);
-        cart3.color = colorON;
-    }
-    else
-    {
-        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = CarteidgeNotPrecense;
-        ReportWithPackageFilter(WasteFilter,"------------ INIT : WHS_waste2 cart is NOT presence_sensor !!! -----------------", __FILE__,__LINE__, WHS_info.WHS_sensors.waste_cartridge2_precense_sensor, RpMessage, 0, 0);
-        Pannel_Leds( CART_3,  MODE_OFF);
-        cart3.color = colorOFF;
-    }
-
-    if (IFS_info.IFS_Ink_precense_sensor == CarteidgePrecense)          CartridgeAuthentication(INK_cartridge);
-    if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == CarteidgePrecense) CartridgeAuthentication(waste_cartridge1);
-    if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == CarteidgePrecense) CartridgeAuthentication(waste_cartridge2);
-    SetActiveWastCartridge();
-
-    if (WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN)
-    {
-        ReportWithPackageFilter(WasteFilter,"------------ WHS_CartridgeCoverOPEN  : add callback for cart1 and cart 2 -----------------", __FILE__,__LINE__, WHS_info.WHS_sensors.cartridge_cover, RpMessage, 0, 0);
-        IFS_info.Cartridge_Ink_device_Id    = AddControlCallback("Ink Cartridge CB"   , WasteTankCBFunction, eOneSecond, CartridgeInkCallBackFunction   , 0,0,0 );
-        WHS_info.Cartridge_Waste1_device_Id = AddControlCallback("Waste1 Cartridge CB", WasteTankCBFunction, eOneSecond, CartridgeWaste1CallBackFunction, 0,0,0 );
-        WHS_info.Cartridge_Waste2_device_Id = AddControlCallback("Waste2 Cartridge CB", WasteTankCBFunction, eOneSecond, CartridgeWaste2CallBackFunction, 0,0,0 );
-    }
-    WHS_info.Cartridge_Cover_device_Id = AddControlCallback("Cartridge Cover Door", WasteTankCBFunction, eOneSecond, CartridgeCoverCallBackFunction, 0,0,0 );
-
-    return OK;
-}
-
-bool RdInkCartridgeSensor()
-{
-    bool ret = notOK;
-    //WHS_Read_GPI_Registers();
-    ret = Is_Cartridge_Present(CART_1);
-    return ret;
-}
-
-bool RdWasteCartridge1Sensor()
-{
-    bool ret = notOK;
-    //WHS_Read_GPI_Registers();
-    ret = Is_Cartridge_Present(CART_2);
-    return ret;
-}
-
-bool RdWasteCartridge2Sensor()
-{
-    bool ret = notOK;
-    //WHS_Read_GPI_Registers();
-    ret = Is_Cartridge_Present(CART_3);
-    return ret;
-}
-
-bool SetActiveWastCartridge()
-{
-    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))
-        {
-            WHS_info.active_cartridge = waste_cartridge1;
-            ReportWithPackageFilter(WasteFilter,"------------ WHS : active_cartridge = waste_cartridge  1 -----------------", __FILE__,__LINE__, WHS_info.active_cartridge, RpMessage, 0, 0);
-            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))
-        {
-            WHS_info.active_cartridge = waste_cartridge2;
-            ReportWithPackageFilter(WasteFilter,"------------ WHS : active_cartridge = waste_cartridge  2 -----------------", __FILE__,__LINE__, WHS_info.active_cartridge, RpMessage, 0, 0);
-            AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  false);
-        }
-    else
-        {
-            WHS_info.active_cartridge = no_waste_cartridge;
-            ReportWithPackageFilter(WasteFilter,"------------ WHS : NO active_cartridge -----------------", __FILE__,__LINE__, WHS_info.active_cartridge, RpMessage, 0, 0);
-            AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  true);
-        }
-    return ret;
-
-}
-
-
-
-/*------------------------------------------------------------------------------------------------*/
-
-
-
-U8 WHS_init(void)
-{
-    SetWastePump(CLOSE);
-    WHS_info.WHS_valve = VALVE_DIR_WASTE_CARTRIDGE1;
-    if (WHS_Type == WHS_TYPE_UNKNOWN)
-        Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
-    else //new WHS
-        Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
-        //Valve_Set(VALVE_WASTE_TANK, VALVE_DIR_WASTE_CARTRIDGE1);
-    InitCartStatus();
-    initWHS_WasteTank();
-
-    return 0;
-}
-
-
-//void midtanktest6_ON(void)
-//{
-//    Valve_Set( VALVE_2W_CART_MID_1, Cartridge_MidTank_ON);
-//    Valve_Set( VALVE_2W_MID_AIR_1 , Cartridge_MidTank_ON);
-//}
-//
-//void midtanktest6_OFF(void)
-//{
-//    Valve_Set( VALVE_2W_CART_MID_1, Cartridge_MidTank_OFF);
-//    Valve_Set( VALVE_2W_MID_AIR_1 , Cartridge_MidTank_OFF);
-//}
-
-
-
-
-
-
-
-
-
-
-
-/*----------------------------------    HW Test   --------------------------------------------------------------*/
-
-
-
-bool RdWasteTankFilterSensor()
-{
-    bool ret = notOK;
-    //WHS_Read_GPI_Registers();
-    WHS_info.WHS_sensors.waste_tank_filter_sensor = WHS_GPI_SW_FILTER_PRES();
-    ret = WHS_info.WHS_sensors.waste_tank_filter_sensor;
-    return ret;
-}
-
-
-U8 RdCartridgeDoor()
-{
-    bool ret = notOK;
-    ret = RdCartridgeCoverSensor();
-    return ret;
-}
-U8 RdWaste1()
-{
-    bool ret = notOK;
-    ret = RdWasteCartridge1Sensor();
-    return ret;
-}
-U8 RdWaste2()
-{
-    bool ret = notOK;
-    ret = RdWasteCartridge2Sensor();
-    return ret;
-}
-U8 SetValve(bool value)
-{
-    bool ret = OK;
-    WHS_info.WHS_valve = value;
-    if (WHS_Type == WHS_TYPE_UNKNOWN)
-        Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
-    else //new WHS
-        Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
-    return ret;
-}
-
-U8 SetPump(bool value)
-{
-    bool ret = notOK;
-    ret = SetWastePump(value);
-    return ret;
-}
-
-U8 RdFilter()
-{
-    bool ret = notOK;
-    ret = RdWasteTankFilterSensor();
-    return ret;
-}
-U8 RdEmpty()
-{
-    bool ret = notOK;
-    ret = RdWasteTankEmptySensor();
-    return ret;
-}
-U8 RdFull()
-{
-    bool ret = notOK;
-    ret = RdWasteTankFullSensor();
-    return ret;
-}
-U8 RdOverFlow()
-{
-    bool ret = notOK;
-    RdWasteTankOverFlowSensor();
-    return ret;
-}
-
-
-
-U8 WHS_HW_test()
-{
-    bool ret = notOK;
-/*    ret = RdCartridgeDoor();
-    while (ret == RdCartridgeDoor());
-*/
-/* ---  connect JO271 cable ---*/
-    ret = RdWaste1();
-    while (ret == RdWaste1());// blue = waste1
-    ret = RdWaste2();
-    while (ret == RdWaste2());// yellow = waste2
-
-    /* ---  connect JO71 JO72 JO121  cable ---*/
-
-    ret = SetValve(1); //red LED On
-    ret = SetValve(0); //red LED Off
-
-
-    ret = SetPump(1);  // led green (backplan) On
-    ret = SetPump(0);  // led green (backplan) Off
-
-    ret = RdFilter();
-    while (ret == RdFilter());
-    ret = RdEmpty();
-    while (ret == RdEmpty());
-    ret = RdFull();
-    while (ret == RdFull());
-//    ret = RdOverFlow();
-//    while (ret == RdOverFlow());
-    return ret;
-}
-
-
-/*------------------------------------------------------------------------------------------------*/
-
-
-
-
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
index e69de29bb..4343c1607 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
@@ -0,0 +1,653 @@
+#include <Container.h>
+#include <DataDef.h>
+#include "include.h"
+#include "Modules/Control/control.h" //  use for FPGA IO
+#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"//#include "FPGA_GPIO.h"  //  use for FPGA IO
+#include "drivers/Valves/Valve.h"
+#include "Common/report/report.h"
+#include "Modules/Waste/Waste_ex.h"
+#include "modules/heaters/heaters_ex.h"
+#include <Drivers/I2C_Communication/RFID_NFC/RFIDTagInfo.h>
+#include "Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h"
+#include <Drivers/I2C_Communication/RFID_NFC/NFC_MainBaord.h>
+#include "Drivers/I2C_Communication/RFID_NFC/NFC.h"
+#include <Utilities/RfidTagHandling.h>
+#include "PMR/IFS/CartridgeState.pb-c.h"
+
+#include  <PMR/Diagnostics/EventType.pb-c.h>
+#include "Modules/AlarmHandling/AlarmHandling.h"
+#include "StateMachines/Initialization/PowerOffSequence.h"
+#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
+#include "CartridgeValidationRequest.pb-c.h"
+#include "CartridgeValidationResponse.pb-c.h"
+#include "Modules/General/buttons.h"
+#include "modules/General/process.h"
+#include "Modules/General/MachineStatus.h"
+#include "Modules/IFS/ifs.h"
+#include <Drivers/I2C_Communication/I2C_Task.h>
+#include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
+#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
+#include <Drivers/I2C_Communication/WHS_Card/D_AD5272_Rheostat/WHS_Rheostat.h>
+
+uint8_t VocPpmAlarmLimit = 10;//PPM
+uint8_t VocPpmLimitForXSec = 10;//Sec
+bool ReadingVocEverySec = false;
+
+bool DoorState = OPEN;
+uint32_t timeout_counter = 0;
+int wasteLevel = 0;
+WasteCartridgeEnum SelectedCard = MaxWasteCartridges;
+CartridgeStateEnum CartState[MaxWasteCartridges];// = {CartridgeStateOUT,CartridgeStateOUT,CartridgeStateOUT};
+uint32_t Cartridge_Cover_Control;
+button *CartLed[MaxWasteCartridges] = {0, &cart2, &cart3};
+WasteTankStateEnum WasteTankState = WasteTankStateIdle;
+
+int init = 1;
+
+bool setWasteValve (WasteCartridgeEnum WasteCartridge);
+
+#define WASTE_CARTRIDGE_SIZE 1500
+#define WASTE_LEVEL_OVERFLOW 2700
+#define WASTE_LEVEL_FULL 2300
+#define WASTE_LEVEL_EMPTY 900
+#define WASTE_EMPTING_TIMEOUT 1500
+double wasteLevelOverflow = WASTE_LEVEL_OVERFLOW;
+double wasteLevelFull = WASTE_LEVEL_FULL;
+double wasteLevelEmpty = WASTE_LEVEL_EMPTY;
+double wasteLevelOverFlow = WASTE_LEVEL_OVERFLOW;
+
+//#define WHS_DEBUG
+
+/////////////////////////////// Cartridges  //////////////////////////////////////
+void Waste_StateMachine(void);
+void cartCART_INSERTED (WasteCartridgeEnum CartId)
+{
+    assert (CartId<MaxWasteCartridges);
+    if (CartState[CartId] != CartridgeStateOUT)
+        Report("Cartridges Cart inserted wrong state", __FILE__, __LINE__, CartId, RpMessage, CartState[CartId], 0);
+    CartState[CartId] = CartridgeStateIN;
+    Pannel_Leds((CartId == WasteCartridge_middle)?CART_2:CART_3, MODE_ON);
+    CartLed[CartId]->color = colorON;
+
+    Report("Cartridges Cart inserted", __FILE__, __LINE__, CartId, RpMessage, CartState[CartId], 0);
+}
+void cartCART_EXTRACTED(WasteCartridgeEnum CartId) //{called from polling function. set state to out, if was ACTIVE – notify waste module)
+{
+    assert (CartId<MaxWasteCartridges);
+    if (CartState[CartId] == CartridgeStateOUT)
+        Report("Cartridges Cart extracted wrong state", __FILE__, __LINE__, CartId, RpMessage, CartState[CartId], 0);
+
+    Report("Cartridges Cart extracted", __FILE__, __LINE__, CartId, RpMessage, CartState[CartId], 0);
+    CartState[CartId] = CartridgeStateOUT;
+    Pannel_Leds((CartId == WasteCartridge_middle)?CART_2:CART_3, MODE_OFF);
+    CartLed[CartId]->color = colorOFF;
+    if (init==0)
+        WHS_Set_IFS_Clearing_Suction(NUM_OF_MIDTANKS);
+
+}
+WasteCartridgeEnum cartSELECT_CART(void) //{ if there is no SELECTED cartridge select the first cartridge in IN state. If there is none, return -1}
+{
+    //Report("Cartridges select cart", __FILE__, __LINE__, CartState[WasteCartridge_middle], RpMessage, CartState[WasteCartridge_lower], 0);
+    if ((CartState[WasteCartridge_middle] == CartridgeStateSELECTED)||(CartState[WasteCartridge_middle] == CartridgeStateACTIVE))
+        return WasteCartridge_middle;
+    if ((CartState[WasteCartridge_lower]  == CartridgeStateSELECTED)||(CartState[WasteCartridge_lower] == CartridgeStateACTIVE))
+        return WasteCartridge_lower;
+    //no selected/active cartridge yet
+    if (CartState[WasteCartridge_middle] == CartridgeStateIN) {
+        CartState[WasteCartridge_middle] = CartridgeStateSELECTED;
+        return WasteCartridge_middle;
+    }
+    if (CartState[WasteCartridge_lower] == CartridgeStateIN) {
+        CartState[WasteCartridge_lower] = CartridgeStateSELECTED;
+        return WasteCartridge_lower;
+    }
+    return MaxWasteCartridges;
+}
+
+void cartFILLING_START(void) //{set state of SELECTED to ACTIVE}
+{
+    if (CartState[WasteCartridge_middle] == CartridgeStateSELECTED) {
+        Report("Cartridges middle Cart active", __FILE__, __LINE__, WasteCartridge_middle, RpMessage, CartState[WasteCartridge_middle], 0);
+        CartState[WasteCartridge_middle] = CartridgeStateACTIVE;
+        CartLed[WasteCartridge_middle]->color = BLINK;
+    } else if (CartState[WasteCartridge_lower] == CartridgeStateSELECTED) {
+        Report("Cartridges lower Cart active", __FILE__, __LINE__, WasteCartridge_lower, RpMessage, CartState[WasteCartridge_lower], 0);
+        CartState[WasteCartridge_lower] = CartridgeStateACTIVE;
+        CartLed[WasteCartridge_lower]->color = BLINK;
+    } else {
+        Report("Cartridges start with no selected cartridge", __FILE__, __LINE__, CartState[WasteCartridge_middle], RpMessage, CartState[WasteCartridge_lower], 0);
+    }
+}
+
+void cartFILLING_END(void)
+{
+    //{set state of ACTIVE to FULL}
+    if (CartState[WasteCartridge_middle] == CartridgeStateACTIVE) {
+        CartState[WasteCartridge_middle] = CartridgeStateFULL;
+        CartLed[WasteCartridge_middle]->color = colorOFF;
+    } else if (CartState[WasteCartridge_lower] == CartridgeStateACTIVE) {
+        CartState[WasteCartridge_lower] = CartridgeStateFULL;
+        CartLed[WasteCartridge_lower]->color = colorOFF;
+    } else {
+        Report("Cartridges end with no active cartridge", __FILE__, __LINE__, CartState[WasteCartridge_middle], RpMessage, CartState[WasteCartridge_lower], 0);
+    }
+    setWasteValve(WasteCartridge_middle);
+
+}
+
+CartridgeStateEnum cartGetState(WasteCartridgeEnum CartId)
+{
+    assert (CartId<MaxWasteCartridges);
+    return CartState[CartId];
+}
+
+bool cartGetPresence (WasteCartridgeEnum CartId)
+{
+    assert (CartId<MaxWasteCartridges);
+    if (CartState[CartId] == CartridgeStateOUT)
+        return false;
+    else
+        return true;
+}
+
+bool NoCartAvailable()
+{
+    uint32_t CartId;
+
+    for(CartId = CART_2; CartId <= CART_3; CartId++) {
+        if (Is_Cartridge_Present(CartId))
+            return false;
+    }
+    return true;
+}
+
+WasteCartridgeEnum cartGetActiveCart()
+{
+    uint32_t CartId;
+
+    for (CartId = 0; CartId < MaxWasteCartridges; CartId++) {
+        if (CartState[CartId] == CartridgeStateACTIVE)
+            return CartId;
+    }
+    return MaxWasteCartridges;
+}
+
+WasteCartridgeEnum cartNotAllFull()
+{
+    uint32_t CartId;
+
+    for (CartId = WasteCartridge_middle; CartId < MaxWasteCartridges; CartId++) {
+        if (CartState[CartId] != CartridgeStateFULL)
+            return true;
+    }
+    return false;
+}
+
+bool SetWastePump( bool power)
+{
+    if ( power == OPEN ) {
+        if (WHS_Type == WHS_TYPE_UNKNOWN) {
+            Pumps_Control(WHS_WTANKPUMP2, OPEN); //waste_pump_power_on();
+        } else { //new WHS
+            Trigger_SetWHSPump(OPEN);
+        }
+        return OPEN;
+    } else {
+        if (WHS_Type == WHS_TYPE_UNKNOWN) {
+            Pumps_Control(WHS_WTANKPUMP2, CLOSE); //waste_pump_power_on();
+        } else { //new WHS
+            Trigger_SetWHSPump(CLOSE);
+        }
+        return CLOSE;
+    }
+}
+
+bool setWasteValve (WasteCartridgeEnum WasteCartridge)
+{
+    bool direction;
+
+    if (WasteCartridge == WasteCartridge_lower) {
+        direction = true;
+    } else {
+        direction = false;
+    }
+
+    if (WHS_Type == WHS_TYPE_UNKNOWN) {
+        Valve_Set(VALVE_WASTE_TANK,direction);
+    } else { //new WHS
+        Trigger_SetWHSValveWatseCartridge(direction);
+    }
+    return direction;
+}
+
+bool RdWasteTankEmptySensor()
+{
+    //double WasteLevel = 0.0;
+
+    if (WHS_Type == WHS_TYPE_UNKNOWN) {
+        return WHS_GPI_WCONTAINER_WARN();
+    } else { //new WHS
+        //WasteLevel = GetWHSWasteTankLevelMiliLiter();
+        if (wasteLevel < wasteLevelEmpty)
+            return 1; //Empty
+    }
+    return 0;
+}
+
+bool RdWasteTankFullSensor()
+{
+    //double WasteLevel = 0.0;
+
+    if (WHS_Type == WHS_TYPE_UNKNOWN) {
+        return WHS_GPI_WCONTAINER_FULL();
+    } else { //new WHS
+        //WasteLevel = GetWHSWasteTankLevelMiliLiter();
+        if (wasteLevel >= wasteLevelFull)
+            return 1; //full
+    }
+    return 0;
+}
+
+bool RdWasteTankOverFlowSensor()
+{
+    //double WasteLevel = 0.0;
+
+    if (WHS_Type == WHS_TYPE_UNKNOWN) {
+        return WHS_GPI_WASTE_OVERFULL();
+    } else {//new WHS
+        //WasteLevel = GetWHSWasteTankLevelMiliLiter();
+        if (wasteLevel > wasteLevelOverflow)
+            return 1; //overflow
+    }
+    return 0;
+}
+
+int WHS_GetCartridgeFillPercent()
+{
+    return (((wasteLevel - wasteLevelEmpty) * 100) / WASTE_CARTRIDGE_SIZE);
+}
+bool WHS_IsContainerFull()
+{
+    return RdWasteTankFullSensor();
+}
+
+bool WHS_IsContainerEmpty()
+{
+    return RdWasteTankEmptySensor();
+}
+
+bool WHS_IsContainerOverflow()
+{
+    return RdWasteTankOverFlowSensor();
+}
+
+bool WHS_WasteCartridgeLowerPresent()
+{
+    return Is_Cartridge_Present(CART_3);
+}
+
+bool WHS_WasteCartridgeMiddlePresent()
+{
+    return Is_Cartridge_Present(CART_2);
+}
+
+bool WHS_IsEmptying()
+{
+    if (WasteTankState == WasteTankStateEmptying) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void Waste_Init()
+{
+    CartState[WasteCartridge_middle] = CartridgeStateOUT;
+    CartState[WasteCartridge_lower] = CartridgeStateOUT;
+    DoorState = OPEN;
+}
+
+bool cartCart_door()//Polled by polling function. Notify waste. Poll each 1 second. During active filling poll each 100msec
+{
+    if(Get_COVER_1_State(CartridgesDoor))//to check the polarity
+    {
+        DoorState = OPEN;
+    }
+    else
+    {
+        DoorState = CLOSE;
+    }
+#ifdef WHS_DEBUG
+    DoorState = CLOSE;
+#endif
+    return DoorState;
+}
+
+uint32_t Waste_DoorOpenDuringEmptying(uint32_t IfIndex, uint32_t ReadValue)
+{
+    cartCart_door();
+    if ((DoorState == OPEN) && (WasteTankState == WasteTankStateEmptying)) {
+        SetWastePump(CLOSE);
+        WasteTankState = WasteTankStatePaused;
+        Report("move to WasteTankStatePaused", __FILE__, __LINE__, DoorState, RpMessage, WasteTankState, 0);
+    }
+    if ((DoorState == CLOSE) && (WasteTankState == WasteTankStatePaused)) {
+        if (cartGetActiveCart() != MaxWasteCartridges) {
+            SetWastePump(OPEN);
+            WasteTankState = WasteTankStateEmptying;
+            Report("return to WasteTankStateEmptying", __FILE__, __LINE__, DoorState, RpMessage, WasteTankState, 0);
+        }
+    }
+    return OK;
+}
+
+void Waste_StateMachine_OneSecond_Call(void)
+{
+    static WasteTankStateEnum prev_state = 0;
+    static int prev_wasteLevel = 0;
+
+    //call cartridge state
+    if ((Is_Cartridge_Present(CART_2) != cartGetPresence(WasteCartridge_middle)) || (init)) {
+        if (Is_Cartridge_Present(CART_2)) {
+            cartCART_INSERTED(WasteCartridge_middle);
+            CartridgeStateUpdate(CARTRIDGE_SLOT__WasteMiddle, CARTRIDGE_STATE__Inserted, 0);
+        } else {
+            cartCART_EXTRACTED(WasteCartridge_middle);
+        }
+    }
+    if ((Is_Cartridge_Present(CART_3) != cartGetPresence(WasteCartridge_lower)) || (init)) {
+        if (Is_Cartridge_Present(CART_3)) {
+            cartCART_INSERTED(WasteCartridge_lower);
+            CartridgeStateUpdate(CARTRIDGE_SLOT__WasteLower, CARTRIDGE_STATE__Inserted, 0);
+        } else {
+            cartCART_EXTRACTED(WasteCartridge_lower);
+        }
+    }
+
+    //call door state
+    cartCart_door();
+
+    //call waste tank level
+#ifndef WHS_DEBUG
+    wasteLevel = GetWHSWasteTankLevelMiliLiter();
+#endif
+
+    if ((WasteTankState != prev_state) || (abs(wasteLevel - prev_wasteLevel) > 50)) {
+        Report("Waste_StateMachine_OneSecond_Call", __FILE__, WasteTankState, SelectedCard, RpMessage, wasteLevel, 0);
+        prev_state = WasteTankState;
+        prev_wasteLevel = wasteLevel;
+    }
+
+    //call state machine
+    Waste_StateMachine();
+
+    if(init)
+        init = 0;
+
+#ifdef WHS_DEBUG
+            wasteLevel += 50;
+#endif
+}
+
+void Waste_StateMachine(void)
+{
+    uint32_t activeCart;
+    switch (WasteTankState)
+    {
+        case WasteTankStateIdle:
+            if(WHS_IsContainerOverflow()) {
+                AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_OVERFLOW,  true);
+            } else {
+                AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_OVERFLOW,  false);
+            }
+            if (cartNotAllFull() == true) {
+                AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  false);
+            }
+            if(WHS_IsContainerFull()) {
+                //check if power down in process
+                if ( PowerOffInProcessGetState() ) {
+                    //Report("Power-down in process", __FILE__, __LINE__, 0, RpMessage, 0, 0);
+                    break;
+                }
+
+                // select cartridge
+                SelectedCard = cartSELECT_CART();
+                if (SelectedCard == MaxWasteCartridges) {
+                    //Report("No Available cart", __FILE__, __LINE__, SelectedCard, RpMessage, 0, 0);
+                    AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  true);
+                    break;
+                } else {
+                    AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  false);
+                }
+
+                //check door
+                //moved door handling down - I want to see the alarm even if the door is open
+                if (DoorState == OPEN) {
+                    //Report("Close cartridge cover", __FILE__, __LINE__, DoorState, RpMessage, 0, 0);
+                    break;
+                }
+                // check RFID - check cartridge OK (inkEmpty)
+                // RFID change status - set WasteEmpty
+
+                //move to next state
+                WasteTankState = WasteTankStateFull;
+                Report("move to WasteTankStateFull", __FILE__, __LINE__, DoorState, RpMessage, WasteTankState, 0);
+            }
+            break;
+        case WasteTankStateFull:
+            //set cart Active
+            cartFILLING_START();
+
+            // set valve selection
+            activeCart = cartGetActiveCart();
+            //Report("WasteTankStateEmptying set valve", __FILE__, __LINE__, activeCart, RpMessage, 0, 0);
+            setWasteValve(activeCart);
+
+            // set count down
+            timeout_counter = 1;
+            AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  false);
+
+            // set emptying limit
+            wasteLevelEmpty = wasteLevel - WASTE_CARTRIDGE_SIZE;
+            waste_seq_step1_cont();
+
+            // start a timer to observe door opening
+            Cartridge_Cover_Control = AddControlCallback("Cartridge Cover Door", Waste_DoorOpenDuringEmptying, 100,  cartCart_door, 0, 0, 0);
+            Report("add control Cartridge Cover Door", __FILE__, __LINE__, 0, RpMessage, 0, 0);
+
+            SetWastePump(OPEN);
+            Report("WasteTankStateEmptying set Pump Open", __FILE__, activeCart, wasteLevel, RpMessage, wasteLevelEmpty, 0);
+
+            //start  emptying
+            // RFID change status - set wasteFilling
+            WasteTankState = WasteTankStateEmptying;
+            CartridgeStateUpdate(activeCart, CARTRIDGE_STATE__Emptying, 0);
+            break;
+        case WasteTankStateEmptying:
+            // if time out or emptying done - idle
+            activeCart = cartGetActiveCart();
+            if (timeout_counter++ > WASTE_EMPTING_TIMEOUT) {
+                SetWastePump(CLOSE);
+                cartFILLING_END();
+                WasteTankState = WasteTankStateIdle;
+                Report("WasteTankStateEmptying TimeOut", __FILE__, __LINE__, 0, RpMessage, 0, 0);
+                CartridgeStateUpdate(activeCart, CARTRIDGE_STATE__Error, WHS_GetCartridgeFillPercent());
+                AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  true);
+                RemoveControlCallback(Cartridge_Cover_Control, Waste_DoorOpenDuringEmptying);
+                timeout_counter = 0;
+            } else if (WHS_IsContainerEmpty()) {
+                SetWastePump(CLOSE);
+                cartFILLING_END();
+                waste_seq_cont_stop();
+                // RFID change status - set wasteFull
+                WasteTankState = WasteTankStateIdle;
+                RemoveControlCallback(Cartridge_Cover_Control, Waste_DoorOpenDuringEmptying);
+                //if (cartNotAllFull() == false)
+                    AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  true);
+                Report("WasteTankStateEmptying done", __FILE__, __LINE__, 0, RpMessage, 0, 0);
+                CartridgeStateUpdate(activeCart, CARTRIDGE_STATE__EmptyingCompleted, WHS_GetCartridgeFillPercent());
+                timeout_counter = 0;
+            }
+            CartridgeStateUpdate(activeCart, CARTRIDGE_STATE__Emptying, WHS_GetCartridgeFillPercent());
+#ifdef WHS_DEBUG
+            wasteLevel -= 100;
+            timeout_counter += 10;
+#endif
+            break;
+        case WasteTankStatePaused:
+            Report("WasteTankStatePaused...", __FILE__, __LINE__, 0, RpMessage, 0, 0);
+            activeCart = cartGetActiveCart();
+            if (activeCart == MaxWasteCartridges)
+            {
+                SetWastePump(CLOSE);
+                cartFILLING_END();
+                waste_seq_cont_stop();
+                // RFID change status - TBD
+                WasteTankState = WasteTankStateIdle;
+                RemoveControlCallback(Cartridge_Cover_Control, Waste_DoorOpenDuringEmptying);
+                if (cartNotAllFull() == false)
+                    AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  true);
+                Report("WasteTankStatePaused done", __FILE__, __LINE__, 0, RpMessage, 0, 0);
+                timeout_counter = 0;
+                CartridgeStateUpdate(activeCart, CARTRIDGE_STATE__Error, WHS_GetCartridgeFillPercent());
+            }
+            break;
+        default:
+            Report("wrong state", __FILE__, WasteTankState, 0, RpMessage, SelectedCard, 0);
+            break;
+    }
+}
+uint32_t Waste_CheckState(int *AlarmId)
+{
+    //check if the waste is ready to run - waste level not above overflow level and no cartridge in the slots
+    if (wasteLevel > wasteLevelOverflow)
+    {
+        Report("cannot start a job with waste tank overflow", __FILE__, __LINE__, wasteLevel, RpMessage, wasteLevelOverflow, 0);
+        JobEndReason = JOB_SAFETY_CRITICAL_ALARM;
+        usnprintf(AlarmReasonStr, 100, "cannot start a job with waste tank overflow");
+        AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_OVERFLOW,  true);
+        *AlarmId = EVENT_TYPE__WASTE_CONTAINER_OVERFLOW;
+        //PrepareReady(Module_Waste,ModuleFail);
+        return JOB_SAFETY_CRITICAL_ALARM;
+    }
+    if ((WHS_IsEmptying())||(NoCartAvailable()))
+    {
+        //PrepareReady(Module_Waste,ModuleDone);
+        return JOB_OK;
+    }
+    else
+    {
+        Report("cannot start a job with cartridges in the IFS", __FILE__, __LINE__, wasteLevel, RpMessage, wasteLevelOverflow, 0);
+        JobEndReason = JOB_WASTE_HANDLING_PROBLEM;
+        AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  true);
+        *AlarmId = EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL;
+        usnprintf(AlarmReasonStr, 100, "cannot start a job with cartridges in the IFS");
+        //PrepareReady(Module_Waste,ModuleFail);
+        return JOB_WASTE_HANDLING_PROBLEM;
+    }
+}
+bool WHS_FlowReady = false,HeadIn_FlowReady = false,HeadOut_FlowReady = false;
+uint32_t WasteReadyControlId = 0xFF;
+float AllowedRangeForHeadBlowerDeviation = 0.07,AllowedRangeForWasteBlowerDeviation = 0.20;
+void setWastePrepareValues(float HeadLimit,float WasteLimit)
+{
+    AllowedRangeForHeadBlowerDeviation = HeadLimit;
+    AllowedRangeForWasteBlowerDeviation = WasteLimit;
+}
+uint32_t Waste_PrepareCallbak(uint32_t IfIndex, uint32_t ReadValue)
+{
+    bool ready = false, headready = false,whsready = false;
+    double HeadFlow = GetWHSAirFlow(HEAD_FLOW_METER);
+    double HeadIn_Flow =  PressureSensorGetPressure(HEAD_PT100_ZONE_5_0X84_0);
+    double HeadOut_Flow = PressureSensorGetPressure(HEAD_PT100_ZONE_7_0X86_0);
+    if ((HeadFlow<(headairflow*(1+AllowedRangeForWasteBlowerDeviation)))
+            &&(HeadFlow>(headairflow*(1-AllowedRangeForWasteBlowerDeviation))))
+    {
+        if (WHS_FlowReady == false)
+            Report("Module waste WHS_FlowReady ready", __FILE__, __LINE__, (int)(HeadFlow*100), RpMessage, WHS_FlowReady, 0);
+        WHS_FlowReady = true;
+    }
+    if ((HeadIn_Flow<(headBlowersFlow[0]*(1+AllowedRangeForHeadBlowerDeviation)))
+            &&(HeadIn_Flow>(headBlowersFlow[0]*(1-AllowedRangeForHeadBlowerDeviation))))
+    {
+        if (HeadIn_FlowReady == false)
+            Report("Module waste HeadIn_FlowReady ready", __FILE__, __LINE__, (int)(HeadIn_Flow*100), RpMessage, HeadIn_FlowReady, 0);
+        HeadIn_FlowReady = true;
+    }
+    if ((HeadOut_Flow<(headBlowersFlow[1]*(1+AllowedRangeForHeadBlowerDeviation)))
+            &&(HeadOut_Flow>(headBlowersFlow[1]*(1-AllowedRangeForHeadBlowerDeviation))))
+    {
+        if (HeadOut_FlowReady == false)
+            Report("Module waste HeadOut_FlowReady ready", __FILE__, __LINE__, (int)(HeadOut_Flow*100), RpMessage, WHS_FlowReady, 0);
+        HeadOut_FlowReady = true;
+    }
+    if (Head_Type <=HEAD_TYPE_FLAT)
+        headready = true;
+    else if ((HeadIn_FlowReady == true)&&(HeadOut_FlowReady == true))
+        headready = true;
+    if (WHS_Type == WHS_TYPE_UNKNOWN)
+        whsready = true;
+    else if (WHS_FlowReady == true)
+        whsready = true;
+    if ((headready == true)&&(whsready == true))
+        ready = true;
+    if (ready == true)
+    {
+        SafeRemoveControlCallback(WasteReadyControlId,Waste_PrepareCallbak);
+        WasteReadyControlId = 0xFF;
+        Report("Module waste prepare ready!", __FILE__, __LINE__, headready, RpMessage, headready, 0);
+        PrepareReady(Module_Waste,ModuleDone);
+    }
+    Report("Module waste prepare", __FILE__, __LINE__, headready, RpMessage, whsready, 0);
+    return OK;
+}
+uint32_t Waste_Prepare(void)
+{
+	WHS_FlowReady = false;HeadIn_FlowReady = false;HeadOut_FlowReady = false;
+    if (WasteReadyControlId != 0xFF)
+        RemoveControlCallback(WasteReadyControlId,Waste_PrepareCallbak);
+    //check that blowers are within 10% of designated flow: WHS, head blowers
+    WasteReadyControlId = AddControlCallback("Cartridge Cover Door", Waste_PrepareCallbak, eOneSecond,  TemplateDataReadCBFunction, 0, 0, 0);
+    Report("Module waste prepare", __FILE__, __LINE__, Head_Type, RpMessage, WHS_Type, 0);
+    return OK;
+}
+
+bool WHS_IsVocPpmOverAlarmLimit()
+{
+    static uint8_t counter = 0;
+    uint8_t VocPpmAlarmLimit90Percent = 0;
+    uint32_t Temp = 0;
+
+    Temp = (uint32_t)VocPpmAlarmLimit * 90;
+    Temp /= 100;
+    VocPpmAlarmLimit90Percent = (uint8_t)Temp;
+
+    if( (  Latest_Gas_Sens_PPM > VocPpmAlarmLimit                                        ) ||     //PPM
+        ( (Latest_Gas_Sens_PPM > VocPpmAlarmLimit90Percent) && (ReadingVocEverySec == true) )     ) //Hysteresis
+    {
+        Report("VOC nearing alarm state", __FILE__, (int)(Latest_Gas_Sens_PPM*100), VocPpmAlarmLimit, RpMessage, counter, 0);
+        //reading every sec
+        ReadingVocEverySec = true;
+        if(counter < 0xFF)
+        {
+            counter++;
+        }
+
+        /*if(counter > VocPpmLimitForXSec)//Sec
+        {
+            AlarmHandlingSetAlarm(EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE,true);
+            return true;//Buzzer ON if defined
+        }*/
+    }
+    else
+    {
+        AlarmHandlingSetAlarm(EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE,false);
+        //move back to noraml reading every Min.
+        ReadingVocEverySec = false;//Turn off the buzzer on the first time sampling a measurment lower than (VocPpmAlarmLimit - 10%)
+        counter = 0;
+    }
+
+    return false;
+}
+
+
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_print.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_print.c
deleted file mode 100644
index e69de29bb..000000000
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_print.c
+++ /dev/null
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
index 485b28ccc..070f3c7e7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
@@ -64,6 +64,7 @@ bool newWHS_init(void)
     Trigger_WHS_Rheostat_init();
 
     status |= WHS_I2C_EEprom_Read_Buf();
+    Trigger_WHS_I2C_EEprom_Read ( 0,  sizeof(WHS_Eeprom.bytes), WHS_Eeprom.Buf);
     //status |= WHS_IO_Init();
     //status |= init_WHS_fan();
     //
@@ -86,7 +87,6 @@ bool newWHS_init(void)
  //   delayms(4000);
     //Trigger_SetWHSBlowerVoltage (0x0C00);
 
-
 return status;
 }
 
@@ -147,3 +147,4 @@ bool WHS_I2C_EEprom_Write_Ch_shai_taest()
     //    status |= I2C_Read(I2C_ID_WHS_CARD, I2CEEPROM_ADDRESS + 1, WHS_Read_Buf, 7);
         return status;
     }
+