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

29 files changed, 1116 insertions, 2057 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 07df07309..78398119b 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -446,6 +446,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
@@ -594,7 +595,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)
@@ -604,7 +606,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;
@@ -615,7 +619,6 @@ void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms
         AlarmhandlingFlags = flags;
     }
 }
-char AlarmReasonStr[100];
 JobEndReasonEnum getEndReason(uint32_t AlarmId)
 {
     switch (AlarmItem[AlarmId].AlarmSource)
@@ -838,7 +841,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     {
         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++)
@@ -982,7 +985,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                 case EVENT_TYPE__VOC_SENSOR_ALARM_TIME:
                 case EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE:
                 //case EVENT_TYPE__POWER_UP_BIT_FAILURE:
-                    FoundReason = JOB_UNSPECIFIED_ERROR;
+                    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;
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 327b5d19b..06434ee50 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -65,6 +65,9 @@
 #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"
+
 Task_Handle Millisecond_Task_Handle;
 /******************** Definitions  ********************************************/
 
@@ -496,9 +499,17 @@ uint32_t MillisecLoop(uint32_t tick)
     #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
@@ -582,7 +593,7 @@ void setRapidPressureRead(bool value)
     if (GetDiagnosticMode() == Diagnostic_Extreme_Mode)
         RapidPressureRead = true;
 }
-
+bool Shinko_Read = true;
 uint16_t PumpCounter = 0;
 uint16_t realtimetest[101];
 uint32_t MillisecLowLoop(uint32_t tick)
@@ -709,6 +720,23 @@ uint32_t MillisecLowLoop(uint32_t tick)
             if (isMotorConfigured(Motor_i))
                 MotorGetStatusFromFPGA(Motor_i);
         }
+        if ((WHS_Type == WHS_TYPE_NEW)&&(Shinko_Read == true))
+        {
+            if(ShinkoTempDeg.Read_Setup == 0x00)//didn't read it yet
+            {
+                WHS_Shinko_Communication(R_SETUP);
+            }
+            else
+            if(0)//TBD - need stop condition to write only once (all the steps) , Read_Setup != setup, Read_Setup != 0, Read_Setup != Prev_Read_Setup
+            {
+                // option to wrte + read setup and stop when read = write
+               WHS_Shinko_Communication(W_SETUP);
+            }
+            else
+            {
+                WHS_Shinko_Communication(R_Value); // Reading every fourth cycle (Set HW, Request, Set HW, Response)
+            }
+        }
     }
     if ((O500Millisecond_Tick)&&(RapidPressureRead == false))
     {
@@ -730,9 +758,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
     {
         //char Lenstr[160];
         //static int Counter = 0;
-        MachineUpdateResponseFunc();
+        //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++)
@@ -767,6 +794,9 @@ uint32_t MillisecLowLoop(uint32_t tick)
             }
             */
         }
+        if (Head_Type == HEAD_TYPE_ARC) {
+            HeadBlowersControlLoop();
+        }
 
         //call waste state machine
         Waste_StateMachine_OneSecond_Call();
@@ -784,7 +814,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     }
     if (OneMinute_Tick)
     {
-//        MachineUpdateResponseFunc();
+        MachineUpdateResponseFunc();
         /*        for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++)
         {
             if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_SCREW)
@@ -808,6 +838,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
         {
             waste_seq_step1();// include 1Sec delay           <- to open !!!!
         }*/
+        Shinko_Read = true;
     }
     if (OneHourTick)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
index 226d0d57a..f7351d0b1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
@@ -50,7 +50,7 @@ void MillisecLogClose(void);
 
 #endif
 
-
+extern bool Shinko_Read;
 extern bool watchdogCriticalAlarm;
 
 extern Task_Handle Millisecond_Task_Handle;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index a76142b00..888934584 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"
@@ -54,6 +56,7 @@
 #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;
@@ -191,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++)
@@ -264,6 +267,7 @@ 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)
 {
@@ -407,6 +411,22 @@ 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 = ShinkoTempDeg.Read_Setup;
+    HeaterState->has_currentvalue = true;
+    HeaterState->currentvalue = ShinkoTempDeg.Read_value;//Shinko_Temperature;//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId])/100;
+    return;
+}
+
+#ifdef FOUR_WINDERS
+    double dancer2,dancer3,dancer4;
+#endif
 void CopyTemperaturesToMonitor(void)
 {
     DiagnosticsMonitor.mixertemperature =
@@ -488,29 +508,42 @@ void CopyTemperaturesToMonitor(void)
                 HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater1];
         DiagnosticsMonitor.n_headcoverheater2temperature =
                 HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater2];
-        DiagnosticsMonitor.headzone4temperature =
-                HeaterTemperature[HEATER_TYPE__HeaterZone4];
-        DiagnosticsMonitor.headzone6temperature =
-                HeaterTemperature[HEATER_TYPE__HeaterZone6];
-        DiagnosticsMonitor.n_headzone4temperature =
-                HeaterCounterIndex[HEATER_TYPE__HeaterZone4];
-        DiagnosticsMonitor.n_headzone6temperature =
-                HeaterCounterIndex[HEATER_TYPE__HeaterZone6];
+        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];
-        DiagnosticsMonitor.headblower1airflow = HeaterTemperature[HEATER_TYPE__HeaterZone5];
-        DiagnosticsMonitor.headblower2airflow = HeaterTemperature[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;
     }
-    DiagnosticsMonitor.n_headblower1airflow = HeaterCounterIndex[HEATER_TYPE__HeaterZone5];
-    DiagnosticsMonitor.n_headblower2airflow = HeaterCounterIndex[HEATER_TYPE__HeaterZone7];
-    DiagnosticsMonitor.headblower1airflow = HeaterTemperature[HEATER_TYPE__HeaterZone5];
-    DiagnosticsMonitor.headblower2airflow = HeaterTemperature[HEATER_TYPE__HeaterZone7];
-    headblowervoltage1 =(double )Head_Fan_PWM_Command[HEAD_FAN_RIGHT];
-    headblowervoltage2  =(double )Head_Fan_PWM_Command[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_headblower1airflow = 1;
+    DiagnosticsMonitor.n_headblower2airflow = 1;
+    DiagnosticsMonitor.headblower1airflow = &dancer4;
+    DiagnosticsMonitor.headblower2airflow = &dancer3;
+    DiagnosticsMonitor.headblowervoltage1 = &dancer2;
     DiagnosticsMonitor.n_headblowervoltage1 = 1;
-    DiagnosticsMonitor.n_headblowervoltage2 = 1;
+#endif
+
     DiagnosticsMonitor.dryerzone1temperature =
             HeaterTemperature[HEATER_TYPE__DryerAirHeater];
     DiagnosticsMonitor.dryerzone2temperature =
@@ -570,9 +603,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];
@@ -580,8 +613,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];
@@ -589,7 +622,7 @@ void DiagnosticOneMinuteCollection(void)
             DiagnosticsMidTankInkLevel[i].data = midtankinklevel[i];
             DiagnosticsMidTankInkLevel[i].n_data = 1;
             DiagnosticsMonitor.midtanksinklevel[i] = &DiagnosticsMidTankInkLevel[i];
-        }
+        }*/
 
     }
     DiagnosticsMonitor.n_overalltemperature = 1;
