merge

30 files changed, 1642 insertions, 902 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index a83d95fa8..22cc33822 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -28,6 +28,7 @@
 #include "drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h"
 #include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
 #include "Common/SWUpdate/FileSystem.h"
+#include "drivers/Flash_ram/MCU_E2Prom.h"
 
 #include "modules/thread/thread_ex.h"
 #include "modules/heaters/heaters_ex.h"
@@ -66,7 +67,6 @@ uint32_t AlarmHandlingControlId = 0xFF;
 uint32_t AlarmHandlingTick = 0;
 
 double     CurrentAlarmHighLimit ,CurrentAlarmLowLimit;
-
 bool    CheckHardLimitAlarms = false,CheckCurrentAlarms = false,CheckTamperAlarms = false,CheckMotorAlarms = false;
 uint8_t alarm_response_buffer[500];
 
@@ -581,14 +581,35 @@ void     AlarmHandlingSetCurrentLimits(double currentalarmhighlimit,double curre
     CurrentAlarmLowLimit = currentalarmlowlimit;
     ReportWithPackageFilter(AlarmFilter,"Alarm Current Limits", __FILE__,__LINE__,(int)(currentalarmhighlimit*100), RpMessage, (int)(currentalarmlowlimit*100), 0);
 }
+uint32_t AlarmhandlingFlags = 0;
+void     AlarmHandlingLoadFlags(void)
+{
+    MCU_E2PromRead(ALARM_SUPPORT_ADDR,&AlarmhandlingFlags);
+
+    CheckHardLimitAlarms = (AlarmhandlingFlags && 0x0001);
+    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);
+}
 
 void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms, bool checkTamperAlarms, bool checkMotorAlarms)
 {
+    uint32_t flags = 0;
     CheckHardLimitAlarms = checkHardLimitAlarms;
     CheckCurrentAlarms = checkCurrentAlarms;
     CheckTamperAlarms = checkTamperAlarms;
     CheckMotorAlarms = checkMotorAlarms;
     ReportWithPackageFilter(AlarmFilter,"Alarm group setting", __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;
+    if (CheckMotorAlarms) flags |= 0x8;
+    if (AlarmhandlingFlags != flags)
+    {
+        MCU_E2PromProgram(ALARM_SUPPORT_ADDR,flags);
+        AlarmhandlingFlags = flags;
+    }
 }
 char AlarmReasonStr[100];
 JobEndReasonEnum getEndReason(uint32_t AlarmId)
@@ -636,7 +657,8 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever
 {
     if (AlarmItem == NULL)
         return ERROR;
-    //DebugLogCategory reprocessedSeverity = Severity;
+
+    DebugLogCategory reprocessedSeverity = Severity;
     //ProcessParameters ProcessParameterZero;
     switch (AlarmItem[AlarmId].AlarmSource)
     {
@@ -691,14 +713,19 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever
                     Valve_Set(IDS_Id_to_AirValve[AlarmItem[AlarmId].DeviceId], AlarmItem[AlarmId].DeviceId );   //AlarmItem[AlarmId].DeviceId/ON
                     Valve_Set(IDS_Id_to_CartrideValve[AlarmItem[AlarmId].DeviceId], AlarmItem[AlarmId].DeviceId );   //Atm_MidTank_OFF/ON
                 }
+                if ((JobIsActive())&&(DispenserUsedInJob[AlarmItem[AlarmId].DeviceId] == false))
+                {
+                    reprocessedSeverity = DEBUG_LOG_CATEGORY__Warning;
+                }
+
             }
 
             break;
         default:
             break;
     }
-    /*switch (reprocessedSeverity)*/
-	switch (Severity)
+    switch (reprocessedSeverity)
+	/*switch (Severity)*/
     {
     case DEBUG_LOG_CATEGORY__Warning:
         //raise flag fr next job
@@ -831,6 +858,13 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     }
     for (Alarm_i = 0;Alarm_i<NumOfSystemAlarms;Alarm_i++)
     {
+        if ((AlarmState[Alarm_i].Status == true)&&(AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical))
+        {
+            status = JOB_SAFETY_CRITICAL_ALARM;
+            ReportWithPackageFilter(AlarmFilter,"critical alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+            AlarmId = Alarm_i;
+            break;
+        }
 
         if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__CoversAlarm)
         {
@@ -876,12 +910,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     {
         if (HeaterCheckReady()==false)
         {
-#warning fit to new head with new alarms
-#ifdef Use_Head_Card
             for (Heater_i=HEATER_TYPE__DryerAirHeater;Heater_i<HEATER_TYPE_MAX_HEATERS;Heater_i++)
-#else
-            for (Heater_i=HEATER_TYPE__DryerAirHeater;Heater_i<MAX_HEATERS_NUM;Heater_i++)
-#endif
             {
                 LoadHeaterState((HeaterType)Heater_i,&HeaterState);
                 if (HeaterState.setpoint)//temperature is set - heater active
@@ -928,10 +957,12 @@ uint32_t AlarmHandling_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
 {
     AlarmHandlingMessageStruc Message;
 
+    if (AlarmHandlingActive == false)
+        return OK;
     //send message to the Millisec task
     Message.messageId = AlarmHandlingTrigger;
     Message.msglen = sizeof(AlarmHandlingMessageStruc);
-    AlarmHandlingTick +=10;
+    AlarmHandlingTick +=100;
     Message.tick = AlarmHandlingTick;
     if (AlarmHandlingMsgQ != NULL)
         Mailbox_post(AlarmHandlingMsgQ , &Message, BIOS_NO_WAIT);
@@ -957,7 +988,7 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value)
 {
     int Alarm_i;
     if (AlarmItem == NULL)
-        return ERROR;
+        return;
     for (Alarm_i = 0;Alarm_i < NumOfSystemAlarms;Alarm_i++)
     {
         if (AlarmItem[Alarm_i].EventType == AlarmId)
@@ -1011,7 +1042,7 @@ uint32_t AlarmHandlingStart(void)
     if ( AlarmHandlingActive == false)
     {
             AlarmHandlingActive = true;
-            AlarmHandlingControlId = AddControlCallback("Alarm Handling",AlarmHandling_ControlTrigger,eTenMillisecond,TemplateDataReadCBFunction,0,0,0);
+            //AlarmHandlingControlId = AddControlCallback("Alarm Handling",AlarmHandling_ControlTrigger,eHundredMillisecond,TemplateDataReadCBFunction,0,0,0);
     }
     return OK;
 }
@@ -1148,24 +1179,31 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                  {
                     if (AlarmItem[Alarm_i].ModuleDeviceId == 0xFF)
                     {
-                        if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
+                        if (LoadHeaterSetPoint(HEATER_TYPE__DryerAirHeater) <= 2)
                         {
-                            if (AlarmItem[Alarm_i].AlarmDirection == true)
+                            Status = false;
+                        }
+                        else
+                        {
+                            if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
                             {
-                                if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                                if (AlarmItem[Alarm_i].AlarmDirection == true)
                                 {
-                                    Status = true;
-                                    if (AlarmState[Alarm_i].Status == false)
-                                        ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                    if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                                    {
+                                        Status = true;
+                                        if (AlarmState[Alarm_i].Status == false)
+                                            ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                    }
                                 }
-                            }
-                            else
-                            {
-                                if (doubleValue <= 0.1)
+                                else
                                 {
-                                    Status = true;
-                                    if (AlarmState[Alarm_i].Status == false)
-                                        ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                    if (doubleValue <= 0.1)
+                                    {
+                                        Status = true;
+                                        if (AlarmState[Alarm_i].Status == false)
+                                            ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                    }
                                 }
                             }
                         }
@@ -1263,7 +1301,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
 
             case ALARM_SOURCE_TYPE__TachoAlarm: // add by shai
                 Status = false;
-                if (CheckCurrentAlarms)
+                if (CheckTamperAlarms)
                 {
 
 //                ReportWithPackageFilter(AlarmFilter,"------------FANS_RPM[Alarm_i]----------------", __FILE__,__LINE__,Alarm_i, RpMessage, value, 0);
@@ -1470,7 +1508,9 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
         ReportWithPackageFilter(AlarmFilter,"Error in alarms data!!!!!!!!! ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpFatalError, 0, Alarm_i);
 
     if ((tick%eOneSecond == 0)&&(EventsNotificationRequestAccepted==true))
+    {
         SendEventNotifications();
+    }
     return OK;
 }
 /******************************************************************************
@@ -1526,7 +1566,7 @@ void SendEventNotifications(void)
     }
 
     EventsResponse.n_events = 0;
-    UInt Key = Task_disable();
+    //UInt Key = Task_disable();
     for (i = 0;i<NumOfSystemAlarms;i++)
     {
         if (AlarmState[i].Status == true)
@@ -1554,14 +1594,24 @@ void SendEventNotifications(void)
                     {
                         EventsResponse.events[e]=AlarmState[i].EventPtr;
                         e++;
+                        if (e >  EventsResponse.n_events)
+                        {
+                            ReportWithPackageFilter(AlarmFilter,"Error in alarm numbers - large ", __FILE__,__LINE__,EventsResponse.n_events, RpFatalError, e, 0);
+                            break;
+                        }
                     }
                 }
             }
+            if (e!=EventsResponse.n_events)
+            {
+                ReportWithPackageFilter(AlarmFilter,"Error in alarm numbers - small ", __FILE__,__LINE__,EventsResponse.n_events, RpFatalError, e, 0);
+                EventsResponse.n_events = e;
+            }
         }
         else
         {
             LOG_ERROR(EventsResponse.n_events,"events malloc error");
-            Task_restore(Key);
+            //Task_restore(Key);
             return;
         }
     }
@@ -1569,8 +1619,9 @@ void SendEventNotifications(void)
     {
         EventsResponse.events = NULL;
     }
-    Task_restore(Key);
+    //Task_restore(Key);
     responseContainer = createAllocatedContainer(MESSAGE_TYPE__StartEventsNotificationResponse,  AlarmHandlingToken, false, &EventsResponse, &start_events_notification_response__pack, &start_events_notification_response__get_packed_size,&alarm_response_buffer);
+    responseContainer.has_continuous = true;
     responseContainer.continuous = true;
 
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
@@ -1629,11 +1680,22 @@ uint32_t StartEventsNotificationRequestFunc(MessageContainer* requestContainer)
 //    ReportInitParams InitParams;
     //ControlStart();
     EventsNotificationRequestAccepted = true;
-    //AlarmHandlingStart();
+    AlarmHandlingStart();
+    MessageContainer responseContainer;
+
+    StartEventsNotificationResponse response = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
 
     StartEventsNotificationRequest* request = start_events_notification_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
     ustrncpy (AlarmHandlingToken, requestContainer->token,36);
     start_events_notification_request__free_unpacked(request,NULL);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StartEventsNotificationResponse,  AlarmHandlingToken, false, &response, &start_events_notification_response__pack, &start_events_notification_response__get_packed_size);
+    responseContainer.has_continuous = true;
+    responseContainer.continuous = true;
+    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    my_free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
     return status;
 }
 uint32_t StopEventsNotificationRequestFunc(MessageContainer* requestContainer)
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
index be7687f28..29be2bd23 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
@@ -13,6 +13,8 @@
 uint32_t AlarmHandlingFlashLoad(void);
 uint32_t AlarmHandlingLoadFile(void);
 
+void AlarmHandlingInit(void);
+
 
 uint32_t AlarmHandling_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 //uint32_t AlarmHandling_CalculateTemperatures(uint32_t SensorId, uint32_t Data);
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 6d92e06c9..fe350d78d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -56,10 +56,9 @@
 #include "Modules/General/buttons.h"
 #include "Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h"
 
-#ifdef Use_WHS_Card
 #include <Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.h>
 #include <Drivers/I2C_Communication/I2C_Task.h>
-#endif
+#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
 Task_Handle Millisecond_Task_Handle;
 /******************** Definitions  ********************************************/
 
@@ -229,11 +228,6 @@ void OneMilliSecondMillisecInterrupt(UArg arg0)
     return ;
 }
 uint32_t PT100Activity = 0;
-int32_t MillisecReadFromI2CTempSensor(uint32_t TempSensorId,  MSecFptr Callback)
-{
-#warning call I2C temeratures
-    return OK;
-}
 
 int32_t MillisecReadFromTempSensor(uint32_t TempSensorId,  MSecFptr Callback)
 {
@@ -575,6 +569,7 @@ void setRapidPressureRead(bool value)
 }
 
 uint16_t PumpCounter = 0;
+uint16_t realtimetest[101];
 uint32_t MillisecLowLoop(uint32_t tick)
 {
     uint8_t Motor_i,Disp_i,temp;
@@ -585,7 +580,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     //test dancers and speed encoders
     //check all callback units (state machine waiting for completion of a change)
     bool Ten_msTick, Fifty_msTick, Hundred_msTick , m20msecTick,m70msecTick,m90msecTick, Onesecond_Tick,OneMinute_Tick,OneHourTick,Gradient_Tick;
-    bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick;
+    bool O700Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick;
     //bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick,O800Millisecond_Tick,O900Millisecond_Tick;
     Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
     Fifty_msTick      =   (tick%eHundredMillisecond == 40)      ?true:false; //eFiftyMillisecond
@@ -593,7 +588,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     m20msecTick  =   (tick%eHundredMillisecond == 20)  ?true:false;
     m70msecTick  =   (tick%eHundredMillisecond == 70)  ?true:false;
     m90msecTick  =   (tick%eHundredMillisecond == 90)  ?true:false;
-    O100Millisecond_Tick  =   (tick%eOneSecond == 100)           ?true:false;
+    O700Millisecond_Tick  =   (tick%eOneSecond == 700)           ?true:false;
     O200Millisecond_Tick  =   (tick%eOneSecond == 200)           ?true:false;
     O400Millisecond_Tick  =   (tick%eOneSecond == 400)           ?true:false;
     O500Millisecond_Tick  =   (tick%eOneSecond == 500)           ?true:false;
@@ -604,14 +599,16 @@ uint32_t MillisecLowLoop(uint32_t tick)
     Onesecond_Tick  =   (tick%eOneSecond == 0)           ?true:false;
     OneMinute_Tick  =   (tick%eOneMinute == 0)           ?true:false;
     OneHourTick  =   (tick%eOneHour == 0)           ?true:false;
+    realtimetest[(tick%1000)/10]++;
     //gather Motor data from FPGA
     //ROM_IntMasterDisable();
-
+    int StartPT100 = 0;
     //Screw_ENC_Velocity_to_DAC(); - for testing the screw enc
-
+    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+        StartPT100 = TEMP_SENSE_ANALOG_DRYER_TEMP1;
     if (Ten_msTick)
     {
-        //Speed_Data = Calculate_Speed_Sensor_Velocity();
+        Speed_Data = Read_Speed_Sensor_TypeII();
         //MillisecReadFromTempSensor(Sensor_Read, NULL);
         //if (Sensor_Read++ >= MAX_MAIN_CARD_TEMPERATURE_SENSOR_ID) Sensor_Read = 0;
         if(Machine_Idle_Mode == true)
@@ -619,39 +616,18 @@ uint32_t MillisecLowLoop(uint32_t tick)
         Trigger_HeaterWriting();
 
     }
-#ifdef Use_Head_Card
     if(Fifty_msTick)
     {
         Trigger_PT100_Read();//call every 50mSec (minimum delay 30mSec)
         //Set_HeadCard_PT100();//call every 50mSec (minimum delay 30mSec)
     }
-#endif
-/*#ifdef Use_Head_Card
-    if (m20msecTick) //read odd PT1000
-    {
-        for (Sensor_i = HEAD_PT100_ZONE_1_0X80_0;Sensor_i < HEAD_PT100_ZONE_2_0X80_1;Sensor_i++)
-        {
-            //MillisecReadFromI2CTempSensor(Sensor_i, NULL);
-        }
-        //Set_HeadCard_PT100();
-#warning call chip select replace in I2C
-    }
-    if (m70msecTick) //read odd PT1000
+    if(m70msecTick)
     {
-        for (Sensor_i = HEAD_PT100_ZONE_2_0X80_1;Sensor_i < HEAD_PT100_RESERVE_0X8E_1;Sensor_i++)
-        {
-            //MillisecReadFromI2CTempSensor(Sensor_i, NULL);
-        }
-        //Set_HeadCard_PT100();
+        AlarmHandling_ControlTrigger(0,0);
     }
-#endif */
     if (m90msecTick)
     {
-#ifdef Use_Head_Card
-        for (Sensor_i = TEMP_SENSE_ANALOG_DRYER_TEMP1;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
-#else
-        for (Sensor_i = 0;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
-#endif
+        for (Sensor_i = StartPT100;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
         {
             MillisecReadFromTempSensor(Sensor_i, NULL);
         }
@@ -664,11 +640,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
         ///////////////////////////////////////////////////////////////////
 
 
-#ifdef Use_Head_Card
-        for (Sensor_i = TEMP_SENSE_ANALOG_DRYER_TEMP1;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
-#else
-        for (Sensor_i = 0;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
-#endif
+        for (Sensor_i = StartPT100;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
         {
             MillisecUpdateTemperatures (Sensor_i,TemperatureSensorRead(Sensor_i));
         }
@@ -689,14 +661,11 @@ uint32_t MillisecLowLoop(uint32_t tick)
             ADC_TriggerCollection();
         }
 
-#ifdef Use_Head_Card
-    //Head_Read_IO_Reg(0x46, HIGH);//READ HEAD CARD LS
-#endif
-
+        Trigger_InputsReading();
     }
     if (Gradient_Tick)
         DispensersCollectionCall();
-    if (O100Millisecond_Tick)
+    if (O700Millisecond_Tick)
     {
         Trigger_Heater_Current_Read();
     }
@@ -736,15 +705,11 @@ uint32_t MillisecLowLoop(uint32_t tick)
         char Lenstr[160];
         static int Counter = 0;
         MachineUpdateResponseFunc();
-        KeepAliveOneSecondCall();
-#ifdef Use_Head_Card
-        TemperatureListString(Lenstr);
-        ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)Counter++,RpWarning,(int) msec_millisecondCounter,0);
-//#ifdef Use_Head_Card
-        for (Sensor_i = TEMP_SENSE_ANALOG_DRYER_TEMP1;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
-#else
-        for (Sensor_i = 0;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
-#endif
+        //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++)
         {
             TemperatureCalc[Sensor_i] =  MillisecCalculateTemperatures ( Sensor_i);
         }
@@ -755,11 +720,12 @@ uint32_t MillisecLowLoop(uint32_t tick)
                 PressureCalc[Disp_i] = MillisecCalculatePressures(Disp_i);
             }
         }
-#ifdef Use_WHS_Card
-    Trigger_WHS_PT100_Read_All();
-    Trigger_WHS_MAX11614_Read_allADC();
-#endif
-
+        Trigger_WHS_PT100_Read_All();
+        Trigger_WHS_MAX11614_Read_allADC();
+        WHS_Blower_Avarege_ORF1(); //drier
+        WHS_Blower_Avarege_ORF3(); //head
+        Trigger_WHSReadAllFanTacho ();
+        WHS_Start_Blower_Control_Closed_Loop ();
     }
     if (OneMinute_Tick)
     {
@@ -778,8 +744,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
         }*/
         midtankDisplay = 1-midtankDisplay;
         Gas_PPM_Info = Calculate_Gas_Power_Consumption();
-        Trigger_WHS_MAX11614_Read_allADC();
-
+        //Trigger_WHS_MAX11614_Read_allADC();
+#ifdef CONTROL_DEBUG
+        ResetControlTime();
+#endif
     }
     if (OneHourTick)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index e093815a9..bea68e314 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -66,8 +66,9 @@
 
 
 
+#define DURATION_LIMIT 6
 /******************** Definitions  ********************************************/
-#define MAX_TANGO_CONTROL_DEVICES 120
+#define MAX_TANGO_CONTROL_DEVICES 100
 /******************** STRUCTURES AND ENUMs  ********************************************/
 
 
@@ -108,6 +109,7 @@ ControlDeviceStruc      ControlArray[MAX_TANGO_CONTROL_DEVICES];
 uint32_t                ControlDatalog[MAX_TANGO_CONTROL_DEVICES];
 #define MAX_BACKLOG_SIZE 100
 uint16_t ControlBacklog[MAX_BACKLOG_SIZE]={0};
+uint32_t ControlTime[MAX_TANGO_CONTROL_DEVICES]={0};
 uint16_t backlogindex = 0;
 uint32_t        Control_timerBase = TIMER0_BASE;        //Timer handle
 uint32_t MaxHighDevices = 0xFF;
@@ -382,6 +384,7 @@ uint32_t  AddControlCallback(char* Name, ControlCBFunction Callback, uint32_t Ct
     if (deviceId == 0xFF)
     {
         LOG_ERROR(deviceId, "Add Callback failed");
+        AlarmHandlingSetAlarm(EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED,true);
         return 0xFF;
     }
     key = GateMutex_enter(gateControlDB);
@@ -556,22 +559,44 @@ uint32_t ControlLoop(uint32_t tick)
 
     return OK;
 }
+uint32_t prevtick = 0;
+#ifdef CONTROL_DEBUG
+void ResetControlTime(void)
+{
+    memset(ControlTime,0,sizeof(ControlTime));
+}
+#endif
 uint32_t ControlLowLoop(uint32_t tick)
 {
+    uint32_t skipped_ticks = 0;
+#ifdef CONTROL_DEBUG
+    uint32_t tempp,tempq,delta;
+    uint32_t sys_ticks_start = msec_millisecondCounter,sys_ticks_end,max = 0,dev = 0;
+#endif
+    if (tick-prevtick>1)
+    {
+        skipped_ticks = tick-prevtick-1;
+        //if (tick-prevtick>10)
+         //   Report("ControlLowLoop skipped",__FILE__,tick,(int)prevtick,RpWarning,(int)skipped_ticks,0);
+    }
+    prevtick = tick;
+
     for (ControlLowDevice_i = 0; ControlLowDevice_i < MAX_TANGO_CONTROL_DEVICES;ControlLowDevice_i++)
     {
         if (ControlArray[ControlLowDevice_i].ControlActive)
         {
-            if (tick == ControlArray[ControlLowDevice_i].StartTick)
+            if (tick - ControlArray[ControlLowDevice_i].StartTick<=skipped_ticks)
                 continue;
             if (ControlArray[ControlLowDevice_i].ControlTiming == eOneMillisecond)
                 continue;
-            if (((tick - ControlArray[ControlLowDevice_i].StartTick)%ControlArray[ControlLowDevice_i].ControlTiming)==0) // run the control on exact intervals
+            if (((tick - ControlArray[ControlLowDevice_i].StartTick)%ControlArray[ControlLowDevice_i].ControlTiming)<=skipped_ticks) // run the control on exact intervals
             {
                 ControlBacklog[backlogindex]=ControlLowDevice_i;
                 if ( ++backlogindex >= MAX_BACKLOG_SIZE)
                     backlogindex = 0;
-
+#ifdef CONTROL_DEBUG
+                tempp = HibernateRTCSSGet();
+#endif
                 if(ControlArray[ControlLowDevice_i].ControlDataReadPtr)
                     ControlDatalog[ControlLowDevice_i] = ControlArray[ControlLowDevice_i].ControlDataReadPtr( ControlArray[ControlLowDevice_i].Parameter1);
                 else
@@ -580,9 +605,38 @@ uint32_t ControlLowLoop(uint32_t tick)
                     ControlArray[ControlLowDevice_i].ControlCallbackPtr(ControlArray[ControlLowDevice_i].IfIndex, ControlDatalog[ControlLowDevice_i]);
                 else
                     LOG_ERROR (ControlLowDevice_i, "Invalid callback ptr");
+#ifdef CONTROL_DEBUG
+                tempq = HibernateRTCSSGet();
+                if (tempq < tempp)
+                {
+                  delta = (32768 - tempp) + tempq + 1;
+                }
+                else
+                  delta = tempq - tempp;
+                if (ControlTime[ControlLowDevice_i]<delta)
+                {
+                    ControlTime[ControlLowDevice_i] = delta;
+                }
+#endif
             }
         } //if control active
     }  //for
+#ifdef CONTROL_DEBUG
+    sys_ticks_end= msec_millisecondCounter;
+    if (sys_ticks_end-sys_ticks_start > DURATION_LIMIT)
+    {
+        Report("ControlLowLoop long",__FILE__,sys_ticks_end-sys_ticks_start,(int)sys_ticks_end,RpWarning,(int)sys_ticks_start,0);
+        for (ControlLowDevice_i = 0; ControlLowDevice_i < MAX_TANGO_CONTROL_DEVICES;ControlLowDevice_i++)
+        {
+            if (ControlTime[ControlLowDevice_i]>max)
+            {
+                max = ControlTime[ControlLowDevice_i];
+                dev = ControlLowDevice_i;
+            }
+        }
+        //Report(ControlArray[dev].Name,__FILE__,__LINE__,dev,RpWarning,max,0);
+    }
+#endif
     //ROM_IntMasterEnable();
 
     return OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index ef4feda09..41f6b2334 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -31,8 +31,8 @@
 #include "drivers/Valves/Valve.h"
 #include "drivers/Heater/Heater.h"
 #include "modules/waste/waste.h"
-#include <Drivers/I2C_Communication/I2C_Task.h>
-
+#include "Drivers/I2C_Communication/I2C_Task.h"
+#include "Drivers/I2C_Communication/I2C.h"
 #include "modules/ids/ids_ex.h"
 
 /********************************************************************************
@@ -58,13 +58,12 @@ uint32_t SetComponentValueRequestRequestFunc(MessageContainer* requestContainer)
     {
         case VALUE_COMPONENT__BlowerVoltage:
               blowervolatgedisplay = true;
-              voltage = request->value;
-              if (voltage == 0.0)
+              intvoltage = (int)request->value;
+              if (intvoltage < 10.0)
                   Turn_the_Blower_Off();
               else
               {
                   Turn_the_Blower_On();
-                  intvoltage = voltage;
                   Control_Voltage_To_Blower(intvoltage);
               }
             break;
@@ -208,11 +207,10 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
                 Control_Dryer_Fan(STOP,0);//use START or STOP,  0 - 100%();
             break;
         case INTERFACE_IOS__GPO_WASTECH_PUMP2://valve
-#ifdef Use_WHS_Card
-    Trigger_SetWHSValveWatseCartridge(request->value);
-#else
-        Valve_Set(VALVE_WASTE_TANK, request->value);
-#endif               // Valve_Set(VALVE_WASTE_TANK, request->value);
+            if (WHS_Type == WHS_TYPE_UNKNOWN)
+                Valve_Set(VALVE_WASTE_TANK, request->value);
+            else
+                Trigger_SetWHSValveWatseCartridge(request->value);
             break;
         case INTERFACE_IOS__GPO_WHS_WTANKPUMP2:
             SetWastePump( request->value);
@@ -227,10 +225,10 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
                 Pumps_Control(WASTECH_PUMP2, request->value);
             break;
         case INTERFACE_IOS__GPO_LED3:
-            HeadCard_Actuators_Control(ACTIN, LOW,request->value);
+            Trigger_Head_Actuators_Control(ACTIN, LOW,request->value);
             break;
         case INTERFACE_IOS__GPO_LED4:
-            HeadCard_Actuators_Control(ACTOT, LOW,request->value);
+            Trigger_Head_Actuators_Control(ACTOT, LOW,request->value);
             break;
         case INTERFACE_IOS__GPO_BUZZER:
             if (request->value == true)
@@ -370,24 +368,27 @@ uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer)
                 Turn_the_Blower_Off();
             break;
         case HARDWARE_BLOWER_TYPE__HeadBlower1:
-#ifdef Use_Head_Card
-            if ((request->has_voltage)&&(request->isactive == true))
-                status = Head_Fan_PWM_Control(0,request->voltage);
-            else if (request->isactive == false)
-                status = Head_Fan_PWM_Control(0,0);
-#else
-            status = NOT_SUPPORTED;
-#endif
+            if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+            {
+                if ((request->has_voltage)&&(request->isactive == true))
+                    status = Head_Fan_PWM_Control(0,request->voltage);
+                else if (request->isactive == false)
+                    status = Head_Fan_PWM_Control(0,0);
+            }
+            else
+                status = NOT_SUPPORTED;
+
             break;
         case HARDWARE_BLOWER_TYPE__HeadBlower2:
-#ifdef Use_Head_Card
-            if ((request->has_voltage)&&(request->isactive == true))
-                status = Head_Fan_PWM_Control(1,request->voltage);
-            else if (request->isactive == false)
-                status = Head_Fan_PWM_Control(1,0);
-#else
-            status = NOT_SUPPORTED;
-#endif
+            if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+            {
+                if ((request->has_voltage)&&(request->isactive == true))
+                    status = Head_Fan_PWM_Control(1,request->voltage);
+                else if (request->isactive == false)
+                    status = Head_Fan_PWM_Control(1,0);
+            }
+            else
+                status = NOT_SUPPORTED;
             break;
         default:
             status = NOT_SUPPORTED;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 71ed7a97b..0764b2028 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -21,6 +21,7 @@
 #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/valves/valve.h"
 
@@ -112,7 +113,9 @@ double midtankinklevel[MAX_SYSTEM_DISPENSERS][1];
 double MidTankpressure[MAX_SYSTEM_DISPENSERS][1];
 double HeadFlowMeter;
 double DrierFlowMeter;
+double AcVoltage;
 double HeatersCurrent[NUM_OF_CURRENT_HEATERS][1];
+double HeadCurrent[MAX_FLAT_HEAD_HEATERS][1];
 double VOC_Sensor;
 double OverallTemperature;
 
@@ -311,11 +314,14 @@ uint32_t DiagnosticsLoadDigitalValues(void)
     DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_SPARE_SSR13_CTRL;
     DigitalOutputState[index++].value = ReadHeadMagnetBit();
 
-    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_LED3;
-    DigitalOutputState[index++].value = HeadCard_Actuators_Status(ACTIN);
+    /*if (Head_Type == HEAD_TYPE_SYLKO) //rapid/pp machines
+    {
+        DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_LED3;
+        DigitalOutputState[index++].value = HeadCard_Actuators_Status(ACTIN);
 
-    DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_LED4;
-    DigitalOutputState[index++].value = HeadCard_Actuators_Status(ACTOT);
+        DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPO_LED4;
+        DigitalOutputState[index++].value = HeadCard_Actuators_Status(ACTOT);
+    }*/
 
     DigitalOutputState[index].interfaceio = INTERFACE_IOS__GPI_WCONTAINER_FULL;
     DigitalOutputState[index++].value = WHS_IsContainerFull();
@@ -404,11 +410,12 @@ void DiagnosticTenMsecCollection(void)
     DiagnosticLoadDancerError(POOLER_DANCER,ThreadGetMotorCalculatedError(POOLER_DANCER));
     DiagnosticLoadDancerError(FEEDER_DANCER,ThreadGetMotorCalculatedError(FEEDER_DANCER));
 
-    //DiagnosticLoadSpeedSensor(getSensorSpeedData());
+    DiagnosticLoadSpeedSensor(getSensorSpeedData());
 }
 void DiagnosticOneMinuteCollection(void)
 {
     int i;
+    bool status = OK;
 
     DiagnosticsMonitor.n_dispensersinklevel = 0;
     DiagnosticsMonitor.n_midtanksinklevel = 0;
@@ -439,6 +446,7 @@ void DiagnosticOneMinuteCollection(void)
     }
     DiagnosticsMonitor.n_overalltemperature = 1;
     OverallTemperature = max(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1),MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2));
+    OverallTemperature = ((int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP1)/100)*1000 + (int)(MillisecGetTemperatures(TEMP_SENSE_AN_ENCLOSURETEMP2)/100));
     DiagnosticsMonitor.overalltemperature = &OverallTemperature;
 
     DiagnosticsMonitor.n_midtank1level = 1;
@@ -457,48 +465,205 @@ void DiagnosticOneMinuteCollection(void)
     DiagnosticsMonitor.midtank7level = MidTankpressure[6];
     DiagnosticsMonitor.n_midtank8level = 1;
     DiagnosticsMonitor.midtank8level = MidTankpressure[7];
-
-    for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
+    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD) //rapid/pp machines
     {
-        if (Read_Head_MixChip_Heaters_Current(i) == true)
+        /*DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
+        DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
+        DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
+        DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];*/
+        Get_Head_Current(HEAD_CURRENT_MIXER,&HeadCurrent[HEAD_CURRENT_ZONE_12+1][0]);
+        DiagnosticsMonitor.n_mixer1heatercurrent = 1;
+        DiagnosticsMonitor.mixer1heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_12+1];
+        if (Head_Type == HEAD_TYPE_SYLKO)
         {
-            HeatersCurrent[i][0] = Get_Heaters_Current(i);
-            switch(i)
+            for (i=0;i<HEAD_CURRENT_ZONE_12;i++)
             {
-            case HEATER_DRYER_CURRENT_1:
-                DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
-                DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
-                break;
-            case HEATER_DRYER_CURRENT_2:
-                DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
-                DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];
-                break;
-            case HEATER_MIXCHIP_CURRENT:
-                DiagnosticsMonitor.n_mixer1heatercurrent = 1;
-                DiagnosticsMonitor.mixer1heatercurrent = HeatersCurrent[HEATER_MIXCHIP_CURRENT];
-                break;
-            case HEATER_HEAD_CURRENT_ZONE_1:
+                if (Get_Head_Heater_Current_Reading_State(i) == true)
+                {
+                    status = Get_Head_Current(i,&HeadCurrent[i][0]);
+                    switch(i)
+                    {
+                    case HEAD_CURRENT_ZONE_1:
+                        DiagnosticsMonitor.n_headzone1heatercurrent = 1;
+                        DiagnosticsMonitor.headzone1heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_1];
+                        break;
+                    case HEAD_CURRENT_ZONE_2:
+                        DiagnosticsMonitor.n_headzone2heatercurrent = 1;
+                        DiagnosticsMonitor.headzone2heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_2];
+                        break;
+                    case HEAD_CURRENT_ZONE_3:
+                        DiagnosticsMonitor.n_headzone3heatercurrent = 1;
+                        DiagnosticsMonitor.headzone3heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_3];
+                        break;
+                    case HEAD_CURRENT_ZONE_4:
+                        DiagnosticsMonitor.n_headzone4heatercurrent = 1;
+                        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];
+                        break;
+/*                    case HEAD_CURRENT_ZONE_6:
+                        DiagnosticsMonitor.n_headzone6heatercurrent = 1;
+                        DiagnosticsMonitor.headzone6heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_6];
+                        break;*/
+                    case HEAD_CURRENT_ZONE_7:
+                        DiagnosticsMonitor.n_headzone7heatercurrent = 1;
+                        DiagnosticsMonitor.headzone7heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_7];
+                        break;
+                    case HEAD_CURRENT_ZONE_8:
+                        DiagnosticsMonitor.n_headzone8heatercurrent = 1;
+                        DiagnosticsMonitor.headzone8heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_8];
+                        break;
+                    case HEAD_CURRENT_ZONE_9:
+                        DiagnosticsMonitor.n_headzone9heatercurrent = 1;
+                        DiagnosticsMonitor.headzone9heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_9];
+                        break;
+                    case HEAD_CURRENT_ZONE_10:
+                        DiagnosticsMonitor.n_headzone10heatercurrent = 1;
+                        DiagnosticsMonitor.headzone10heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_10];
+                        break;
+                    case HEAD_CURRENT_ZONE_11:
+                        DiagnosticsMonitor.n_headzone11heatercurrent = 1;
+                        DiagnosticsMonitor.headzone11heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_11];
+                        break;
+                    case HEAD_CURRENT_ZONE_12:
+                        DiagnosticsMonitor.n_headzone12heatercurrent = 1;
+                        DiagnosticsMonitor.headzone12heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_12];
+                        break;
+                    default:
+                        break;
+                    }
+                }
+            }
+        }
+        else //arc head
+        {
+            i = 0;
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_ZONE_1) == true)
+            {
+                Get_Head_Current(HEAD_CURRENT_ZONE_1,&HeadCurrent[i][0]);
                 DiagnosticsMonitor.n_headzone1heatercurrent = 1;
-                DiagnosticsMonitor.headzone1heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_1];
-                break;
-            case HEATER_HEAD_CURRENT_ZONE_2:
+                DiagnosticsMonitor.headzone1heatercurrent = HeadCurrent[i];
+                i++;
+            }
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_ZONE_2) == true)
+            {
+                Get_Head_Current(HEAD_CURRENT_ZONE_2,&HeadCurrent[i][0]);
                 DiagnosticsMonitor.n_headzone2heatercurrent = 1;
-                DiagnosticsMonitor.headzone2heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_2];
-                break;
-            case HEATER_HEAD_CURRENT_ZONE_3:
+                DiagnosticsMonitor.headzone2heatercurrent = HeadCurrent[i];
+                i++;
+            }
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_ZONE_3) == true)
+            {
+                Get_Head_Current(HEAD_CURRENT_ZONE_3,&HeadCurrent[i][0]);
                 DiagnosticsMonitor.n_headzone3heatercurrent = 1;
-                DiagnosticsMonitor.headzone3heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_3];
-                break;
-            case HEATER_HEAD_CURRENT_ZONE_4:
+                DiagnosticsMonitor.headzone3heatercurrent = HeadCurrent[i];
+                i++;
+            }
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTIN_1) == true)
+            {
+                Get_Head_Current(HEAD_CURRENT_HTIN_1,&HeadCurrent[i][0]);
                 DiagnosticsMonitor.n_headzone4heatercurrent = 1;
-                DiagnosticsMonitor.headzone4heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_4];
-                break;
-            case HEATER_HEAD_CURRENT_ZONE_5_6:
+                DiagnosticsMonitor.headzone4heatercurrent = HeadCurrent[i];
+                i++;
+            }
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTOT_1) == true)
+            {
+                Get_Head_Current(HEAD_CURRENT_HTOT_1,&HeadCurrent[i][0]);
                 DiagnosticsMonitor.n_headzone5_6heatercurrent = 1;
-                DiagnosticsMonitor.headzone5_6heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6];
-                break;
-            default:
-                break;
+                DiagnosticsMonitor.headzone5_6heatercurrent = HeadCurrent[i];
+                i++;
+            }
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTIN_1) == true)
+            {
+                Get_Head_Current(HEAD_CURRENT_HTIN_2,&HeadCurrent[i][0]);
+                DiagnosticsMonitor.n_headzone7heatercurrent = 1;
+                DiagnosticsMonitor.headzone7heatercurrent = HeadCurrent[i];
+                i++;
+            }
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTIN_1) == true)
+            {
+                Get_Head_Current(HEAD_CURRENT_HTIN_3,&HeadCurrent[i][0]);
+                DiagnosticsMonitor.n_headzone8heatercurrent = 1;
+                DiagnosticsMonitor.headzone8heatercurrent = HeadCurrent[i];
+                i++;
+            }
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTIN_1) == true)
+            {
+                Get_Head_Current(HEAD_CURRENT_HTIN_4,&HeadCurrent[i][0]);
+                DiagnosticsMonitor.n_headzone9heatercurrent = 1;
+                DiagnosticsMonitor.headzone9heatercurrent = HeadCurrent[i];
+                i++;
+            }
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTOT_2) == true)
+            {
+                Get_Head_Current(HEAD_CURRENT_HTOT_2,&HeadCurrent[i][0]);
+                DiagnosticsMonitor.n_headzone10heatercurrent = 1;
+                DiagnosticsMonitor.headzone10heatercurrent = HeadCurrent[i];
+                i++;
+            }
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTOT_3) == true)
+            {
+                Get_Head_Current(HEAD_CURRENT_HTOT_3,&HeadCurrent[i][0]);
+                DiagnosticsMonitor.n_headzone11heatercurrent = 1;
+                DiagnosticsMonitor.headzone11heatercurrent = HeadCurrent[i];
+                i++;
+            }
+            if (Get_Head_Heater_Current_Reading_State(HEAD_CURRENT_HTOT_4) == true)
+            {
+                Get_Head_Current(HEAD_CURRENT_HTOT_4,&HeadCurrent[i][0]);
+                DiagnosticsMonitor.n_headzone12heatercurrent = 1;
+                DiagnosticsMonitor.headzone12heatercurrent = HeadCurrent[i];
+                i++;
+            }
+        }
+
+    }
+    else
+    {
+        for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
+        {
+            if (Get_Heater_Current_Reading_State(i) == true)
+            {
+                HeatersCurrent[i][0] = Get_Heaters_Current(i);
+                switch(i)
+                {
+                case HEATER_DRYER_CURRENT_1:
+                    DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
+                    DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
+                    break;
+                case HEATER_DRYER_CURRENT_2:
+                    DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
+                    DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];
+                    break;
+                case HEATER_MIXCHIP_CURRENT:
+                    DiagnosticsMonitor.n_mixer1heatercurrent = 1;
+                    DiagnosticsMonitor.mixer1heatercurrent = HeatersCurrent[HEATER_MIXCHIP_CURRENT];
+                    break;
+                case HEATER_HEAD_CURRENT_ZONE_1:
+                    DiagnosticsMonitor.n_headzone1heatercurrent = 1;
+                    DiagnosticsMonitor.headzone1heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_1];
+                    break;
+                case HEATER_HEAD_CURRENT_ZONE_2:
+                    DiagnosticsMonitor.n_headzone2heatercurrent = 1;
+                    DiagnosticsMonitor.headzone2heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_2];
+                    break;
+                case HEATER_HEAD_CURRENT_ZONE_3:
+                    DiagnosticsMonitor.n_headzone3heatercurrent = 1;
+                    DiagnosticsMonitor.headzone3heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_3];
+                    break;
+                case HEATER_HEAD_CURRENT_ZONE_4:
+                    DiagnosticsMonitor.n_headzone4heatercurrent = 1;
+                    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];
+                    break;
+                default:
+                    break;
+                }
             }
         }
     }
