Version 1.4.6.8: remove most of head/whs ifdefs, checked to be working. fix control for missed milliseconds calls and more

15 files changed, 312 insertions, 297 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index a83d95fa8..c2e121348 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -877,11 +877,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
@@ -1011,7 +1007,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;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index c8b4a306c..fdd5feef9 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -56,10 +56,8 @@
 #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
 Task_Handle Millisecond_Task_Handle;
 /******************** Definitions  ********************************************/
 
@@ -606,9 +604,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
     OneHourTick  =   (tick%eOneHour == 0)           ?true:false;
     //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();
@@ -619,39 +618,14 @@ 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
-    {
-        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();
-    }
-#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 +638,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,10 +659,7 @@ 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();
@@ -737,14 +704,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
         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
+        for (Sensor_i = StartPT100;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
         {
             TemperatureCalc[Sensor_i] =  MillisecCalculateTemperatures ( Sensor_i);
         }
@@ -755,10 +718,8 @@ 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
 
     }
     if (OneMinute_Tick)
@@ -779,6 +740,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
         midtankDisplay = 1-midtankDisplay;
         Gas_PPM_Info = Calculate_Gas_Power_Consumption();
         //Trigger_WHS_MAX11614_Read_allADC();
+        ResetControlTime();
 
     }
     if (OneHourTick)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index e093815a9..e85a36057 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -108,6 +108,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;
@@ -556,8 +557,22 @@ uint32_t ControlLoop(uint32_t tick)
 
     return OK;
 }