@@ -648,8 +681,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;
@@ -806,8 +839,8 @@ 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;
@@ -886,7 +919,7 @@ void DiagnosticOneSecCollection(void)
         }
         else
         {
-            DiagnosticsMonitor.chillertemperature = &WasteLevel;
+            DiagnosticsMonitor.chillertemperature = &ShinkoTempDeg.Read_value;//Shinko_Temperature;
         }
         DiagnosticsMonitor.n_chillertemperature = 1;
         DiagnosticsMonitor.n_wastelevel = 1;
@@ -941,6 +974,8 @@ void DiagnosticOneSecCollection(void)
         //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));
@@ -975,11 +1010,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++)
         {
@@ -1030,6 +1073,7 @@ void SendDiagnostics(void)
     //MessageContainer responseContainer;
     StartDiagnosticsResponse response = START_DIAGNOSTICS_RESPONSE__INIT;
     //int i;
+    int chillerHeaterId = 0;
 
     if (DiagnosticsActive == false)
     {
@@ -1232,12 +1276,17 @@ void SendDiagnostics(void)
         LoadHeaterState(HEATER_TYPE__HeaterZone11,&HeaterInfo[i++]);
         LoadHeaterState(HEATER_TYPE__HeaterZone12,&HeaterInfo[i++]);
     }
-    if ((Head_Type == HEAD_TYPE_FLAT)||(Head_Type == HEAD_TYPE_ARC))
+    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;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index d9f8d30fd..b40bbe4c7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -64,11 +64,11 @@ uint32_t MotorHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
     {
         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;
@@ -107,7 +107,7 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     }
     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;
     }
@@ -177,7 +177,7 @@ 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);
+                    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;
                 }
@@ -226,7 +226,7 @@ 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);
+                    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;
                 }
@@ -260,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
     {
@@ -338,7 +338,7 @@ uint32_t DispenserHomingProgressReport(uint32_t deviceID, uint32_t ReadValue)
     response.progress = IDS_Dispenser_Data[deviceID].consumedinnanolitter;
 
     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));
@@ -359,7 +359,7 @@ 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
@@ -412,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
@@ -445,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;
@@ -462,12 +462,29 @@ uint32_t DispenserAbortHomingRequestFunc(MessageContainer* requestContainer)
 
 return OK;
 }
+/********************************************************************************
+ * Drier Loading Arm Homing
+ ********************************************************************************/
+uint32_t Drier_Center = 0;
+float Calculate_Arm_Angle(uint32_t Current_Angle)
+{
+    uint32_t angle;
+    float Calc_angle;
+    if (Current_Angle >= Drier_Center)
+        angle = Current_Angle - Drier_Center;
+    else
+        angle = Current_Angle + 0x3FFF - Drier_Center;
+    Calc_angle = angle/0x3FFF;
+    MCU_E2PromProgram(EEPROM_DRIER_LOADING_ARM_ANGLE,Calc_angle);
+    ReportWithPackageFilter(DiagnosticsFilter,"Calculate_Arm_Angle",__FILE__,(int)(Calc_angle*1000),Current_Angle,RpMessage,Drier_Center,0);
+    return Calc_angle;
+}
 uint32_t Diagnostics_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_t BusyFlag)
 {
     MessageContainer responseContainer;
     MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
 
-    Report("Diagnostics_Set_Load_Arm_To_Stopper time",__FILE__,__LINE__,msec_millisecondCounter,RpMessage,0,0);
+    ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Set_Load_Arm_To_Stopper time",__FILE__,__LINE__,msec_millisecondCounter,RpMessage,0,0);
 
     //NumberOfDrierLoaderCycles=0;
     //storeLoadArmParameters();
@@ -488,13 +505,13 @@ uint32_t Diagnostics_Dryer_UnLoading_Callback(uint32_t MotorId, uint32_t ReadVal
 {
     D_numberOfCycles++;
     uint32_t temp = Read_Dryer_ENC_Position();
-    Report("Diagnostics_Dryer_UnLoading_Callback",__FILE__,ReadValue,temp,RpMessage,D_DrierPrevLocation,0);
-    //Report("Diagnostics_Dryer_UnLoading_Callback details",__FILE__,(int)(TotalLoadedLen),D_numberOfCycles,RpMessage,CallbackCounter,0);
-    if ((abs (temp -D_DrierPrevLocation)>1000  )&&(ReadValue == NOTBUSY)) // OK - take another round
+    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
     {
         D_DrierPrevLocation = temp;
-        Report("Diagnostics_Dryer_UnLoading cycles",__FILE__,D_numberOfCycles,LoadArmRounds,RpMessage,0,0);
+        ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_UnLoading cycles",__FILE__,D_numberOfCycles,LoadArmRounds,RpMessage,0,0);
         if (D_numberOfCycles<LoadArmRounds)
         {
             MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-D_numberOfCycles);
@@ -505,15 +522,15 @@ uint32_t Diagnostics_Dryer_UnLoading_Callback(uint32_t MotorId, uint32_t ReadVal
         {
             MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Diagnostics_Set_Load_Arm_To_Stopper_Callback,15000,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize);
             MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-D_numberOfCycles);
-            Report("Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+            ReportWithPackageFilter(DiagnosticsFilter,"Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
         }
     }
     else  //timeout or no movement
     {
-        Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+        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
 
-        Report("Drier unloading timeout(1) or no movement",__FILE__,temp,D_DrierPrevLocation,RpWarning,ReadValue,0);
+        ReportWithPackageFilter(DiagnosticsFilter,"Drier unloading timeout(1) or no movement",__FILE__,temp,D_DrierPrevLocation,RpWarning,ReadValue,0);
     }
     return OK;
 }
@@ -533,8 +550,9 @@ uint32_t Diagnostics_Dryer_UnLoading(void)
         MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
 
     MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&temp);
+    Drier_Center = temp;
     D_DrierPrevLocation = temp;
-    Report("Diagnostics_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,D_DrierPrevLocation,RpMessage, LoadArmRounds,0);
+    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);
@@ -548,7 +566,8 @@ uint32_t Diagnostics_Dryer_MovetoEncoderPosition_Callback(uint32_t MotorId, uint
     MessageContainer responseContainer;
     MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
 
-    //Report("Diagnostics_Dryer_MovetoEncoderPosition_Callback",__FILE__,__LINE__,0,RpMessage,CallbackCounter,0);
+    ReportWithPackageFilter(DiagnosticsFilter,"Store angle of arm drier - ended",__FILE__,__LINE__,(int)(Calculate_Arm_Angle(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;
@@ -566,13 +585,13 @@ uint32_t Diagnostics_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue
 {
     D_numberOfCycles++;
 
-    Report("Diagnostics_Dryer_Loading_Callback",__FILE__,(int)D_numberOfCycles,(int)D_DrierPrevLocation,RpMessage,ReadValue,0);
+    ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics_Dryer_Loading_Callback",__FILE__,(int)D_numberOfCycles,(int)D_DrierPrevLocation,RpMessage,ReadValue,0);
 
     MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,D_numberOfCycles);
     if (ReadValue == NOTBUSY)
     {
-        //Report("Diagnostics_Dryer_Loading_Callback",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
-        //Report("Diagnostics_Dryer_Loading_Callback details",__FILE__,(int)(TotalLoadedLen),numberOfCycles,RpMessage,CallbackCounter,0);
+        //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,
@@ -581,12 +600,13 @@ uint32_t Diagnostics_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue
         else
         {
             MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Diagnostics_Dryer_MovetoEncoderPosition_Callback,15000,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize);
-            Report("Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+            ReportWithPackageFilter(DiagnosticsFilter,"Store Number of cycles in drier",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
         }
     }
     else
     {
-        Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+        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(ReadValue)*360),RpMessage,D_numberOfCycles,0);
         MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
     }
     return OK;
@@ -594,9 +614,14 @@ uint32_t Diagnostics_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue
 
 uint32_t Diagnostics_Dryer_Loading(void)
 {
+    //float Calc_angle;
+#warning assuming loading starts from 0
     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__,__LINE__,D_numberOfCycles,RpMessage,LoadArmRounds,0);
+    Drier_Center = 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;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index ac2009bcd..4ff2e546c 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -43,6 +43,7 @@
 #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"
@@ -55,6 +56,7 @@
 #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);
@@ -65,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";
@@ -183,6 +186,10 @@ uint32_t HWConfigurationInit(void)
     //WHS_init(); // remove call to old WHS
 #endif
 
+    if (WHS_Type == WHS_TYPE_NEW)
+    {
+        InitConsole_WHS_UART3();//WHS Shinko communication
+    }
     // Waste Init (WHS)
     Waste_Init();
 
@@ -431,6 +438,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");
@@ -494,6 +506,10 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
                 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
@@ -568,7 +584,18 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
             {
                 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();
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 28ad81a6c..b83fa6610 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
@@ -15,6 +15,7 @@
 #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"
@@ -39,10 +40,12 @@ 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;
@@ -57,6 +60,38 @@ int MachineUpdateResponseFunc(void)
     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;
+    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))
+            usetemp = 0;
+        else  if ((int1valid == false)&&(int2valid == true))
+            usetemp = internaltemp2/100;
+    }
+
+    MachineStatus.has_overalltemperature = true;
+
+
     if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
     {
       MachineStatus.spoolstate = SPOOL_STATE__Absent;
@@ -84,7 +119,6 @@ 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
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index d41b3c1a0..e5595a965 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -41,6 +41,7 @@ double dryerairflow = 5.0;
 double pressurebuildup = 0;
 double dryerzone1temp = 0;
 int32_t tableindex = 0;
+double headBlowersFlow[2] = {1.0,1.0};
 
 double dryerbufferMeters = 0;
 double dryerbufferCentimeters = 0;
@@ -303,9 +304,10 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
         {
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, false,ProcessParams->lblowertemp);
         }
+
+        status |= HeadBlowerCommandRequestMessage(HEAD_FAN_RIGHT, ProcessParams->rblowerflow);
+        status |= HeadBlowerCommandRequestMessage(HEAD_FAN_LEFT, ProcessParams->lblowerflow);
         Trigger_HeaterWriting();
-        Trigger_Head_Fan_Control(HEAD_FAN_RIGHT,ProcessParams->rblowerflow);
-        Trigger_Head_Fan_Control(HEAD_FAN_LEFT,ProcessParams->lblowerflow);
     }
 
     if (status)
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.h b/Software/Embedded_SW/Embedded/Modules/General/process.h
index 7cd592aad..f7f16d11e 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.h
@@ -19,6 +19,7 @@ extern double headairflow;
 extern double dryerairflow;
 extern double pressurebuildup;
 extern double dryerzone1temp;