@@ -514,41 +679,84 @@ void DiagnosticOneMinuteCollection(void)
     DrierFlowMeter = GetWHSAirFlow(DRIER_FLOW_METER);
     DiagnosticsMonitor.n_dryerairflow = 1;
     DiagnosticsMonitor.dryerairflow = &DrierFlowMeter;
+
     HeadFlowMeter = GetWHSAirFlow(HEAD_FLOW_METER);
     DiagnosticsMonitor.n_headairflow = 1;
     DiagnosticsMonitor.headairflow = &HeadFlowMeter;
 
+/*    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD) //rapid/pp machines
+    {
+        AcVoltage = ReadVAC();
+        DiagnosticsMonitor.whsblower2voltage = &AcVoltage;
+        DiagnosticsMonitor.n_whsblower2voltage = 1;
+    }
+*/
+
 
 
 }
+void DiaglosticChangeBlowerData()
+{
+    DiagnosticsMonitor.n_blowervoltage = 1;
+    diagvoltage = getBlowerState();
+    DiagnosticsMonitor.blowervoltage = &diagvoltage;
+}
 void DiagnosticOneSecCollection(void)
 {
     int i;
-#ifdef Use_Head_Card
-    DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone2, MillisecGetTemperatures(HEAD_PT100_ZONE_2_0X80_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone3, MillisecGetTemperatures(HEAD_PT100_ZONE_3_0X82_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone4, MillisecGetTemperatures(HEAD_PT100_ZONE_4_0X82_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone5, MillisecGetTemperatures(HEAD_PT100_ZONE_5_0X84_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone6, MillisecGetTemperatures(HEAD_PT100_ZONE_6_0X84_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone7, MillisecGetTemperatures(HEAD_PT100_ZONE_7_0X86_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone8, MillisecGetTemperatures(HEAD_PT100_ZONE_8_0X86_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone9, MillisecGetTemperatures(HEAD_PT100_ZONE_9_0X88_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone10, MillisecGetTemperatures(HEAD_PT100_ZONE_10_0X88_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone11, MillisecGetTemperatures(HEAD_PT100_ZONE_11_0X8A_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone12, MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater1, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater2, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0));
-#else
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
-#endif
+    memset(HeaterCounterIndex,0,sizeof(HeaterCounterIndex));
+
+    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD) //rapid/pp machines
+    {
+        AcVoltage = ReadVAC();
+        DiagnosticsMonitor.whsblower2voltage = &AcVoltage;
+        DiagnosticsMonitor.n_whsblower2voltage = 1;
+    }
+    if (WHS_Type == WHS_TYPE_NEW) //rapid/pp machines
+    {
+        DrierFlowMeter = GetWHSAirFlow(DRIER_FLOW_METER);
+        DiagnosticsMonitor.n_dryerairflow = 1;
+        DiagnosticsMonitor.dryerairflow = &DrierFlowMeter;
+
+        HeadFlowMeter = GetWHSAirFlow(HEAD_FLOW_METER);
+        DiagnosticsMonitor.n_headairflow = 1;
+        DiagnosticsMonitor.headairflow = &HeadFlowMeter;
+    }
+    if (Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    {
+        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
+        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
+        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
+        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
+        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
+        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
+        DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
+    }
+    if (Head_Type == HEAD_TYPE_SYLKO)
+    {
+        DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone2, MillisecGetTemperatures(HEAD_PT100_ZONE_2_0X80_1));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone3, MillisecGetTemperatures(HEAD_PT100_ZONE_3_0X82_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone4, MillisecGetTemperatures(HEAD_PT100_ZONE_4_0X82_1));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone5, MillisecGetTemperatures(HEAD_PT100_ZONE_5_0X84_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone6, MillisecGetTemperatures(HEAD_PT100_ZONE_6_0X84_1));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone7, MillisecGetTemperatures(HEAD_PT100_ZONE_7_0X86_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone8, MillisecGetTemperatures(HEAD_PT100_ZONE_8_0X86_1));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone9, MillisecGetTemperatures(HEAD_PT100_ZONE_9_0X88_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone10, MillisecGetTemperatures(HEAD_PT100_ZONE_10_0X88_1));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone11, MillisecGetTemperatures(HEAD_PT100_ZONE_11_0X8A_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone12, MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1));
+    }
+    if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    {
+        DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone2, MillisecGetTemperatures(HEAD_PT100_ZONE_2_0X80_1));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone3, MillisecGetTemperatures(HEAD_PT100_ZONE_3_0X82_0));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater1, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1));
+        DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater2, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0));
+    }
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP3));
@@ -587,13 +795,12 @@ void Diagnostic100msecCollection(void)
             dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
         }
     }
