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

32 files changed, 515 insertions, 402 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
index 8aabafd2e..873c89b7e 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FileSystem.c
@@ -715,8 +715,10 @@ FRESULT FileWrite(void * buffer, uint16_t size,char *path, uint32_t timeout)
                 Fresult = f_write(FileHandle,buffer,size,&Bytes );
                 if(Fresult != FR_OK)
                 {
-                    LOG_ERROR (Fresult,"fread error");
+                    LOG_ERROR (Fresult,"fwrite error");
                 }
+                //LOG_ERROR (Bytes,"f_write ok no of bytes");
+                 Report("f_write ok no of bytes", __FILE__, __LINE__, Bytes, RpWarning,   (int)size, 0);
                 f_close(FileHandle);
             }
             else
@@ -762,6 +764,7 @@ FRESULT FileRead(char *path, uint32_t *Size, void **Buffer)
                     {
                         *Buffer = buffer;
                         *Size = (uint32_t)fno->fsize;
+                        Report("f_read ok no of bytes", __FILE__, __LINE__, Bytes, RpWarning,   (int)fno->fsize, 0);
                     }
                     else
                     {
diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
index ec3bc602e..25f5927e7 100644
--- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
+++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
@@ -20,7 +20,7 @@ typedef struct
 } TangoVersion_t;
 
 
-TangoVersion_t _gTangoVersion = {1,4,6,7};
+TangoVersion_t _gTangoVersion = {1,4,6,8};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
  char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d
diff --git a/Software/Embedded_SW/Embedded/Common/Utilities/idle_task.c b/Software/Embedded_SW/Embedded/Common/Utilities/idle_task.c
index 437e06815..8d1040ea2 100644
--- a/Software/Embedded_SW/Embedded/Common/Utilities/idle_task.c
+++ b/Software/Embedded_SW/Embedded/Common/Utilities/idle_task.c
@@ -199,9 +199,12 @@ uint32_t unload_max_count=0;
       #endif
    }
 }
- void IdleTaskGetLoadTable (uint32_t *Buffer)
+ void IdleTaskGetLoadTable (uint32_t *aBuffer)
  {
-     memcpy (Buffer,idle_load_table,sizeof(idle_load_table));
+     int i;
+     for (i=0;i<100;i++)
+         aBuffer[i] = idle_load_table[i];
+     //memcpy (aBuffer,idle_load_table,sizeof(idle_load_table));
  }
  uint32_t MillisecCounter = 0;
  uint32_t ControlCounter = 0;
diff --git a/Software/Embedded_SW/Embedded/Common/report/filter.c b/Software/Embedded_SW/Embedded/Common/report/filter.c
index f0eb5a140..753123ee7 100644
--- a/Software/Embedded_SW/Embedded/Common/report/filter.c
+++ b/Software/Embedded_SW/Embedded/Common/report/filter.c
@@ -40,7 +40,7 @@ uint8_t filterTableSize;
 uint8_t filterNumOfCurrentEntries;
 
 /* The mask of currently enabled severity. */
-static ErrorSeverity SeverityLevel;
+ErrorSeverity SeverityLevel;
 
 /* flag allows or dennies filter usage */
 static bool filterDontUse;
diff --git a/Software/Embedded_SW/Embedded/Common/report/reportInit.c b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
index a7d7c17ef..a9e940c8c 100644
--- a/Software/Embedded_SW/Embedded/Common/report/reportInit.c
+++ b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
@@ -192,15 +192,54 @@ void SetupDebugDisributorsRequestFunc(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__SetupDebugDisributorsResponse, requestContainer->token, true, &response, &setup_debug_disributors_response__pack, &setup_debug_disributors_response__get_packed_size);
     container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
 