+extern double headBlowersFlow[2];
 
 extern int32_t tableindex;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index 0220d1a6c..284b2de6c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -22,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);
@@ -41,3 +43,10 @@ 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();
+void HeadBlowersCfg();
+void HeadBlowersControlLoop ();
+uint32_t  HeadBlowerCommandRequestMessage(int blowerId, float flow);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index ce3ced6ef..3c7248204 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,8 @@
 /******************** Data Structures  ********************************************/
 #define OVERHEAT_COUNT_LIMIT 3
 #define UNDERHEAT_COUNT_LIMIT 3
+#define MIN_ALLOWED_PWM 0
+#define MAX_ALLOWED_PWM 255
 
  int Overheat_Count_Limit = OVERHEAT_COUNT_LIMIT;
  int Underheat_Count_Limit = UNDERHEAT_COUNT_LIMIT;
@@ -82,6 +88,20 @@ typedef struct
 HeaterControlConfig_t  HeaterPIDConfig[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 //PID_Config_Params   temp_params;
 
+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};
+
 /******************** GLOBAL PARAMETERS  ********************************************/
 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};
@@ -91,11 +111,15 @@ uint32_t    UnderHeatCounter [HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,
 uint32_t    MainDryerHeaterMaxTempControl = 0xFF;
 uint32_t    SecondDryerHeaterMaxTempControl = 0xFF;
 uint32_t    DisasterControlId = 0xFF;
+double      PressureSensorV0[2] = {0.0, 0.0};
+uint8_t     HeadBlowersCloseLoopTime[2] = {2, 2};
+
 #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
+#define PRESSURE_SENSOR_CP  0.269
+extern uint16_t Head_Fan_Tach[2];
+extern uint8_t Head_Fan_PWM_Command[2];
 
 bool UseSecondaryDrierHeater = true;
 
@@ -113,7 +137,7 @@ void initializeArrays(void)
         HeaterId2PT100Id[i] = 0xFF;
         HeaterId2CurrentId[i] = NUM_OF_CURRENT_HEATERS;
     }
-    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
+    if (Head_Type == HEAD_TYPE_FLAT)
     {
         HeaterId2PT100Id[HEATER_TYPE__DryerAirHeater] =       DRYER_AIR_PT100;
         HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater] =      DRYER_MAIN_PT100;
@@ -154,7 +178,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,7 +209,50 @@ 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;
+        */
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater1] =     HEAD_PT100_AIR_HEATER_2_0X8C_1;//HEAD_PT100_ZONE_11_0X8A_0; 
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     HEAD_PT100_AIR_HEATER_1_0X8C_0 ;//HEAD_PT100_ZONE_12_0X8A_1; 
 
+        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;
@@ -236,7 +303,7 @@ uint32_t HeatersDisasterControl(uint32_t x,uint32_t y);
 
 uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue);
 void HeatersStartControlTimer (void);
-
+int HeadBlowersGetPWM(uint8_t blowerId);
 
 //**********************************************************************
 //******************** CODE  *******************************************/
@@ -571,6 +638,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;
@@ -1843,3 +1944,193 @@ void HeatersControlTask(UArg arg0, UArg arg1)
         }
     }
 }