-    if (DiagnosticMode == Diagnostic_Extreme_Mode)
-    {
-        for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
-        {
-            HeatersCurrent[i][0] = Get_Heaters_Current(i);
-        }
-    }
+
+    DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
+    HeatersCurrent[HEATER_DRYER_CURRENT_1][0] = Get_Heaters_Current(HEATER_DRYER_CURRENT_1);
+    DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
+    HeatersCurrent[HEATER_DRYER_CURRENT_2][0] = Get_Heaters_Current(HEATER_DRYER_CURRENT_2);
+
    /*dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
      dispenser2motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2);
      dispenser3motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3);
@@ -615,7 +822,6 @@ void DiagnosticsReset(void)
     memset(MotorCounterIndex,0,sizeof(MotorCounterIndex));
     memset(DancerErrorCounterIndex,0,sizeof(DancerErrorCounterIndex));
     SpeedCounterIndex = 0;
-    memset(HeaterCounterIndex,0,sizeof(HeaterCounterIndex));
     DiagnosticsIndex = 0;
     DiagnosticsMonitor.n_dancer1angle =  0;
     DiagnosticsMonitor.n_dancer2angle =  0;
@@ -711,41 +917,46 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.headzone1temperature = HeaterTemperature[HEATER_TYPE__HeaterZone1];
     DiagnosticsMonitor.headzone2temperature = HeaterTemperature[HEATER_TYPE__HeaterZone2];
     DiagnosticsMonitor.headzone3temperature = HeaterTemperature[HEATER_TYPE__HeaterZone3];
-    DiagnosticsMonitor.headzone4temperature = HeaterTemperature[HEATER_TYPE__HeaterZone4];
-    DiagnosticsMonitor.headzone5temperature = HeaterTemperature[HEATER_TYPE__HeaterZone5];
-    DiagnosticsMonitor.headzone6temperature = HeaterTemperature[HEATER_TYPE__HeaterZone6];
-#ifdef Use_Head_Card
-    DiagnosticsMonitor.headzone7temperature = HeaterTemperature[HEATER_TYPE__HeaterZone7];
-    DiagnosticsMonitor.headzone8temperature = HeaterTemperature[HEATER_TYPE__HeaterZone8];
-    DiagnosticsMonitor.headzone9temperature = HeaterTemperature[HEATER_TYPE__HeaterZone9];
-    DiagnosticsMonitor.headzone10temperature = HeaterTemperature[HEATER_TYPE__HeaterZone10];
-    DiagnosticsMonitor.headzone11temperature = HeaterTemperature[HEATER_TYPE__HeaterZone11];
-    DiagnosticsMonitor.headzone12temperature = HeaterTemperature[HEATER_TYPE__HeaterZone12];
-    DiagnosticsMonitor.headcoverheater1temperature = HeaterTemperature[HEATER_TYPE__HeadCoverHeater1];
-    DiagnosticsMonitor.headcoverheater2temperature = HeaterTemperature[HEATER_TYPE__HeadCoverHeater2];
-
-#endif
-    DiagnosticsMonitor.dryerzone1temperature = HeaterTemperature[HEATER_TYPE__DryerAirHeater];
-    DiagnosticsMonitor.dryerzone2temperature = HeaterTemperature[HEATER_TYPE__DryerMainHeater];
-    DiagnosticsMonitor.dryerzone3temperature = HeaterTemperature[HEATER_TYPE__DryerSecondaryHeater];
-
     DiagnosticsMonitor.n_mixertemperature = HeaterCounterIndex[HEATER_TYPE__MixerHeater];
     DiagnosticsMonitor.n_headzone1temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone1];
     DiagnosticsMonitor.n_headzone2temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone2];
     DiagnosticsMonitor.n_headzone3temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone3];
-    DiagnosticsMonitor.n_headzone4temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone4];
-    DiagnosticsMonitor.n_headzone5temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone5];
-    DiagnosticsMonitor.n_headzone6temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone6];
-#ifdef Use_Head_Card
-    DiagnosticsMonitor.n_headzone7temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone7];
-    DiagnosticsMonitor.n_headzone8temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone8];
-    DiagnosticsMonitor.n_headzone9temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone9];
-    DiagnosticsMonitor.n_headzone10temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone10];
-    DiagnosticsMonitor.n_headzone11temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone11];
-    DiagnosticsMonitor.n_headzone12temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone12];
-    DiagnosticsMonitor.n_headcoverheater1temperature = HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater1];
-    DiagnosticsMonitor.n_headcoverheater2temperature = HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater2];
-#endif
+    if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD))
+    {
+        DiagnosticsMonitor.headzone4temperature = HeaterTemperature[HEATER_TYPE__HeaterZone4];
+        DiagnosticsMonitor.headzone5temperature = HeaterTemperature[HEATER_TYPE__HeaterZone5];
+        DiagnosticsMonitor.headzone6temperature = HeaterTemperature[HEATER_TYPE__HeaterZone6];
+        DiagnosticsMonitor.n_headzone4temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone4];
+        DiagnosticsMonitor.n_headzone5temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone5];
+        DiagnosticsMonitor.n_headzone6temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone6];
+    }
+    if (Head_Type == HEAD_TYPE_SYLKO)
+    {
+        DiagnosticsMonitor.headzone7temperature = HeaterTemperature[HEATER_TYPE__HeaterZone7];
+        DiagnosticsMonitor.headzone8temperature = HeaterTemperature[HEATER_TYPE__HeaterZone8];
+        DiagnosticsMonitor.headzone9temperature = HeaterTemperature[HEATER_TYPE__HeaterZone9];
+        DiagnosticsMonitor.headzone10temperature = HeaterTemperature[HEATER_TYPE__HeaterZone10];
+        DiagnosticsMonitor.headzone11temperature = HeaterTemperature[HEATER_TYPE__HeaterZone11];
+        DiagnosticsMonitor.headzone12temperature = HeaterTemperature[HEATER_TYPE__HeaterZone12];
+        DiagnosticsMonitor.n_headzone7temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone7];
+        DiagnosticsMonitor.n_headzone8temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone8];
+        DiagnosticsMonitor.n_headzone9temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone9];
+        DiagnosticsMonitor.n_headzone10temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone10];
+        DiagnosticsMonitor.n_headzone11temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone11];
+        DiagnosticsMonitor.n_headzone12temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone12];
+    }
+    if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_STAPLE_SPUN))
+//    if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    {
+        DiagnosticsMonitor.headcoverheater1temperature = HeaterTemperature[HEATER_TYPE__HeadCoverHeater1];
+        DiagnosticsMonitor.headcoverheater2temperature = HeaterTemperature[HEATER_TYPE__HeadCoverHeater2];
+        DiagnosticsMonitor.n_headcoverheater1temperature = HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater1];
+        DiagnosticsMonitor.n_headcoverheater2temperature = HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater2];
+    }
+    DiagnosticsMonitor.dryerzone1temperature = HeaterTemperature[HEATER_TYPE__DryerAirHeater];
+    DiagnosticsMonitor.dryerzone2temperature = HeaterTemperature[HEATER_TYPE__DryerMainHeater];
+    DiagnosticsMonitor.dryerzone3temperature = HeaterTemperature[HEATER_TYPE__DryerSecondaryHeater];
+
     DiagnosticsMonitor.n_dryerzone1temperature = HeaterCounterIndex[HEATER_TYPE__DryerAirHeater];
     DiagnosticsMonitor.n_dryerzone2temperature = HeaterCounterIndex[HEATER_TYPE__DryerMainHeater];
     DiagnosticsMonitor.n_dryerzone3temperature = HeaterCounterIndex[HEATER_TYPE__DryerSecondaryHeater];
@@ -823,7 +1034,7 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.n_midtank8level = 1;
     DiagnosticsMonitor.midtank8level = MidTankpressure[7];
 
-    DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
+/*    DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
     DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
     DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
     DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];
@@ -839,7 +1050,7 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.headzone4heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_4];
     DiagnosticsMonitor.n_headzone5_6heatercurrent = 1;
     DiagnosticsMonitor.headzone5_6heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6];
-
+*/
     VOC_Sensor = (double) getGasReading();
     DiagnosticsMonitor.n_filterdeltapressure = 1;
     DiagnosticsMonitor.filterdeltapressure = &VOC_Sensor;
@@ -851,20 +1062,38 @@ void SendDiagnostics(void)
     response.n_digitalinterfacestates = DiagnosticsLoadDigitalValues();
     response.digitalinterfacestates = digitalinterfacestates;
 
-#ifdef Use_Head_Card
-    for (i=HEATER_TYPE__DryerAirHeater;i<HEATER_TYPE_MAX_HEATERS;i++)
-#else
-	for (i=HEATER_TYPE__DryerAirHeater;i<MAX_HEATERS_NUM;i++)
-#endif
+    response.n_heatersstates = 0;
+    i = 0;
+    LoadHeaterState(HEATER_TYPE__DryerAirHeater,&HeaterInfo[i++]);
+    LoadHeaterState(HEATER_TYPE__DryerMainHeater,&HeaterInfo[i++]);
+    LoadHeaterState(HEATER_TYPE__DryerSecondaryHeater,&HeaterInfo[i++]);
+    LoadHeaterState(HEATER_TYPE__MixerHeater,&HeaterInfo[i++]);
+    LoadHeaterState(HEATER_TYPE__HeaterZone1,&HeaterInfo[i++]);
+    LoadHeaterState(HEATER_TYPE__HeaterZone2,&HeaterInfo[i++]);
+    LoadHeaterState(HEATER_TYPE__HeaterZone3,&HeaterInfo[i++]);
+
+    if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD))
+    {
+        LoadHeaterState(HEATER_TYPE__HeaterZone4,&HeaterInfo[i++]);
+        LoadHeaterState(HEATER_TYPE__HeaterZone5,&HeaterInfo[i++]);
+        LoadHeaterState(HEATER_TYPE__HeaterZone6,&HeaterInfo[i++]);
+    }
+    if (Head_Type == HEAD_TYPE_SYLKO)
+    {
+        LoadHeaterState(HEATER_TYPE__HeaterZone7,&HeaterInfo[i++]);
+        LoadHeaterState(HEATER_TYPE__HeaterZone8,&HeaterInfo[i++]);
+        LoadHeaterState(HEATER_TYPE__HeaterZone9,&HeaterInfo[i++]);
+        LoadHeaterState(HEATER_TYPE__HeaterZone10,&HeaterInfo[i++]);
+        LoadHeaterState(HEATER_TYPE__HeaterZone11,&HeaterInfo[i++]);
+        LoadHeaterState(HEATER_TYPE__HeaterZone12,&HeaterInfo[i++]);
+    }
+    if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_STAPLE_SPUN))
+    //if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
     {
-        LoadHeaterState((HeaterType)i,&HeaterInfo[i]);
-        //heatersstates[i] = &HeaterInfo[i];
+        LoadHeaterState(HEATER_TYPE__HeadCoverHeater1,&HeaterInfo[i++]);
+        LoadHeaterState(HEATER_TYPE__HeadCoverHeater2,&HeaterInfo[i++]);
     }
-#ifdef Use_Head_Card
-    response.n_heatersstates = HEATER_TYPE_MAX_HEATERS;
-#else
-    response.n_heatersstates = MAX_HEATERS_NUM;
-#endif
+    response.n_heatersstates = i;
     response.heatersstates = heatersstates;
 
     response.has_elapsedmilli = true;
@@ -879,6 +1108,7 @@ void SendDiagnostics(void)
 
 //    diagnosticsresponseContainer = createContainer(MESSAGE_TYPE__StartDiagnosticsResponse,  DiagnosticsToken, false, &response, &start_diagnostics_response__pack, &start_diagnostics_response__get_packed_size);
     diagnosticsresponseContainer = createAllocatedContainer(MESSAGE_TYPE__StartDiagnosticsResponse,  DiagnosticsToken, false, &response, &start_diagnostics_response__pack, &start_diagnostics_response__get_packed_size,diagnostics_response_ptr);
+    diagnosticsresponseContainer.has_continuous = true;
     diagnosticsresponseContainer.continuous = true;
 
     if (diagnosticsresponseContainer.data.data)
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
index c9698d05e..b7b1ec9c8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
@@ -11,7 +11,7 @@
 
 extern bool blowervolatgedisplay;
 extern bool midtankDisplay;
-extern double voltage;
+
 extern char* diagnosticscontainer_buffer;
 
 typedef enum
@@ -52,6 +52,7 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer);
 uint32_t SetValveStateRequestFunc(MessageContainer* requestContainer);
 uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer);
 
+void DiaglosticChangeBlowerData();
 
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index c58d54a8c..be8e84f3e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -45,6 +45,7 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
 
     responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
+    responseContainer.has_continuous = true;
     responseContainer.continuous = true;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
@@ -141,6 +142,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
     responseContainer.error = ERROR_CODE__INVALID_PROCESS_ID;
     responseContainer.errormessage = "Job Active or incorrect motor ID";
     responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse,  requestContainer->token, true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
+    responseContainer.has_continuous = true;
     responseContainer.continuous = true;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
@@ -186,6 +188,7 @@ uint32_t DispenserHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     //MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
 
     responseContainer = createContainer(MESSAGE_TYPE__DispenserHomingResponse, HomingToken[MotorId], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
+    responseContainer.has_continuous = true;
     responseContainer.continuous = true;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
@@ -212,6 +215,7 @@ uint32_t DispenserHomingRequestFunc(MessageContainer* requestContainer)
     if (speed == 0) speed = 150;
 
     responseContainer = createContainer(MESSAGE_TYPE__DispenserHomingResponse,  requestContainer->token, false, &response, &dispenser_homing_response__pack, &dispenser_homing_response__get_packed_size);
+    responseContainer.has_continuous = true;
     responseContainer.continuous = true;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 82d2dc226..ec59385ab 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -40,6 +40,7 @@
 #include "drivers/I2C_Communication/DAC/Blower.h"
 #include "drivers/Valves/Valve.h"
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
+#include "Drivers/I2C_Communication/I2C.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
 
 #include "StateMachines/Printing/PrintingSTM.h"
@@ -128,6 +129,7 @@ uint32_t HWConfigurationInit(void)
         status = HWConfiguration(UploadRequest);
         if (status !=OK)
         {
+            AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE,ON);
             SetMachineState(MACHINE_STATE_HW_CONFIG_FAILED);
             STATUS_GREEN_LED_OFF;
         }
@@ -145,14 +147,15 @@ uint32_t HWConfigurationInit(void)
     if (buffer)
         free (buffer);
 
+    Trigger_Head_Init_PT100();//OK
     //EmbeddedParametersInit();
     IDS_Dispenser_Content_Init();
     //ProcessParamsInit();
     Buttons_Init();
+    if (WHS_Type == WHS_TYPE_NEW)
+        newWHS_init();
     WHS_init();
-#ifdef Use_WHS_Card
-    newWHS_init();
-#endif
+
     ADC_MUX_Init();
     GeneralHwReady = true;
 
@@ -185,7 +188,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->has_initialdispenserpressure = true;
             EmbeddedParameters->initialdispenserpressure = 0.25;
             EmbeddedParameters->has_initialdispensertimeout = true;
-            EmbeddedParameters->initialdispensertimeout = 60000;
+            EmbeddedParameters->initialdispensertimeout = 180000;
             EmbeddedParameters->has_initialdispensertimelag = true;
             EmbeddedParameters->initialdispensertimelag = 100;
             EmbeddedParameters->has_dispenserbuildpressurespeed = true;
@@ -207,7 +210,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->has_midtankpressurecorrection = true;
             EmbeddedParameters->midtankpressurecorrection = 0.0;
             EmbeddedParameters->has_dispenserpresegmentwfcf = true;
-            EmbeddedParameters->dispenserpresegmentwfcf = 80;
+            EmbeddedParameters->dispenserpresegmentwfcf = 40;
             EmbeddedParameters->has_startheatingoninitsequence = true;
             EmbeddedParameters->startheatingoninitsequence = true; //set to true shlomo 14/5/2019
             EmbeddedParameters->n_generalparameters = 8;
@@ -250,7 +253,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->has_idlemixertemperature = true;
             EmbeddedParameters->idlemixertemperature = 0;
             EmbeddedParameters->has_powerofftemperaturelimit = true;
-            EmbeddedParameters->powerofftemperaturelimit = 50;
+            EmbeddedParameters->powerofftemperaturelimit = 90;
             EmbeddedParameters->has_ids_presegment_wfcf_timebeforesegment = true;
             EmbeddedParameters->ids_presegment_wfcf_timebeforesegment = 20000;
             uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(EmbeddedParameters));
@@ -383,6 +386,7 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
 {
     uint32_t status  = 0;
     int Dancer_i, Dispenser_i,PID_i,tempheaterId;
+    HardwareBlowerType blowerType = HARDWARE_BLOWER_TYPE__DefaultBlower;
 
     if (UploadRequest == NULL)
     {
@@ -491,13 +495,18 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
     }
 
     BlowerCfg.enabled = true;
-    BlowerCfg.voltage = 3000;
-    BlowerCfg.heatingvoltage = 3000;
-#ifdef Use_WHS_Card
-    HardwareBlowerType blowerType = HARDWARE_BLOWER_TYPE__WHSBlower2;
-#else
-    HardwareBlowerType blowerType = HARDWARE_BLOWER_TYPE__DefaultBlower;
-#endif
+    if (WHS_Type == WHS_TYPE_UNKNOWN)
+    {
+        blowerType = HARDWARE_BLOWER_TYPE__DefaultBlower;
+        BlowerCfg.voltage = 3000;
+        BlowerCfg.heatingvoltage = 2650;
+    }
+    else
+    {
+        blowerType = HARDWARE_BLOWER_TYPE__WHSBlower2;
+        BlowerCfg.voltage = 2200;
+        BlowerCfg.heatingvoltage = 2000;
+    }
     if (request->n_blowers)
     {
         for (Dispenser_i = 0; Dispenser_i < request->n_blowers ; Dispenser_i++)
@@ -516,25 +525,6 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
             }
         }
     }
-    //from now on starting blower on INIT, so that the chiller does not freeze
-    /*if (BlowerCfg.enabled == true)
-    {
-        Turn_the_Blower_On();//Turn on with the Default_Voltage
-        if (BlowerCfg.heatingvoltage)
-            Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
-        else
-            Control_Voltage_To_Blower(BlowerCfg.voltage-500);
-
-    }*/
-
-/*
-    for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
-    {
-        Enable_MidTank_Pressure_Reading(Dispenser_i);
-        Valve_Set(IDS_Id_to_AirValve[Dispenser_i], Atm_MidTank_ON );   //Atm_MidTank_OFF/ON
-    }
-    GenHWControlId = AddControlCallback(NULL, GenHWInitCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
-*/
     ControlStart();
     AlarmHandlingStart();
     //ThreadInitialTestStub(request);
@@ -734,6 +724,21 @@ uint32_t LoadConfigurationParamsFromFile(bool Initialize)
     }
     return Fresult;
 }
+void HWConfigurationLoadFile(void)
+{
+    FRESULT Fresult = FR_OK;
+    uint8_t* buffer = NULL;
+    uint32_t Bytes = 0;
+    buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
+    if (buffer)
+    {
+       ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&Bytes);
+       ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, Bytes, buffer);
+       free (buffer);
+       FlashInitResults[0] = true;
+    }
+    Report("Hardware Initialized", __FILE__,__LINE__,Bytes, RpMessage, GENHWCFG_MAP_IN_FLASH, 0);
+}
 void FlashInitAndLoad(void)
 {
     FRESULT Fresult = FR_OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h
index 5fd8588af..55490a140 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.h
@@ -16,7 +16,9 @@ extern uint32_t MachineCalibrationDataRequestFunc(MessageContainer* requestConta
 extern void HWSystemResetRequest(MessageContainer* requestContainer);
 uint32_t HWConfigurationInit(void);
 void FlashInitAndLoad(void);
-uint32_t LoadConfigurationParamsFromFile(bool Initialize);
+uint32_t LoadConfigurationParamsFromFile(bool);
+void HWConfigurationLoadFile(void);
+
 extern HardwareBlower BlowerCfg;
 
 extern bool DataUpdated;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
index 157841365..3f557496c 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
@@ -48,10 +48,10 @@ int MachineUpdateResponseFunc(void)
         return OK;
 
     StartMachineStatusUpdateResponse response = START_MACHINE_STATUS_UPDATE_RESPONSE__INIT;
-    MachineStatus MachineStatus;
+    MachineStatus MachineStatus = MACHINE_STATUS__INIT;
     response.status = &MachineStatus;
 
-    machine_status__init(&MachineStatus);
+    //machine_status__init(&MachineStatus);
     MachineStatus.has_state = true;
     MachineStatus.state = StoredMachineStatus;
     MachineStatus.n_idspackslevels = 0;
@@ -83,6 +83,7 @@ int MachineUpdateResponseFunc(void)
 
 
     responseContainer = /*MachineUpdate*/createContainer(MESSAGE_TYPE__StartMachineStatusUpdateResponse, MachineUpdateToken, false, &response, &start_machine_status_update_response__pack, &start_machine_status_update_response__get_packed_size);
+    responseContainer.has_continuous = true;
     responseContainer.continuous = true;
     //if (responseContainer.data.data)
     {
@@ -138,6 +139,7 @@ uint32_t StopMachineUpdateFunc(MessageContainer* requestContainer)
 //TODO Handle the request!!!!
     MachineUpdateStopReporting();
     responseContainer = createContainer(MESSAGE_TYPE__StopMachineStatusUpdateResponse, MachineUpdateToken, false, &response, &stop_machine_status_update_response__pack, &stop_machine_status_update_response__get_packed_size);
+    responseContainer.has_continuous = true;
     responseContainer.continuous = true;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
index d8c68b345..7326dc039 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
@@ -130,6 +130,7 @@ bool get_pbAction (button *pBtn, PB_Status ReadValue )
         case OFFPB:
             if (ReadValue == PRESS)
             {
+                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: OFFPB -> COUNTPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                 pBtn->count = 1 ;
                 pBtn->Action = COUNTPB;
             }
@@ -146,22 +147,39 @@ bool get_pbAction (button *pBtn, PB_Status ReadValue )
                 if (pBtn->count > SECOND5)
                 {
                     pBtn->Action = LONGPB;
+                    ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> LONGPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
                 }
             }
             else
             {
                 pBtn->count = 0 ;
                 pBtn->Action = SHORTPB;
+                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: COUNTPB -> SHORTPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
             }
             break;
         case SHORTPB:
             pBtn->Action = OFFPB;
+            ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: SHORTPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
             break ;
         case LONGPB:
             if (ReadValue == RELEASE)
             {
                 pBtn->count = 0 ;
                 pBtn->Action = OFFPB;
+                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: LONGPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+            }
+            else
+            {
+                pBtn->Action = REPLONGPB;
+                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: LONGPB -> REPLONGPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+            }
+            break ;
+        case REPLONGPB:
+            if (ReadValue == RELEASE)
+            {
+                pBtn->count = 0 ;
+                pBtn->Action = OFFPB;
+                ReportWithPackageFilter(GeneralFilter,"------------ get_pbAction: REPLONGPB -> OFFPB -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
             }
             break ;
         default:
@@ -211,6 +229,7 @@ uint32_t Buttons_Init(void)
     power.state = sttON; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING
     power.count = 0;
 
+    Task_sleep(15);
     AddControlCallback("ButtonPowerCB", ButtonPowerCBFunction, BUTTONS_SAMPLE_TIME, ButtonPowerCallBackFunction, 0,0,0 ); // eFiftyMillisecond
 
     strcpy(jog.bttn_name, "jog");
@@ -221,6 +240,7 @@ uint32_t Buttons_Init(void)
     jog.state = sttENABLE; // sttDISABLE, sttENABLE, sttJOGGING
     jog.count = 0;
 
+    Task_sleep(15);
     AddControlCallback("ButtonJogCB", ButtonJogCBFunction, BUTTONS_SAMPLE_TIME, ButtonJogCallBackFunction, 0,0,0 ); //
 
     strcpy(load.bttn_name, "load");
@@ -231,6 +251,7 @@ uint32_t Buttons_Init(void)
     load.state = sttRDY; //
     load.count = 0;
 
+    Task_sleep(15);
     AddControlCallback("ButtonLoadCB", ButtonLoadCBFunction, BUTTONS_SAMPLE_TIME, ButtonLoadCallBackFunction, 0,0,0 ); //
 return OK;
 }
@@ -259,36 +280,57 @@ uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         case sttDISABLE:
            if (JobIsActive() == false)
            {
+               ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: jog.state=sttDISABLE , JobIsActive() == false-----------------", __FILE__,__LINE__,jog.state, RpMessage, jog.Action, 0);
                jog.color =  colorON;
                Pannel_Leds(THREAD_JOGGING, MODE_ON);
                jog.state = sttENABLE;
            }
            break;
         case sttENABLE:
-            if (jog.Action == COUNTPB)
+            if (JobIsActive() == true)
             {
-                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is sttENABLE and  PRESS-----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);    jog.state = sttJOGGING;
-                jog.color =  colorON;
-                jog.color =  BLINK;
-                ThreadJoggingFunc(40);
-                jog.state = sttJOGGING;
+                 ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is Disable -----------------", __FILE__,__LINE__,jog.state, RpMessage, jog.Action, 0);
+                 jog.Action = OFFPB;
+                 jog.color =  colorOFF;
+                 Pannel_Leds(THREAD_JOGGING,MODE_OFF);
+                 jog.state = sttDISABLE;
             }
             else
             {
-                if (JobIsActive() == true)
+                if (jog.Action == COUNTPB)
                 {
-                     ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is Disable -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
-                     jog.Action = OFFPB;
-                     jog.color =  colorOFF;
-                     Pannel_Leds(THREAD_JOGGING,MODE_OFF);
-                     jog.state = sttDISABLE;
+                    ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is sttENABLE and  PRESS-----------------", __FILE__,__LINE__,jog.state, RpMessage, jog.Action, 0);
+                    jog.color =  colorON;
+                    jog.color =  BLINK;
+                    ThreadJoggingFunc(40);
+                    jog.state = sttJOGGING;
                 }
             }
+
+//            if (jog.Action == COUNTPB)
+//            {
+//                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is sttENABLE and  PRESS-----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+//                jog.color =  colorON;
+//                jog.color =  BLINK;
+//                ThreadJoggingFunc(40);
+//                jog.state = sttJOGGING;
+//            }
+//            else
+//            {
+//                if (JobIsActive() == true)
+//                {
+//                     ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: Jogging is Disable -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+//                     jog.Action = OFFPB;
+//                     jog.color =  colorOFF;
+//                     Pannel_Leds(THREAD_JOGGING,MODE_OFF);
+//                     jog.state = sttDISABLE;
+//                }
+//            }
             break;
         case sttJOGGING:
             if (jog.Action == SHORTPB) //PB is OFF
             {
-                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttJOGGING action->SHORTPB-----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);    jog.state = sttJOGGING;
+                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttJOGGING action SHORTPB, sttJOGGING -> sttENABLE,  stop JOGGING----------------", __FILE__,__LINE__,jog.state, RpMessage, jog.Action, 0);
                 ThreadAbortJoggingFunc(); 
                 jog.color =  colorON;
                 Pannel_Leds(THREAD_JOGGING, MODE_ON);
@@ -296,26 +338,25 @@ uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             }
             else if (jog.Action == LONGPB)
             {
-                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttJOGGING action->LONGPB-----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);    jog.state = sttJOGGING;
+                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttJOGGING action LONGPB,  sttJOGGING -> sttLONG_JOGGING-----------------", __FILE__,__LINE__, jog.state, RpMessage, jog.Action, 0);
                 jog.state = sttLONG_JOGGING;