+uint32_t prevtick = 0;
+void ResetControlTime(void)
+{
+    memset(ControlTime,0,sizeof(ControlTime));
+}
 uint32_t ControlLowLoop(uint32_t tick)
 {
+    uint32_t tempp,tempq,delta;
+    uint32_t skipped_ticks = 0;
+    if (tick-prevtick>1)
+    {
+        skipped_ticks = tick-prevtick-1;
+        //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)
@@ -566,12 +581,13 @@ uint32_t ControlLowLoop(uint32_t tick)
                 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;
 
+                tempp = HibernateRTCSSGet();
                 if(ControlArray[ControlLowDevice_i].ControlDataReadPtr)
                     ControlDatalog[ControlLowDevice_i] = ControlArray[ControlLowDevice_i].ControlDataReadPtr( ControlArray[ControlLowDevice_i].Parameter1);
                 else
@@ -580,6 +596,18 @@ 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");
+                tempq = HibernateRTCSSGet();
+                if (tempq < tempp)
+                {
+                  delta = (32768 - tempp) + tempq + 1;
+                }
+                else
+                  delta = tempq - tempp;
+
+                if (ControlTime[ControlLowDevice_i]<delta)
+                {
+                    ControlTime[ControlLowDevice_i] = delta;
+                }
             }
         } //if control active
     }  //for
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index ef4feda09..598675f8c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -208,11 +208,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 +226,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 +369,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..e63314bac 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -524,31 +524,41 @@ void DiagnosticOneMinuteCollection(void)
 void DiagnosticOneSecCollection(void)
 {
     int i;
-#ifdef Use_Head_Card
-    DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone2, MillisecGetTemperatures(HEAD_PT100_ZONE_2_0X80_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone3, MillisecGetTemperatures(HEAD_PT100_ZONE_3_0X82_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone4, MillisecGetTemperatures(HEAD_PT100_ZONE_4_0X82_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone5, MillisecGetTemperatures(HEAD_PT100_ZONE_5_0X84_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone6, MillisecGetTemperatures(HEAD_PT100_ZONE_6_0X84_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone7, MillisecGetTemperatures(HEAD_PT100_ZONE_7_0X86_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone8, MillisecGetTemperatures(HEAD_PT100_ZONE_8_0X86_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone9, MillisecGetTemperatures(HEAD_PT100_ZONE_9_0X88_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone10, MillisecGetTemperatures(HEAD_PT100_ZONE_10_0X88_1));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone11, MillisecGetTemperatures(HEAD_PT100_ZONE_11_0X8A_0));
-    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone12, MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1));
-    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
+    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));
@@ -711,41 +721,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];
@@ -851,20 +866,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;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 82d2dc226..b05cb61e1 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -150,9 +150,8 @@ uint32_t HWConfigurationInit(void)
     //ProcessParamsInit();
     Buttons_Init();
     WHS_init();
-#ifdef Use_WHS_Card
-    newWHS_init();
-#endif
+    if (WHS_Type == WHS_TYPE_NEW)
+        newWHS_init();
     ADC_MUX_Init();
     GeneralHwReady = true;
 
@@ -383,6 +382,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)
     {
@@ -493,11 +493,10 @@ 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__WHSBlower2;
+    else
+        blowerType = HARDWARE_BLOWER_TYPE__DefaultBlower;
     if (request->n_blowers)
     {
         for (Dispenser_i = 0; Dispenser_i < request->n_blowers ; Dispenser_i++)
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index 1ef4a0931..5bfc46559 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -101,13 +101,9 @@ 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);
@@ -197,13 +193,9 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
 #endif
     }
     if (ProcessParams->dryerzone1temp>1)
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, true,
-                ProcessParams->dryerzone1temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, true,ProcessParams->dryerzone1temp);
     else
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, false,
-                ProcessParams->dryerzone1temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, false,ProcessParams->dryerzone1temp);
 /*    if (ProcessParams->dryerzone2temp)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, true,
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
index d20f0511b..a91919bc4 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
@@ -63,27 +63,21 @@ uint32_t Heaters_Init(void)
     int i;
     //ROM_TimerDisable(Heater_timerBase, TIMER_A);
 
-#ifdef  Use_Head_Card
-    HeadADCPT100_SensorInitConfig();//OK
-#endif
+    Trigger_Head_Init_PT100();//OK
+
     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);
 
     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;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 6b7a01103..96ce9331d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -125,6 +125,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,
@@ -641,7 +642,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);
@@ -785,17 +786,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 +807,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 +873,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 +884,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 +912,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 +967,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 +993,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,7 +1076,7 @@ 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();
@@ -1097,7 +1100,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 +1175,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 +1200,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 +1233,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))
@@ -1257,6 +1264,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 +1377,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;
         }
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index c31e21e23..e6e5923c0 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -66,52 +66,58 @@ 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
+        if (WHS_Type == WHS_TYPE_NEW)
         {
-            addr =  I2CExp2_ADDRESS;
-        }
-        else
-        {
-            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)
-        {
-            value = 1;
-        }
-        else
-        {
-            value = 0;
+            if (request->delay & 0x0001)
+            {
+                value = 1;
+            }
+            else
+            {
+                value = 0;
+            }
+            response.progress = Write_WHS_9555_io_value( addr,  port,  pin,  value);
+            response.has_progress = true;
         }
-        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 == 0x3E8) && (request->delay <= 0x0fff))// set WHS Blower speed 0x00-0xfff
+    {
+        if (WHS_Type == WHS_TYPE_NEW)
         {
-            //Trigger_WHS_Set_Volt_Blower_Control(request->delay);
             Trigger_SetWHSBlowerVoltage (request->delay);
             response.progress = 0;
             response.has_progress = true;
-        }
+        }        //Trigger_WHS_Set_Volt_Blower_Control(request->delay);
+    }
     else
-       if(request->amount == 0x3EA)
+    if(request->amount == 0x3EA)
+    {
+        uint16_t tempu16 = 0;
+       if (WHS_Type == WHS_TYPE_NEW)
        {
-           uint16_t tempu16;
            switch(request->delay )// set WHS Blower speed 0x00-0xfff
            {
            case 0:
@@ -144,16 +150,17 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
            default :
                tempu16 = 0x500;  //get_cur_vlv2(&tempu16);
                break;
-
-
            }
-           response.progress = (double)tempu16;
-           response.has_progress = true;
        }
+       response.progress = (double)tempu16;
+       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 +170,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;
@@ -275,18 +282,18 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         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);
+            //getWHSFanTacho(((request->amount & 0x0000000F)-1),  &fan_tacho);
+        }
         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];
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/StubRealTimeUsage.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/StubRealTimeUsage.c
index 2342ef962..2091b3bc5 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/StubRealTimeUsage.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/StubRealTimeUsage.c
@@ -47,7 +47,7 @@ void Stub_RealTimeUsageRequest(MessageContainer* requestContainer)
 
 
     response.n_percentile = 100;
-    response.percentile = malloc(sizeof(response.percentile)*response.n_percentile);
+    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/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index bac3ba1d0..a629afc50 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -401,9 +401,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 +509,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 +534,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;
     }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 2484b9444..59b5642fb 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -300,12 +300,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 +500,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
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index 3c67dd8e1..5fcab9c13 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -327,11 +327,11 @@ 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
+        if (WHS_Type == WHS_TYPE_UNKNOWN)
+            Pumps_Control(WHS_WTANKPUMP2, OPEN); //waste_pump_power_on();
+        else //new WHS
+            Trigger_SetWHSPump(OPEN);
+
         REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP ----------------- ");
         WHS_info.WHS_pump.status = OPEN;
         WHS_info.WHS_pump.time = STARTCOUNT;
@@ -339,11 +339,10 @@ bool SetWastePump( bool power)
     }
     else
     {
-#ifdef Use_WHS_Card
-        Trigger_SetWHSPump(CLOSE);
-#else
-        Pumps_Control(WHS_WTANKPUMP2, CLOSE); //waste_pump_power_on();
-#endif
+        if (WHS_Type == WHS_TYPE_UNKNOWN)
+            Pumps_Control(WHS_WTANKPUMP2, CLOSE); //waste_pump_power_on();
+        else //new WHS
+            Trigger_SetWHSPump(CLOSE);
         REPORT_MSG(WHS_empty," ------------ WHS WHS_empty stop PUMP ----------------- ");
         WHS_info.WHS_pump.status = CLOSE;
         WHS_info.WHS_pump.time = STOPCOUNT;
@@ -374,12 +373,11 @@ bool SetValveDirection()
     }
     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;
@@ -406,11 +404,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)
@@ -641,8 +639,8 @@ 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!!!! ----------------- ");
+                ReportWithPackageFilter(WasteFilter,"------------ WHS_full , cartridge cover is open cant start the pump!!!! ----------------- ", __FILE__,__LINE__,(int)(WHS_emptying), RpMessage, (int)(WHS_info.WHS_sensors.cartridge_cover), 0);
+                ReportWithPackageFilter(WasteFilter,"------------ close the cartridge cover to start the pump!!!! ----------------- ", __FILE__,__LINE__,(int)(WHS_emptying), RpMessage, (int)(WHS_info.WHS_sensors.cartridge_cover), 0);
                 //pump_on_flag = OPEN;
                 AlarmHandlingSetAlarm( EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE,  true);
 
@@ -1268,11 +1266,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 +1336,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..a255f55a0 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/newWHS_init.c
@@ -53,7 +53,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);