+
+
+/********************************************************************************
+ * 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 = 600;
+    HeadBlowerControl[0].m_params.IntegralErrorMultiplier = 100;
+    HeadBlowerControl[0].m_params.ProportionalErrorMultiplier = 100;
+    HeadBlowerControl[0].m_params.epsilon = 0.2;
+    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 = 600;
+    HeadBlowerControl[1].m_params.IntegralErrorMultiplier = 100;
+    HeadBlowerControl[1].m_params.ProportionalErrorMultiplier = 100;
+    HeadBlowerControl[1].m_params.epsilon = 0.2;
+    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) {
+        HeadBlowerControl[blowerId].m_integral = 0;
+        calculatedPwm = MIN_ALLOWED_PWM;
+    }
+    if (calculatedPwm > MAX_ALLOWED_PWM) {
+        HeadBlowerControl[blowerId].m_integral = 0;
+        calculatedPwm = MAX_ALLOWED_PWM;
+    }
+    Trigger_Head_Fan_Control(blowerId, calculatedPwm);
+    return OK;
+}
+
+bool HeadBlowerFlowControl(double Q_value, uint8_t blowerId)
+{
+    double currentFlow = 0.0;
+    int sensorId;
+
+    sensorId = (blowerId == HEAD_FAN_RIGHT)?(HEAD_PT100_ZONE_5_0X84_0):(HEAD_PT100_ZONE_7_0X86_0);
+    currentFlow = PressureSensorGetPressure(sensorId);
+    HeadBlowerPidFunc(Q_value,currentFlow, blowerId);
+    return OK;
+}
+
+void HeadBlowersControlLoop ()
+{
+    int blowerId;
+    static int count[2] = {0, 0};
+    if (GetMachineState() < MACHINE_STATE_WAIT_FOR_COOLER)
+        return; //do not start before controller is initialized and running
+
+    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)
+{
+    int sensorId;
+    sensorId = (blowerId == HEAD_FAN_RIGHT)?(HEAD_PT100_ZONE_5_0X84_0):(HEAD_PT100_ZONE_7_0X86_0);
+    PressureSensorV0[blowerId] = MillisecGetTemperatures(sensorId);
+    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;
+
+    Cp = PRESSURE_SENSOR_CP;
+    V0 = (SensorId == HEAD_PT100_ZONE_5_0X84_0)?(PressureSensorV0[0]):(PressureSensorV0[1]);
+    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/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index ee308ce62..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];
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
index 09f5ae108..256d25aa5 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
@@ -62,25 +62,25 @@ uint32_t IDS_Cleaning_Move_Actuators()
    {
        Trigger_Head_Actuators_Stub(ACTIN, ENABLE, UP);
        //Trigger_Head_Actuators_Control(ACTIN, LOW,true);
-       Report("IDS_Cleaning_Move_ActuatorUp", __FILE__, __LINE__, 1, RpWarning,   CleaningStageCounter, 0);
+       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();
-       Report("IDS_Cleaning_Stop_Actuator", __FILE__, __LINE__, Tup, RpWarning,   CleaningStageCounter, 0);
+       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);
-       Report("IDS_Cleaning_MoveDown", __FILE__, __LINE__, Tdelay1, RpWarning,   CleaningStageCounter, 0);
+       ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_MoveDown", __FILE__, __LINE__, Tdelay1, RpWarning,   CleaningStageCounter, 0);
    }
    else if (CleaningStageCounter == Tdelay2)
    {
        CleaningStageCounter = 0;
        Trigger_Head_Actuators_Stub(ACTIN, DISABLE, DONTCARE);
-       Report("IDS_Cleaning_Stop_delay", __FILE__, __LINE__, Tdelay2, RpWarning,   CleaningStageCounter, 0);
+       ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_delay", __FILE__, __LINE__, Tdelay2, RpWarning,   CleaningStageCounter, 0);
    }
 
 
@@ -98,7 +98,7 @@ uint32_t IDS_Cleaning_Move_Actuators()
     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;
 }
@@ -112,7 +112,7 @@ uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callbac
     //Trigger_Head_Actuators_Control(ACTIN, LOW,false);
     CleaningStageCounter = 0;
     CleaningStage = CleaningStageIdle;
-    Report("IDS_Cleaning_Center_And_Stop_Rockers actuator down", __FILE__, __LINE__, timeout, RpWarning,   123456, 0);
+    ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Center_And_Stop_Rockers actuator down", __FILE__, __LINE__, timeout, RpWarning,   123456, 0);
 
     return status;
 }*/
@@ -124,8 +124,8 @@ uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr
     Tdelay2 = RightRockerSpeed;
     status = IDS_Dispenser_Start_Motor_and_Open_Valve(CLEANER_DISPENSER, dispenserSpeed, callback);
     Init_CleaningStageCounter();
-    Report("IDS_Cleaning_Spray_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning,   dispenserSpeed, 0);
-    Report("IDS_Cleaning parameters", __FILE__, Tup*100, Tdelay1*100, RpWarning,   Tdelay2*100, 0);
+    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;
 
@@ -134,11 +134,11 @@ 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);
     HeadCard_Actuators_Relocate();
     Init_CleaningStageCounter();
     CleaningStage = CleaningStageIdle;
-    Report("IDS_Cleaning_Stop_Cleaning_Solution actuator relocate", __FILE__, __LINE__, CleaningStage, RpWarning,   CleaningStageCounter, 0);
+    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 7693d1520..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)
@@ -353,16 +353,23 @@ void IDS_Dispenser_Content_Calculation (char DispenserId)
     //        IDS_Dispenser_Data[DispenserId].nanolitterperpulse ;//* dir;
     //double consumedintimeframe = (double)(CurrentDispenserSpeed[DispenserId]); //pulses only
     //consumedintimeframe = 10+DispenserId;
-    IDS_Dispenser_Data[DispenserId].consumedinnanolitter += (CurrentDispenserSpeed[DispenserId]*4/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%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)
@@ -394,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)
 {
@@ -403,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)
 {
@@ -418,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_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 14bb59661..79418a8d8 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -72,8 +72,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
 
@@ -89,7 +89,7 @@ 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;
@@ -105,12 +105,14 @@ void IDS_Dispenser_SetAutoHoming_Config(AutoHoming_Config_enum Config)
 
 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)
 {
@@ -173,11 +175,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
@@ -202,7 +204,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);
@@ -236,25 +238,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;
     }
 
@@ -262,7 +264,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
         }
     }
@@ -287,13 +289,13 @@ 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;
@@ -306,10 +308,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;
     }
 
@@ -344,10 +346,10 @@ 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
@@ -369,10 +371,10 @@ 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);
+      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);
@@ -421,7 +423,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])
     {
@@ -439,14 +441,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
         }
     }
@@ -478,7 +480,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;
@@ -498,12 +500,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;
@@ -524,7 +526,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;
         }
     }
@@ -534,11 +535,10 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
     if (GetDispenserPressure(DispenserId)>3.0)
     {
         //10/8/2020 pulling down 2000 steps
-        Report("Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,2000,0);
+        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,2000*MotorsCfg[HW_Motor_Id].microstep);
@@ -559,7 +559,7 @@ 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;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 9c82cb1bf..d40f3c00b 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -103,7 +103,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)
@@ -122,9 +122,9 @@ void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, doubl
      if ( ids_rightcleaningmotorspeed)
          RightRockerSpeed = ids_rightcleaningmotorspeed;
      minimal_intersegment_length = ids_cleaningstopbeforesegmenttime+ids_cleaningstartspraypresegmenttime+2000;
-     Report("IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,__LINE__,RightRockerSpeed,RpWarning,(int)LeftRockerSpeed,0);
-     Report("IDS_Dispenser_SetPreSegmentCleaningValues ",__FILE__,minimal_intersegment_length,InterSegmentStartSprayCleaner,RpWarning,(int)InterSegmentCenterRockers,0);
-     Report("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);
+     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;
@@ -189,21 +189,21 @@ 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
@@ -291,7 +291,7 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
                          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++;
@@ -329,7 +329,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);
@@ -337,7 +337,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
@@ -357,7 +357,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;
 
  }