-                if (JobIsActive() == false) // added because sometimes the jog stops because of another reason and the button s stucked blinking
-                {
-                    jog.color =  colorON;
-                    Pannel_Leds(THREAD_JOGGING, MODE_ON);
-                    jog.state = sttENABLE;
-                }
-
             }
             break;
         case sttLONG_JOGGING:
              if (jog.Action == COUNTPB)
              {
-                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttLONG_JOGGING action->COUNTPB-----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);    jog.state = sttJOGGING;ThreadAbortJoggingFunc(); // to do!!!!
+                ReportWithPackageFilter(GeneralFilter,"------------ joggingMachine: sttLONG_JOGGING action COUNTPB,  sttLONG_JOGGING -> sttENABLE, stop JOGGING-----------------", __FILE__,__LINE__, jog.state, RpMessage, jog.Action, 0);
                 ThreadAbortJoggingFunc();
                 jog.color =  colorON;
                 Pannel_Leds(THREAD_JOGGING, MODE_ON);
                 jog.state = sttENABLE;
              }
+             if (JobIsActive() == false) // added because sometimes the jog stops because of another reason and the button s stucked blinking
+             {
+                 jog.color =  colorON;
+                 Pannel_Leds(THREAD_JOGGING, MODE_ON);
+                 jog.state = sttENABLE;
+             }
             break;
         default:
             break;
@@ -338,6 +379,9 @@ uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue)
            ReportWithPackageFilter(GeneralFilter,"------------ thread loading LONGPB  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
            LoadLongPress( &load );
            break;
+       case REPLONGPB:
+           ReportWithPackageFilter(GeneralFilter,"------------ thread loading REPLONGPB please release the PB  -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
+           break;
        default:
            if (ThreadLoadingActive() == false)
            {
@@ -532,7 +576,7 @@ return OK;
 uint32_t LoadStatMachine( button *pBtn)
 {
 
-    ReportWithPackageFilter(GeneralFilter,"------------ start loading -----------------", __FILE__,__LINE__,pBtn->state, RpMessage, pBtn->color, 0);
+    ReportWithPackageFilter(GeneralFilter,"------------ (state) (color) -----------------", __FILE__,__LINE__,pBtn->state, RpMessage, pBtn->color, 0);
     switch (pBtn->state)
     {
         case sttRDY :
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index 1ef4a0931..815a26385 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -22,6 +22,7 @@
 #include "modules/ids/ids_ex.h"
 #include "Common/SWUpdate/FileSystem.h"
 #include "StateMachines/Initialization/PowerIdle.h"
+#include "StateMachines/Initialization/InitSequence.h"
 
 #include "drivers/Flash_ram/FlashProgram.h"
 
@@ -57,12 +58,22 @@ void HeatersStopControlOnHeatersOff(ProcessParameters* ProcessParams)
     temp_sum += ProcessParams->headzone4temp;
     temp_sum += ProcessParams->headzone5temp;
     temp_sum += ProcessParams->headzone6temp;
+    temp_sum += ProcessParams->headzone7temp;
+    temp_sum += ProcessParams->headzone8temp;
+    temp_sum += ProcessParams->headzone9temp;
+    temp_sum += ProcessParams->headzone10temp;
+    temp_sum += ProcessParams->headzone11temp;
+    temp_sum += ProcessParams->headzone12temp;
 
     if (temp_sum == 0)// heating off
     {
         HeatersControlStop();
         REPORT_MSG(temp_sum,"Heating control off - temperatures off");
     }
+    else
+    {
+        HeatersControlStart();
+    }
 }
 uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
 {
@@ -84,6 +95,11 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     if (ProcessParams->headzone6temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER;
     if (status != 0)
         return status;
+    if (GetMachineState()<MACHINE_STATE_HEATING_STARTED)
+    {
+        status = ERROR_CODE__GENERAL_ERROR;
+        return status;
+    }
     if (ProcessParams)
     {
         memcpy (&ProcessParametersKeep,ProcessParams,sizeof(ProcessParameters));
@@ -101,191 +117,135 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
         }
     }
     if (ProcessParams->mixertemp>1)
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__MixerHeater, true,
-                ProcessParams->mixertemp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__MixerHeater, true,ProcessParams->mixertemp);
     else
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__MixerHeater, false,
-                ProcessParams->mixertemp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__MixerHeater, false,ProcessParams->mixertemp);
     if (ProcessParams->headzone1temp>1)
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, true,ProcessParams->headzone1temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, true,ProcessParams->headzone1temp);
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, true,ProcessParams->headzone1temp);
-#endif
     }
     else
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, false,ProcessParams->headzone1temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, false,ProcessParams->headzone1temp);
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, false,ProcessParams->headzone1temp);
-#endif
     }
     if (ProcessParams->headzone2temp>1)
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, true,ProcessParams->headzone2temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, true,ProcessParams->headzone2temp);
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, true,ProcessParams->headzone2temp);
-#endif
     }
     else
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, false,ProcessParams->headzone2temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, false,ProcessParams->headzone2temp);
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, false,ProcessParams->headzone2temp);
-#endif
     }
     if (ProcessParams->headzone3temp>1)
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, true,ProcessParams->headzone3temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, true,ProcessParams->headzone3temp);
-#endif
     }
     else
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, false,ProcessParams->headzone3temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, false,ProcessParams->headzone3temp);
-#endif
     }
-    if (ProcessParams->headzone4temp>1)
+    if(Head_Type != HEAD_TYPE_STAPLE_SPUN)
     {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, true,ProcessParams->headzone4temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, true,ProcessParams->headzone4temp);
-#endif
-    }
-    else
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, false,ProcessParams->headzone4temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, false,ProcessParams->headzone4temp);
-#endif
-    }
-    if (ProcessParams->headzone5temp>1)
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, true,ProcessParams->headzone5temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, true,ProcessParams->headzone5temp);
-#endif
-    }
-    else
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, false,ProcessParams->headzone5temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, false,ProcessParams->headzone5temp);
-#endif
-    }
-    if (ProcessParams->headzone6temp>1)
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, true,ProcessParams->headzone6temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, true,ProcessParams->headzone6temp);
-#endif
-    }
-    else
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, false,ProcessParams->headzone6temp);
-#ifdef Use_Head_Card
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, false,ProcessParams->headzone6temp);
-#endif
+        if (ProcessParams->headzone4temp>1)
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, true,ProcessParams->headzone4temp);
+        }
+        else
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, false,ProcessParams->headzone4temp);
+        }
+        if (ProcessParams->headzone5temp>1)
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, true,ProcessParams->headzone5temp);
+        }
+        else
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, false,ProcessParams->headzone5temp);
+        }
+        if (ProcessParams->headzone6temp>1)
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, true,ProcessParams->headzone6temp);
+        }
+        else
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, false,ProcessParams->headzone6temp);
+        }
     }
     if (ProcessParams->dryerzone1temp>1)
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, true,
-                ProcessParams->dryerzone1temp);
-    else
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, false,
-                ProcessParams->dryerzone1temp);
-/*    if (ProcessParams->dryerzone2temp)
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, true,
-                ProcessParams->dryerzone2temp);
-    else
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, false,
-                ProcessParams->dryerzone2temp);
-    if (ProcessParams->dryerzone3temp)
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, true,
-                ProcessParams->dryerzone3temp);
-    else
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, false,
-                ProcessParams->dryerzone3temp);
-                */
-  /*  if (ProcessParams->headzone7temp>1)
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, true,ProcessParams->headzone7temp);
-    }
-    else
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, false,ProcessParams->headzone7temp);
-    }
-    if (ProcessParams->headzone8temp>1)
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, true,ProcessParams->headzone8temp);
-    }
-    else
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, false,ProcessParams->headzone8temp);
-    }
-    if (ProcessParams->headzone9temp>1)
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, true,ProcessParams->headzone9temp);
-    }
-    else
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, false,ProcessParams->headzone9temp);
-    }
-    if (ProcessParams->headzone10temp>1)
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, true,ProcessParams->headzone10temp);
-    }
-    else
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, false,ProcessParams->headzone10temp);
-    }
-    if (ProcessParams->headzone11temp>1)
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, true,ProcessParams->headzone11temp);
-    }
-    else
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, false,ProcessParams->headzone11temp);
-    }
-    if (ProcessParams->headzone12temp>1)
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, true,ProcessParams->headzone12temp);
-    }
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, true,ProcessParams->dryerzone1temp);
     else
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, false,ProcessParams->dryerzone1temp);
+    if(Head_Type == HEAD_TYPE_SYLKO)
     {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, false,ProcessParams->headzone12temp);
-    }
-    if (ProcessParams->stspzone1temp>1)
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, true,ProcessParams->stspzone1temp);
-    }
-    else
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, false,ProcessParams->stspzone1temp);
-    }
-    if (ProcessParams->stspzone2temp>1)
-    {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, true,ProcessParams->stspzone2temp);
+        if (ProcessParams->headzone7temp>1)
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, true,ProcessParams->headzone7temp);
+        }
+        else
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, false,ProcessParams->headzone7temp);
+        }
+        if (ProcessParams->headzone8temp>1)
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, true,ProcessParams->headzone8temp);
+        }
+        else
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, false,ProcessParams->headzone8temp);
+        }
+        if (ProcessParams->headzone9temp>1)
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, true,ProcessParams->headzone9temp);
+        }
+        else
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, false,ProcessParams->headzone9temp);
+        }
+        if (ProcessParams->headzone10temp>1)
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, true,ProcessParams->headzone10temp);
+        }
+        else
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, false,ProcessParams->headzone10temp);
+        }
+        if (ProcessParams->headzone11temp>1)
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, true,ProcessParams->headzone11temp);
+        }
+        else
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, false,ProcessParams->headzone11temp);
+        }
+        if (ProcessParams->headzone12temp>1)
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, true,ProcessParams->headzone12temp);
+        }
+        else
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, false,ProcessParams->headzone12temp);
+        }
     }
-    else
+    if(Head_Type == HEAD_TYPE_STAPLE_SPUN)
     {
-        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, false,ProcessParams->stspzone2temp);
+        if (ProcessParams->stspzone1temp>1)
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, true,ProcessParams->stspzone1temp);
+        }
+        else
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, false,ProcessParams->stspzone1temp);
+        }
+        if (ProcessParams->stspzone2temp>1)
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, true,ProcessParams->stspzone2temp);
+        }
+        else
+        {
+            status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, false,ProcessParams->stspzone2temp);
+        }
     }
-*/
+
     HeatersStopControlOnHeatersOff(ProcessParams);
     dyeingspeed = ProcessParams->dyeingspeed;
     dryerbufferlength = ProcessParams->dryerbufferlength;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
index 05425cc45..b1d870919 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
@@ -17,6 +17,7 @@ extern int     DCTimeSliceAllocation[HEATER_TYPE_MAX_HEATERS];
 extern int      NumberOFSlicesInUse;
 extern uint32_t MillisecondsPerChange;
 
+void initializeArrays(void);
 
 typedef struct  HeaterPIDControlConfigstruc
 {
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index bcc19bd6f..0c6ee94ee 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -12,6 +12,7 @@ extern EventType HeaterEventType[HEATER_TYPE_MAX_HEATERS];
 extern EventType HeaterUnderEventType[HEATER_TYPE_MAX_HEATERS];
 extern EventType HeaterUnderEventType_B[HEATER_TYPE_MAX_HEATERS];
 
+extern uint32_t stub_heating_limit;
 //uint32_t HeaterCommandRequestMessage(MessageContainer* requestContainer);
 uint32_t HeaterConfigRequestMessage(HardwarePidControl* request);
 uint32_t HeaterConfigSetSharedHeatersParams (uint32_t outputproportionalcycletime, uint32_t outputproportionalsinglestep);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
index d20f0511b..349d5a5e3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
@@ -63,27 +63,20 @@ uint32_t Heaters_Init(void)
     int i;
     //ROM_TimerDisable(Heater_timerBase, TIMER_A);
 
-#ifdef  Use_Head_Card
-    HeadADCPT100_SensorInitConfig();//OK
-#endif
     FPGA_SensorInitConfig();
 
     memset(HeaterControl,0,sizeof(HeaterControl));
-//#ifdef Use_Head_Card
     for (i = 0;i<HEATER_TYPE_MAX_HEATERS; i++)
-/*#else
-    for (i = 0;i<MAX_HEATERS_NUM; i++)
-#endif*/
         DeActivateHeater(i);
+    initializeArrays();
 
     BlowerCfg.enabled = true;
     BlowerCfg.voltage = 3000;
     BlowerCfg.heatingvoltage = 3000;
-#ifdef Use_WHS_Card
-    BlowerCfg.hardwareblowertype = HARDWARE_BLOWER_TYPE__WHSBlower2;
-#else
-    BlowerCfg.hardwareblowertype = HARDWARE_BLOWER_TYPE__DefaultBlower;
-#endif
+    if (WHS_Type == WHS_TYPE_UNKNOWN)
+        BlowerCfg.hardwareblowertype = HARDWARE_BLOWER_TYPE__DefaultBlower;
+    else
+        BlowerCfg.hardwareblowertype = HARDWARE_BLOWER_TYPE__WHSBlower2;
 
     return OK;
 }
@@ -193,11 +186,12 @@ uint32_t HeaterConfigSetSharedHeatersParams(uint32_t outputproportionalcycletime
  *
  * parameters - the cycle time for the coordinated operation, the size (in MCU cycles) of a single step.
  */
+uint32_t stub_heating_limit = 100;
 uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_outputproportionalpowerlimit)
 {
    int Slice_i;
    int Heater1000Slices,Heater200aSlices /*,Heater200bSlices Currently both 200W heaters will work together*/;
-
+   uint32_t stub_outputproportionalpowerlimit = new_outputproportionalpowerlimit;
 
    if (NumberOFSlicesInUse > MAX_TIMESLICES )
    {
@@ -205,8 +199,10 @@ uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_ou
        return ERROR;//NumberOFSlicesInUse = MAX_TIMESLICES;
    }
 
+   if (stub_outputproportionalpowerlimit > stub_heating_limit)
+       stub_outputproportionalpowerlimit = stub_heating_limit;
    // all numbers are rounded down. better to have carefully calculated numbers
-   HeaterControl[deviceId].outputproportionalpowerlimit = new_outputproportionalpowerlimit;///100;
+   HeaterControl[deviceId].outputproportionalpowerlimit = stub_outputproportionalpowerlimit;///100;
    Heater1000Slices = HeaterControl[HEATER_TYPE__DryerMainHeater].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
    Heater200aSlices = HeaterControl[HEATER_TYPE__DryerSecondaryHeater].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 6b7a01103..06da53823 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -40,6 +40,8 @@
 
 #include "StateMachines/Printing/PrintingSTM.h"
 #include "StateMachines/Initialization/PowerIdle.h"
+#include "StateMachines/Initialization/PowerOffSequence.h"
+#include "StateMachines/Initialization/InitSequence.h"
 
 
 /******************** Data Structures  ********************************************/
@@ -93,17 +95,95 @@ uint32_t    DisasterControlId = 0xFF;
 #define MINIMUM_HEATER_READ 9.0
 #define MAXIMUM_HEATER_READ 283
 
-#ifdef Use_Head_Card
 uint32_t HeaterId2PT100Id[HEATER_TYPE_MAX_HEATERS] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,HEAD_PT100_ZONE_1_0X80_0, HEAD_PT100_ZONE_2_0X80_1, HEAD_PT100_ZONE_3_0X82_0,
                                                       HEAD_PT100_ZONE_4_0X82_1, HEAD_PT100_ZONE_5_0X84_0, HEAD_PT100_ZONE_6_0X84_1,HEAD_PT100_MIXER_0X8E_0, HEAD_PT100_ZONE_7_0X86_0, HEAD_PT100_ZONE_8_0X86_1,
                                                       HEAD_PT100_ZONE_9_0X88_0, HEAD_PT100_ZONE_10_0X88_1, HEAD_PT100_ZONE_11_0X8A_0, HEAD_PT100_ZONE_12_0X8A_1,HEAD_PT100_AIR_HEATER_2_0X8C_1,HEAD_PT100_AIR_HEATER_1_0X8C_0 };
 HEATERS_CURRENT HeaterId2CurrentId[HEATER_TYPE_MAX_HEATERS] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEAD_CURRENT_ZONE_1, HEAD_CURRENT_ZONE_2,
                                                                HEAD_CURRENT_ZONE_3, HEAD_CURRENT_ZONE_4, HEAD_CURRENT_ZONE_5, HEAD_CURRENT_ZONE_6, HEAD_CURRENT_MIXER, HEAD_CURRENT_ZONE_7,
                                                                HEAD_CURRENT_ZONE_8, HEAD_CURRENT_ZONE_9, HEAD_CURRENT_ZONE_10, HEAD_CURRENT_ZONE_11, HEAD_CURRENT_ZONE_12,HEAD_CURRENT_HTIN_1,HEAD_CURRENT_HTOT_1};
-#else
-uint32_t HeaterId2PT100Id[HEATER_TYPE_MAX_HEATERS] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HEAD6_PT100,MIXER_PT100,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
-HEATERS_CURRENT HeaterId2CurrentId[HEATER_TYPE_MAX_HEATERS] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEATER_HEAD_CURRENT_ZONE_1,HEATER_HEAD_CURRENT_ZONE_2,HEATER_HEAD_CURRENT_ZONE_3,HEATER_HEAD_CURRENT_ZONE_4,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_MIXCHIP_CURRENT};
-#endif
+void initializeArrays(void)
+{
+    int i;
+    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
+    {
+        HeaterId2PT100Id[i] = 0xFF;
+        HeaterId2CurrentId[i] = NUM_OF_CURRENT_HEATERS;
+    }
+    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    {
+        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;
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     HEAD_PT100_AIR_HEATER_1_0X8C_0 ;
+
+        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;
+
+    }
+    else
+    {
+        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] =          TEMP_SENSE_ANALOG_DYEINGH_TEMP1;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone2] =          TEMP_SENSE_ANALOG_DYEINGH_TEMP2;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone3] =          TEMP_SENSE_ANALOG_DYEINGH_TEMP3;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone4] =          TEMP_SENSE_ANALOG_DYEINGH_TEMP4;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone5] =          TEMP_SENSE_ANALOG_DYEINGH_TEMP5;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone6] =          HEAD6_PT100;
+        HeaterId2PT100Id[HEATER_TYPE__MixerHeater] =          MIXER_PT100;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone7] =          0xFF;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone8] =          0xFF;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone9] =          0xFF;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone10] =         0xFF;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone11] =         0xFF;
+        HeaterId2PT100Id[HEATER_TYPE__HeaterZone12] =         0xFF;
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater1] =     0xFF;
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     0xFF;
+
+        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] =          HEATER_HEAD_CURRENT_ZONE_1;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone2] =          HEATER_HEAD_CURRENT_ZONE_2;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone3] =          HEATER_HEAD_CURRENT_ZONE_3;
+        HeaterId2CurrentId[HEATER_TYPE__HeaterZone4] =          HEATER_HEAD_CURRENT_ZONE_4;
+        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;
+
+    }
+}
 uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
 bool HeatersRestart = false;
 