-
-    if (request->has_debugdistributor == true )
-    {
-        status|=ReportSwitchPackageFilter(request->debugdistributor   , request->distributoractive);
-    }
-    else
+    switch (request->debugdistributor  )
     {
-        status = ERROR_CODE__INVALID_PARAMETER;
-        ReportWithPackageFilter(GeneralFilter,"SetupDebugDisributorsRequest error",__FILE__,__LINE__,request->has_debugdistributor,RpWarning,0,  0);
+        case DEBUG_DISTRIBUTOR_TYPE__ControlFilter:
+            status|=ReportSwitchPackageFilter(ControlFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__HeatersFilter:
+            status|=ReportSwitchPackageFilter(HeatersFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__JobFilter:
+            status|=ReportSwitchPackageFilter(JobFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__WasteFilter:
+            status|=ReportSwitchPackageFilter(WasteFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__AlarmFilter:
+            status|=ReportSwitchPackageFilter(AlarmFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__DiagnosticsFilter:
+            status|=ReportSwitchPackageFilter(DiagnosticsFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__IDSFilter:
+            status|=ReportSwitchPackageFilter(IDSFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__ThreadFilter:
+            status|=ReportSwitchPackageFilter(ThreadFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__GeneralFilter:
+            status|=ReportSwitchPackageFilter(GeneralFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__CommFilter:
+            status|=ReportSwitchPackageFilter(CommFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__FPGAFilter:
+            status|=ReportSwitchPackageFilter(FPGAFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__LoadFilter:
+            status|=ReportSwitchPackageFilter(LoadFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__InitFilter:
+            status|=ReportSwitchPackageFilter(InitFilter   , request->distributoractive);
+            break;
+        case DEBUG_DISTRIBUTOR_TYPE__MaintFilter:
+            status|=ReportSwitchPackageFilter(MaintFilter   , request->distributoractive);
+            break;
+        default:
+            status = ERROR_CODE__INVALID_PARAMETER;
+            ReportWithPackageFilter(GeneralFilter,"SetupDebugDisributorsRequest error",__FILE__,__LINE__,request->has_debugdistributor,RpWarning,0,  0);
+            break;
     }
     if (status)
     {
@@ -310,36 +349,33 @@ uint32_t SetDebugLogCategoryFunc(MessageContainer* requestContainer)
     SetDebugLogCategoryResponse response = SET_DEBUG_LOG_CATEGORY_RESPONSE__INIT;
     uint32_t status = ERROR;
 
-    if (request->has_minimumcategory)
+    switch(request->minimumcategory)
     {
-        switch(request->minimumcategory)
-        {
-            case DEBUG_LOG_CATEGORY__Info:
-                ReportSeveritySet(RpMessage);
-                status = OK;
-                break;
-            case DEBUG_LOG_CATEGORY__Warning:
-                ReportSeveritySet(RpWarning);
-                status = OK;
-                break;
-            case DEBUG_LOG_CATEGORY__Error:
-                ReportSeveritySet(RpError);
-                status = OK;
-                break;
-            case DEBUG_LOG_CATEGORY__Critical:
-                ReportSeveritySet(RpFatalError);
-                status = OK;
-                break;
-            case DEBUG_LOG_CATEGORY__Debug:
-                ReportSeveritySet(RpPrivate);
-                status = OK;
-                break;
-            default:
-                break;
-        }
+        case DEBUG_LOG_CATEGORY__Info:
+            ReportSeveritySet(RpMessage);
+            status = OK;
+            break;
+        case DEBUG_LOG_CATEGORY__Warning:
+            ReportSeveritySet(RpWarning);
+            status = OK;
+            break;
+        case DEBUG_LOG_CATEGORY__Error:
+            ReportSeveritySet(RpError);
+            status = OK;
+            break;
+        case DEBUG_LOG_CATEGORY__Critical:
+            ReportSeveritySet(RpFatalError);
+            status = OK;
+            break;
+        case DEBUG_LOG_CATEGORY__Debug:
+            ReportSeveritySet(RpPrivate);
+            status = OK;
+            break;
+        default:
+            break;
     }
 
-    responseContainer = createContainer(MESSAGE_TYPE__SetDebugLogCategoryResponse, protobufToken, false, &response, &set_debug_log_category_response__pack, &set_debug_log_category_response__get_packed_size);
+    responseContainer = createContainer(MESSAGE_TYPE__SetDebugLogCategoryResponse, requestContainer->token, true, &response, &set_debug_log_category_response__pack, &set_debug_log_category_response__get_packed_size);
     responseContainer.continuous = false;
     if (status != OK)
     {
@@ -429,7 +465,7 @@ STATUS ReportInit(ReportInitParams InitParams)
     JobFilter  = ReportAddFilterPackage("Job");
     WasteFilter  = ReportAddFilterPackage("Waste");
     AlarmFilter  = ReportAddFilterPackage("Alarm");
-    DiagnosticsFilter  = ReportAddFilterPackage("Diagnostics");
+    DiagnosticsFilter  = ReportAddFilterPackage("Diagnost");
     IDSFilter  = ReportAddFilterPackage("IDS");
     ThreadFilter  = ReportAddFilterPackage("Thread");
     GeneralFilter  = ReportAddFilterPackage("General");
@@ -439,6 +475,6 @@ STATUS ReportInit(ReportInitParams InitParams)
     InitFilter  = ReportAddFilterPackage("Init");
     MaintFilter  = ReportAddFilterPackage("Maint");
 //    Filter  = ReportAddFilterPackage("");
-
+    ReportSwitchPackageFilter(WasteFilter,REPORT_OFF);
     return status;
 }
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 8e37577c9..a1d9fe52d 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -376,6 +376,14 @@ typedef enum
 
 extern uint8_t Head_Type;
 
+//WHS types
+typedef enum
+{
+    WHS_TYPE_UNKNOWN,
+    WHS_TYPE_NEW,
+}WHS_TYPE;
+
+extern uint8_t WHS_Type;
 
 typedef enum
 {
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
index af326b4ed..c620cebdb 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.c
@@ -807,12 +807,17 @@ void Pumps_Control(PUMPS_ENUM Pump_Id, bool Direction) //1 - OPEN, 0 - CLOSE ??
     {
         // Waste Pump Control
         case WASTECH_PUMP2:
+            if (WHS_Type == WHS_TYPE_UNKNOWN)
+            {
                 if (Direction == true)
                     ActivateCoolerPump();
                 else
                     DeActivateCoolerPump();
                 //F1_GPO_Reg.bits.F1_GPO_WASTECH_PUMP2 = Direction;
                 SecondaryPumpActive = Direction;
+            }
+            else
+                LOG_ERROR(WHS_Type,"Pump activated on new whs");
             break;
         case WHS_WTANKPUMP2:
                 F1_GPO_Reg.bits.F1_GPO_WHS_WTANKPUMP2 = Direction;
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.h b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.h
index 0b2c60822..a24a6ee68 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.h
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.h
@@ -62,13 +62,7 @@ WHS_PT100_4_0X82_1,
 
 #warning assuming that we won't use whs card without head card..
 
-//#if defined(Use_WHS_Card)
-    #define MAX_TANGO_TEMPERATURE_SENSOR_ID  MAX_WHS_CARD_TEMP_SENS_ID // WHS + Head cards
-/*#elif defined(Use_Head_Card)
-    #define MAX_TANGO_TEMPERATURE_SENSOR_ID  MAX_HEAD_CARD_TEMP_SENS_ID
-#else
-    #define MAX_TANGO_TEMPERATURE_SENSOR_ID  MAX_MAIN_CARD_TEMP_SENS_ID
-#endif*/
+#define MAX_TANGO_TEMPERATURE_SENSOR_ID  MAX_WHS_CARD_TEMP_SENS_ID // WHS + Head cards
 
 typedef enum
 {
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c
index 2dfae1ba4..a1ffa2475 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/DAC/Blower.c
@@ -152,14 +152,16 @@ uint32_t Turn_the_Blower_On()
 
     blowerStatus = true;
     voltage = Default_Voltage;
-
-#ifdef Use_WHS_Card
-    Trigger_WHS_init_Blower();
-    Trigger_SetWHSBlowerVoltage(Default_Voltage);
-#else
-    status = Write_Control_Register();
-    status |= Write_DAC_and_Input_Register(DAC_mV2Bits(Default_Voltage));
-#endif
+    if (WHS_Type == WHS_TYPE_UNKNOWN)
+    {
+        status = Write_Control_Register();
+        status |= Write_DAC_and_Input_Register(DAC_mV2Bits(Default_Voltage));
+    }
+    else //new WHS
+    {
+        Trigger_WHS_init_Blower();
+        Trigger_SetWHSBlowerVoltage(Default_Voltage);
+    }
 
     return status;
 }
@@ -167,11 +169,14 @@ uint32_t Turn_the_Blower_On()
 uint32_t Control_Voltage_To_Blower(uint32_t mV)
 {
     uint32_t status = OK;
-#ifdef Use_WHS_Card
-    Trigger_SetWHSBlowerVoltage(mV);
-#else
-    status |= Write_DAC_and_Input_Register(DAC_mV2Bits(mV));
-#endif
+    if (WHS_Type == WHS_TYPE_UNKNOWN)
+    {
+        status |= Write_DAC_and_Input_Register(DAC_mV2Bits(mV));
+    }
+    else //new WHS
+    {
+        Trigger_SetWHSBlowerVoltage(mV);
+    }
     voltage = mV;
 
     return status;
@@ -181,11 +186,14 @@ uint32_t Turn_the_Blower_Off()
 {
     uint32_t status = OK;
 
-#ifdef Use_WHS_Card
-    Trigger_SetWHSBlowerVoltage(0);
-#else
-    status |= Write_DAC_and_Input_Register(0);
-#endif
+    if (WHS_Type == WHS_TYPE_UNKNOWN)
+    {
+        status |= Write_DAC_and_Input_Register(0);
+    }
+    else //new WHS
+    {
+        Trigger_SetWHSBlowerVoltage(0);
+    }
     blowerStatus = false;
 
     return status;
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.c
index 7efa8c65f..80411394b 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.c
@@ -18,6 +18,9 @@ uint32_t Select_Main_Head_Mux_Channel()
 {
     uint32_t status= OK;
 
+    if (Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD)
+        return OK;
+
     uint8_t Write_Buf[1];
 
     if(Main_Mux_Flag != HEAD)
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
index 0733d5f5b..2b6510079 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.c
@@ -135,9 +135,7 @@ uint32_t HeadADCPT100_Reset(void)
         {
             //Reset the device
             Write_Buf[0] = ADS122X_RESET_CMD;
-            #ifdef Use_Head_Card
-                Select_Main_Head_Mux_Channel();
-            #endif
+            Select_Main_Head_Mux_Channel();
             status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, i, Write_Buf, 1);
             //status |= I2C_Write(I2C_ID_HEAD_CARD, I2C_ADC_ADS122C04_SLAVE_ADD, Write_Buf, 1);
             //Wait at least (50 us + 32 · t(CLK)) after the RESET command is sent before sending any other command.
@@ -160,9 +158,7 @@ uint32_t HeadADCPT100_StartSync(TEMPERATURE_SENSOR_ID_ENUM SensorId)
 
     Write_Buf[0] = ADS122X_START_CMD;
 
-    #ifdef Use_Head_Card
-        Select_Main_Head_Mux_Channel();
-    #endif
+    Select_Main_Head_Mux_Channel();
 
     Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 1);
     //Status |= I2C_Write(I2C_ID_HEAD_CARD, I2C_ADC_ADS122C04_SLAVE_ADD, Write_Buf, 1);
@@ -180,9 +176,7 @@ uint32_t HeadADCPT100_PowerDown(TEMPERATURE_SENSOR_ID_ENUM SensorId)
 
     Write_Buf[0] = ADS122X_POWERDOWN_CMD;
 
-    #ifdef Use_Head_Card
-        Select_Main_Head_Mux_Channel();
-    #endif
+    Select_Main_Head_Mux_Channel();
     Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 1);
     //Status |= I2C_Write(I2C_ID_HEAD_CARD, I2C_ADC_ADS122C04_SLAVE_ADD, Write_Buf, 1);
 
@@ -193,7 +187,7 @@ uint32_t Data_ADC_Head = 0;
 uint32_t HeadADCPT100_SendReadDataCommand(TEMPERATURE_SENSOR_ID_ENUM SensorId)
 {
     uint32_t Status = OK;
-    uint8_t Write_Buf[1]= {0};
+    uint8_t Write_Buf[1]= 0;
 
     uint8_t temp[3] = {0,0,0};
 
@@ -203,9 +197,7 @@ uint32_t HeadADCPT100_SendReadDataCommand(TEMPERATURE_SENSOR_ID_ENUM SensorId)
     //Write_Buf[0] = ADS122X_RDATA_CMD;
     Write_Buf[0] = ADS122X_RDATA_CMD;
 
-    #ifdef Use_Head_Card
-        Select_Main_Head_Mux_Channel();
-    #endif
+    Select_Main_Head_Mux_Channel();
     Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 1);
     //Status |= I2C_Write(I2C_ID_HEAD_CARD, I2C_ADC_ADS122C04_SLAVE_ADD, Write_Buf, 1);
 
@@ -239,9 +231,7 @@ uint32_t HeadADCPT100_WriteReg(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint8_t reg,
     Write_Buf[0] = ADS122X_WRITE_CMD(reg);
     Write_Buf[1] = writeValue;
 
-    #ifdef Use_Head_Card
-        Select_Main_Head_Mux_Channel();
-    #endif
+    Select_Main_Head_Mux_Channel();
     Status |= I2C_Write_SensorId(I2C_ID_HEAD_CARD, SensorId, Write_Buf, 2);
     //Status |= I2C_Write(I2C_ID_HEAD_CARD, I2C_ADC_ADS122C04_SLAVE_ADD, Write_Buf, 2);
 
@@ -357,9 +347,7 @@ uint32_t HeadADCPT100_Config_callback(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint3
     if(HeadTempSensConfig[SensorId].Config == DONE)
         return Status;
 
-    #ifdef Use_Head_Card
-        Select_Main_Head_Mux_Channel();
-    #endif
+    Select_Main_Head_Mux_Channel();
 
     switch(Stage)
     {
@@ -511,9 +499,7 @@ uint32_t HeadCard_Toggle_PT100(TEMPERATURE_SENSOR_ID_ENUM SensorId)
     if((SensorId < HEAD_PT100_ZONE_1_0X80_0) || (SensorId > MAX_HEAD_CARD_TEMP_SENS_ID))
         return ERROR;
 
-    #ifdef Use_Head_Card
-        Select_Main_Head_Mux_Channel();
-    #endif
+    Select_Main_Head_Mux_Channel();
 
     if(Save_Sel_Status != HeadTempSensConfig[SensorId].SEL)
     {
@@ -602,9 +588,7 @@ uint32_t  HeadADCPT100_ReadReg(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint8_t reg,
 
     uint8_t Write_Buf[1];
 
-    #ifdef Use_Head_Card
-        Select_Main_Head_Mux_Channel();
-    #endif
+    Select_Main_Head_Mux_Channel();
 
     Write_Buf[0] = ADS122X_READ_CMD(reg);
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
index efb46c5be..a6599cbe8 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C.h
@@ -30,6 +30,9 @@ void Trigger_Heater_Current_Read(void);
 void Trigger_MidTank_Pressure_Read(void);
 void Trigger_PT100_Read(void);
 void Trigger_HeaterWriting(void);
+void Trigger_Head_Init_PT100(void);
+void Trigger_Head_Actuators_Control(uint32_t Act_ID, bool Active_Low_Pwr, bool Direction);
+void Trigger_InputsReading(void);
 uint32_t Block_Main_MUX_TCA9548A_0xE4(); ////unused I2C MUX
 
 extern uint8_t Main_Mux_Flag ;
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
index 450f3747f..a82c04a3a 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
@@ -38,6 +38,8 @@ typedef enum
     HeaterWriting,
     Inputs_Reading,// I/O
     Outputs_Writing,
+    Head_Init_PT100,
+    Actuators_Control,
 
     /* enum for WHS :*/
     WHS_start,
@@ -118,6 +120,32 @@ void Trigger_PT100_Read(void)
     return;
 
 }
+void Trigger_Head_Init_PT100(void)
+{
+    I2C_ReadingMessageStruc I2C_ReadingMessage;
+    //uint8_t Midtank_i;
+
+    I2C_ReadingMessage.messageId = Head_Init_PT100;
+    if (I2C_ReadingMsgQ != NULL)
+        Mailbox_post(I2C_ReadingMsgQ , &I2C_ReadingMessage, BIOS_NO_WAIT);
+    return;
+}
+
+void Trigger_Head_Actuators_Control(uint32_t Act_ID, bool Active_Low_Pwr, bool Direction)
+{
+    I2C_ReadingMessageStruc I2C_ReadingMessage;
+    //uint8_t Midtank_i;
+
+    I2C_ReadingMessage.messageId = Actuators_Control;
+    I2C_ReadingMessage.parameter = Act_ID;
+    I2C_ReadingMessage.parameter2 = Active_Low_Pwr;
+    I2C_ReadingMessage.parameter3 = (uint8_t *)Direction;
+    if (I2C_ReadingMsgQ != NULL)
+        Mailbox_post(I2C_ReadingMsgQ , &I2C_ReadingMessage, BIOS_NO_WAIT);
+    return;
+}
+
+
 void Trigger_HeaterWriting(void)
 {
     I2C_ReadingMessageStruc I2C_ReadingMessage;
@@ -129,6 +157,17 @@ void Trigger_HeaterWriting(void)
     return;
 
 }
+void Trigger_InputsReading(void)
+{
+    I2C_ReadingMessageStruc I2C_ReadingMessage;
+    //uint8_t Midtank_i;
+
+    I2C_ReadingMessage.messageId = Inputs_Reading;
+    if (I2C_ReadingMsgQ != NULL)
+        Mailbox_post(I2C_ReadingMsgQ , &I2C_ReadingMessage, BIOS_NO_WAIT);
+    return;
+
+}
 
 void Trigger_WHS_init_IO(void)
 {
@@ -351,10 +390,14 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
         /* select the correct I2C bus */
         if (I2C_ReadingMessage.messageId > WHS_start)
         {
+            if (WHS_Type == WHS_TYPE_UNKNOWN)
+                continue;
             Select_Main_WHS_Mux_Channel();
         }
         else
         {
+            if (Head_Type == HEAD_TYPE_UNKNOWN)
+                continue;
             Select_Main_Head_Mux_Channel();
         }
 
@@ -377,6 +420,12 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
         case HeaterWriting:
             Write_Head_Card_Heaters_Commands();
             break;
+        case Head_Init_PT100:
+            HeadADCPT100_SensorInitConfig();
+            break;
+        case Actuators_Control:
+            HeadCard_Actuators_Control(I2C_ReadingMessage.parameter, (bool)I2C_ReadingMessage.parameter2,(bool)I2C_ReadingMessage.parameter2);
+            break;
         case Inputs_Reading:
             Head_Read_IO_Reg(0x46, HIGH);//READ HEAD CARD LS
             break;
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/ADS122X04_Driver.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/ADS122X04_Driver.c
index 4df4dc6c3..b6540df04 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/ADS122X04_Driver.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/D_ADS122_PT100/ADS122X04_Driver.c
@@ -69,7 +69,7 @@ bool D_ADS122_ReadDataCommand(uint8_t i2cbus, uint8_t i2cadd, uint32_t* p_Data_A
 
     Status |= I2C_Read(i2cbus, i2cadd, &temp, 3);
     Data_ADS122X = (temp & 0xFF0000) >> 16 | (temp & 0xFF00) | (temp & 0x0000FF) << 16;//First send the MSB so we need to reorder the bytes
-     *p_Data_ADS122X = CalculateTemperatures(Data_ADS122X);
+     //*p_Data_ADS122X = CalculateTemperatures(Data_ADS122X);
 #warning what to do with the data   ???????
     return Status;
 }
@@ -270,9 +270,7 @@ bool D_ADS122_InitConfigReg()
 //    if(HeadTempSensConfig[SensorId].Config == DONE)
 //        return Status;
 //
-//    #ifdef Use_Head_Card
 //        Select_Main_Head_Mux_Channel();
-//    #endif
 //
 //    switch(Stage)
 //    {
@@ -410,9 +408,7 @@ bool D_ADS122_InitConfigReg()
 //    if((SensorId < HEAD_PT100_ZONE_1_0X80_0) || (SensorId > MAX_HEAD_CARD_TEMP_SENS_ID))
 //        return ERROR;
 //
-//    #ifdef Use_Head_Card
 //        Select_Main_Head_Mux_Channel();
-//    #endif
 //
 //    if(Save_Sel_Status != HeadTempSensConfig[SensorId].SEL)
 //    {
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c
index f36905ba1..1d7a788f6 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/WHS_Card/EEPROM/WHS_EEPROM.c
@@ -15,6 +15,12 @@
 
 //uint8_t WHS_Write_Buf[Max_WHS_buf_size +2];
 
+#ifdef Use_Whs_Card
+uint8_t WHS_Type = WHS_TYPE_NEW;
+#else
+    uint8_t WHS_Type = WHS_TYPE_UNKNOWN;
+#endif
+
 #define MAX_ALLOWS_PAGE_WRITE 256
 #define MIN_READ_BYTE 1
 
diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg
index 195dd3e15..26fd2a980 100644
--- a/Software/Embedded_SW/Embedded/Embedded.cfg
+++ b/Software/Embedded_SW/Embedded/Embedded.cfg
@@ -152,25 +152,25 @@ Program.global.communication = Task.create("&communicationTask", CommRxTaskParam
 var MillisecLowTaskParams = new Task.Params();
 MillisecLowTaskParams.instance.name = "MilliSecondLow";
 MillisecLowTaskParams.stackSize = 2048;
-MillisecLowTaskParams.priority = 4;
+MillisecLowTaskParams.priority = 5;
 Program.global.millisecLow = Task.create("&MillisecLowTask", MillisecLowTaskParams);
 
 var ControlLowTaskParams = new Task.Params();
 ControlLowTaskParams.instance.name = "controlLow";
 ControlLowTaskParams.stackSize = 4096;
-ControlLowTaskParams.priority = 5;
+ControlLowTaskParams.priority = 6;
 Program.global.controlLow = Task.create("&controlLowTask", ControlLowTaskParams);
 
 var DiagnosticsTaskParams = new Task.Params();
 DiagnosticsTaskParams.instance.name = "Diagnostics";
-DiagnosticsTaskParams.priority = 6;
+DiagnosticsTaskParams.priority = 4;
 DiagnosticsTaskParams.stackSize = 8192;
 Program.global.Diagnostics = Task.create("&DiagnosticsTask", DiagnosticsTaskParams);
 
 var ADCProcessTaskParams = new Task.Params();
 ADCProcessTaskParams.instance.name = "adcProcess";
 ADCProcessTaskParams.stackSize = 512;
-ADCProcessTaskParams.priority = 3;
+ADCProcessTaskParams.priority = 2;
 Program.global.adcProcess = Task.create("&ADCProcessTask", ADCProcessTaskParams);
 
 var ReportTaskParams = new Task.Params();
@@ -181,7 +181,7 @@ Program.global.report = Task.create("&reportService", ReportTaskParams);
 
 var updateTaskParams = new Task.Params();
 updateTaskParams.instance.name = "update";
-updateTaskParams.priority = 4;
+updateTaskParams.priority = 2;
 Program.global.update = Task.create("&updateTask", updateTaskParams);
 
 /* ================ Text configuration ================ */
diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index 99e83a6aa..05c3d8c04 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -249,6 +249,7 @@ int main(void)
    Init_All_I2C();
    Block_Main_MUX_TCA9548A_0xE4();//unused, same i2c as head and whs cards
    Check_Head_Type_Via_EEPROM();
+   //Check_WHS_Type_Via_EEPROM();
 
    #ifndef EVALUATION_BOARD
    STATUS_RED_LED_ON;
@@ -323,9 +324,8 @@ int main(void)
     //Read_Speed_Sensor_TypeII();//must be delay between Set_Speed_Sensor_TypeII_Registers to Read_Speed_Sensor_TypeII
 
     //Test_ADS120_Internal_Temperature_Sensor(0);
-#ifdef Use_Head_Card
-    Head_IO_Init();
-#endif
+    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+        Head_IO_Init();
 
 #ifndef EVALUATION_BOARD
     Main_EEPROM_Read_Main_Card_SN();
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);