@@ -452,22 +452,24 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
  uint32_t DispenserPrepareControlId = 0xFF;
  int NumOfActiveDispensers = 0;
  int DispenserBuildTimeCounter = 0;
-#define DISPENSER_UP_MOVEMENT
+ double TargetNumberOfStepsPreRun,MaximalPressurePreRun;
  int DispenserTotalPrepareSteps[MAX_SYSTEM_DISPENSERS];
  bool DispenserLastMovementDown[MAX_SYSTEM_DISPENSERS];
-#define PRESSURE_READ_TIME_GAP 100
+
+ #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;
@@ -490,7 +492,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
              }
          }
@@ -514,6 +516,37 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
   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)
  {
@@ -525,6 +558,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
  //set the speed only before the first segment, speed is constant accros job
      int Dispenser_i,n_dispensers;
      double segmentfirst_speed;
+     double pressure;
 
      //REPORT_MSG((int)DispenserPrepareControlId, "Prepare Callback");
 
@@ -532,99 +566,73 @@ 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++)
              {
-                 for (i = 0; i < MAX_DYE_DISPENSERS; i++)
-                 {
-                     DispenserTotalPrepareSteps[i]+=(CurrentDispenserSpeed[i]*PRESSURE_READ_TIME_GAP/eOneSecond);
-                     DispenserLastMovementDown[i] = false;
-                 }
-                 //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)
                  {
-#ifdef DISPENSER_UP_MOVEMENT
-                     if (DispenserTotalPrepareSteps[i]>120000)
-#endif
-                     {
-                         NumofReadyDispensers++;
-                         Report("Dispenser total prepare steps ready",__FILE__,DispenserTotalPrepareSteps[i],(int)(DispenserPreparePressure*100),RpWarning,IDS_Dispenser_Data[i].consumedinnanolitter,0);
-                     }
-                     if (Special_Dispensers == true)
-                     {
-                         MotorStop(HW_Motor_Id, Hard_Hiz);
-                         CurrentDispenserSpeed[i] = 0;
-                     //Report("IDS stopped ready",__FILE__,i,(int)(DispenserPreparePressure*100),RpWarning,(int)NumofReadyDispensers,0);
-                     }
-                     else
-                     {
-                         tempSpeed = CurrentDispenserSpeed[i];
-                         updatedSpeed = (tempSpeed*0.992>100)?tempSpeed*0.992:100;
-                         MotorSetSpeed(HW_Motor_Id, updatedSpeed);
-                         CurrentDispenserSpeed[i] = updatedSpeed;
-                         //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
-                     }
+                     AdjustDispenserSpeedToPressure(i,MaximalPressurePreRun,pressure);
+                 }
+                 else if (pressure > DispenserPreparePressure*1.2)
+                 {
+                     MotorStop(HW_Motor_Id, Hard_Hiz);
+                     CurrentDispenserSpeed[i] = 1;
                  }
                  else
                  {
-                     if (Special_Dispensers == true)
-                     {
-                         tempSpeed = (DispenserPreparePressure-GetDispenserPressure(i))*InitialDispenserSpeed;
-                         if (tempSpeed<300)
-                             tempSpeed = 300;
-                     }
-                     else
-                     {
-                         tempSpeed = CurrentDispenserSpeed[i];
-                     }
-                     updatedSpeed = (tempSpeed*1.03<InitialDispenserSpeed)?tempSpeed*1.03:InitialDispenserSpeed;
-                     MotorSetSpeed(HW_Motor_Id, updatedSpeed);
-                     CurrentDispenserSpeed[i] = updatedSpeed;
+                     if (AdjustDispenserSpeedToPressure(i,DispenserPreparePressure,pressure) == true)
+                         NumofReadyDispensers++;
                  }
+                 ReportWithPackageFilter(IDSFilter,"IDS prepare",__FILE__,i,(int)DispenserTotalPrepareSteps[i],RpWarning,(int)(CurrentDispenserSpeed[i]*100),0);
              }
          }
-         if (GetDispenserPressure(CLEANER_DISPENSER) > 0.02)
+         pressure = GetDispenserPressure(CLEANER_DISPENSER);
+         if (pressure > 0.02)
          {
              HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
              MotorStop(HW_Motor_Id, Hard_Hiz);
              if (CurrentDispenserSpeed[CLEANER_DISPENSER])
-                 Report("IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
+                 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))
          {
              DispenserBuildTimeCounter = 0;
              pressureReady = true;
-             Report("pressureReady = true  or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)(DispenserPreparePressure*100),0);
+             ReportWithPackageFilter(IDSFilter,"pressureReady = true  or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)(DispenserPreparePressure*100),0);
          }
      }
      else if (endOfPrepareWCF == false)
      {
          if ((DispenserBuildTimeCounter == PRESSURE_READ_TIME_GAP)&&(FirstBrushStop))
          {
-             Report("start prepare dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+             ReportWithPackageFilter(IDSFilter,"start prepare dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
              if (FirstBrushStop)
              {
                  REPORT_MSG(FirstBrushStop->index,"WFCFBrushStopRead Index");
@@ -673,7 +681,7 @@ 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,
@@ -681,8 +689,8 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                                        (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
                          {
@@ -690,11 +698,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,IdsMessage, __FILE__, __LINE__, DispenserBuildTimeCounter, RpWarning,   WFCF, 0);
+
                  }//if n_dis
              }
          }
@@ -708,7 +720,7 @@ 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);
 
          }
      }
@@ -720,11 +732,11 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
              MotorStop(HW_Motor_Id, Hard_Hiz);
              CurrentDispenserSpeed[CLEANER_DISPENSER] = 0;
-             Report("IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)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;
@@ -747,9 +759,9 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
     JobTicket* JobTicket = JobDetails;
 
     JobEndSequence = false;
-    if ((pressurebuildup>0.1)&&(pressurebuildup<4.0))
+    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)
@@ -759,7 +771,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
     }
     if ((cleanerFlow>200)&&(cleanerFlow<1150))
     {
-        Report("Setting cleanerFlow from RML cleanerFlow",__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)
@@ -767,6 +779,8 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
         CleaningDispenserSpeed = 0;
         EnableCleaning = false;
     }
+    TargetNumberOfStepsPreRun = InitialDispenserTimeout;
+    MaximalPressurePreRun = InitialDispenserPressure;
 
     for (Motor_i = 0;Motor_i < MAX_SYSTEM_DISPENSERS;Motor_i++)
     {
@@ -811,7 +825,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;
      }
 
@@ -827,11 +841,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;
-             Report("Dispenser total prepare steps zero",__FILE__,i,DispenserTotalPrepareSteps[i],RpWarning,IDS_Dispenser_Data[i].consumedinnanolitter,0);
+             ReportWithPackageFilter(IDSFilter,"Dispenser total prepare steps zero",__FILE__,i,DispenserTotalPrepareSteps[i],RpWarning,IDS_Dispenser_Data[i].consumedinnanolitter,0);
          }
          else
          {
@@ -839,12 +853,12 @@ 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);
+                     ReportWithPackageFilter(IDSFilter,"Homing Inactive dispenser",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
                      IDS_HomeDispenser (i, 1000 , NULL);
                  }
                  else
                  {
-                     Report("Inactive dispenser already homing",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+                     ReportWithPackageFilter(IDSFilter,"Inactive dispenser already homing",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
                  }
              }
          }