@@ -125,6 +205,7 @@ Mailbox_Handle  HeatersControlMsgQ = NULL;
 bool    HeaterReady[HEATER_TYPE_MAX_HEATERS] = {true};
 bool    HeaterAtTemp[HEATER_TYPE_MAX_HEATERS] = {true};
 uint32_t HeaterPreviousRead[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters
+uint32_t HeaterSpikeRead[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters
 EventType HeaterEventType[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,
                                          EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,
                                               EVENT_TYPE__MIXER_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_7_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_8_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_9_OVERTEMPERATURE,
@@ -216,7 +297,7 @@ typedef enum{
     MAX_INTERNAL_ALARMS
 }InternalTemperatureTestPointsEnum;
 int InternalAlarmCounter[MAX_INTERNAL_ALARMS] = {0,0,0};
-uint32_t InternalId2PT100Id[MAX_INTERNAL_ALARMS] = {TEMP_SENSE_AN_ENCLOSURETEMP1,TEMP_SENSE_AN_ENCLOSURETEMP1,0xFF};
+uint32_t InternalId2PT100Id[MAX_INTERNAL_ALARMS] = {TEMP_SENSE_AN_ENCLOSURETEMP1,TEMP_SENSE_AN_ENCLOSURETEMP2,0xFF};
 int32_t    InternalOverHeatCounter [MAX_INTERNAL_ALARMS] = {0,0,0};
 bool    InternalAlarmActive[MAX_INTERNAL_ALARMS] = {false,false,false};
 uint32_t ControlIdtoInternalId[MAX_INTERNAL_ALARMS] = {0xFF,0xFF,0xFF};
@@ -362,7 +443,10 @@ uint32_t HeatersSingleHeaterEnd(int HeaterId)
             HeaterCmd[HeaterId].targettemperatue = 0;
             HeaterReady[HeaterId] = true;
             HeaterAtTemp[HeaterId] = true;
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
+            if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+                Disable_Reading_Heaters_ADC(HeaterId2CurrentId[HeaterId]);
+            else
+                Disable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
         }
         else if (HeaterId < MAX_AC_HEATERS) //AC Heaters
         {
@@ -390,8 +474,8 @@ uint32_t HeatersSingleHeaterEnd(int HeaterId)
             }
             DeActivateHeater(HEATER_TYPE__DryerMainHeater);
             DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
+            //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
+            //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
             HeaterPIDConfig[HeaterId].m_SetParam = 0;
             HeaterCmd[HeaterId].targettemperatue = 0;
             HeaterReady[HeaterId] = true;
@@ -615,6 +699,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     HeaterAtTemp[HeaterId] = false;
     if (BlowerCfg.enabled == true)
     {
+        //WHS_Start_Blower_Control_Closed_Loop(2.5);
         Turn_the_Blower_On();//Turn on with the Default_Voltage
         if (BlowerCfg.heatingvoltage)
             Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
@@ -641,7 +726,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
     HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
     if((HeaterPreviousRead[HeaterId]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HeaterId]))
     {
-        ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HeaterId,RpError, 0,0);
+        ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,HeaterId,HeaterPreviousRead[HeaterId],RpError, 0,0);
         if (ControlIdtoMaxHeaterId [HeaterId] != 0xFF)
         {
             RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
@@ -671,7 +756,10 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
     AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false);
     AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);
 
-    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
+    if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+        Enable_Reading_Heaters_ADC(HeaterId2CurrentId[HeaterId]);
+    else
+        Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
 
     //ReportWithPackageFilter(HeatersFilter,"PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
@@ -785,17 +873,11 @@ bool HeaterGetOverTemperatureState(uint8_t HeaterId)
     return HeaterMaxTempFlag[HeaterId];
 }
 uint32_t MainPT100Read = 0,SecondaryPT100Read = 0;
-int MinuteCallerMaxAc = 0,MinuteCallerMaxDc = 0,MinuteCallerAc = 0,MinuteCallerDc = 0;
 uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=HEATER_TYPE_MAX_HEATERS;
     int32_t MaxreadValue;
 
-    if (MinuteCallerMaxAc++ >= 60)
-    {
-        MinuteCallerMaxAc = 0;
-        ReportWithPackageFilter(HeatersFilter, "MinuteCallerMaxAc",__FILE__,__LINE__,IfIndex,RpError, readValue,0);
-    }
     if (IfIndex>>8 != IfTypeHeaters)
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
@@ -812,6 +894,15 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
         ReportWithPackageFilter(HeatersFilter,"Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        if (HeaterSpikeRead[index] == 0)
+        {
+            HeaterSpikeRead[index] = readValue;
+        }
+        else
+        {
+            HeaterPreviousRead[index] = HeaterSpikeRead[index];
+            HeaterSpikeRead[index] = 0;
+        }
         HeaterMaxTempFlag[index] = true;
         DeActivateHeater(HEATER_TYPE__DryerMainHeater);
         HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
@@ -869,11 +960,6 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=HEATER_TYPE_MAX_HEATERS;
-    if (MinuteCallerMaxDc++ >= 60*10)
-    {
-        MinuteCallerMaxDc = 0;
-        ReportWithPackageFilter(HeatersFilter, "MinuteCallerMaxDc",__FILE__,__LINE__,IfIndex,RpError, readValue,0);
-    }
     if (IfIndex>>8 != IfTypeHeaters)
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
@@ -885,7 +971,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
         return OK;
     if ((HeaterPreviousRead[index]) >= HeaterControl[index].sensormaxvalue)
     {
-        ReportWithPackageFilter(HeatersFilter,"Heater over the max temperature",__FILE__,OverHeatCounter[index],index,RpWarning,HeaterControl[index].sensormaxvalue,  0);
+        ReportWithPackageFilter(HeatersFilter,"Heater over the max temperature",__FILE__,index,OverHeatCounter[index],RpWarning,HeaterControl[index].sensormaxvalue,  0);
         if(OverHeatCounter[index]++ >=Overheat_Count_Limit)
         {
             OverHeatCounter[index] = Overheat_Count_Limit;
@@ -913,8 +999,8 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     {
         if (HeaterReady[index]==true)
         {
-            ReportWithPackageFilter(HeatersFilter,"Heater under the min temperature",__FILE__,UnderHeatCounter[index],index,RpWarning,HeaterControl[index].sensorminvalue,  0);
-            ReportWithPackageFilter(HeatersFilter,"Heater under the min temperature",__FILE__,HeaterReady[index],GetHeaterState(index),RpWarning,HeaterPreviousRead[index],  0);
+            ReportWithPackageFilter(HeatersFilter,"Heater under the min temperature",__FILE__,index,UnderHeatCounter[index],RpWarning,HeaterControl[index].sensorminvalue,  0);
+            ReportWithPackageFilter(HeatersFilter,"Heater under the min temperature more info",__FILE__,HeaterReady[index],GetHeaterState(index),RpWarning,HeaterPreviousRead[index],  0);
         }
         if(UnderHeatCounter[index]++ >=Underheat_Count_Limit)
         {
@@ -968,11 +1054,6 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=HEATER_TYPE_MAX_HEATERS;
     //uint8_t len = 0;
-    if (MinuteCallerAc++ >= 60)
-    {
-        MinuteCallerAc = 0;
-        ReportWithPackageFilter(HeatersFilter, "MinuteCallerAc",__FILE__,__LINE__,IfIndex,RpError, readValue,0);
-    }
     if (IfIndex>>8 != IfTypeHeaters)
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
@@ -999,6 +1080,15 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         ReportWithPackageFilter(HeatersFilter,"AC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         if (readValue > HeaterCmd[index].targettemperatue)
         {
+            if (HeaterSpikeRead[index] == 0)
+            {
+                HeaterSpikeRead[index] = readValue;
+            }
+            else
+            {
+                HeaterPreviousRead[index] = HeaterSpikeRead[index];
+                HeaterSpikeRead[index] = 0;
+            }
             DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
             DeActivateHeater(HEATER_TYPE__DryerMainHeater);
             HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
@@ -1073,21 +1163,22 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
               &&  (readValue < (HeaterCmd[index].targettemperatue *  ((100+HeaterControl[index].outputproportionalband)/100))))
         {
             //InitialHeating = false;
-            ReportWithPackageFilter(HeatersFilter,"AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
+            ReportWithPackageFilter(HeatersFilter,"AC PID Activating",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
             DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
             HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
             HeatersControlStart();
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
             if (BlowerCfg.enabled == true)
             {
+                //WHS_Start_Blower_Control_Closed_Loop(5.0);
                 Turn_the_Blower_On();//Turn on with the Default_Voltage
                 if (BlowerCfg.voltage)
                     //Gradual_Increase_Blower(BlowerCfg.heatingvoltage,BlowerCfg.voltage);
                     Control_Voltage_To_Blower(BlowerCfg.voltage);
             }
             HeaterReady[index] = true;
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
+            //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
+            //Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
 
         }
         return OK;
@@ -1097,7 +1188,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
             {
                 //InitialHeating = false;
-                ReportWithPackageFilter(HeatersFilter,"AC Ready",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
+                ReportWithPackageFilter(HeatersFilter,"AC Ready",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
                 HeaterAtTemp[index] = true;
                 HeaterPrepareReady();
             }
@@ -1172,11 +1263,6 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     int index=HEATER_TYPE_MAX_HEATERS;
     //int len;
    //uint8_t len = 0;
-    if (MinuteCallerDc++ >= 60*10)
-    {
-        MinuteCallerDc = 0;
-        ReportWithPackageFilter(HeatersFilter, "MinuteCallerDc",__FILE__,__LINE__,IfIndex,RpError, readValue,0);
-    }
     if (IfIndex>>8 != IfTypeHeaters)
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
@@ -1202,6 +1288,15 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             DeActivateHeater(index);
             HeaterRecalculateHeaterParams(index, 0);
+            if (HeaterSpikeRead[index] == 0)
+            {
+                HeaterSpikeRead[index] = readValue;
+            }
+            else
+            {
+                HeaterPreviousRead[index] = HeaterSpikeRead[index];
+                HeaterSpikeRead[index] = 0;
+            }
         }
     }
     HeaterPreviousRead[index] = readValue;
@@ -1226,7 +1321,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                     DeActivateHeater(index);
                     HeaterRecalculateHeaterParams(index, 0);
                     //Heaters OFF until coming into the proportional band
-                    ReportWithPackageFilter(HeatersFilter,"HEATER Over temperature ", __FILE__,__LINE__,index, RpMessage, readValue, 0);
+                    ReportWithPackageFilter(HeatersFilter,"HEATER Over temperature ", __FILE__,index,HeaterCmd[index].targettemperatue, RpMessage, readValue, 0);
                     return OK;
                 }
         if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
@@ -1246,7 +1341,10 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             //DCInitialHeating[index] = false;
             HeatersControlStart();
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[index]);
+            if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+                Disable_Reading_Heaters_ADC(HeaterId2CurrentId[index]);
+            else
+                Disable_Reading_Heaters_Current(HeaterId2CurrentId[index]);
             HeaterReady[index] = true;
         }
         return OK;
@@ -1257,6 +1355,11 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             ReportWithPackageFilter(HeatersFilter,"DC Ready",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
             HeaterAtTemp[index] = true;
+            if (HeaterReady[index] == false)
+            {
+                HeaterReady[index] = true;
+                ReportWithPackageFilter(HeatersFilter,"DC FastReady",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
+            }
             HeaterPrepareReady();
         }
     }
@@ -1365,7 +1468,7 @@ uint32_t HeatersDisasterControl(uint32_t x,uint32_t y)
         temperature = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
         if ((temperature>=HeaterDisasterTemp[HeaterId])&&(temperature<28300))
         {
-            ReportWithPackageFilter(HeatersFilter,"Disaster Temperature ",__FILE__,HeaterId,temperature,RpWarning,HeaterDisasterTemp[HeaterId], 0);
+            //ReportWithPackageFilter(HeatersFilter,"Disaster Temperature ",__FILE__,HeaterId,temperature,RpWarning,HeaterDisasterTemp[HeaterId], 0);
             if (HeaterDisasterCounter[HeaterId]++ >= DISASTER_COUNTER_LIMIT)
                 HeaterDisasterCounter[HeaterId] = DISASTER_COUNTER_LIMIT;
         }
@@ -1383,6 +1486,78 @@ uint32_t HeatersDisasterControl(uint32_t x,uint32_t y)
     }
     return OK;
 }
+bool UseSecondaryDrierHeater = true;
+double TotalCurrentLimit(double VAC)
+{
+    if (VAC<=210)
+    {
+        return 5.8;
+    }
+    else if (VAC>222)
+    {
+        return 5.15;
+    }
+    else
+    {
+        return 5.5;
+    }
+
+}
+uint32_t DrierHeaterVoltageSetup(double voltage)
+{
+    double DrierAcVoltage = 0.0;
+    char str[100];
+    bool tempDrier2 = UseSecondaryDrierHeater;
+
+    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD) //rapid/pp machines
+    {
+        DrierAcVoltage = ReadVAC();
+        if (DrierAcVoltage<=180)
+        {
+            AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
+            ReportWithPackageFilter(HeatersFilter,"Power too low!!!!!", __FILE__,__LINE__,DrierAcVoltage, RpMessage, 0, 0);
+        }
+        else if (DrierAcVoltage>264)
+        {
+            AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
+            ReportWithPackageFilter(HeatersFilter,"Power too high!!!!!", __FILE__,__LINE__,DrierAcVoltage, RpMessage, 0, 0);
+            ReportWithPackageFilter(HeatersFilter,"Power too high!!!!!", __FILE__,__LINE__,DrierAcVoltage, RpMessage, 0, 0);
+            ReportWithPackageFilter(HeatersFilter,"Power too high!!!!!", __FILE__,__LINE__,DrierAcVoltage, RpMessage, 0, 0);
+            HeatersEnd();
+            //PowerOffPowerOff();
+        }
+        else if (DrierAcVoltage<205)
+        {
+            UseSecondaryDrierHeater = true;
+        }
+        else if (DrierAcVoltage>224)
+        {
+            UseSecondaryDrierHeater = false;
+        }
+        else
+        {
+            if ((GetZone2RMSCurrent(DrierAcVoltage)+Get_Heaters_Current(HEATER_DRYER_CURRENT_1))>TotalCurrentLimit(DrierAcVoltage))
+            {
+                UseSecondaryDrierHeater = false;
+            }
+            else
+            {
+                UseSecondaryDrierHeater = true;
+            }
+        }
+    }
+    else
+    {
+        UseSecondaryDrierHeater = true;
+    }
+    if (tempDrier2 != UseSecondaryDrierHeater)
+    {
+        usnprintf(str, 100, "\r\n Changing Drier 2 setting VAC %d D1 Current %d D2 assumed current %d limit %d"
+                        ,DrierAcVoltage,(int)(GetZone2RMSCurrent(DrierAcVoltage)*100),(int)(Get_Heaters_Current(HEATER_DRYER_CURRENT_1)*100),(int)(TotalCurrentLimit(DrierAcVoltage)*100));
+        ReportWithPackageFilter(HeatersFilter,str, __FILE__,__LINE__,DrierAcVoltage, RpMessage, UseSecondaryDrierHeater, 0);
+    }
+return OK;
+}
 uint32_t HeatersControlLoop(uint32_t tick)
 {
     //char str[100];
@@ -1410,7 +1585,7 @@ uint32_t HeatersControlLoop(uint32_t tick)
 
     if (AcHeaterDisaster == false)
     {
-        if (HeaterReady[HEATER_TYPE__DryerAirHeater] == true)
+        //if (HeaterReady[HEATER_TYPE__DryerAirHeater] == true)
         {
             if (TimeSliceAllocation[SliceCounter] == HEATER_TYPE__DryerMainHeater)
             {
@@ -1422,9 +1597,9 @@ uint32_t HeatersControlLoop(uint32_t tick)
                     //DeActivate HEATER_TYPE__DryerSecondaryHeater
                     //DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                 }
-                if (HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)
+                if ((HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)&&(UseSecondaryDrierHeater == true))
                 {
-#warning trial use both heaters in drier
+//#warning trial use both heaters in drier
                     ActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                     //DeActivate HEATER_TYPE__DryerSecondaryHeater
                     //DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index f43cf8c56..6e4eed580 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -27,9 +27,9 @@
 
 uint32_t CloseValveTimeout = 10;
 uint32_t OpenValveTimeout = 10;
-#define DISPENSER_BUILD_PRESSURE_SPEED 900
-#define DISPENSER_BUILD_PRESSURE_LIMIT 1.5
-#define DISPENSER_BUILD_PRESSURE_TIMEOUT 60000
+#define DISPENSER_BUILD_PRESSURE_SPEED 940
+#define DISPENSER_BUILD_PRESSURE_LIMIT 1.0
+#define DISPENSER_BUILD_PRESSURE_TIMEOUT 120000
 #define DISPENSER_BUILD_PRESSURE_LAG 50
 #define DEFAULT_NANOLITER_PER_PULSE 2.34
 uint32_t DispenserPrepareSpeed = DISPENSER_BUILD_PRESSURE_SPEED;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index a819448a8..5c01d7563 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -76,6 +76,8 @@ uint32_t IDS_StopHomeDispenser (uint32_t deviceID);
 uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId,  uint32_t timeout , callback_fptr callback);
 bool     IDS_IsHomingActive(uint32_t DispenserId);
 
+
+
 uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback);
 uint32_t IDS_Dispenser_Alarm_On (uint8_t deviceID);
 uint32_t IDS_Dispenser_Alarm_Off (uint8_t deviceID);
@@ -90,6 +92,8 @@ void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, doubl
 void IDS_Dispenser_SetPreSegmentCleaningValues(double ids_cleaningspeed,double ids_cleaningstartspraypresegmenttime ,double ids_cleaningstopbeforesegmenttime,double ids_leftcleaningmotorspeed,double ids_rightcleaningmotorspeed);
 void IDS_Dispenser_SetAutoHoming_Config(AutoHoming_Config_enum Config);
 
+bool Set_Check_Pressure_Bypass(int);
+
 uint32_t IDS_Dispenser_Close_Valve_And_Stop_Motor(int DispenserId, callback_fptr callback);
 uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpeed, callback_fptr callback);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index ad0f29392..3b6291285 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -90,7 +90,11 @@ AutoHoming_Config_enum AutoHoming_Config = AutoHoming_off;
 void IDS_Dispenser_SetAutoHoming_Config(AutoHoming_Config_enum Config)
 {
     Report("IDS_Dispenser_SetAutoHoming_Config ",__FILE__,__LINE__,Config,RpWarning,AutoHoming_Config,0);
+#ifdef SPECIAL_DISPENSERS
+    AutoHoming_Config = AutoHoming_off;
+#else
     AutoHoming_Config = Config;
+#endif
 }
 
 void IDS_Dispenser_SetBackLashValues(double   initialdispenserpressure,   uint32_t initialdispensertimeout,   uint32_t initialdispensertimelag,   uint32_t initialdispenserspeed)
@@ -199,7 +203,7 @@ uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
 //    MotorSetSpeed(motorId, InitialDispenserSpeed);
     CurrentDispenserSpeed[DispenserId] = 0;
 /////////////////////////////////////////////////////////////
-    if (Extended_Motor_Param == true)
+    if (Extended_Motor_Param[motorId] == true)
         Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
     //MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     HomingActive[DispenserId]= false;
@@ -264,7 +268,7 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
         HomingActive[DispenserId] = true;
         //open dispenser valve dispenser to midtank direction
         Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-        if (Extended_Motor_Param == true)
+        if (Extended_Motor_Param[MotorId] == true)
             Power_Step_01_Dispenser_Mode(DispenserId,Current);
         KeepMicrostep[DispenserId] = MotorsCfg[MotorId].microstep;
         //MotorSetMicroStep(MotorId, 1);
@@ -275,15 +279,15 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
         IDS_Dispenser_RefillStarted(DispenserId,1);
         if (DispenserId== LUBRICANT_DISPENSER)
         {
-            MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed/2,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
-            CurrentDispenserSpeed[DispenserId] = speed/2;
-            Report("IDS_HomeDispenser ",__FILE__,__LINE__,(int)DispenserId,RpWarning,speed/2,0);
+            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);
         }
         else
         {
             MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
             CurrentDispenserSpeed[DispenserId] = speed;
-            Report("IDS_HomeDispenser ",__FILE__,__LINE__,(int)DispenserId,RpWarning,speed,0);
+            Report("IDS_HomeDispenser ",__FILE__,(int)midTankContent*1000,(int)DispenserId,RpWarning,speed,0);
         }
         CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]);
         return OK;
@@ -322,7 +326,7 @@ uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
     HomingActive[DispenserId] = false;
     PrimingActive[DispenserId] = false;
     Control_TCA9534ByPass(DispenserId,DISABLE);// use ENABLE or DISABLE
-    if (Extended_Motor_Param == true)
+    if (Extended_Motor_Param[MotorId] == true)
         Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
     //MotorSetMicroStep(MotorId, KeepMicrostep[DispenserId]);
     CurrentDispenserSpeed[DispenserId] = 0;
@@ -400,7 +404,7 @@ uint32_t IDS_EmptyDispenserCallback(uint32_t motorId, uint32_t ReadValue)
 
     MotorStop(motorId,Hard_Hiz);
     CurrentDispenserSpeed[DispenserId] = 0;
-    if (Extended_Motor_Param == true)
+    if (Extended_Motor_Param[motorId] == true)
         Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
     //MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     PrimingActive[DispenserId]= false;
@@ -445,7 +449,7 @@ uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fpt
         HomingRequestCallback[DispenserId] = callback;
         //open dispenser valve dispenser to midtank direction
         Control3WayValvesWithCallback ((Valves_t)DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-        if (Extended_Motor_Param == true)
+        if (Extended_Motor_Param[MotorId] == true)
             Power_Step_01_Dispenser_Mode(DispenserId,Current);
         //Valve_Set((Valves_t) request->index, Dispenser_Mixer);
         KeepMicrostep[DispenserId] = MotorsCfg[MotorId].microstep;
@@ -473,7 +477,7 @@ uint32_t IDS_Dispenser_Alarm_On (uint8_t DispenserId)
     status |= MotorAbortMovetoLimitSwitch(MotorId);
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Disable_MidTank_Pressure_Reading(DispenserId);
-    if (Extended_Motor_Param == true)
+    if (Extended_Motor_Param[MotorId] == true)
         Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
     //status |= MotorSetMicroStep(MotorId, KeepMicrostep[DispenserId]);
     status |= MotorStop(MotorId, Hard_Hiz);
@@ -496,6 +500,15 @@ uint32_t IDS_ReCheck_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
 
     return OK;
 }
+bool Check_Pressure_Bypass = false;
+bool Set_Check_Pressure_Bypass (int value)
+{
+    if (value == 0)
+        Check_Pressure_Bypass = false;
+    else
+        Check_Pressure_Bypass = true;
+    return Check_Pressure_Bypass;
+}
 uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
 {
     TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
@@ -507,6 +520,8 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
             return ERROR;
         }
     }
+    if (Check_Pressure_Bypass == true)
+        return OK;
 
     if (GetDispenserPressure(DispenserId)>3.0)
     {
@@ -533,7 +548,8 @@ void IDS_Dispenser_Init(uint8_t DispenserId)
     PrimingActive[DispenserId]= false;
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+#ifdef SPECIAL_DISPENSERS
     if (ControlIdtoInactiveDispenserId[DispenserId] == 0xFF)
         ControlIdtoInactiveDispenserId[DispenserId] = AddControlCallback("IDS_Check_Pressure", IDS_Check_Pressure_Callback, eOneMinute,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
-
+#endif
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 708b11342..0c28ee564 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -519,16 +519,16 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
              {
                  HW_Motor_Id = DispenserIdToMotorId[i];
-                 if (GetDispenserPressure(i) > DispenserPreparePressure)
+                 if (GetDispenserPressure(i) > DispenserPreparePressure*1.05)
                  {
                      NumofReadyDispensers++;
-                     CurrentDispenserSpeed[i] = 0;
 #ifdef SPECIAL_DISPENSERS
                      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.985>100)?tempSpeed*0.985:100;
+                     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);
@@ -543,7 +543,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 #else
                      tempSpeed = CurrentDispenserSpeed[i];
 #endif
-                     updatedSpeed = (tempSpeed*1.02<InitialDispenserSpeed)?tempSpeed*1.02:InitialDispenserSpeed;
+                     updatedSpeed = (tempSpeed*1.03<InitialDispenserSpeed)?tempSpeed*1.03:InitialDispenserSpeed;
                      MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                      CurrentDispenserSpeed[i] = updatedSpeed;
 #ifdef SPECIAL_DISPENSERS
@@ -569,7 +569,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              Report("pressureReady = true  or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
          }
      }
-#ifndef SPECIAL_DISPENSERS
+//#ifndef SPECIAL_DISPENSERS
      else if (endOfPrepareWCF == false)
      {
          if ((DispenserBuildTimeCounter == PRESSURE_READ_TIME_GAP)&&(FirstBrushStop))
@@ -614,8 +614,11 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                              segmentfirst_speed /= 100;
                              DispenserSegmentReady[DispenserId] = false;
                              //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-                             //IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed,NULL);
+#ifdef SPECIAL_DISPENSERS
+                             IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed,NULL);
+#else
                              MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
+#endif
                              CurrentDispenserSpeed[Dispenser_i] = segmentfirst_speed;
 
                              usnprintf(IdMessage, 80,
@@ -657,13 +660,13 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
          }
      }
-#endif
+/*#endif
 #ifdef SPECIAL_DISPENSERS
      if (pressureReady == true)
-#else
+#else*/
      //start new stage
      if (endOfPrepareWCF == true)
-#endif
+//#endif
      {
          SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
          DispenserPrepareControlId = 0xFF;
@@ -785,6 +788,9 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
          for (i = 0; i < MAX_DYE_DISPENSERS; i++)
          {
              dispenserspeed = DispenserPrepareSpeed;
+#ifdef SPECIAL_DISPENSERS
+             dispenserspeed = 300;
+#endif
              TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[i];
 
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
@@ -1024,7 +1030,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
 */
      //InterSegmentStepsLimit = lInterSegmentLength*10;//100 millisec steps
      InterSegmentStepsCount+=100;
-     if (InterSegmentStepsCount == lInterSegmentLength)
+     if (InterSegmentStepsCount >= lInterSegmentLength)
      {
          //IDS_Valve_PresegmentReady(1,0);
          Report("End of Pre-segment Handling",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
@@ -1033,6 +1039,8 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          if (CurrentDispenserSpeed[CLEANER_DISPENSER]>0)
              IDS_Cleaning_Stop_Cleaning_Solution (NULL);
          setRapidPressureRead(false);
+         if (JobEndSequence == true)
+             DistanceToSpoolReady(Module_IDS,ModuleDone);
      }
      if (EnableCleaning == true)
      {
@@ -1058,7 +1066,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          //cleaning
          return OK;
      }
-#ifndef SPECIAL_DISPENSERS
+//#ifndef SPECIAL_DISPENSERS
      if ((InterSegmentStartWFCFDispensers > 12000)&&(InterSegmentStartWFCFDispensers == (InterSegmentStepsCount+12000)))
      {
 	 	//start prepare 4 seconds before wcf
@@ -1139,7 +1147,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          //close waste valve one second before segment - trial
          Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
      }
-#endif
+//#endif
      return OK;
  }
 uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
@@ -1510,7 +1518,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
 #else
      Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
 #endif
-     //IDS_Cleaning_Stop_Cleaning_Solution(NULL);
+     IDS_Cleaning_Stop_Cleaning_Solution(NULL);
      SegmentNumOfBrushStops = Segment->n_brushstops;
      BrushStopTime = Segment->length*1000/(double)SegmentNumOfBrushStops;  //brushstop in meters //brushstop in millisecond
      BrushStopTime = ((BrushStopTime*100)/dyeingspeed);//brushstop in seconds
@@ -1537,7 +1545,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
     if (DispenserPreSegmentControlId != 0xFF)
     {
         Report("IDS presegment not yet ended!!",__FILE__,__LINE__,(int)InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
-        IDS_Cleaning_Stop_Cleaning_Solution (NULL);
+        //IDS_Cleaning_Stop_Cleaning_Solution (NULL);
         RemoveControlCallback(DispenserPreSegmentControlId, IDSPreSegmentStateCallbackRunner );
         DispenserPreSegmentControlId = 0xFF;
     }
@@ -1580,6 +1588,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
   {
       int i;
       DispenserDistanceToSpoolReady[deviceID] = true;
+      REPORT_MSG(deviceID,"IDS_Valve_DistanceToSpoolReady End called");
       for (i=0;i<MAX_DYE_DISPENSERS;i++)
       {
           if (DispenserDistanceToSpoolReady[i] == false)
@@ -1587,7 +1596,6 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
               return OK; //not all configured heaters are ready
           }
       }
-      REPORT_MSG(deviceID,"IDS_Valve_DistanceToSpoolReady End called");
       DistanceToSpoolReady(Module_IDS,ModuleDone);
    return OK; // all configured heaters are ready
   }
@@ -1596,22 +1604,23 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
  {
      int Dispenser_i;
 
-     REPORT_MSG(100,"Dispenser DTS");
+     REPORT_MSG(NumOfActiveDispensers,"Dispenser DTS");
      Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste);  //#bug 323
          for (Dispenser_i = 0;Dispenser_i < MAX_DYE_DISPENSERS;Dispenser_i++)
          {
              DispenserDistanceToSpoolReady[Dispenser_i] = true;
-             if (DispenserUsedInJob[Dispenser_i]==false)//unconfigured dispenser
-                 continue;
-             DispenserDistanceToSpoolReady[Dispenser_i] = false;
-#ifdef SPECIAL_DISPENSERS
-             IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
-#else
-             MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
-#endif
-             Control3WayValvesWithCallback ((Valves_t)Dispenser_i, MidTank_Dispenser, IDS_Valve_DistanceToSpoolValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
-             CurrentDispenserSpeed[Dispenser_i] = 0;
-             //IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_DistanceToSpoolValveReady);
+             if (DispenserUsedInJob[Dispenser_i]==true)//unconfigured dispenser
+             {
+                 DispenserDistanceToSpoolReady[Dispenser_i] = false;
+    #ifdef SPECIAL_DISPENSERS
+                 IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
+    #else
+                 MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
+    #endif
+                 Control3WayValvesWithCallback ((Valves_t)Dispenser_i, MidTank_Dispenser, IDS_Valve_DistanceToSpoolValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
+                 CurrentDispenserSpeed[Dispenser_i] = 0;
+                 //IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_DistanceToSpoolValveReady);
+             }
          }
 
          //cleaning
@@ -1622,13 +1631,13 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          lInterSegmentLength = (dryerbufferCentimeters*1000/dyeingspeed);
          lInterSegmentLength-=(lInterSegmentLength%100);   //round to a 100 multiplication
          InterSegmentStepsCount = 0;
-         DispenserPreSegmentControlId = AddControlCallback(NULL, IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
+         DispenserPreSegmentControlId = AddControlCallback("IDS DTS", IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
          if (DispenserPreSegmentControlId == 0xFF)
          {
              Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
              return ERROR;
          }
-         Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)IntersegmentLength,0);
+         Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
          /*if (EnableCleaning == true)
          {
              InterSegmentStartSprayCleaner = 500;
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
index a358bd724..a98cc173e 100644
--- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
@@ -104,15 +104,13 @@ bool DetectIfCartridgeFinished(int int_MidTank_Pressure_1000)
 
 WHS_sensor CartridgeInkCallBackFunction()
 {
-    uint32_t parameter = 6 ;
-
-    WHS_sensor ret = WHS_no_event;
+     WHS_sensor ret = WHS_no_event;
 
     if (IFS_info.IFS_Ink_precense_sensor != RdInkCartridgeSensor())
     {
-        REPORT_MSG(parameter," ------------ find  : IFS_Ink_presence_sensor event   ----------------- ");
         WHS_info.event = IFS_INK_presence_sensor;
         IFS_info.IFS_Ink_precense_sensor = !IFS_info.IFS_Ink_precense_sensor;
+        ReportWithPackageFilter(WasteFilter,"------------ find  : IFS_Ink_presence_sensor event  -----------------", __FILE__,__LINE__, IFS_info.IFS_Ink_precense_sensor, RpMessage, 0, 0);
         ret = IFS_INK_presence_sensor;
     }
     return ret;
@@ -173,11 +171,10 @@ WHS_sensor CartridgeInkTimeOutCallBackFunction()
     /*** first TimeOut  ***/
     if (IFS_info.Ink.time_out == CARTRIDGE_INK_TIMEOUT)
     {
-        ReportWithPackageFilter(WasteFilter,"------------ first IFS_info.Ink.time_out   -----------------", __FILE__, __LINE__, (IFS_info.Ink.time_out * SECONDS_5), RpMessage, MidTank_Pressure, 0);
+        ReportWithPackageFilter(WasteFilter,"------------ first IFS_info.Ink.time_out, close valves  -----------------", __FILE__, __LINE__, (IFS_info.Ink.time_out * SECONDS_5), RpMessage, (int_MidTank_Pressure_1000), 0);
         //IFS_info.Ink.time_out = 0;
         //return IFS_info.event = IFS_Timeout;
 
-       REPORT_MSG(WHS_emptying," ------------ IFS_Timeout close valves----------------- ");
         // try again :
         // start timeout
         // close and open the correct valves
@@ -189,13 +186,13 @@ WHS_sensor CartridgeInkTimeOutCallBackFunction()
 
     if (IFS_info.Ink.time_out == (CARTRIDGE_INK_TIMEOUT + 1)) //need to open the valve for second chance
         {
-        ReportWithPackageFilter(WasteFilter,"------------ IFS_Timeout open valves for second timeout  -----------------", __FILE__, __LINE__, (IFS_info.Ink.time_out * SECONDS_5), RpMessage, MidTank_Pressure, 0);
+        ReportWithPackageFilter(WasteFilter,"------------ IFS_Timeout open valves for second timeout  -----------------", __FILE__, __LINE__, (IFS_info.Ink.time_out * SECONDS_5), RpMessage, (int_MidTank_Pressure_1000), 0);
         MidTankValvesAction(Cartridge_MidTank_ON);
         }
 
     if (IFS_info.Ink.time_out >= (CARTRIDGE_INK_TIMEOUTx2 + 1))
         {
-            REPORT_MSG(WHS_full," ------------ IFS_Timeout_Second_Time ----------------- ");
+            ReportWithPackageFilter(WasteFilter,"------------ IFS_Timeout_Second_Time  -----------------", __FILE__, __LINE__, (IFS_info.Ink.time_out * SECONDS_5), RpMessage, (int_MidTank_Pressure_1000), 0);
             IFS_info.Ink.time_out = 0;
             MidTankValvesAction(Cartridge_MidTank_OFF);
             WHS_info.event = IFS_Timeout_Second;
@@ -295,7 +292,7 @@ uint32_t ReadCartridgeData(cartridge_name cart_name)
     //-------------------------------------------------------------------------------------------
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
-    REPORT_MSG(WHS_full," ------------ IFS: send message_container__pack ----------------- ");
+    ReportWithPackageFilter(WasteFilter,"------------ IFS: send message_container__pack  -----------------", __FILE__, __LINE__, CARTRIDGE_ACTION__Inserted, RpMessage, 0, 0);
     my_free(responseContainer.data.data);
     SendChars((char*)container_buffer, container_size);
 
@@ -320,19 +317,19 @@ bool CartridgeValidationResponseFunc(MessageContainer* requestContainer)
     // 2. the index is out of rang
     if (response == NULL)
     {
-        REPORT_MSG(WHS_filling," ------------ IFS_filling message from PPC is null!!! ----------------- "); // write to log error
+        ReportWithPackageFilter(WHS_filling,"------------ IFS_filling message from PPC is null!!! -----------------", __FILE__,__LINE__,0, RpMessage, 0, 0);
         return ret;
     }
 
     if (response->index < NUM_OF_MIDTANKS)
     {
         IFS_info.Ink.cart_color = response->index; // midtank 1-8
-        ReportWithPackageFilter(WasteFilter,"------------ IFS get message response->index is  -----------------", __FILE__, __LINE__, response->index, RpMessage, 0, 0);
+        ReportWithPackageFilter(WHS_filling,"------------ IFS get message response->index is  -----------------", __FILE__, __LINE__, response->index, RpMessage, 0, 0);
         WHS_info.event = IFS_INK_authentication_pass;
     }
     else
     {
-        ReportWithPackageFilter(WasteFilter,"------------ IFS get message response->index is out of rang -----------------", __FILE__, __LINE__, response->index, RpMessage, 0, 0);
+        ReportWithPackageFilter(WHS_filling,"------------ IFS get message response->index is out of rang -----------------", __FILE__, __LINE__, response->index, RpMessage, 0, 0);
         WHS_info.event = IFS_INK_authentication_fail;
     }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index c31e21e23..ccd051c71 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -10,13 +10,16 @@
 
 #include "Drivers/USB_Communication/USBCDCD.h"
 #include "StateMachines/Initialization/PowerOffSequence.h"
+#include "StateMachines/Initialization/PowerIdle.h"
 
 #include "drivers/Flash_Memory/FATFS/ff.h"
 #include "drivers/Flash_Memory/FATFS/Control_File_System.h"
+#include "drivers/Flash_ram/FlashProgram.h"
 #include "drivers/adc_sampling/adc.h"
 #include "drivers/Heater/TemperatureSensor.h"
 #include "drivers/ADC_Sampling/adc.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
+#include "Drivers/SSI_Comm/Dancer/Dancer.h"
 
 #include "Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h"
 #include "Drivers/I2C_Communication/Head_Card/Fan/fan_click.h"
@@ -27,6 +30,7 @@
 #include "Modules/IDS/ids_ex.h"
 #include "Modules/Control/MillisecTask.h"
 #include "modules/thread/thread_ex.h"
+#include "modules/heaters/heaters_ex.h"
 #include <Drivers/I2C_Communication/I2C.h>
 #include <Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.h>
 #include <Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h>
@@ -39,6 +43,8 @@
 #include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
 #include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
 
+#include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
+
 extern float NumberOfRotationPerPassage;  // how many rotations per spool passage
 
 //#include "graphics_adapter.h"
@@ -66,94 +72,164 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     uint8_t pin  = 0;
     uint8_t value= 0;
 
-#ifdef Use_WHS_Card
     if(request->amount == 0x3E9) // set TCA9555 u3 or u4
     {
-        if (request->delay & 0x8000)        // bit15 select the chip address
-        {
-            addr =  I2CExp2_ADDRESS;
-        }
-        else
+        if (WHS_Type == WHS_TYPE_NEW)
         {
-            addr =  I2CExp1_ADDRESS;
-        }
+            if (request->delay & 0x8000)        // bit15 select the chip address
+            {
+                addr =  I2CExp2_ADDRESS;
+            }
+            else
+            {
+                addr =  I2CExp1_ADDRESS;
+            }
 
-        if  (request->delay & 0x4000)   // bit 14 select port 0 or 1
-        {
-            port = D_TCA9555_PORT_1;
-        }
-        else
-        {
-            port = D_TCA9555_PORT_0;
-        }
+            if  (request->delay & 0x4000)   // bit 14 select port 0 or 1
+            {
+                port = D_TCA9555_PORT_1;
+            }
+            else
+            {
+                port = D_TCA9555_PORT_0;
+            }
 
-        pin = ((request->delay & 0x0F00) >> 8);  // 8..11
+            pin = ((request->delay & 0x0F00) >> 8);  // 8..11
 
-        if (request->delay & 0x0001)
+            if (request->delay & 0x0001)
+            {
+                value = 1;
+            }
+            else
+            {
+                value = 0;
+            }
+            response.progress = Write_WHS_9555_io_value( addr,  port,  pin,  value);
+            response.has_progress = true;
+        }
+    }
+    else
+        if((request->amount == 0x3E8) && (request->delay <= 0x0fff))// set WHS Blower speed 0x00-0xfff
         {
-            value = 1;
+            if (WHS_Type == WHS_TYPE_NEW)
+            {
+                Trigger_SetWHSBlowerVoltage (request->delay);
+                response.progress = 0;
+                response.has_progress = false;
+            }
         }
-        else
+    else
+        if (request->amount == 0x3E7) // set WHS Blower speed by Q value
         {
-            value = 0;
+             if (WHS_Type == WHS_TYPE_NEW)
+             {
+                 WHS_Set_SetPoint_Q_value((double) request->delay);
+                 response.progress = 0;
+                 response.has_progress = false;
+             }
         }
-        response.progress = Write_WHS_9555_io_value( addr,  port,  pin,  value);
-        response.has_progress = true;
-    }
     else
-        if((request->amount == 0x3E8) && (request->delay <= 0x0fff))// set WHS Blower speed 0x00-0xfff
+        if (request->amount == 0x3E6) // get WHS Blower speed by Q value
         {
-            //Trigger_WHS_Set_Volt_Blower_Control(request->delay);
-            Trigger_SetWHSBlowerVoltage (request->delay);
-            response.progress = 0;
-            response.has_progress = true;
+             if (WHS_Type == WHS_TYPE_NEW)
+             {
+                 response.progress = WHS_Get_Volt_Blower_Control();
+                 //response.progress = 0;
+                 response.has_progress = true;
+             }
         }
+    //   WHS_Get_Volt_Blower_Control
     else
-       if(request->amount == 0x3EA)
-       {
-           uint16_t tempu16;
-           switch(request->delay )// set WHS Blower speed 0x00-0xfff
-           {
-           case 0:
-               get_orf_1(&tempu16);
-               break;
-           case 1:
-               get_orf_2(&tempu16);
-               break;
-           case 2:
-               get_orf_3(&tempu16);
-               break;
-           case 3:
-               get_vlev1(&tempu16);
-               break;
-           case 4:
-               get_vlev2(&tempu16);
-               break;
-           case 5:
-               get_gas_out(&tempu16);
-               break;
-           case 6:
-               get_cur_fan(&tempu16);
-               break;
-           case 7:
-               get_cur_vlv1(&tempu16);
-               break;
-           case 8:
-               tempu16 = 0;  //get_cur_vlv2(&tempu16);
-               break;
-           default :
-               tempu16 = 0x500;  //get_cur_vlv2(&tempu16);
-               break;
-
+        if(request->amount == 0x3EA)
+        {
+            uint16_t tempu16 = 0;
+            double temp_double = 0.0;
+            if (WHS_Type == WHS_TYPE_NEW)
+            {
+                switch(request->delay )// get A2D
+                {
+                    case 0:
+                        get_orf_1(&tempu16);
+                        break;
+                    case 1:
+                        get_orf_2(&tempu16);
+                        break;
+                    case 2:
+                        get_orf_3(&tempu16);
+                        break;
+                    case 3:
+                        get_vlev1(&tempu16);
+                        break;
+                    case 4:
+                        get_vlev2(&tempu16);
+                        break;
+                    case 5:
+                        get_gas_out(&tempu16);
+                        break;
+                    case 6:
+                        get_cur_fan(&tempu16);
+                        break;
+                    case 7:
+                        get_cur_vlv1(&tempu16);
+                        break;
+                    case 8:
+                        tempu16 = 0;  //get_cur_vlv2(&tempu16);
+                        break;
+                    case 10:
+                        temp_double = get_ORF1_Q();
+                        break;
+                    case 12:
+                        temp_double = get_ORF3_Q();
+                        break;
+                    case 20:
+                        temp_double = get_average_ORF1_Q();
+                        break;
+                    case 22:
+                        temp_double = get_average_ORF3_Q();
+                        break;
 
+                    case 11:
+                        //get_orf_2(&tempu16);
+                        break;
+                    case 13:
+                        //get_vlev1(&tempu16);
+                        break;
+                    case 14:
+                        //get_vlev2(&tempu16);
+                        break;
+                    case 15:
+                        //get_gas_out(&tempu16);
+                        break;
+                    case 16:
+                        //get_cur_fan(&tempu16);
+                        break;
+                    case 17:
+                        //get_cur_vlv1(&tempu16);
+                        break;
+                    case 18:
+                        //tempu16 = 0;  //get_cur_vlv2(&tempu16);
+                        break;
+                    default :
+                        tempu16 = 0x500;  //get_cur_vlv2(&tempu16);
+                        break;
+                }
            }
+       if ((request->delay)<10)
+       {
            response.progress = (double)tempu16;
-           response.has_progress = true;
        }
+       else
+       {
+           response.progress = temp_double;
+       }
+       response.has_progress = true;
+    }
     else //
-        if(request->amount == 0x3EB)
+    if(request->amount == 0x3EB)
+    {
+        uint16_t tempu16 = 0;
+        if (WHS_Type == WHS_TYPE_NEW)
         {
-            uint16_t tempu16;
             if (request->delay <= 0x03FF)
             {
                 Trigger_WHS_Set_RDAC(request->delay);  // 0 -> 0x03FF
@@ -163,11 +239,11 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                 Trigger_WHS_set_Rheostat_to_CLEAN_AIR();
             }
             get_gas_out(&tempu16);
-            response.progress = (double)tempu16;
-            response.has_progress = true;
         }
+        response.progress = (double)tempu16;
+        response.has_progress = true;
+    }
     else
-#endif
     if((request->amount == 0xDE) && (request->delay < 8) && (request->delay >= 0)) // read dispenser type + LS status
     {
         response.progress = ((Dispenser_struct[request->delay].Type) << 8) + Dispenser_struct[request->delay].Status;
@@ -182,6 +258,34 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
+    if(request->amount == 0xAD1) //Set_Check_Pressure_Bypass
+    {
+        LOG_ERROR((request->delay)?1:0,"Set_Check_Pressure_Bypass");
+        response.progress = Set_Check_Pressure_Bypass(request->delay);
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xAD2) //Set_Thread_Rockers_Bypass
+    {
+        LOG_ERROR((request->delay)?1:0,"Set_Thread_Rockers_Bypass");
+        response.progress = Set_Thread_Rockers_Bypass(request->delay);
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xAD3) //Set_Auto_Shutdown_Bypass
+    {
+        LOG_ERROR((request->delay)?1:0,"Set_Auto_Shutdown_Bypass");
+        response.progress = Set_Auto_Shutdown_Bypass(request->delay);
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xAD4) //Set_Auto_Idle_Bypass
+    {
+        LOG_ERROR((request->delay)?1:0,"Set_Auto_Idle_Bypass");
+        response.progress = Set_Auto_Idle_Bypass(request->delay);
+        response.has_progress = true;
+    }
+    else
     if((request->amount == 0x01) && ((request->delay &0x010000) == 0x010000)) //change mode powerset01
     {
         response.progress = Power_Step_01_Mode(((request->delay &0x00FF00)>>8), request->delay &0x0000FF);
@@ -209,33 +313,143 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
     }
     else
-    if(request->amount == 0x0EAD)  //Head Card I/O
-    {
-        uint8_t Write_Buf[2] = {0,0};
-        uint8_t Script_Slave_Add = request -> delay >> 16;
-        Write_Buf[0] = request -> delay >> 8;
-        Write_Buf[1] = request -> delay & 0x0000FF;
+        if(request->amount == 0x0EAD)  //Head Card I/O
+        {
+            uint8_t Read_Buf[1] = {0};
+            uint8_t Write_Buf[2] = {0,0};
+            uint8_t Script_Slave_Add = request -> delay >> 16;//Slave address 0x40 / 0x42 / 0x44 / 0x46
+            Write_Buf[0] = (request -> delay & 0x00FF00) >> 8;//read/write low/high
+            /*
+            ------------------
+            | Byte | WR | RD |
+            ------------------
+            | Low  | 02 | 00 |
+            | High | 03 | 01 |
+            ------------------
+            */
+            Write_Buf[1] = request -> delay & 0x0000FF;//data to write
 
-        Select_Main_Head_Mux_Channel();
-        I2C_Write(I2C_ID_HEAD_CARD, Script_Slave_Add, Write_Buf, 2);
+            response.has_progress = false;
 
-        delayms(1);
+            Select_Main_Head_Mux_Channel();
 
-        uint8_t Read_Buf[2] = {0,0};
-        I2C_Read(I2C_ID_HEAD_CARD, Script_Slave_Add + 1, Read_Buf, 2);
-        response.progress = Read_Buf[1] << 8 | Read_Buf[0];
-        response.has_progress = true;
+            if(Write_Buf[0] == 0)//Read
+            {
+                Head_Read_IO_Reg(Script_Slave_Add, LOW);
 
-    }
-    else
+                delayms(1);
+                if(Script_Slave_Add == 0x40)
+                {
+                    Read_Buf[0] = Head_I2C_EXP1_0x40.uchar[0];
+                    response.progress = Read_Buf[0];
+                    response.has_progress = true;
+                }
+                else
+                if(Script_Slave_Add == 0x42)
+                {
+                    Read_Buf[0] = Head_I2C_EXP2_0x42.uchar[0];
+                    response.progress = Read_Buf[0];
+                    response.has_progress = true;
+                }
+                else
+                if(Script_Slave_Add == 0x44)
+                {
+                    Read_Buf[0] = Head_I2C_EXP3_0x44.uchar[0];
+                    response.progress = Read_Buf[0];
+                    response.has_progress = true;
+                }
+                else
+                if(Script_Slave_Add == 0x46)
+                {
+                    Read_Buf[0] = Head_I2C_EXP4_0x46.uchar[0];
+                    response.progress = Read_Buf[0];
+                    response.has_progress = true;
+                }
+            }
+            else
+
+            if(Write_Buf[0] == 1)//Read
+            {
+                Head_Read_IO_Reg(Script_Slave_Add, HIGH);
+
+                delayms(1);
+                if(Script_Slave_Add == 0x40)
+                {
+                    Read_Buf[0] = Head_I2C_EXP1_0x40.uchar[1];
+                    response.progress = Read_Buf[0];
+                    response.has_progress = true;
+                }
+                else
+                if(Script_Slave_Add == 0x42)
+                {
+                    Read_Buf[0] = Head_I2C_EXP2_0x42.uchar[1];
+                    response.progress = Read_Buf[0];
+                    response.has_progress = true;
+                }
+                else
+                if(Script_Slave_Add == 0x44)
+                {
+                    Read_Buf[0] = Head_I2C_EXP3_0x44.uchar[1];
+                    response.progress = Read_Buf[0];
+                    response.has_progress = true;
+                }
+                else
+                if(Script_Slave_Add == 0x46)
+                {
+                    Read_Buf[0] = Head_I2C_EXP4_0x46.uchar[1];
+                    response.progress = Read_Buf[0];
+                    response.has_progress = true;
+                }
+            }
+            else
+            if(Write_Buf[0] == 2)//write
+            {
+                if(Script_Slave_Add == 0x40)
+                {
+                    Head_I2C_EXP1_0x40.uchar[0] = Write_Buf[1];
+                }
+                else
+                if(Script_Slave_Add == 0x42)
+                {
+                    Head_I2C_EXP2_0x42.uchar[0] = Write_Buf[1];
+                }
+                else
+                if(Script_Slave_Add == 0x46)
+                {
+                    Head_I2C_EXP4_0x46.uchar[0] = (Write_Buf[1] & 0x80);
+                }
+
+                Head_Write_IO_Reg(Script_Slave_Add, LOW);
+            }
+            if(Write_Buf[0] == 3)//write
+            {
+                if(Script_Slave_Add == 0x40)
+                {
+                    Head_I2C_EXP1_0x40.uchar[1] = Write_Buf[1];
+                }
+                else
+                if(Script_Slave_Add == 0x42)
+                {
+                    Head_I2C_EXP2_0x42.uchar[1] = Write_Buf[1];
+                }
+                else
+                if(Script_Slave_Add == 0x46)
+                {
+                    Head_I2C_EXP3_0x44.uchar[1] = (Write_Buf[1] & 0x0C);
+                }
+                Head_Write_IO_Reg(Script_Slave_Add, HIGH);
+            }
+        }
+        else
     if(request->amount == 0xFEAD)  //functions Head Card I/O
     {
         Select_Main_Head_Mux_Channel();
 
         if((request -> delay & 0xFFF000) == 0xCAF000)//Actuator
         {
-            HeadCard_Actuators_Control((ACTUATORS)((request -> delay & 0x100)>>8), (bool)((request -> delay & 0x10)>>4), (bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
-            response.progress = HeadCard_Actuators_Status((ACTUATORS)(request -> delay & 0x100)>>8);
+            //HeadCard_Actuators_Control((ACTUATORS)(((request -> delay) & 0x100)>>8), /*(bool)((request -> delay & 0x10)>>4), */(bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
+            Trigger_Head_Actuators_Control((ACTUATORS)(((request -> delay) & 0x100)>>8), (bool)((request -> delay & 0x10)>>4), (bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
+            //response.progress = HeadCard_Actuators_Status((ACTUATORS)((request -> delay) & 0x100)>>8);
             response.has_progress = true;
         }
         else
@@ -259,7 +473,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         //Test_Head_fan_Click();
 
         Head_Fan_PWM_Control(0, request->delay & 0xFF);
-
+        Task_sleep(2000);
 
         //response.progress = Fan_Click_Info.Product_ID;
         response.progress = Head_Fan_Tach[0];
@@ -270,23 +484,25 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     if((request->amount == 0xFAC1) /*&& (request->delay == 0xFAC)*/) //Head Fan control
     {
         Head_Fan_PWM_Control(1, request->delay & 0xFF);
-
+        Task_sleep(2000);
         response.progress = Head_Fan_Tach[1];
         response.has_progress = true;
     }
     else
-#ifdef Use_WHS_Card
     if ((request->amount & 0x0000FFF0) == 0xFAC0) //WHS Fan control
     {
         uint16_t fan_tacho = 0;
 
-        Trigger_SetWHSFanSpeed(((request->amount & 0x0000000F)-1) , request->delay & 0x000000FF);
-//        getWHSFanTacho(((request->amount & 0x0000000F)-1),  &fan_tacho);
+        if (WHS_Type == WHS_TYPE_NEW)
+        {
+            Trigger_SetWHSFanSpeed(((request->amount & 0x0000000F)-1) , request->delay & 0x000000FF);
+            Task_sleep(2000);
+            fan_tacho = WHS_Get_fan_tach( (request->amount & 0x0000000F)-1);
+        }
         response.progress = fan_tacho;
         response.has_progress = true;
     }
     else
-#endif
     if((request->amount == 0x0A) && ((request->delay >= 0) && (request->delay < 8))) //read the midtank calibration
     {
         response.progress = Initial_Offset_A[request->delay];
@@ -350,14 +566,14 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     else
     if((request->amount == 0x0CE) && (request->delay == 0x0CE)) //Get Gas Sensor
     {
-        LOG_ERROR(request->delay,"FlashInitAndLoad");
-        FlashInitAndLoad();
+        LOG_ERROR(request->delay,"FlashInit");
+        FlashInit();
         response.progress = (double)OK;
         response.has_progress = true;
 
     }
     else
-    if(request->amount == 0x0CC)  //Cùøàøïâò÷ Vùêïâùàïíî ø÷ãôíîã÷
+    if(request->amount == 0x0CC)  //Cartridge Validation Response Demo
     {
         LOG_ERROR(request->delay,"ResponseDemo");
 		ResponseDemo(request->delay);
@@ -401,7 +617,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
-    if(request->amount == 0xB2)  //fast refresh for pressure
+    if(request->amount == 0xB2)  //Set loading arm cycles
     {
         LOG_ERROR(request->delay,"Set loading arm cycles");
 
@@ -413,21 +629,50 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     if(request->amount == 0xB3)  //fast refresh for pressure
     {
         LOG_ERROR(request->amount,"keep alive test");
-        //keepalivetest = true;
         response.progress = keepalivetest;
         response.has_progress = true;
 
     }
     else
-        if(request->amount == 0xB4)  //fast refresh for pressure
+    if(request->amount == 0xB4)  //IDS_Dispenser_Content_Init
+    {
+        LOG_ERROR(request->amount,"IDS_Dispenser_Content_Init");
+        IDS_Dispenser_Content_Init();
+        response.progress = keepalivetest;
+        response.has_progress = true;
+
+    }
+    else
+    if(request->amount == 0xB5)  //fast refresh for pressure
+    {
+        if (request->delay<=100)
         {
-            LOG_ERROR(request->amount,"IDS_Dispenser_Content_Init");
-            IDS_Dispenser_Content_Init();
-            //keepalivetest = true;
-            response.progress = keepalivetest;
-            response.has_progress = true;
+            LOG_ERROR(request->delay,"set stub_heating_limit");
+            stub_heating_limit = request->delay;
+        }
+        response.progress = request->delay;
+        response.has_progress = true;
 
+    }
+    else
+    if(request->amount == 0xC3)  //suspend I2C task
+    {
+        if (request->delay == 0)
+        {
+            LOG_ERROR(request->delay,"Suspend I2C");
+            PowerOffHeatersOff();
+            Task_sleep(1000);
+            Task_setPri (I2C_Task_Handle,-1);
+        }
+        else
+        {
+            LOG_ERROR(request->delay,"Resume");
+            Task_setPri (I2C_Task_Handle,8);
         }
+        response.progress = request->delay;
+        response.has_progress = true;
+
+    }
     else     
 	if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/StubRealTimeUsage.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/StubRealTimeUsage.c
index 2342ef962..765e183cb 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/StubRealTimeUsage.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/StubRealTimeUsage.c
@@ -46,8 +46,8 @@ void Stub_RealTimeUsageRequest(MessageContainer* requestContainer)
     StubRealTimeUsageResponse response =   STUB_REAL_TIME_USAGE_RESPONSE__INIT;
 
 
-    response.n_percentile = 100;
-    response.percentile = malloc(sizeof(response.percentile)*response.n_percentile);
+    response.n_percentile = 101;
+    response.percentile = my_malloc(sizeof(response.percentile)*response.n_percentile);
     if (response.percentile)
         IdleTaskGetLoadTable(response.percentile);
     else
@@ -55,7 +55,7 @@ void Stub_RealTimeUsageRequest(MessageContainer* requestContainer)
     //free(request);
     //-------------------------------------------------------------------------------------------
     responseContainer = createContainer(MESSAGE_TYPE__StubRealTimeUsageResponse, requestContainer->token, true, &response, &stub_real_time_usage_response__pack, &stub_real_time_usage_response__get_packed_size);
-    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+    uint8_t* container_buffer = my_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);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
index 6bd4e6f48..132d46fb7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Cartridge.c
@@ -11,45 +11,42 @@
 #include "driverlib/gpio.h"
 
 #include "Drivers/USB_Communication/USBCDCD.h"
+#include "Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h"
+#include "Drivers/I2C_Communication/RFID_NFC/NFC.h"
 
 #include "Stub_Status.h"
 
 void Stub_CartridgeReadRequest(MessageContainer* requestContainer)
 {
-    uint32_t status = NOT_SUPPORTED;
+    uint32_t status = PASSED;
     MessageContainer responseContainer;
 
     StubCartridgeReadRequest* request = stub_cartridge_read_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
-	//request->cartridgeid
+    Init_RFID_Reader();
+    uint8_t readerID = request->cartridgeid;
+    Connect_to_RFID_Reder(readerID);//2
 
-    /*
-      int i;
-      for( i=0;i<8;i++)
-      {
-            Read_MidTank_Pressure_Sensor(i);
-            SysCtlDelay(1);
-      }
+    StubCartridgeReadResponse response =   STUB_CARTRIDGE_READ_RESPONSE__INIT;
 
-    */
+    response.cartridgeid = request->cartridgeid;
+    response.has_cartridgeid = true;
 
-    StubCartridgeReadResponse response =   STUB_CARTRIDGE_READ_RESPONSE__INIT;
-	
-	response.cartridgeid = request->cartridgeid;
-	response.has_cartridgeid = true;
-	
-	//response.cartridgecolor
-	response.has_cartridgecolor = false;
+    response.cartridgecolor = (uid[6] << 24) | (uid[5] << 16) | (uid[4] << 8) | uid[3];
+    //response.cartridgecolor
+    response.has_cartridgecolor = true;
+
+    response.cartridgeversion = (uid[2] << 16) | (uid[1] << 8) | uid[0];
+    //response.cartridgeversion
+    response.has_cartridgeversion = true;
+
+    response.cartridgedata = RFID_Status;
+    //response.cartridgedata
+    response.has_cartridgedata = false;
+
+    //response.cartridgeused
+    response.has_cartridgeused = false;
 
-	//response.cartridgeversion
-	response.has_cartridgeversion = false;
-	
-	//response.cartridgedata
-	response.has_cartridgedata = false;
-	
-	//response.cartridgeused
-	response.has_cartridgeused = false;
-	
     status_response(status,&response.status, &response.statusword ,&response.has_statusword);
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index bac3ba1d0..128564586 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -31,7 +31,7 @@
 #include "drivers/SSI_Comm/Dancer/Dancer.h"
 #include "drivers/motors/motor.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
-
+#include "Drivers/I2C_Communication/I2C.h"
 #include "PMR/Stubs/StubHeatingTestRequest.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestResponse.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestPollRequest.pb-c.h"
@@ -180,6 +180,14 @@
         ProcessParametersClear.headzone4temp  = 0;
         ProcessParametersClear.headzone5temp  = 0;
         ProcessParametersClear.headzone6temp  = 0;
+        ProcessParametersClear.headzone7temp  = 0;
+        ProcessParametersClear.headzone8temp  = 0;
+        ProcessParametersClear.headzone9temp  = 0;
+        ProcessParametersClear.headzone10temp  = 0;
+        ProcessParametersClear.headzone11temp  = 0;
+        ProcessParametersClear.headzone12temp  = 0;
+        ProcessParametersClear.stspzone1temp  = 0;
+        ProcessParametersClear.stspzone2temp  = 0;
         ProcessParametersClear.dyeingspeed = 40;
         ProcessParametersClear.dryerbufferlength = ProcessParametersKeep.dryerbufferlength;
         if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
@@ -191,6 +199,7 @@
         }
         else
         {
+            //WHS_Start_Blower_Control_Closed_Loop(2.5);
             Turn_the_Blower_On();//Turn on with the Default_Voltage
             if (BlowerCfg.heatingvoltage)
                 Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
@@ -401,9 +410,7 @@
         CallbackCounter++;
         //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
         MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 0, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-#ifdef Use_Head_Card
-        HeadCard_Actuators_Control(ACTOT, LOW,true);
-#endif
+        Trigger_Head_Actuators_Control(ACTOT, LOW,true);
         return OK;
     }
     uint32_t Thread_Load_Lift_Dancers(void)
@@ -511,9 +518,7 @@
         CallbackCounter++;
 //        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
         MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 2, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-#ifdef Use_Head_Card
-        HeadCard_Actuators_Control(ACTOT, LOW,false);
-#endif
+        Trigger_Head_Actuators_Control(ACTOT, LOW,false);
         return OK;
     }
     uint32_t Thread_Load_Resume_Heating(void)
@@ -538,7 +543,7 @@
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
-        MotorMovetoDancerPosition (HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize, 100, FEEDER_DANCER ,true, Thread_Load_Jog_Feeder_To_Middle_Point_Callback,4000);
+        MotorMovetoDancerPosition (HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize, 400, FEEDER_DANCER ,true, Thread_Load_Jog_Feeder_To_Middle_Point_Callback,4000);
         return OK;
     }
 
@@ -1360,6 +1365,7 @@ uint32_t ThreadLoadingReport(void)
 
     //-------------------------------------------------------------------------------------------
     responseContainer = createContainer(MESSAGE_TYPE__StartThreadLoadingResponse, ThreadLoadingToken, last, &response, &start_thread_loading_response__pack, &start_thread_loading_response__get_packed_size);
+    responseContainer.has_continuous = true;
     responseContainer.continuous = true;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
@@ -1416,6 +1422,7 @@ uint32_t StopThreadLoadingFunc(MessageContainer* requestContainer)
     MessageContainer responseContainer;
     MessageState = 2;
     Thread_Load_End();
+    MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,numberOfCycles);
     Report("StopThreadLoadingFunc",__FILE__,__LINE__,0xFF,RpWarning,(int)LoadStages,0);
 
     responseContainer = createContainer(MESSAGE_TYPE__StopThreadLoadingResponse, requestContainer->token, true, &Cresponse, &stop_thread_loading_response__pack, &stop_thread_loading_response__get_packed_size);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 420b782b5..114edc0cd 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -38,6 +38,8 @@ uint32_t ThreadDistanceToSpoolState(void);
 uint32_t ThreadEndState();
 uint32_t ThreadInitialTestStub();
 
+bool Set_Thread_Rockers_Bypass (int value);
+
 uint32_t StoreDancerConfigMessage(void);
 uint32_t LoadDancerConfigMessage(void);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 2484b9444..1dd101f82 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -28,6 +28,7 @@
 #include "drivers/Heater/Heater.h"
 #include "drivers/Motors/Motor.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
+#include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "modules/heaters/heaters.h"
 #include "modules/General/process.h"
 #include "modules/ids/ids_ex.h"
@@ -117,8 +118,8 @@ uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Rea
 
   if (Current_Read < Previous_Read)
   {
-    ReportWithPackageFilter(ThreadFilter,"Length rollover",__FILE__,__LINE__,(int)Current_Read,RpWarning,(int)Previous_Read,0);
     Time_Pass = (MAX_COUNTER - Previous_Read) + Current_Read + 1;
+    ReportWithPackageFilter(ThreadFilter,"Length rollover",__FILE__,Time_Pass,(int)Current_Read,RpWarning,(int)Previous_Read,0);
   }
   else
     Time_Pass = Current_Read - Previous_Read;
@@ -178,7 +179,10 @@ uint32_t ThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             initialpos = 0;
         }
         prevprev = PreviousPosition;
-        positionDiff = Control_Delta_Position_Pass(CurrentPosition,PreviousPosition);
+        if (Extended_Motor_Param[ThreadMotorIdToMotorId[index]] == true) //powerstep driver reverses the direction
+            positionDiff = Control_Delta_Position_Pass(PoolerPreviousPosition,PoolerCurrentPosition);
+        else
+            positionDiff = Control_Delta_Position_Pass(PoolerCurrentPosition,PoolerPreviousPosition);
         //positionDiff = positionDiff / MotorsCfg[ThreadMotorIdToMotorId[index]].microstep;
         PreviousPosition = CurrentPosition;
 
@@ -268,7 +272,10 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             Poolerinitialpos = 0;
         }
         prevprev = PoolerPreviousPosition;
-        positionDiff = Control_Delta_Position_Pass(PoolerCurrentPosition,PoolerPreviousPosition);
+        if (Extended_Motor_Param[ThreadMotorIdToMotorId[index]] == true) //powerstep driver reverses the direction
+            positionDiff = Control_Delta_Position_Pass(PoolerPreviousPosition,PoolerCurrentPosition);
+        else
+            positionDiff = Control_Delta_Position_Pass(PoolerCurrentPosition,PoolerPreviousPosition);
         //positionDiff = positionDiff / MotorsCfg[ThreadMotorIdToMotorId[index]].microstep;
         PoolerPreviousPosition = PoolerCurrentPosition;
 
@@ -300,12 +307,7 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     {
         if (PrepareState == true)
         {
-//#ifdef Use_Head_Card
-//            strcpy(Lenstr,"Heating up");
-//#else
-            //later - add temperatures
-             TemperatureListString(Lenstr);
-//#endif
+            TemperatureListString(Lenstr);
             SendJobProgress(0.0,0,false, Lenstr);
         }
         else
@@ -505,6 +507,10 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
 			//pooler dancer is right sided: data is opposite
             TranslatedReadValue = (-1*TranslatedReadValue);
+        }
+        if (index == POOLER_MOTOR)
+        {
+            //pooler dancer is right sided: data is opposite
             JobCounter++;
         }
         //TranslatedReadValue = 0;//test
@@ -911,7 +917,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
 
 void SetOriginMotorSpeed(float process_speed)
 {
-    int i,Motor_i, HW_Motor_Id;
+    int Motor_i, HW_Motor_Id;
     for (Motor_i = 0; Motor_i <= WINDER_MOTOR; Motor_i++)
     {
         HW_Motor_Id = ThreadMotorIdToMotorId[Motor_i];
@@ -959,6 +965,15 @@ uint32_t ThreadDryerRampUp(uint32_t IfIndex, uint32_t BusyFlag)
 
     return OK;
 }
+bool Thread_Rockers_Bypass = false;
+bool Set_Thread_Rockers_Bypass (int value)
+{
+    if (value == 0)
+        Thread_Rockers_Bypass = false;
+    else
+        Thread_Rockers_Bypass = true;
+    return Thread_Rockers_Bypass;
+}
 
 //********************************************************************************************************************
 uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
@@ -996,17 +1011,19 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
 #ifdef HUNDRED_MICROSECONDS_DANCER_READ
      MillisecLogInit();
 #endif
-
-        if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].maxfrequency > 0)
-        {
-            MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize);
-            MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 1);
-        }
-        if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].maxfrequency > 0)
-        {
-            MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize);
-            MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 1);
-        }
+         if (Thread_Rockers_Bypass == false)
+         {
+            if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].maxfrequency > 0)
+            {
+                MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize);
+                MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 1);
+            }
+            if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].maxfrequency > 0)
+            {
+                MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize);
+                MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 1);
+            }
+         }
         if (EnableLubrication == true)
         {
             IDS_StartLubrication();
@@ -1109,7 +1126,7 @@ char Endstr[150];
 {
      int Motor_i;
      ThreadControlActive = false;
-     uint32_t status = OK,tempCtl;
+     uint32_t status = OK;
      usnprintf(Endstr, 100, "Total _processed length: Feeder: %d Pooler %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
      SendJobProgress(0.0,0,false, Endstr);
      ReportWithPackageFilter(ThreadFilter,Endstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
@@ -1123,7 +1140,7 @@ char Endstr[150];
      if (SpeedControlId != 0xFF)
      {
          if(RemoveControlCallback(SpeedControlId,ThreadLengthCBFunction)!=OK)
-             ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)SpeedControlId,0);
+             ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)ThreadLengthCBFunction,RpError,(int)SpeedControlId,0);
          SpeedControlId = 0xFF;
      }
      if (PoolerSpeedControlId != 0xFF)