@@ -865,7 +879,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)
                      {
@@ -878,7 +892,7 @@ 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);
                  }*/
              }
@@ -886,7 +900,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
          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;
-         Report("IDS start cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
+         ReportWithPackageFilter(IDSFilter,"IDS start cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
 
 
      }
@@ -912,7 +926,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))
       {
@@ -939,7 +953,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
               {
@@ -947,20 +961,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;
@@ -983,7 +997,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;
@@ -1008,9 +1022,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
@@ -1026,13 +1040,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,IdsMessage, __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);
 
          }
@@ -1112,25 +1130,25 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
      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 )&&
@@ -1141,7 +1159,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          }
          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);
          }
@@ -1163,7 +1181,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);
@@ -1210,7 +1228,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,
@@ -1218,10 +1236,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,IdsMessage, __FILE__, __LINE__, FileBrushStop->index, RpWarning,   lInterSegmentLength, 0);
              }
          }
          //startDispensersAtSegmentSpeed*1=WFCFClenerSpray(speed);
@@ -1248,7 +1269,7 @@ uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
     {
         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++)
@@ -1259,22 +1280,22 @@ 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);
-                    Report("Unhandled BrushStopRead Error",__FILE__,statbuf.used,(int)statbuf.stackSize,RpWarning,(int)statbuf.stackHeap,0);
+                    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);
-                    Report("Unhandled brushstops ERROR",__FILE__,__LINE__,(int)tFileBrushStop,RpWarning,(int)PrevSegment->brushstopscount,0);
+                    ReportWithPackageFilter(IDSFilter,"Unhandled brushstops ERROR",__FILE__,__LINE__,(int)tFileBrushStop,RpWarning,(int)PrevSegment->brushstopscount,0);
                     status = ERROR;
                     break;
                 }
             }//for brushstops
         }
     }
-    Report("Unhandled brushstops result",__FILE__,__LINE__,(int)Brush_i,RpWarning,(int)PrevSegment->brushstopscount,0);
+    ReportWithPackageFilter(IDSFilter,"Unhandled brushstops result",__FILE__,__LINE__,(int)Brush_i,RpWarning,(int)PrevSegment->brushstopscount,0);
     return OK;
 }
 uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
@@ -1294,7 +1315,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
     REPORT_MSG(Segment->n_brushstops,"IDSPreSegmentState");
     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;
         PreSegmentReady(Module_IDS,ModuleFail);
         return ERROR;
@@ -1318,10 +1339,10 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
                 DispenserPreSegmentControlId = AddControlCallback(NULL,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)
             {
@@ -1352,10 +1373,10 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
         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;
@@ -1386,7 +1407,7 @@ 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;
             PreSegmentReady(Module_IDS,ModuleFail);
         }
@@ -1468,7 +1489,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)
     {
@@ -1513,7 +1534,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,
@@ -1521,8 +1542,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
             {
@@ -1540,10 +1561,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,IdsMessage, __FILE__, __LINE__, FileBrushStop->index, RpWarning,n_dispensers, 0);
+
 }
 uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
 {
@@ -1553,7 +1578,7 @@ 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)
@@ -1565,13 +1590,13 @@ uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue)
 
     if (BrushStopControlId == 0xFF)
     {
-        Report("!!!BrushStopControlId = 0xFF",__FILE__,msec_millisecondCounter,(int)BrushStopStartTime,RpWarning,(int)BrushStopLength,0);
+        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;
@@ -1590,14 +1615,14 @@ 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
         {
             Task_stat(Task_self(),&statbuf);
-            Report("BrushStopRead Error",__FILE__,statbuf.used,(int)statbuf.stackSize,RpWarning,(int)statbuf.stackHeap,0);
+            ReportWithPackageFilter(IDSFilter,"BrushStopRead Error",__FILE__,statbuf.used,(int)statbuf.stackSize,RpWarning,(int)statbuf.stackHeap,0);
             JobEndReason = JOB_OUT_OF_DYE;
             SegmentReady(Module_IDS,ModuleFail);
         }
@@ -1607,10 +1632,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;
     }
@@ -1624,7 +1649,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
@@ -1646,7 +1671,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      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;
@@ -1661,13 +1686,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__,DispenserPreSegmentControlId,(int)InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+        ReportWithPackageFilter(IDSFilter,"IDS presegment not yet ended!!",__FILE__,DispenserPreSegmentControlId,(int)InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
         RemoveControlCallback(DispenserPreSegmentControlId, IDSPreSegmentStateCallbackRunner );
         DispenserPreSegmentControlId = 0xFF;
     }
@@ -1682,10 +1707,10 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
         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
@@ -1761,10 +1786,10 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          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;
@@ -1784,7 +1809,7 @@ 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);
+         ReportWithPackageFilter(IDSFilter,"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);
@@ -1818,7 +1843,7 @@ 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++)
      {
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
index 1edc03264..0f95fb2e2 100644
--- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
@@ -27,5 +27,6 @@ void ResponseDemo(int MidtankId);
 bool IFS_MidTankFilling(void);
 MidTank_t IFS_MidTankIsActive(void);
 bool IFS_CartridgeLowerPresent();
+bool CartridgeValidationResponseFunc(MessageContainer* requestContainer);
 
 #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 853f6913a..8856d873a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -809,21 +809,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
@@ -833,9 +844,16 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
         if (WHS_Type == WHS_TYPE_NEW)
         {
-            Trigger_SetWHSFanSpeed(((request->amount & 0x0000000F)-2) , request->delay & 0x000000FF);
-            Task_sleep(2000);
-            fan_tacho = WHS_Get_fan_tach( (request->amount & 0x0000000F)-2);
+            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;
@@ -880,6 +898,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)
         {
@@ -912,6 +931,7 @@ 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;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
index 1f2da8dc0..13032f49d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
@@ -54,7 +54,7 @@ typedef struct
 
 
 #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];
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index c478b82de..cd7c146fe 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -103,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;
@@ -111,6 +111,7 @@
     float numberOfSteps = 0;
     float numberOfCycles = 0;
     double DrierPrevLocation = 0;
+    int DrierCenterLocation = 0;
     FPGA_GPI_ENUM screw[2] = {GPI_LS_SCREW_RIGHT,GPI_LS_SCREW_LEFT};
     int Screw_Dir = false;
     bool InitCalled = false;
@@ -120,6 +121,9 @@
     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);
     bool ThreadLoaded(void);
@@ -200,6 +204,7 @@
         {
             LOG_ERROR (LoadStages, "Thread_Load_Reduce_Heat failed");
             strcpy(LoadErrorMsg,"Thread_Load_Reduce_Heat failed");
+            load.color = fastBILNK;
             LoadStatus = ERROR;
             TryAgain = true;
             //ThreadLoadButton(LoadStages);
@@ -346,14 +351,6 @@
         //HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2,
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
         //DeActivateHeadMagnet();
-        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);
-            }
-        }
         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);
         int direction;
@@ -366,11 +363,18 @@
             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_actuators",__FILE__,__LINE__,LOW,RpMessage,false,0);
-            Trigger_Head_Actuators_Stub(ACTOT, ENABLE, UP);
-            Trigger_Head_Actuators_Stub(ACTIN, ENABLE, UP);
+            Report("Thread_Load_Lift right actuator",__FILE__,__LINE__,LOW,RpMessage,false,0);
+            Trigger_Head_Actuators_Control(ACTIN, LOW,true);//UP
         }
         return OK;
     }
@@ -391,6 +395,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)
@@ -458,6 +468,11 @@
         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;
     }
@@ -493,6 +508,11 @@
             }*/
 
         }
+        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)
@@ -501,18 +521,6 @@
         //Close Dyeing Head Cover And Dryer Lid
         //HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2,
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
-        if (Head_Type == HEAD_TYPE_FLAT)
-        {
-            Report("Thread_Load_Close_actuators",__FILE__,__LINE__,LOW,RpMessage,true,0);
-            Trigger_Head_Actuators_Stub(ACTOT, ENABLE, DOWN);
-            //Trigger_Head_Actuators_Stub(ACTIN, ENABLE, DOWN);
-            HeadCard_Actuators_Relocate();
-        }
-        if (Head_Type != HEAD_TYPE_ARC)
-        {
-            CallbackCounter++;
-            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);
-        }
         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);
         int direction;
@@ -525,6 +533,15 @@
             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)
@@ -657,7 +674,7 @@
         {
             TryAgain = true;
             SecondTry = false;
-            Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
+            Report("Loading drier - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
             MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,numberOfCycles+CurrentlyLoaded);
             TimeoutsCounter = 0;
             CallbackCounter = 0;
@@ -717,7 +734,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;
@@ -754,6 +771,7 @@
                                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");
@@ -761,6 +779,7 @@
         LoadingControlId = 0xFF;
         ThreadAbortJoggingFunc();
         LoadStages++;
+        ProcessParametersKeep.feedertension = keepfeedertension;
         ThreadLoadStateMachine(LoadStages);
         return OK;
     }
@@ -768,6 +787,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;
@@ -799,6 +820,11 @@
            RemoveControlCallback(SpeedTControlId, ThreadLoadLengthCBFunction );
            SpeedTControlId = 0xFF;
         }
+        if (ThreadLoadControlId != 0xFF)
+        {
+           RemoveControlCallback(ThreadLoadControlId, ThreadUpdateCallBackFunction );
+           ThreadLoadControlId = 0xFF;
+        }
 
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_RLOADING);
@@ -807,7 +833,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);
@@ -836,14 +865,14 @@
         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);
@@ -862,14 +891,14 @@
         }
         else  //timeout or no movement
         {
-            Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
+            Report("Unloading drier - 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 -DrierPrevLocation)<200)
+            if (abs(temp -DrierCenterLocation)<200)
             {
-                if (temp<DrierPrevLocation)
+                if (temp<DrierCenterLocation)
                     direction = 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize;
                 else
                     direction = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize;
@@ -1001,6 +1030,7 @@
             }
         }
         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/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
@@ -1020,10 +1050,12 @@
         return OK;
     }
 
+    double percentage;
     uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM ReadValue)
     {
         REPORT_MSG(ReadValue,"ThreadLoadStateMachine");
         //ThreadLoaded();
+        percentage = ReadValue*7;
         ThreadLoadingReport();
 
         if (LoadStages!=ReadValue)
@@ -1108,6 +1140,7 @@
             break;
         case THREAD_LOAD_END:
             LoadStages = THREAD_LOAD_END;
+            percentage = 100.0;
             Thread_Load_End();
             break;
         default:
@@ -1138,20 +1171,28 @@ uint32_t ThreadLoadButton(THREAD_LOAD_STAGES_ENUM ReadValue)
         {
             LoadStatus = OK;
             SecondTry = true;
-            Report("Calling State machine",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
+            load.color = BLINK;
+            Report("Calling State machine retry",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
             ThreadLoadStateMachine(LoadStages);
         }
         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;
             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);
         ThreadLoadStateMachine(LoadStages);
+        SecondTry = false;
     }
     return OK;
 }
@@ -1460,9 +1501,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;
@@ -1495,11 +1541,19 @@ uint32_t TryThreadLoadingFunc(MessageContainer* requestContainer)
     ThreadLoadButton(LoadStages);
     return OK;
 }
+uint32_t ThreadUpdateCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+{
+
+    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;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 1ce27115d..2b6492dab 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -347,10 +347,15 @@ 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;
+    int i,tempmot;
     //double screw_horizontal_speed = 0;
     //double RotationsPerSecond;
         if (WinderMotorSpeedCounter++>=MAX_WINDER_SPEED_CALCULATION)
@@ -369,6 +374,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;
@@ -707,11 +720,13 @@ void ScrewTimerInterrupt(int ARG0)
         MotorSetDirection (SCREW_3_Motor, ScrewCurrentDirection);
         MotorSetDirection (SCREW_4_Motor, ScrewCurrentDirection);
 #endif
-        MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed);
 #ifdef FOUR_WINDERS
-        MotorSetSpeedDirect (SCREW_2_Motor, ScrewSpeed);
-        MotorSetSpeedDirect (SCREW_3_Motor, ScrewSpeed);
-        MotorSetSpeedDirect (SCREW_4_Motor, ScrewSpeed);
+        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();
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 4339c5312..c3f181b52 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,6 +17,11 @@ 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;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index bbb3e4040..1920db03a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -151,6 +151,39 @@ uint32_t MotorPidRequestMessage(HardwarePidControl* request)
         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";
@@ -159,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)
     {
@@ -208,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 79832120b..275e7e5b7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -46,13 +46,15 @@
 
 double CurrentControlledSpeed[MAX_THREAD_MOTORS_NUM] = {0};
 
-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};
 #ifdef FOUR_WINDERS
-Dancers_4_Winders ThreadMotorIdToDancerId[MAX_THREAD_MOTORS_NUM] = {FEEDER_DANCER,NUM_OF_DANCERS,POOLER_DANCER,WINDER_DANCER,NUM_OF_DANCERS};
+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};
-#endif
 uint32_t    ControlIdtoMotorId [MAX_THREAD_MOTORS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF};
+#endif
 uint32_t    SpeedControlId=0xFF;
 uint32_t    PoolerSpeedControlId=0xFF;
 
@@ -432,7 +434,10 @@ uint32_t ThreadControlSpeedReadFunction(uint32_t IfIndex, uint32_t ReadValue)
 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)
@@ -550,7 +555,6 @@ 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;
@@ -621,6 +625,29 @@ 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))
+        {
+            //pooler dancer is right sided: data is opposite
+            TranslatedReadValue = (-1*TranslatedReadValue);
+        }
+#endif
         if (index == POOLER_MOTOR)
         {
             //pooler dancer is right sided: data is opposite
@@ -650,6 +677,10 @@ 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);
             //EndState(CurrentJob,TMessage );
             SendSegmentFail();