@@ -1135,7 +1152,6 @@ char Endstr[150];
 
      for ( Motor_i = 0;Motor_i <= WINDER_MOTOR;Motor_i++)
      {
-         tempCtl = ControlIdtoMotorId[Motor_i];
          if (ControlIdtoMotorId[Motor_i] != 0xFF)
          {
              status = RemoveControlCallback(ControlIdtoMotorId[Motor_i],ThreadControlCBFunction);
@@ -1144,7 +1160,6 @@ char Endstr[150];
              else
                  ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)ControlIdtoMotorId[Motor_i],0);
          }
-         //ReportWithPackageFilter(ThreadFilter,"Remove Control",__FILE__,Motor_i,(int)status,RpError,(int)tempCtl,0);
 
      }
 	 Task_sleep(100);
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index 3c67dd8e1..c8101c031 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -327,25 +327,31 @@ bool SetWastePump( bool power)
 //    if (( power == OPEN ) && (WHS_info.WHS_sensors.cartridge_cover == CLOSE))
     if ( power == OPEN )
     {
-#ifdef Use_WHS_Card
-        Trigger_SetWHSPump(OPEN);
-#else
-        Pumps_Control(WHS_WTANKPUMP2, OPEN); //waste_pump_power_on();
-#endif
-        REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP ----------------- ");
+        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
     {
-#ifdef Use_WHS_Card
-        Trigger_SetWHSPump(CLOSE);
-#else
-        Pumps_Control(WHS_WTANKPUMP2, CLOSE); //waste_pump_power_on();
-#endif
-        REPORT_MSG(WHS_empty," ------------ WHS WHS_empty stop PUMP ----------------- ");
-        WHS_info.WHS_pump.status = CLOSE;
+        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;
     }
@@ -367,19 +373,20 @@ bool SetValveDirection()
     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);
     }
-    ReportWithPackageFilter(WasteFilter,"------------WHS_info.WHS_valve   -----------------", __FILE__,__LINE__,WHS_info.WHS_valve, RpMessage, 0 ,0);
 
 
-#ifdef Use_WHS_Card
-        Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
-#else
+    if (WHS_Type == WHS_TYPE_UNKNOWN)
         Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
-#endif
+    else //new WHS
+        Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
+
     //ret = OK;
 
     return ret;
@@ -398,7 +405,6 @@ U8 CartridgeWasteFilling(bool status)
         //Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mode); //set cartridge led color slow blink
         SetWastePump(OPEN);
         //WHS_info.WHS_pump.time = 0;
-        REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP  ----------------- ");
         AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  false);
         ret=OK;
     }
@@ -406,11 +412,11 @@ U8 CartridgeWasteFilling(bool status)
     {
         SetWastePump(CLOSE);
         WHS_info.WHS_valve = VALVE_DIR_WASTE_CARTRIDGE1;
-#ifdef Use_WHS_Card
-        Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
-#else
-        Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
-#endif
+        if (WHS_Type == WHS_TYPE_UNKNOWN)
+            Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
+        else //new WHS
+            Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
+
         AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  true);
 
         switch (WHS_info.active_cartridge)
@@ -418,16 +424,16 @@ U8 CartridgeWasteFilling(bool status)
               case waste_cartridge1:
                   Pannel_Leds( CART_2,  MODE_OFF);                //set led color
                   cart2.color = colorOFF;
-                  REPORT_MSG(WHS_empty," ------------ WHS  waste_cartridge1 is used please replace it ----------------- ");
+                  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;
-                  REPORT_MSG(WHS_empty," ------------ WHS  waste_cartridge2 is used please replace it ----------------- ");
+                  ReportWithPackageFilter(WasteFilter,"------------ WHS  waste_cartridge2 is used please replace it -----------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
                   break;
               case no_waste_cartridge:
-                  REPORT_MSG(WHS_empty," ------------ !!!!!WHS  No waste cartridge !!!!! ----------------- ");
-                  REPORT_MSG(WHS_empty," ------------ !!!! WHS  insert 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:
@@ -481,40 +487,20 @@ WHS_sttMachin UpdateStateMachine()
     if ( WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORnotFULL)
     {
         WHS_info.sttMachine = WHS_empty  ;
-        REPORT_MSG(WHS_empty," ------------ WHS 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))
+    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  ;
-        REPORT_MSG(WHS_full," ------------ WHS 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  ;
-        REPORT_MSG(WHS_sttError," ------------ WHS sensor Error  ----------------- ");
+        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);
     }
-
-/*    if (//(WHS_info.WHS_sensors.waste_tank_over_flow_sensor       == SENSORnotOVERFLOW)   &&
-        ( WHS_info.WHS_sensors.waste_tank_full_sensor            == SENSORnotFULL)       &&
-        ((WHS_info.WHS_sensors.waste_tank_empty_sensor           == SENSORnotEMPTY)     ||
-         (WHS_info.WHS_sensors.waste_tank_empty_sensor           == SENSOREMPTY)))
-        WHS_info.sttMachine = WHS_empty  ;
-    else if (//(WHS_info.WHS_sensors.waste_tank_over_flow_sensor  == SENSORnotOVERFLOW)   &&
-             (WHS_info.WHS_sensors.waste_tank_full_sensor       == SENSORFULL)          &&
-             (WHS_info.WHS_sensors.waste_tank_empty_sensor      == SENSORnotEMPTY))
-        WHS_info.sttMachine =  WHS_full  ;
-    else if (//(WHS_info.WHS_sensors.waste_tank_over_flow_sensor  == SENSOROVERFLOW)      &&
-             (WHS_info.WHS_sensors.waste_tank_full_sensor       == SENSORFULL)          &&
-             (WHS_info.WHS_sensors.waste_tank_empty_sensor      == SENSORnotEMPTY))
-        WHS_info.sttMachine =  WHS_overflow  ;
-    else
-        {
-        WHS_info.sttMachine =  WHS_sttError  ;
-            REPORT_MSG(WHS_sttError," ------------ WHS sensor Error  ----------------- ");
-        }
-*/
-    return OK;
+    return WHS_info.sttMachine;
 }
 
 
@@ -522,26 +508,13 @@ 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 OverflowSensorEvent()
-{
-    WHS_sensor ret = WHS_no_event;
-    if (RdWasteTankOverFlowSensor() != WHS_info.WHS_sensors.waste_tank_over_flow_sensor)
-    {
-         WHS_info.event =  WHS_overflow_sensor;
-         ret = WHS_overflow_sensor;
-         WHS_info.WHS_sensors.waste_tank_over_flow_sensor = !(WHS_info.WHS_sensors.waste_tank_over_flow_sensor);
-    }
-    return ret;
-}
-*/
-
 WHS_sensor EmptySensorEvent()
 {
     WHS_sensor ret = WHS_no_event;
@@ -550,6 +523,7 @@ WHS_sensor EmptySensorEvent()
         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;
 }
@@ -562,6 +536,7 @@ WHS_sensor FullSensorEvent()
         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;
 }
@@ -580,6 +555,7 @@ WHS_sensor WasteTankCallBackFunction()
     {
         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())
@@ -597,7 +573,6 @@ WHS_sensor WasteTankCallBackFunction()
 bool WasteTankCBFunction()
 {
 
-    uint8_t parameter = 7;
     bool ret = notOK;
     static bool pump_on_flag = CLOSE;
     //uint32_t Cartridge_Cover_device_Id = 0;
@@ -611,11 +586,11 @@ bool WasteTankCBFunction()
                 if (WHS_info.sttMachine == WHS_empty)
                 {
                     WHS_info.sttMachine = WHS_filling;
-                    REPORT_MSG(WHS_filling," ------------ WHS_filling ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS WHS_filling ------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
                 }
                 else
                 {
-                    REPORT_MSG(WHS_filling," ------------ WHS EMPTY sensor failed !!!!!!! ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS WHS EMPTY sensor failed !!!!!!! ------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
                 }
             }
             else //SENSOREMPTY
@@ -623,7 +598,7 @@ bool WasteTankCBFunction()
                 if (WHS_info.sttMachine == WHS_emptying)
                 {
                     WHS_info.sttMachine = WHS_empty;
-                    REPORT_MSG(WHS_filling," ------------ 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
@@ -631,7 +606,7 @@ bool WasteTankCBFunction()
                 }
                 else
                 {
-                    REPORT_MSG(WHS_emptying," ------------ WHS EMPTY sensor failed !!!!!!! ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS WHS EMPTY sensor failed !!!!!!! -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
                 }
             }
             break;
@@ -641,9 +616,9 @@ bool WasteTankCBFunction()
                 break;
             if ((WHS_info.WHS_sensors.cartridge_cover == OPEN) && (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL))
             {
-                REPORT_MSG(WHS_emptying," ------------ WHS_full , cartridge cover is open cant start the pump!!!! ----------------- ");
-                REPORT_MSG(WHS_emptying," ------------ close the cartridge cover to start the pump!!!! ----------------- ");
-                //pump_on_flag = OPEN;
+                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;
@@ -652,7 +627,7 @@ bool WasteTankCBFunction()
             if (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL)
             {
                 WHS_info.sttMachine = WHS_full;
-                REPORT_MSG(WHS_emptying," ------------ 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)
@@ -670,7 +645,7 @@ bool WasteTankCBFunction()
 
                 if (ret != OK)
                 {
-                    //recreate the full event until cartridge is inserted or atontocation
+                    //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;
                 }
 
@@ -681,34 +656,21 @@ bool WasteTankCBFunction()
                 if (WHS_info.sttMachine == WHS_full)
                 {
                     WHS_info.sttMachine = WHS_emptying;
-                    REPORT_MSG(WHS_emptying," ------------ 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
                 {
-                    REPORT_MSG(WHS_full," ------------ WHS FULL sensor failed !!!!!!! ----------------- ");
+                    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_overflow_sensor:
-            if (WHS_info.WHS_sensors.waste_tank_empty_sensor)
-            {
-
-                // 1.StopMacine
-                 WHS_info.sttMachine = WHS_overflow;
-            }
-            else
-            {
-                WHS_info.sttMachine = WHS_full;
-            }
-            break;
-*/
         case WHS_cartridge_cover_sensor:
 
             if ( WHS_info.WHS_sensors.cartridge_cover == OPEN )
             {
-                REPORT_MSG(parameter," Cartridge cover open ");//popup message :"Cartridge cover open"  //todo
+                ReportWithPackageFilter(WasteFilter,"------------ WHS, Cartridge cover open -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, WHS_info.WHS_sensors.cartridge_cover, 0);//popup message :"Cartridge cover open"  //todo
                 if ( WHS_info.WHS_pump.status == OPEN)
                 {
                     CartridgeWasteFilling(CLOSE);
@@ -728,7 +690,7 @@ bool WasteTankCBFunction()
                 }
                 else
                 {
-                    REPORT_MSG(parameter,"Power down in process");//popup message :"Cartridge cover open"  //todo
+                    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
                 }
 
 
@@ -757,7 +719,7 @@ bool WasteTankCBFunction()
                 if ( IFS_info.INK_isOK_flag )
                 {
                     IFS_info.INK_isOK_flag = false;//0
-                    REPORT_MSG(WHS_full," ------------ change INK cartridge status to color Used ----------------- ");
+                    ReportWithPackageFilter(WasteFilter,"------------ WHS, change INK cartridge status to color Used -------------", __FILE__, __LINE__, IFS_info.INK_isOK_flag, RpMessage, 0, 0);
                     // test the Mid-tank capacity is not at Nadav sequence
                     MidTank_Pressure = Get_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);
                     if ( MidTank_Pressure > MidTank_Pressure_EMPTY )
@@ -765,11 +727,10 @@ bool WasteTankCBFunction()
                         ReportWithPackageFilter(WasteFilter,"------------ close door  MidTank_Pressure > MidTank_Pressure_EMPTY -----------------", __FILE__,__LINE__,(int)(MidTank_Pressure_EMPTY*1000), RpMessage, (int)(MidTank_Pressure*1000), 0);
                         MidTankValvesAction(Cartridge_MidTank_OFF);
                         //Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
-                        REPORT_MSG(WHS_full," ------------ Mid-tank not empty ----------------- ");
+                        ReportWithPackageFilter(WasteFilter,"------------ WHS, Mid-tank not empty -------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
                         break;
                     }
                     IFS_info.MidTank_capacity = MidTank_Pressure;
-                    REPORT_MSG(WHS_full," ------------ Mid-tank filling in process ----------------- ");
                     ReportWithPackageFilter(WasteFilter,"------------ Mid-tank filling in process -----------------", __FILE__,__LINE__,(int)(MidTank_Pressure_EMPTY*1000), RpMessage, (int)(MidTank_Pressure*1000), 0);
                     Pannel_Leds(CART_1, MODE_ON);
                     cart1.color  = BLINK;
@@ -799,7 +760,7 @@ bool WasteTankCBFunction()
             if (IFS_info.IFS_Ink_precense_sensor == CarteidgePrecense)
             {
                 // is power down in process??  //todo
-                if ( !PowerOffInProcessGetState() ) // not in power down proccess
+                if ( !PowerOffInProcessGetState() ) // not in power down process
                 {
                     Pannel_Leds(CART_1, MODE_ON);
                     cart1.color = colorON;
@@ -808,10 +769,8 @@ bool WasteTankCBFunction()
                 else
                 {
                     //  print: "power down in process";
-                    REPORT_MSG(WHS_full," ------------ 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
             {
@@ -824,14 +783,13 @@ bool WasteTankCBFunction()
                     IFS_info.Ink.time_out = 0;
                     IFS_info.Cartridge_Ink_TimeOut_device_Id = RemoveControlCallback(IFS_info.Cartridge_Ink_TimeOut_device_Id, WasteTankCBFunction );
                 }
-
             }
             break;
 
         case IFS_INK_authentication_pass:
             if (!ColorMatch())
             {
-                    REPORT_MSG(WHS_full," ------------ cartridge color does not match ----------------- ");
+                    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;
@@ -920,7 +878,7 @@ bool WasteTankCBFunction()
                     break;
 
         case WHS_Timeout:
-            REPORT_MSG(WHS_emptying," ------------ 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;
@@ -940,12 +898,12 @@ bool WasteTankCBFunction()
         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 );
-            REPORT_MSG(WHS_full," ------------ Change cartridge status to Fail ----------------- ");
+            ReportWithPackageFilter(WasteFilter,"------------ WHS, Change cartridge status to Fail -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
 
             MidTankValvesAction(Cartridge_MidTank_OFF);
             cart1.color = fastBILNK;
-            REPORT_MSG(WHS_full," ------------ Display Mid-tank # filling fail ----------------- ");
-            REPORT_MSG(WHS_full," ------------ call customer support ----------------- ");
+            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);
@@ -954,11 +912,11 @@ bool WasteTankCBFunction()
         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 );
-            REPORT_MSG(WHS_full," ------------ Change cartridge status to Waste Empty ----------------- ");
+            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);
-            REPORT_MSG(WHS_full," ------------ Display Mid-tank # filling done ----------------- ");
+            ReportWithPackageFilter(WasteFilter,"------------ Display Mid-tank # filling done -------------", __FILE__, __LINE__, WHS_info.sttMachine, RpMessage, 0, 0);
             break;
 
 
@@ -979,7 +937,6 @@ bool WasteTankCBFunction()
 
 bool RdCartridgeCoverSensor()
 {
-    uint32_t parameter = 6 ;
 
     //REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor    ----------------- ");
     bool ret = notOK;
@@ -989,11 +946,11 @@ bool RdCartridgeCoverSensor()
     ret = Get_COVER_1_State(CartridgesDoor);
     if ((ret == OPEN ) && (ret != WHS_info.WHS_sensors.cartridge_cover))
     {
-        Report(" ------------ RD Cartridge Cover Sensor is = OPEN(1)    ----------------- ",__FILE__,__LINE__,ret,RpWarning,ret,0);
+        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))
     {
-        REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor is = CLOSE(0)   ----------------- ");
+        ReportWithPackageFilter(WasteFilter,"------------ RD Cartridge Cover Sensor is = CLOSE(0) -------------", __FILE__, __LINE__, ret, RpMessage, 0, 0);
     }
     return ret;
 }
@@ -1003,21 +960,18 @@ bool RdCartridgeCoverSensor()
 
 WHS_sensor CartridgeCoverCallBackFunction()
 {
-    uint32_t parameter = 6 ;
-
-
     WHS_sensor ret = WHS_no_event;
    //ret = RdCartridgeCoverSensor();
     if ( WHS_info.WHS_sensors.cartridge_cover != RdCartridgeCoverSensor() )
     {
-        REPORT_MSG(parameter," ------------ find  :  WHS_cartridge_cover_sensor event   ----------------- ");
         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
     {
-            REPORT_MSG(parameter," ------------ Mid-tank Filling  :  Close cartridge cover   ----------------- ");
+        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)
     {
@@ -1089,15 +1043,13 @@ WHS_sensor CartridgeCoverCallBackFunction()
 
 WHS_sensor CartridgeWaste1CallBackFunction()
 {
-    uint32_t parameter = 6 ;
-
     WHS_sensor ret = WHS_no_event;
     //ret = RdCartridgeCoverSensor();
     if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor != RdWasteCartridge1Sensor())
     {
-        REPORT_MSG(parameter," ------------ find  : WHS_waste1_presence_sensor event   ----------------- ");
         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;
@@ -1105,15 +1057,13 @@ WHS_sensor CartridgeWaste1CallBackFunction()
 
 WHS_sensor CartridgeWaste2CallBackFunction()
 {
-    uint32_t parameter = 6 ;
-
     WHS_sensor ret = WHS_no_event;
-    //ret = RdCartridgeCoverSensor();
+
     if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor != RdWasteCartridge2Sensor())
     {
-        REPORT_MSG(parameter," ------------ find  : WHS_waste2_presence_sensor event   ----------------- ");
         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;
@@ -1122,42 +1072,40 @@ WHS_sensor CartridgeWaste2CallBackFunction()
 /*------------------------------- Waste Cartridge + IFS Cartridge    -----------------------------------------*/
 bool InitCartStatus()
 {
-    uint32_t parameter = 6 ;
-
     WHS_info.WHS_sensors.cartridge_cover = RdCartridgeCoverSensor();
 
     /* INK =>  CART_1 */
-    REPORT_MSG(parameter," ------------------------------------------------------------------------------------------ ");
-    REPORT_MSG(parameter," ------------!!!!!!!  at INIT what to do if IFS_INK is presence  !!!!!!!  ----------------- ");
-    REPORT_MSG(parameter," ------------------------------------------------------------------------------------------ ");
+    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())
     {
-       REPORT_MSG(parameter," ------------  INIT : IFS_INK is presence    ----------------- ");
-       IFS_info.IFS_Ink_precense_sensor = CarteidgePrecense;
-       Pannel_Leds( CART_1,  MODE_ON);
-       cart1.color = colorON;
+        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
     {
-       REPORT_MSG(parameter," ------------  INIT : IFS_INK is NOT presence   ----------------- ");
-       IFS_info.IFS_Ink_precense_sensor = CarteidgeNotPrecense;
-       Pannel_Leds( CART_1,  MODE_OFF);
-       cart1.color = colorOFF;
+        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())
     {
-        REPORT_MSG(parameter," ------------  INIT : WHS_waste1 cart is presence   ----------------- ");
         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
     {
-        REPORT_MSG(parameter," ------------  INIT : WHS_waste1 cart is NOT presence !!!     ----------------- ");
         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;
     }
@@ -1165,21 +1113,19 @@ bool InitCartStatus()
     /* waste_cartridge2 => CART_3  */
     if (RdWasteCartridge2Sensor())
     {
-        REPORT_MSG(parameter," ------------  INIT : WHS_waste2 cart is presence   ----------------- ");
         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
     {
-        REPORT_MSG(parameter," ------------  INIT : WHS_waste2 cart is NOT presence_sensor !!!     ----------------- ");
         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);
@@ -1187,7 +1133,7 @@ bool InitCartStatus()
 
     if (WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN)
     {
-        REPORT_MSG(parameter," ------------ WHS_CartridgeCoverOPEN  : add callback for cart1 and cart 2   ----------------- ");
+        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 );
@@ -1201,8 +1147,6 @@ bool RdInkCartridgeSensor()
 {
     bool ret = notOK;
     WHS_Read_GPI_Registers();
-    //WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = Is_Cartridge_Present(CART_2);
-    //ret = WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;
     ret = Is_Cartridge_Present(CART_1);
     return ret;
 }
@@ -1211,8 +1155,6 @@ bool RdWasteCartridge1Sensor()
 {
     bool ret = notOK;
     WHS_Read_GPI_Registers();
-    //WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = Is_Cartridge_Present(CART_2);
-    //ret = WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;
     ret = Is_Cartridge_Present(CART_2);
     return ret;
 }
@@ -1221,37 +1163,34 @@ bool RdWasteCartridge2Sensor()
 {
     bool ret = notOK;
     WHS_Read_GPI_Registers();
-    //WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = Is_Cartridge_Present(CART_3);
-    //ret = WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;
     ret = Is_Cartridge_Present(CART_3);
     return ret;
 }
 
 bool SetActiveWastCartridge()
 {
-    uint8_t parameter = 5;
-
     bool ret = notOK;
+
     if (( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == PRECENSE )
          &&   (WHS_info.cartridge_1.autheticate == PASSED)
          &&   (WHS_info.cartridge_1.status == WasteEmpty))
         {
-            REPORT_MSG(parameter," ------------  WHS : active_cartridge = waste_cartridge  1   ----------------- ");
             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))
         {
-            REPORT_MSG(parameter," ------------  WHS : active_cartridge = waste_cartridge  2   ----------------- ");
             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
         {
-            REPORT_MSG(parameter," ------------  WHS : NO active_cartridge   ----------------- ");
             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;
@@ -1268,11 +1207,10 @@ U8 WHS_init(void)
 {
     SetWastePump(CLOSE);
     WHS_info.WHS_valve = VALVE_DIR_WASTE_CARTRIDGE1;
-#ifdef Use_WHS_Card
-        Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
-#else
+    if (WHS_Type == WHS_TYPE_UNKNOWN)
         Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
-#endif
+    else //new WHS
+        Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
         //Valve_Set(VALVE_WASTE_TANK, VALVE_DIR_WASTE_CARTRIDGE1);
     InitCartStatus();
     initWHS_WasteTank();
@@ -1339,12 +1277,10 @@ U8 SetValve(bool value)
 {
     bool ret = OK;
     WHS_info.WHS_valve = value;
-#ifdef Use_WHS_Card
-        Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
-#else
+    if (WHS_Type == WHS_TYPE_UNKNOWN)
         Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
-#endif
-
+    else //new WHS
+        Trigger_SetWHSValveWatseCartridge(WHS_info.WHS_valve);
     return ret;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
index c42546d1b..99b96ddf3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
@@ -9,13 +9,13 @@
 #include <Drivers/I2C_Communication/WHS_Card/I2C_WHS_Mux.h>
 #include <Drivers/I2C_Communication/I2C.h>
 #include "Drivers/I2C_Communication/WHS_Card/WHS_data.h"
-#include <Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
 #include <Drivers/I2C_Communication/I2C_Task.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_AD5272_Rheostat/WHS_Rheostat.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/WHS_PT100_ADC.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
+#include <Drivers/I2C_Communication/WHS_Card/EEPROM/D_EEPROM.h>
 #include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
 
 bool test_9555(void);
@@ -24,17 +24,21 @@ bool WHS_I2C_EEprom_Write_Ch_shai_taest(void);
 bool newWHS_init(void)
 {
     bool status = OK;
-    Main_Mux_Flag = 0;
+
+    //Main_Mux_Flag = 0;
 
 
 //    delayms(4000);
 //    status = Select_Main_WHS_Mux_Channel();
+
+    //Trigger_Check_WHS_Type_Via_EEPROM();
     Trigger_WHS_init_IO();
     Trigger_WHS_init_fan();
     Trigger_WHS_init_PT100();
     Trigger_WHS_init_Blower();
     Trigger_WHS_MAX11614_Init();
     Trigger_WHS_Rheostat_init();
+
     //status |= WHS_IO_Init();
     //status |= init_WHS_fan();
     //
@@ -53,7 +57,7 @@ bool newWHS_init(void)
 //  //test_9555();
 //    status |= WHS_I2C_EEprom_Write_Ch_shai_taest();
 
-    Set_All_WHS_Fans(0xFF);
+    //Set_All_WHS_Fans(0xFF);
  //   delayms(4000);
     //Trigger_SetWHSBlowerVoltage (0x0C00);