@@ -702,24 +733,26 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             }*`/
         }*/
         calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*OriginalMotorSpd_2PPS[index];
-        if (index != WINDER_MOTOR)
+        if (index < WINDER_MOTOR)
             calculated_speed = calculated_speed*InitialDryerSpeed/OriginalMotorSpd_2PPS[DRYER_MOTOR];
         //calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*CurrentControlledSpeed[index];
-        if (0)//(JobCounter % 1000 == 0)
-        //if (JobCounter < 100)//(FirstCalcInJob == true)
+        //if (0)//(JobCounter % 1000 == 0)
+#ifdef FOUR_WINDERS
+        if (JobCounter % 500 < 4)//(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 %d",
+                len = 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,
                                 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, (int)(InitialDryerSpeed*100/OriginalMotorSpd_2PPS[DRYER_MOTOR]));
-                ReportWithPackageFilter(ThreadFilter,TMessage,__FILE__,MotorSamplePointer[index],JobCounter,RpError,ReadValue,0);
+                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
@@ -735,14 +768,6 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                 }*/
                 CurrentControlledSpeed[index] = calculated_speed;
                 MotorSetSpeed(ThreadMotorIdToMotorId[index], calculated_speed);
-#ifdef FOUR_WINDERS
-                if (index == WINDER_MOTOR)
-                {
-                    MotorSetSpeed(Winder_2_Motor, calculated_speed);
-                    MotorSetSpeed(Winder_3_Motor, calculated_speed);
-                    MotorSetSpeed(Winder_4_Motor, calculated_speed);
-                }
-#endif
             }
             else
             {
@@ -817,6 +842,16 @@ uint32_t HandleJobThreadControlParameters(ThreadParameters* ThreadParams)
     {
         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.Kp = ThreadParams->feederp;
     if(ThreadParams->feederi)
@@ -832,11 +867,32 @@ uint32_t HandleJobThreadControlParameters(ThreadParameters* ThreadParams)
         MotorControlConfig[POOLER_MOTOR].m_params.Kd = ThreadParams->pullerd;
 
     if(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;
@@ -1032,13 +1088,14 @@ uint32_t ThreadPrepareState(void *JobDetails)
     IntersegmentLength = JobTicket->intersegmentlength;
 
     PrepareWaitCount = 0;
+#ifndef FOUR_WINDERS
     status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__LeftDancer, windertension);
     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 Puller",__FILE__,HARDWARE_DANCER_TYPE__MiddleDancer,PrepareWaitCount,RpWarning,(int)pullertension,0);
     status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__RightDancer, feedertension);
     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)
     {
@@ -1098,6 +1155,11 @@ uint32_t ThreadPrepareState(void *JobDetails)
     {
         HW_Motor_Id = ThreadMotorIdToMotorId[Motor_i];
         Pid_Id = Motor_i;/*ThreadMotorIdToControlId[Motor_i];*/
+#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;
@@ -1210,6 +1272,22 @@ uint32_t ThreadPrepareState(void *JobDetails)
                 ControlIdtoMotorId[Motor_i] = AddControlCallback(NULL,ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
 #endif
             }
+#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
     }
 
 #ifdef TEST_PID_THREAD
@@ -1274,7 +1352,7 @@ uint32_t UpdatePidDuringRun(HardwarePidControl *request)
 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)
@@ -1509,7 +1587,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)
          {
@@ -1522,17 +1600,9 @@ 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);
-#ifdef FOUR_WINDERS
-        if (Motor_i == WINDER_MOTOR)
-        {
-            MotorStop(Winder_2_Motor, Hard_Hiz);
-            MotorStop(Winder_3_Motor, Hard_Hiz);
-            MotorStop(Winder_4_Motor, Hard_Hiz);
-        }
-#endif
 
      }
      MotorStop(HARDWARE_MOTOR_TYPE__MOTO_RLOADING,Hard_Hiz);
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
index 0da3530a9..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
-#if 0
-#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
-#endif
-
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index 870463321..e69de29bb 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -1,1455 +0,0 @@
-/*   ----  WHS      */
-#if 0
-#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 <Drivers/I2C_Communication/RFID_NFC/RFIDTagInfo.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>
-#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
-#include <Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.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
-
-float MidTankEmptyLimit = MidTank_Pressure_EMPTY;
-
-/*------------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);
-
-
-
-NFCTag_t 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 = WasteEmpty; // to do
-        break;
-    case waste_cartridge2:
-        WHS_info.cartridge_2.serial_number = temp_funcion;
-        WHS_info.cartridge_2.status = WasteEmpty;
-        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)
-{
-    if ((IFS_Availability[1] == IFS_RECOGNIZED)&&(IFS_Availability[2] == IFS_RECOGNIZED)) //ifs installed -check cartridges
-     {
-        if ((WHS_WasteCartridgeLowerPresent() == false)&&(WHS_WasteCartridgeMiddlePresent() == false))
-            return ERROR;
-     }
-
-    /*
-    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();
-        }
-        switch (WHS_info.active_cartridge)
-           {
-              case waste_cartridge1:
-                  Pannel_Leds( CART_2,  MODE_ON);                //set led color
-                  cart2.color = BLINK;
-                  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_ON);                //set led color
-                  cart3.color = BLINK;
-                  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);
-                  SetWastePump(CLOSE);
-                  //WHS_info.WHS_pump.time = 0;
-                  AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  true);
-                  ret = ERROR;
-                  break;
-              default:
-                  break;
-           }
-        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 1500
-#define WASTE_LEVEL_OVERFLOW 2700
-#define WASTE_LEVEL_FULL 2300
-#define WASTE_LEVEL_EMPTY 900
-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 = SENSORnotFULL;
-    //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 = SENSORFULL;
-    }
-    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(OFF);
-                    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(ON);
-                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 > MidTankEmptyLimit )
-                    {
-                        ReportWithPackageFilter(WasteFilter,"------------ close door  MidTank_Pressure > MidTankEmptyLimit -----------------", __FILE__,__LINE__,(int)(MidTankEmptyLimit*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)(MidTankEmptyLimit*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 );
-                    WHS_Set_IFS_Clearing_Suction(IFS_info.Ink.cart_color);
-                }
-            }
-            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;
-                        WHS_Set_IFS_Clearing_Suction(NUM_OF_MIDTANKS);
-                    }
-                    //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;
-                       */
-                    }
-                    WHS_Set_IFS_Clearing_Suction(NUM_OF_MIDTANKS);
-                    //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();
-
-    if (Is_PP_Machine())
-    {
-        MidTankEmptyLimit = MidTank_PP_Pressure_EMPTY;
-    }
-    else
-    {
-        MidTankEmptyLimit = MidTank_Pressure_EMPTY;
-    }
-
-    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;
-}
-
-#endif
-/*------------------------------------------------------------------------------------------------*/
-
-
-
-
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
index 222b618d2..6de20a567 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
@@ -76,7 +76,7 @@ void cartCART_EXTRACTED(WasteCartridgeEnum CartId) //{called from polling functi
 }
 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);
+    //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))
@@ -520,10 +520,10 @@ uint32_t Waste_Prepare(void)
     else
     {
         Report("cannot start a job with cartridges in the IFS", __FILE__, __LINE__, wasteLevel, RpMessage, wasteLevelOverflow, 0);
-        JobEndReason = JOB_OTHER_ALARM;
+        JobEndReason = JOB_WASTE_HANDLING_PROBLEM;
         AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  true);
         usnprintf(AlarmReasonStr, 100, "cannot start a job with cartridges in the IFS");
         //PrepareReady(Module_Waste,ModuleFail);
-        return JOB_OTHER_ALARM;
+        return JOB_WASTE_HANDLING_PROBLEM;
     }
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
index c8169ebef..3a84a1bbd 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
@@ -148,3 +148,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;
     }
+