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

39 files changed, 256 insertions, 163 deletions

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 626a4ec8d..6fa7c0fdf 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,36};
+TangoVersion_t _gTangoVersion = {1,4,6,37};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
  char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 64717ec0c..7ae727e09 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -28,7 +28,7 @@
 
 //#define EMC_FORCE_MOT_CLOCK_INTERNAL
 
-//#define VAC_TEST
+//#define VAC_TESTHeadCard_Actuators_Stub
 
 //#define SPECIAL_DISPENSERS
 extern bool Special_Dispensers;
@@ -385,10 +385,10 @@ typedef union
 typedef enum
 {
     HEAD_TYPE_UNKNOWN,
-    HEAD_TYPE_SYLKO_WITHOUT_CARD,
+    HEAD_TYPE_FLAT_WITHOUT_CARD,
     HEAD_TYPE_UNKNOWN_WITH_CARD,
-    HEAD_TYPE_SYLKO,
-    HEAD_TYPE_STAPLE_SPUN,
+    HEAD_TYPE_FLAT,
+    HEAD_TYPE_ARC,
 }HEAD_TYPE;
 
 extern uint8_t Head_Type;
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 6069c78ff..303d5a43d 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
@@ -433,17 +433,21 @@ bool FPGA_Read_limit_Switches(FPGA_GPI_ENUM Limit_Switch)
             LM_Status = LS_Left.bits.F1_LS_LSPARE2;
                 break;
         case I2C_HEADCARD_COVER_LS_FRONT:
-            if(Head_Type == HEAD_TYPE_SYLKO)
-                LM_Status = !(Head_I2C_EXP4_0x46.bits.INPUT_LS_FRONT);
+        case I2C_HEADCARD_ARC_LS_ACTUATOR:
+                LM_Status = !(Head_I2C_EXP4_0x46.bits.INPUT_LS_FRONT_ARC_ACT);
                 break;
         case I2C_HEADCARD_COVER_LS_REAR:
-            if(Head_Type == HEAD_TYPE_SYLKO)
-                LM_Status = !(Head_I2C_EXP4_0x46.bits.INPUT_LS_REAR);
+        case I2C_HEADCARD_COVER_LS_ARC:
+                LM_Status = !(Head_I2C_EXP4_0x46.bits.INPUT_LS_REAR_ARC_COVER);
                 break;
         case I2C_HEADCARD_COVER_LS_UPPER:
-            if(Head_Type == HEAD_TYPE_SYLKO)
+            if(Head_Type == HEAD_TYPE_FLAT)
                 LM_Status = !(Head_I2C_EXP4_0x46.bits.INPUT_LS_UP);
                 break;
+        case I2C_HEADCARD_COVER_LS_TUNNEL_ARC:
+            if(Head_Type == HEAD_TYPE_ARC)
+                LM_Status = !(Head_I2C_EXP4_0x46.bits.INPUT_LS_ARC_TUNNEL_COVER);
+                break;
         default :
             LM_Status = NO_LIMIT;
             break;
@@ -528,7 +532,7 @@ uint32_t MagnetControlId = 0xFF;
 uint32_t MagnetCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
 {
 
-    if(Head_Type == HEAD_TYPE_SYLKO)
+    if(Head_Type == HEAD_TYPE_FLAT)
         Trigger_Head_Magnet(DISABLE_MAGNET);
         //HeadCard_HeadMagnet_Disable();
     else
@@ -547,7 +551,7 @@ uint32_t ActivateHeadMagnet()
     Report("ActivateHeadMagnet - Close the lid magnet",__FILE__,__LINE__,(int)HARDWARE_MOTOR_TYPE__MOTO_RLOADARM,RpWarning,(int)DH_LID_OPEN,0);
     //WHS_Start_Blower_Control_Closed_Loop(BlowerSetPoint);
     //Task_sleep(500);
-    if(Head_Type == HEAD_TYPE_SYLKO)
+    if(Head_Type == HEAD_TYPE_FLAT)
         //HeadCard_ActivateHeadMagnet();
         Trigger_Head_Magnet(CLOSE_MAGNET);
     else
@@ -578,7 +582,7 @@ uint32_t DeActivateHeadMagnet()
 
     //WHS_Start_Blower_Control_Closed_Loop(0.0);
 
-    if(Head_Type == HEAD_TYPE_SYLKO)
+    if(Head_Type == HEAD_TYPE_FLAT)
     {
         Trigger_Head_Magnet(OPEN_MAGNET);
         //HeadCard_DeActivateHeadMagnet();
diff --git a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h
index 0ff0fa2de..a7999ea2e 100644
--- a/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h
+++ b/Software/Embedded_SW/Embedded/Drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h
@@ -162,6 +162,9 @@ typedef enum
     I2C_HEADCARD_COVER_LS_FRONT,
     I2C_HEADCARD_COVER_LS_REAR,
     I2C_HEADCARD_COVER_LS_UPPER,
+    I2C_HEADCARD_ARC_LS_ACTUATOR,
+    I2C_HEADCARD_COVER_LS_ARC,
+    I2C_HEADCARD_COVER_LS_TUNNEL_ARC,
 
     //-----------------------
     MAX_GPI
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
index 824858dfd..960e6cfae 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
@@ -125,7 +125,7 @@ uint32_t ActivateHeater (int HeaterId)
     }
     else
     {        //F2_CTRL |= portMap[HeaterId].m_pin;
-        if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+        if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
             HeadCard_Control_Heaters(HeaterTypetoHeadHeater[HeaterId],ON);
         else
         {
@@ -194,7 +194,7 @@ uint32_t DeActivateHeater (int HeaterId)
     }
     else
     {
-        if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+        if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
             HeadCard_Control_Heaters(HeaterTypetoHeadHeater[HeaterId],OFF);
         else
         {
@@ -252,7 +252,7 @@ bool GetHeaterState (int HeaterId)
     }
     else
     {
-        if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+        if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
         {
             return(Get_HeadCard_Heater_State(HeaterTypetoHeadHeater[HeaterId]));
         }
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
index 23accb66a..68392c72f 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/TemperatureSensor.c
@@ -180,7 +180,7 @@ int TemperatureSensorRead(TEMPERATURE_SENSOR_ID_ENUM SensorId)
 int TemperatureListString(char* str)
 {
     int len;
-    if(Head_Type == HEAD_TYPE_SYLKO)
+    if(Head_Type == HEAD_TYPE_FLAT)
     {
         len = usnprintf(str, 160, "Prepare H1: ,%d, H2: ,%d, H3: ,%d, H4: ,%d, H5: ,%d, H6: ,%d, H7: ,%d, H8: ,%d, H9: ,%d, H10: ,%d, H11: ,%d, H12: ,%d,  M: ,%d, D: ,%d,",
                         TempSensorResponse[HEAD_PT100_ZONE_1_0X80_0].Temperature_C_mult_by_100/100, TempSensorResponse[HEAD_PT100_ZONE_2_0X80_1].Temperature_C_mult_by_100/100,
@@ -192,7 +192,7 @@ int TemperatureListString(char* str)
                         TempSensorResponse[HEAD_PT100_MIXER_0X8E_0].Temperature_C_mult_by_100/100,  TempSensorResponse[TEMP_SENSE_ANALOG_DRYER_TEMP1].Temperature_C_mult_by_100/100);
 
     }
-    else if(Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    else if(Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD)
     {
         len = usnprintf(str, 150, "Prepare H1: %d H2: %d H3: %d H4: %d H5: %d H6: %d D1: %d D2: %d D3: %d M: %d",TempSensorResponse[TEMP_SENSE_ANALOG_DYEINGH_TEMP1].Temperature_C_mult_by_100/100,
                         TempSensorResponse[TEMP_SENSE_ANALOG_DYEINGH_TEMP2].Temperature_C_mult_by_100/100,TempSensorResponse[TEMP_SENSE_ANALOG_DYEINGH_TEMP3].Temperature_C_mult_by_100/100,
@@ -202,7 +202,7 @@ int TemperatureListString(char* str)
                         ,TempSensorResponse[MIXER_PT100].Temperature_C_mult_by_100/100);
         //Prepare H1: 78 H2: 111 H3: 137 H4: 135 H5: 144 H6: 75 D1: 120 D2: 167 D3: 158 M: 129
     }
-    else if(Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    else if(Head_Type == HEAD_TYPE_ARC)
     {
         len = usnprintf(str, 160, "Prepare H1: ,%d, H2: ,%d, H3: ,%d, AL1:  AR1: M: ,%d, D: ,%d,",
                         TempSensorResponse[HEAD_PT100_ZONE_1_0X80_0].Temperature_C_mult_by_100/100, TempSensorResponse[HEAD_PT100_ZONE_2_0X80_1].Temperature_C_mult_by_100/100,
@@ -457,8 +457,8 @@ uint32_t CalculateTemperatures(TEMPERATURE_SENSOR_ID_ENUM SensorId, uint32_t Dat
         uint32_t NoOfAvrSamples = 5;//TODO - how many Samples
         Status = Filter_Temparature_Measurement(SensorId, Current_Measurement_C, NoOfAvrSamples);
     #else
-        if((Head_Type == HEAD_TYPE_STAPLE_SPUN) && (( SensorId ==  HEAD_PT100_ZONE_6_0X84_1) || ( SensorId ==  HEAD_PT100_ZONE_8_0X86_1) || ( SensorId ==  HEAD_PT100_ZONE_5_0X84_0) || ( SensorId ==  HEAD_PT100_ZONE_7_0X86_0)))//pressure sensors
-        //if((Head_Type == HEAD_TYPE_STAPLE_SPUN) && (( SensorId ==  HEAD_PT100_ZONE_5_0X84_0) || ( SensorId ==  HEAD_PT100_ZONE_7_0X86_0)))//pressure sensors
+        if((Head_Type == HEAD_TYPE_ARC) && (( SensorId ==  HEAD_PT100_ZONE_6_0X84_1) || ( SensorId ==  HEAD_PT100_ZONE_8_0X86_1) || ( SensorId ==  HEAD_PT100_ZONE_5_0X84_0) || ( SensorId ==  HEAD_PT100_ZONE_7_0X86_0)))//pressure sensors
+        //if((Head_Type == HEAD_TYPE_ARC) && (( SensorId ==  HEAD_PT100_ZONE_5_0X84_0) || ( SensorId ==  HEAD_PT100_ZONE_7_0X86_0)))//pressure sensors
         {
             //Head Staple spun pressure sensors
             //bits to mvolts
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c
index 9f2e929d5..2d2de930b 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/ADC_MUX/ADC_MUX.c
@@ -418,7 +418,7 @@ uint32_t Heaters_Current_Bits[9];//just for debug
 
 void Enable_Reading_Heaters_Current(HEATERS_CURRENT Heater_ID) //0-8
 {
-    if((Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
+    if((Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
         return;
     if (Heater_ID>=NUM_OF_CURRENT_HEATERS)
         return;
@@ -426,7 +426,7 @@ void Enable_Reading_Heaters_Current(HEATERS_CURRENT Heater_ID) //0-8
 }
 void Disable_Reading_Heaters_Current(HEATERS_CURRENT Heater_ID) //0-8
 {
-    if((Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
+    if((Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
         return;
     if (Heater_ID>=NUM_OF_CURRENT_HEATERS)
         return;
@@ -434,7 +434,7 @@ void Disable_Reading_Heaters_Current(HEATERS_CURRENT Heater_ID) //0-8
 }
 bool Get_Heater_Current_Reading_State(HEATERS_CURRENT Heater_ID) //0-8
 {
-    if((Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
+    if((Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
         return false;
     if (Heater_ID>=NUM_OF_CURRENT_HEATERS)
         return false;
@@ -444,7 +444,7 @@ bool Get_Heater_Current_Reading_State(HEATERS_CURRENT Heater_ID) //0-8
 uint32_t Read_Heaters_Current(HEATERS_CURRENT Heater_ID) //0-8
 {
     uint32_t Status = OK;
-    if((Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
+    if((Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)&&(Heater_ID>=HEATER_DRYER_CURRENT_3))
         return 0;
 
     if (Heater_ID>=NUM_OF_CURRENT_HEATERS)
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/EEPROM/Head_EEPROM.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/EEPROM/Head_EEPROM.c
index 0d767b864..af0c5511d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/EEPROM/Head_EEPROM.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/EEPROM/Head_EEPROM.c
@@ -126,29 +126,29 @@ uint32_t Check_Head_Type_Via_EEPROM()
 
     if((Head_i2c_status == I2C_MASTER_ERR_ADDR_ACK)||(status == 0xFF))
     {
-        Head_Type = HEAD_TYPE_SYLKO_WITHOUT_CARD;
+        Head_Type = HEAD_TYPE_FLAT_WITHOUT_CARD;
     }
     else
     {
 
-        if(Read_Buf[1] == HEAD_TYPE_STAPLE_SPUN)
+        if(Read_Buf[1] == HEAD_TYPE_ARC)
         {
-            Head_struct.Read_Head_EEPROM.bytes.HeadType = HEAD_TYPE_STAPLE_SPUN;
+            Head_struct.Read_Head_EEPROM.bytes.HeadType = HEAD_TYPE_ARC;
         }
         else
         {
-            Head_struct.Read_Head_EEPROM.bytes.HeadType = HEAD_TYPE_SYLKO;
+            Head_struct.Read_Head_EEPROM.bytes.HeadType = HEAD_TYPE_FLAT;
         }
 
         Head_struct.Read_Head_EEPROM.bytes.Head_SN        = Read_Buf[0];
-        //Head_struct.Read_Head_EEPROM.bytes.HeadType = Read_Buf[1]; //HEAD_TYPE_SYLKO / HEAD_TYPE_STAPLE_SPUN
+        //Head_struct.Read_Head_EEPROM.bytes.HeadType = Read_Buf[1]; //HEAD_TYPE_SYLKO / HEAD_TYPE_ARC
 
         Head_Type = Head_struct.Read_Head_EEPROM.bytes.HeadType;
 
         //Head_Type = HEAD_TYPE_UNKNOWN_WITH_CARD; - if identify the type by reading the PT100
     }
 #else
-    Head_Type = HEAD_TYPE_SYLKO_WITHOUT_CARD;
+    Head_Type = HEAD_TYPE_FLAT_WITHOUT_CARD;
 #endif
 
     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 f8a425e36..0a53550e7 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,7 +18,7 @@ uint32_t Select_Main_Head_Mux_Channel()
 {
     uint32_t status= OK;
 
-    if (Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    if (Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD)
         return OK;
 
     uint8_t Write_Buf[1];
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
index 1ac0e439b..800684813 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.c
@@ -117,7 +117,7 @@ uint32_t Head_IO_Init()
     Head_I2C_EXP2_0x42.bits.OUTPUT_ACTLOW_HTIN_LATCH_RST = 0x01;
     Head_I2C_EXP2_0x42.bits.OUTPUT_ACTLOW_HTOT_LATCH_RST = 0x01;
 
-    if(Head_Type == HEAD_TYPE_STAPLE_SPUN)// Set 24 to pressure sensor in arc head
+    if(Head_Type == HEAD_TYPE_ARC)// Set 24 to pressure sensor in arc head
     {
         Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_EN = ENABLE;
         Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_DIR = 0x00;
@@ -329,7 +329,7 @@ uint32_t HeadCard_ActivateHeadMagnet()
 {
     uint32_t status = OK;
 
-    if(Head_Type == HEAD_TYPE_SYLKO)
+    if(Head_Type == HEAD_TYPE_FLAT)
     {
         Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_EN = ENABLE;
         Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_DIR = 0x01;//?
@@ -343,7 +343,7 @@ uint32_t HeadCard_DeActivateHeadMagnet()
 {
     uint32_t status = OK;
 
-    if(Head_Type == HEAD_TYPE_SYLKO)
+    if(Head_Type == HEAD_TYPE_FLAT)
     {
         Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_EN = ENABLE;
         Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_DIR = 0x00;//?
@@ -356,7 +356,7 @@ uint32_t HeadCard_DeActivateHeadMagnet()
 uint32_t HeadCard_HeadMagnet_Disable()
 {
     uint32_t status = OK;
-    if(Head_Type == HEAD_TYPE_SYLKO)
+    if(Head_Type == HEAD_TYPE_FLAT)
     {
         Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_EN = DISABLE;
         status |= Head_Write_IO_Reg(0x42,LOW);
@@ -368,7 +368,7 @@ uint32_t HeadCard_ActivateHeadPressureArcBlowers()
 {
     uint32_t status = OK;
     //MAG_EN<=’1’, MAG_DIR<=’0’  - Board is powered by 24V.
-    if(Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    if(Head_Type == HEAD_TYPE_ARC)
     {
         Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_EN = ENABLE;
         Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_DIR = 0x00;
@@ -381,7 +381,7 @@ uint32_t HeadCard_DeActivateHeadPressureArcBlowers()
 {
     uint32_t status = OK;
     //MAG_EN<=’0’, MAG_DIR<=’0’  -- no 24V on the board
-    if(Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    if(Head_Type == HEAD_TYPE_ARC)
     {
         Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_EN = DISABLE;
         Head_I2C_EXP2_0x42.bits.OUTPUT_MAG_DIR = 0x00;
@@ -552,7 +552,7 @@ uint32_t HeadCard_ActStubCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) /
     else
         Report("Remove control callback failed",__FILE__,__LINE__,(int)ActControlId,RpWarning,(int)HeadCard_ActStubCallBackFunction,0);
 
-    Report("HeadCard_ActStubCallBackFunction",__FILE__,__LINE__,(int)ActControlId,RpWarning,(int)Act_ID,0);
+    //Report("HeadCard_ActStubCallBackFunction",__FILE__,__LINE__,(int)ActControlId,RpWarning,(int)Act_ID,0);
     if(Act_ID == ACTIN)//0
     {
         Head_I2C_EXP4_0x46.bits.OUTPUT_ACTLOW_ACTIN_ON  = HIGH;
@@ -569,6 +569,9 @@ uint32_t HeadCard_ActStubCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) /
 uint32_t HeadCard_Actuators_Stub(ACTUATORS Act_ID, bool Enable, bool Direction)//ENABLE/DISABLE, DOWN/UP/DONTCARE
 {
     uint32_t status = OK;
+    if (Head_Type != HEAD_TYPE_FLAT)
+        return OK;
+
     Report("HeadCard_Actuators_Stub",__FILE__,Act_ID,(int)Enable,RpWarning,(int)Direction,0);
 
     if(Enable == true)
@@ -602,15 +605,15 @@ uint32_t HeadCard_Actuators_Stub(ACTUATORS Act_ID, bool Enable, bool Direction)/
         {
             Head_I2C_EXP4_0x46.bits.OUTPUT_ACTLOW_ACTOT_ON  = HIGH;
         }
-        if (RemoveControlCallback(ActControlId, HeadCard_ActStubCallBackFunction )==OK)
-            ActControlId = 0xFF;
-        else
-            Report("Remove control callback failed",__FILE__,__LINE__,(int)ActControlId,RpWarning,(int)HeadCard_ActStubCallBackFunction,0);
+        if (ActControlId != 0xFF)
+        {
+            if (RemoveControlCallback(ActControlId, HeadCard_ActStubCallBackFunction )==OK)
+                ActControlId = 0xFF;
+            else
+                Report("Remove control callback failed",__FILE__,__LINE__,(int)ActControlId,RpWarning,(int)HeadCard_ActStubCallBackFunction,0);
+        }
     }
 
-    status |= Head_Write_IO_Reg(0x42,HIGH);
-    status |= Head_Write_IO_Reg(0x46,LOW_AND_HIGH);
-
     return status;
 }
 
@@ -737,7 +740,7 @@ bool isActuatorOnLowestLocation(void) // Give indication if the actuator stopped
 uint32_t HeadCard_Actuators_Relocate_callback(uint32_t IfIndex, uint32_t BusyFlag) // use IfIndex for Act_ID
 {
     count_time++;
-    //ReportWithPackageFilter(ThreadFilter,"actuators relocation",__FILE__,msec_millisecondCounter,ActuatorLocating,RpMessage,count_time,0);
+    ReportWithPackageFilter(ThreadFilter,"actuators relocation",__FILE__,msec_millisecondCounter,ActuatorLocating,RpMessage,count_time,0);
     switch (ActuatorLocating)
     {
         case ActuatorIdle:
@@ -752,7 +755,7 @@ uint32_t HeadCard_Actuators_Relocate_callback(uint32_t IfIndex, uint32_t BusyFla
             }
             break;
         case ActuatorWait:
-            if (isActuatorOnLowestLocation())//read the inputs in Hundred_msTick
+            if ((isActuatorOnLowestLocation())||(count_time>200))//read the inputs in Hundred_msTick
             {
                 Trigger_Head_Actuators_Stub(ACTIN, ENABLE, UP);
                 moveuptime = count_time;
@@ -784,13 +787,20 @@ uint32_t HeadCard_Actuators_Relocate_callback(uint32_t IfIndex, uint32_t BusyFla
 }
 uint32_t HeadCard_Actuators_Relocate(void)
 {
-    if ((ActuatorLocating == ActuatorIdle)||(ActuatorLocating == ActuatorLocated))
+    if (Head_Type != HEAD_TYPE_FLAT)
+        return OK;
+    //if ((ActuatorLocating == ActuatorIdle)||(ActuatorLocating == ActuatorLocated))
     {
+        Trigger_Head_Actuators_Stub(ACTIN, DISABLE, DONTCARE);
         ActuatorLocating = ActuatorMoveDown;
         count_time = 0;
         ReportWithPackageFilter(ThreadFilter,"actuators relocation",__FILE__,msec_millisecondCounter,ActuatorLocating,RpMessage,count_time,0);
         ActuatorLocatingControl =  AddControlCallback("Actuator Location", HeadCard_Actuators_Relocate_callback, eTenMillisecond, TemplateDataReadCBFunction,0,0, 0 );
     }
+    /*else
+    {
+        ReportWithPackageFilter(ThreadFilter,"actuators relocation FAILED",__FILE__,__LINE__,ActuatorLocating,RpMessage,count_time,0);
+    }*/
     return ActuatorLocatingControl;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h
index 33187d1f6..bfaf5937d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h
@@ -138,19 +138,19 @@ typedef union
         bool IN_ACTLOW_OCUR_BREAK_HTOT2       : 1; //P01
         bool IN_ACTLOW_OCUR_BREAK_HTOT3       : 1; //P02
         bool IN_ACTLOW_OCUR_BREAK_HTOT4       : 1; //P03
-        bool INPUT_BREAK_MIX         : 1; //P04
-        bool INPUT_ACTLOW_LIMIT_740W : 1; //P05
-        bool INPUT_FAN_ALERT         : 1; //P06
-        bool OUTPUT_ACT_DIR          : 1; //P07
+        bool INPUT_BREAK_MIX                  : 1; //P04
+        bool INPUT_ACTLOW_LIMIT_740W          : 1; //P05
+        bool INPUT_FAN_ALERT                  : 1; //P06
+        bool OUTPUT_ACT_DIR                   : 1; //P07
 
-        bool INPUT_ACTIN_EN          : 1; //p10
-        bool INPUT_ACTOT_EN          : 1; //p11
-        bool OUTPUT_ACTLOW_ACTIN_ON  : 1; //p12
-        bool OUTPUT_ACTLOW_ACTOT_ON  : 1; //p13
-        bool INPUT_LS_FRONT          : 1; //p14
-        bool INPUT_LS_REAR           : 1; //p15
-        bool INPUT_LS_UP             : 1; //p16
-        bool INPUT_LS_SPARE          : 1; //p17
+        bool INPUT_ACTIN_EN                   : 1; //p10
+        bool INPUT_ACTOT_EN                   : 1; //p11
+        bool OUTPUT_ACTLOW_ACTIN_ON           : 1; //p12
+        bool OUTPUT_ACTLOW_ACTOT_ON           : 1; //p13
+        bool INPUT_LS_FRONT_ARC_ACT           : 1; //p14
+        bool INPUT_LS_REAR_ARC_COVER          : 1; //p15
+        bool INPUT_LS_UP                      : 1; //p16
+        bool INPUT_LS_ARC_TUNNEL_COVER        : 1; //p17
     }bits;
     unsigned char uchar[2];
     unsigned short ushort;
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 108676b47..ec27b4f57 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
@@ -263,7 +263,7 @@ uint8_t HeadADCPT100_InitConfigReg()
 
         for(i=HEAD_PT100_ZONE_1_0X80_0;i < MAX_HEAD_CARD_TEMP_SENS_ID;i++) // for now we are using the same configuration to all of them
         {
-            if((Head_Type == HEAD_TYPE_STAPLE_SPUN) && (( i ==  HEAD_PT100_ZONE_6_0X84_1) || ( i ==  HEAD_PT100_ZONE_8_0X86_1) || ( i ==  HEAD_PT100_ZONE_5_0X84_0) || ( i ==  HEAD_PT100_ZONE_7_0X86_0)))//pressure sensors
+            if((Head_Type == HEAD_TYPE_ARC) && (( i ==  HEAD_PT100_ZONE_6_0X84_1) || ( i ==  HEAD_PT100_ZONE_8_0X86_1) || ( i ==  HEAD_PT100_ZONE_5_0X84_0) || ( i ==  HEAD_PT100_ZONE_7_0X86_0)))//pressure sensors
             {
                 // - - - - - - - - - - Reg0 - - - - - - - - - -
                 HeadTempSensConfig[i].Reg0.bits.PGA_BYPASS     = ADS122X_PGA_BYPASS                      ;//Bit 0
@@ -335,7 +335,7 @@ uint8_t HeadADCPT100_InitConfigReg()
 
         for(i=HEAD_PT100_ZONE_2_0X80_1;i < HEAD_PT100_RESERVE_0X8E_1;i++)
         {
-            if((Head_Type == HEAD_TYPE_STAPLE_SPUN) && (( i ==  HEAD_PT100_ZONE_6_0X84_1) || ( i ==  HEAD_PT100_ZONE_8_0X86_1)))//pressure sensors
+            if((Head_Type == HEAD_TYPE_ARC) && (( i ==  HEAD_PT100_ZONE_6_0X84_1) || ( i ==  HEAD_PT100_ZONE_8_0X86_1)))//pressure sensors
             {
                 HeadTempSensConfig[i].Reg0.bits.MUX            = HEAD_CONFIG_ODD_PT100_MUX                   ;//Bits 4-7          
             }
@@ -762,7 +762,7 @@ uint32_t control_HeadCard_PT100(uint8_t HEAD_CONFIG_PT100_MUX)
             //delayms(5);
             for(SensorId = HEAD_PT100_ZONE_2_0X80_1; SensorId < HEAD_PT100_RESERVE_0X8E_1; SensorId++)
             {
-                if((Head_Type == HEAD_TYPE_STAPLE_SPUN) && (( SensorId ==  HEAD_PT100_ZONE_6_0X84_1) || ( SensorId ==  HEAD_PT100_ZONE_8_0X86_1)))//pressure sensors
+                if((Head_Type == HEAD_TYPE_ARC) && (( SensorId ==  HEAD_PT100_ZONE_6_0X84_1) || ( SensorId ==  HEAD_PT100_ZONE_8_0X86_1)))//pressure sensors
                 {
                     //Config_Mux
                 }
@@ -818,7 +818,7 @@ uint32_t control_HeadCard_PT100(uint8_t HEAD_CONFIG_PT100_MUX)
             //delayms(5);
             for(SensorId = HEAD_PT100_ZONE_1_0X80_0; SensorId < HEAD_PT100_ZONE_2_0X80_1; SensorId++)
             {
-                if((Head_Type == HEAD_TYPE_STAPLE_SPUN) && (( SensorId ==  HEAD_PT100_ZONE_5_0X84_0) || ( SensorId ==  HEAD_PT100_ZONE_7_0X86_0)))//pressure sensors
+                if((Head_Type == HEAD_TYPE_ARC) && (( SensorId ==  HEAD_PT100_ZONE_5_0X84_0) || ( SensorId ==  HEAD_PT100_ZONE_7_0X86_0)))//pressure sensors
                 {
 
                 }
@@ -1004,12 +1004,12 @@ uint32_t Detect_Head_PT100_Faults(TEMPERATURE_SENSOR_ID_ENUM SensorId)
 
         if((ERR_Couner >= 9) && (ERR_Couner < 14) || ((Detect_PT100_Faults[HEAD_PT100_AIR_HEATER_1_0X8C_0] == OK ) || (Detect_PT100_Faults[HEAD_PT100_AIR_HEATER_2_0X8C_1] == OK )) )
         {
-            //Head_Type = HEAD_TYPE_STAPLE_SPUN;
+            //Head_Type = HEAD_TYPE_ARC;
 
             if(ERR_Couner==9)
-                ReportWithPackageFilter(GeneralFilter,"HEAD_TYPE_STAPLE_SPUN",__FILE__,__LINE__,ERR_Couner,RpMessage,0,0);
+                ReportWithPackageFilter(GeneralFilter,"HEAD_TYPE_ARC",__FILE__,__LINE__,ERR_Couner,RpMessage,0,0);
             else
-                ReportWithPackageFilter(HeatersFilter,"HEAD_TYPE_STAPLE_SPUN with PT100 not working",__FILE__,__LINE__,ERR_Couner,RpError, Detect_PT100_Faults[HEAD_PT100_AIR_HEATER_1_0X8C_0] +2*(Detect_PT100_Faults[HEAD_PT100_AIR_HEATER_2_0X8C_1]),0);
+                ReportWithPackageFilter(HeatersFilter,"HEAD_TYPE_ARC with PT100 not working",__FILE__,__LINE__,ERR_Couner,RpError, Detect_PT100_Faults[HEAD_PT100_AIR_HEATER_1_0X8C_0] +2*(Detect_PT100_Faults[HEAD_PT100_AIR_HEATER_2_0X8C_1]),0);
         }
         else if((ERR_Couner >= 2) && (ERR_Couner < 9))
         {
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 90f197587..7d2cf7868 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Task.c
@@ -631,7 +631,7 @@ void I2C_ReadingTask(UArg arg0, UArg arg1)
             break;
         case Heater_Current_Reading:
             //Report("Read_Heaters_Current",__FILE__,__LINE__,255,RpWarning,0,0);
-            if((Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)&&(I2C_ReadingMessage.parameter>=HEATER_DRYER_CURRENT_3))
+            if((Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)&&(I2C_ReadingMessage.parameter>=HEATER_DRYER_CURRENT_3))
                 Read_Head_ADC(I2C_ReadingMessage.parameter);
 //            else
 //                Read_Heaters_Current(I2C_ReadingMessage.parameter);
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC.c
index 877f0a32b..8da522961 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/NFC.c
@@ -175,6 +175,12 @@ RFID_RETURN_CODE  TagReadData()
     return SUCCESS;
 }
 
+RFID_RETURN_CODE  WriteCRCValue()
+{
+
+    return SUCCESS;
+}
+
 uint32_t RFIDTagComm_StateMachine(StateMachineMode Mode)
 {
     uint32_t Status = OK;
@@ -184,7 +190,7 @@ uint32_t RFIDTagComm_StateMachine(StateMachineMode Mode)
     switch(TagStage)
     {
         case Tag_Idle:
-        //Not Active
+        //Tag Not Active
         break;
         case Tag_PrepareForDiscovery:
 
@@ -245,7 +251,11 @@ uint32_t RFIDTagComm_StateMachine(StateMachineMode Mode)
 
             break;
         case Tag_UpdateCheckSum:
-        break;
+                crc_ccitt_init();
+                //crc_ccitt_update(buf,len);
+                WriteCRCValue();
+
+            break;
         case Tag_DisconnectComm:
 
                 RFIDRetValue = RFID_StopDiscovery(readerID);
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.c
index 30a6d6f16..4171a62a6 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.c
@@ -381,27 +381,29 @@ RFID_RETURN_CODE WriteValue( uint32_t readerID, NxpNci_RfIntf_t *tagInfo, uint8_
     return retCode;
 }
 
-RFID_RETURN_CODE ReadValue( uint32_t readerID, NxpNci_RfIntf_t *tagInfo, uint8_t *value, uint8_t valueIndex, uint32_t *valueNum )
+
+
+uint32_t ReadValue( uint32_t readerID, NxpNci_RfIntf_t *tagInfo, uint8_t *value, uint8_t valueIndex, RFID_RETURN_CODE *rfidCode )
 {
-    RFID_RETURN_CODE retCode;
+    uint32_t retCode = 0;
     uint8_t i, data[512];
     uint16_t succeededSize = 0;
+
     uint8_t startBlock = GetBlockLocation( Fields[valueIndex].fieldLocation );
-    retCode = RFID_CardModeReceive( readerID, tagInfo, data, startBlock, Fields[valueIndex].fieldLength + BLOCK_SIZE, &succeededSize);
-    if ( retCode != SUCCESS )
+    *rfidCode = RFID_CardModeReceive( readerID, tagInfo, data, startBlock, Fields[valueIndex].fieldLength + BLOCK_SIZE, &succeededSize);
+    if ( *rfidCode != SUCCESS )
         return retCode;
     memcpy( value, &data[ Fields[valueIndex].fieldLocation % BLOCK_SIZE], Fields[valueIndex].fieldLength ) ;
     if ( Fields[valueIndex].isNum == true )
     {
-        *valueNum = 0;
+        retCode = 0;
         for ( i = 0; i < Fields[valueIndex].fieldLength; i++ )
         {
-            *valueNum *= 10;
-            *valueNum += value[i] - '0';
-            //*valueNum += value[i];
-            //if ( i < Fields[valueIndex].fieldLength - 1 )
-            //    *valueNum <<= 8;
+            retCode *= 10;
+            retCode += value[i] - '0';
+
         }
+
     }
     return retCode;
 }
@@ -956,6 +958,29 @@ int incrementCounterAndCompare( uint32_t readerID, NxpNci_RfIntf_t *tagInfo, int
     return 1;
 }
 
+void crc_ccitt_init(void)
+{
+    m_crc = 0xffff;
+}
+
+void crc_ccitt_update(unsigned char * buf, int len)
+{
+    int i, j;
+
+    for ( i = 0; i < len; i++ )
+    {
+        m_crc ^= buf[i];
+        for ( j = 0; j < 8; j++ )
+        {
+            if ( m_crc & 0x0001 )
+                m_crc = (m_crc >> 1) ^ 0x8408;
+            else
+                m_crc = (m_crc >> 1);
+        }
+    }
+}
+
+
 void RFID_Test()
 {
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h
index 90860ea50..b07c79f4f 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/RFID_NFC/logi-tag/LT_RFID.h
@@ -56,6 +56,7 @@ typedef struct{
 } FIELDS_LOCATIONS;
 
 FIELDS_LOCATIONS Fields[NUMBER_OF_FIELDS];
+unsigned int m_crc;
 
 RFID_RETURN_CODE RFID_Connect(uint32_t readerID);
 RFID_RETURN_CODE RFID_Disconnect(uint32_t readerID);
@@ -70,7 +71,8 @@ RFID_RETURN_CODE RFID_CardModeSend(uint32_t readerID, NxpNci_RfIntf_t *tagInfo,
 bool IsTagValid(uint32_t readerID, NxpNci_RfIntf_t *tagInfo);
 uint32_t GetCounter (uint32_t readerID, NxpNci_RfIntf_t *tagInfo);
 RFID_RETURN_CODE WriteValue( uint32_t readerID, NxpNci_RfIntf_t *tagInfo, uint8_t *value, uint8_t valueIndex, uint32_t valueNum );
-RFID_RETURN_CODE ReadValue( uint32_t readerID, NxpNci_RfIntf_t *tagInfo, uint8_t *value, uint8_t valueIndex, uint32_t *valueNum );
+
+uint32_t ReadValue( uint32_t readerID, NxpNci_RfIntf_t *tagInfo, uint8_t *value, uint8_t valueIndex, RFID_RETURN_CODE *rfidCode );
 RFID_RETURN_CODE getUID( uint32_t readerID, NxpNci_RfIntf_t *tagInfo, uint8_t *uid );
 void calcHash( uint8_t *input, uint16_t inputLen, uint8_t *output  );
 bool setHashValue( uint32_t readerID, NxpNci_RfIntf_t *tagInfo, uint8_t *uid, uint16_t inputLen );
@@ -89,6 +91,10 @@ void MD5Update( MD5_CTX *, unsigned char *, unsigned int );
 void MD5Final( unsigned char results[16], MD5_CTX * );
 
 //////////////////////////////////////
+void crc_ccitt_init(void);
+void crc_ccitt_update(unsigned char * buf, int len);
+//////////////////////////////////////
+
 // helpers
 void InitFields();
 void SetFieldsLocationLen();
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
index cd66c7a16..ad7e91b88 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c
@@ -72,6 +72,7 @@ uint32_t MotorsInit(void)
             MotorConfigState[i] = false;
         }
 
+#ifndef EVALUATION_BOARD
     //option to change itafter initialization  (to solve EMC issues) in the function Control_motors_clock_source
     #ifdef EMC_FORCE_MOT_CLOCK_INTERNAL
         F3_Moto_Clk_Src_Sel.Motor.LDRIVING = INTERNAL;
@@ -86,6 +87,7 @@ uint32_t MotorsInit(void)
     #endif
 
     F3_MOTO_CLK_SRC_SEL = F3_Moto_Clk_Src_Sel.ushort;
+#endif
 
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
index e505ac017..90ac22e7d 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Motors/MotorActions.c
@@ -878,7 +878,7 @@ void MotorActionsInit(void)
         MotorDriverResponse[i].Status = 0xFFFFFFFF;
         StoredMotorPosition[i] = 0;
     }
-    if (Head_Type == HEAD_TYPE_SYLKO)//adjust the limit switches
+    if (Head_Type == HEAD_TYPE_FLAT)//adjust the limit switches
     {
         Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID] = I2C_HEADCARD_COVER_LS_FRONT;
         Motor_Id_to_LS_IdUp  [HARDWARE_MOTOR_TYPE__MOTO_DH_LID] = I2C_HEADCARD_COVER_LS_REAR ;
diff --git a/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c b/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
index 3f43e5243..96c7702bb 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
@@ -181,7 +181,7 @@ void Valve_Command(Valves_t Valve_Id) //1 - OPEN, 0 - CLOSE
                 F1_GPO_Reg.bits.F1_VALVE_WASTE_TANK = ValveRequest[Valve_Id].Direction;
             break;
         case VALVE_MIXCHIP_WASTECH:
-            if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+            if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
                 Trigger_Head_MixerValve(ValveRequest[Valve_Id].Direction);
             else
                 F1_GPO_Reg.bits.F1_VALVE_MIXCHIP_WASTECH = ValveRequest[Valve_Id].Direction;
diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index 45059e9c4..ccda43cfd 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -271,6 +271,7 @@ int main(void)
     //OpenLogFile();
 
    Init_All_I2C();
+#ifndef EVALUATION_BOARD
    Block_Main_MUX_TCA9548A_0xE4();//unused, same i2c as head and whs cards
    I2C_BUSY_DELAY = 3000; //temporary workaround!!!
    Check_Head_Type_Via_EEPROM();//without trigger
@@ -280,22 +281,21 @@ int main(void)
    {
        PP_Machine = true;
    }
-   if ((Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)||(WHS_Type == WHS_TYPE_NEW))
+   if ((Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)||(WHS_Type == WHS_TYPE_NEW))
    {
        I2C_ReadingTask_Init();
    }
-   if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+   if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
    {
        Trigger_Head_io_Init();//Head_IO_Init();//moved to set 24 to pressure sensor in arc earlier
    }
 
-   #ifndef EVALUATION_BOARD
    STATUS_RED_LED_ON;
    STATUS_GREEN_LED_ON;
    FPGA_Init();
-   #endif
 
    Init_IFS();//must be done after FPGA_Init
+#endif
 
 	MAP_FPULazyStackingEnable();
 
@@ -329,8 +329,10 @@ int main(void)
 
     ControlStart();
     Heaters_Init();
+#ifndef EVALUATION_BOARD
     MotorsInit();
-//Shai    WHS_HW_test(); // for WHS sensor test
+#endif
+    //Shai    WHS_HW_test(); // for WHS sensor test
 
     #ifndef EVALUATION_BOARD
         Init_Machine_Leds();
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index cc8ae5be8..07df07309 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -967,6 +967,10 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
             }
         }
     }
+    if (Configured[Module_Waste])
+    {
+        FoundReason = Waste_Prepare();
+    }
     if ((AlarmState[Alarm_i].Status == true)&&(FoundReason == JOB_OK))
     {
         if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 27fc8a707..242bdc3ce 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -621,7 +621,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     //ROM_IntMasterDisable();
     int StartPT100 = 0;
     //Screw_ENC_Velocity_to_DAC(); - for testing the screw enc
-    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
         StartPT100 = TEMP_SENSE_ANALOG_DRYER_TEMP1;
     if (Ten_msTick)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index d872b30b5..79e84ebca 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -378,7 +378,7 @@ uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer)
                 Turn_the_Blower_Off();
             break;
         case HARDWARE_BLOWER_TYPE__HeadBlower1:
-            if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+            if (Head_Type == HEAD_TYPE_ARC)
             {
                 if ((request->has_voltage)&&(request->isactive == true))
                     Trigger_Head_Fan_Control(HEAD_FAN_RIGHT,request->voltage);
@@ -390,7 +390,7 @@ uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer)
 
             break;
         case HARDWARE_BLOWER_TYPE__HeadBlower2:
-            if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+            if (Head_Type == HEAD_TYPE_ARC)
             {
                 if ((request->has_voltage)&&(request->isactive == true))
                     Trigger_Head_Fan_Control(HEAD_FAN_LEFT,request->voltage);
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 1f5093601..7963a9290 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -147,6 +147,7 @@ double dispenser8motorfrequency[DIAGNOSTICS_LIMIT+1];
 Task_Handle Diagnostics_Task_Handle;
 Mailbox_Handle          DiagnosticsMsgQ = NULL;
 
+extern uint8_t Head_Fan_PWM_Command[2] ;
 bool blowervolatgedisplay = false;
 bool midtankDisplay = false;
 double diagvoltage = 0;
@@ -262,6 +263,7 @@ uint8_t  MotorCounterIndex[MAX_THREAD_MOTORS_NUM]= {0,0,0};
 double MotorValue[MAX_THREAD_MOTORS_NUM][DIAGNOSTICS_LIMIT+1];
 uint8_t  SpeedCounterIndex= 0;
 double SpeedValue[DIAGNOSTICS_DANCER_LIMIT+1];
+double headblowervoltage1 = 0.0, headblowervoltage2 = 0.0;
 
 void DiagnosticLoadMotor(int MotorId, int frequency)
 {
@@ -361,10 +363,10 @@ void DiagnosticLoadTemperature(int HeaterId, int temperature)
         ReportWithPackageFilter(DiagnosticsFilter,"wrong Heater Id",__FILE__,__LINE__,(int)HeaterId,RpError,(int)0,0);
         return;
     }
-    if ((temperature < 1000)||(temperature>28000)) //error read, all 0xF or all 0
+    /*if ((temperature < 1000)||(temperature>28000)) //error read, all 0xF or all 0
     {
         return;
-    }
+    }*/
     HeaterTemperature[HeaterId][HeaterCounterIndex[HeaterId]] = temp/100;
     if (HeaterCounterIndex[HeaterId]<DIAGNOSTICS_LIMIT )
         HeaterCounterIndex[HeaterId]++;
@@ -423,8 +425,8 @@ void CopyTemperaturesToMonitor(void)
             HeaterCounterIndex[HEATER_TYPE__HeaterZone2];
     DiagnosticsMonitor.n_headzone3temperature =
             HeaterCounterIndex[HEATER_TYPE__HeaterZone3];
-    if ((Head_Type == HEAD_TYPE_SYLKO)
-            || (Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD))
+    if ((Head_Type == HEAD_TYPE_FLAT)
+            || (Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD))
     {
         DiagnosticsMonitor.headzone4temperature =
                 HeaterTemperature[HEATER_TYPE__HeaterZone4];
@@ -439,7 +441,7 @@ void CopyTemperaturesToMonitor(void)
         DiagnosticsMonitor.n_headzone6temperature =
                 HeaterCounterIndex[HEATER_TYPE__HeaterZone6];
     }
-    if (Head_Type == HEAD_TYPE_SYLKO)
+    if (Head_Type == HEAD_TYPE_FLAT)
     {
         DiagnosticsMonitor.headzone7temperature =
                 HeaterTemperature[HEATER_TYPE__HeaterZone7];
@@ -476,7 +478,7 @@ void CopyTemperaturesToMonitor(void)
                 HeaterCounterIndex[HEATER_TYPE__HeadCoverHeater2];
     }
     //if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_STAPLE_SPUN))
-    if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    if (Head_Type == HEAD_TYPE_ARC)
     {
         DiagnosticsMonitor.headcoverheater1temperature =
                 HeaterTemperature[HEATER_TYPE__HeadCoverHeater1];
@@ -499,6 +501,16 @@ void CopyTemperaturesToMonitor(void)
         DiagnosticsMonitor.headblower1airflow = HeaterTemperature[HEATER_TYPE__HeaterZone5];
         DiagnosticsMonitor.headblower2airflow = HeaterTemperature[HEATER_TYPE__HeaterZone7];
     }
+    DiagnosticsMonitor.n_headblower1airflow = HeaterCounterIndex[HEATER_TYPE__HeaterZone5];
+    DiagnosticsMonitor.n_headblower2airflow = HeaterCounterIndex[HEATER_TYPE__HeaterZone7];
+    DiagnosticsMonitor.headblower1airflow = HeaterTemperature[HEATER_TYPE__HeaterZone5];
+    DiagnosticsMonitor.headblower2airflow = HeaterTemperature[HEATER_TYPE__HeaterZone7];
+    headblowervoltage1 =(double )Head_Fan_PWM_Command[HEAD_FAN_RIGHT];
+    headblowervoltage2  =(double )Head_Fan_PWM_Command[HEAD_FAN_LEFT];
+    DiagnosticsMonitor.headblowervoltage1 = &headblowervoltage1;
+    DiagnosticsMonitor.headblowervoltage2 = &headblowervoltage2;
+    DiagnosticsMonitor.n_headblowervoltage1 = 1;
+    DiagnosticsMonitor.n_headblowervoltage2 = 1;
     DiagnosticsMonitor.dryerzone1temperature =
             HeaterTemperature[HEATER_TYPE__DryerAirHeater];
     DiagnosticsMonitor.dryerzone2temperature =
@@ -601,7 +613,7 @@ void DiagnosticOneMinuteCollection(void)
     DiagnosticsMonitor.midtank7level = MidTankpressure[6];
     DiagnosticsMonitor.n_midtank8level = 1;
     DiagnosticsMonitor.midtank8level = MidTankpressure[7];
-    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD) //rapid/pp machines
+    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD) //rapid/pp machines
     {
         /*DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
         DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
@@ -610,7 +622,7 @@ void DiagnosticOneMinuteCollection(void)
         Get_Head_Current(HEAD_CURRENT_MIXER,&HeadCurrent[HEAD_CURRENT_ZONE_12+1][0]);
         DiagnosticsMonitor.n_mixer1heatercurrent = 1;
         DiagnosticsMonitor.mixer1heatercurrent = HeadCurrent[HEAD_CURRENT_ZONE_12+1];
-        if (Head_Type == HEAD_TYPE_SYLKO)
+        if (Head_Type == HEAD_TYPE_FLAT)
         {
             for (i=0;i<HEAD_CURRENT_ZONE_12;i++)
             {
@@ -841,7 +853,7 @@ void DiagnosticOneSecCollection(void)
     int i;
     memset(HeaterCounterIndex,0,sizeof(HeaterCounterIndex));
 
-    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD) //rapid/pp machines
+    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD) //rapid/pp machines
     {
         AcVoltage = ReadVAC();
         DiagnosticsMonitor.whsblower2voltage = &AcVoltage;
@@ -886,7 +898,7 @@ void DiagnosticOneSecCollection(void)
     DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
     DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];
 
-    if (Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    if (Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD)
     {
         DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
         DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
@@ -896,7 +908,7 @@ void DiagnosticOneSecCollection(void)
         DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
         DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
     }
-    if (Head_Type == HEAD_TYPE_SYLKO)
+    if (Head_Type == HEAD_TYPE_FLAT)
     {
         DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
@@ -915,7 +927,7 @@ void DiagnosticOneSecCollection(void)
         DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater1, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1));
         DiagnosticLoadTemperature(HEATER_TYPE__HeadCoverHeater2, MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0));
     }
-    if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    if (Head_Type == HEAD_TYPE_ARC)
     {
         DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
         DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
@@ -1196,22 +1208,22 @@ void SendDiagnostics(void)
     LoadHeaterState(HEATER_TYPE__HeaterZone2,&HeaterInfo[i++]);
     LoadHeaterState(HEATER_TYPE__HeaterZone3,&HeaterInfo[i++]);
 
-    if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD))
+    if ((Head_Type == HEAD_TYPE_FLAT)||(Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD))
     {
         LoadHeaterState(HEATER_TYPE__HeaterZone4,&HeaterInfo[i++]);    
     }
 	LoadHeaterState(HEATER_TYPE__HeaterZone5,&HeaterInfo[i++]);
 	//LoadHeaterState(HEATER_TYPE__HeaterZone6,&HeaterInfo[i++]);
-	 if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_SYLKO_WITHOUT_CARD))
+	 if ((Head_Type == HEAD_TYPE_FLAT)||(Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD))
     {
         LoadHeaterState(HEATER_TYPE__HeaterZone6,&HeaterInfo[i++]);  
     }
-	if ((Head_Type == HEAD_TYPE_SYLKO)||(Head_Type == HEAD_TYPE_STAPLE_SPUN))
+	if ((Head_Type == HEAD_TYPE_FLAT)||(Head_Type == HEAD_TYPE_ARC))
 	{
         LoadHeaterState(HEATER_TYPE__HeaterZone7,&HeaterInfo[i++]);
 		//LoadHeaterState(HEATER_TYPE__HeaterZone8,&HeaterInfo[i++]);
 	}
-    if (Head_Type == HEAD_TYPE_SYLKO)
+    if (Head_Type == HEAD_TYPE_FLAT)
     {		
         LoadHeaterState(HEATER_TYPE__HeaterZone8,&HeaterInfo[i++]);
 		LoadHeaterState(HEATER_TYPE__HeaterZone9,&HeaterInfo[i++]);
@@ -1219,7 +1231,7 @@ void SendDiagnostics(void)
         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_FLAT)||(Head_Type == HEAD_TYPE_ARC))
     //if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
     {
         LoadHeaterState(HEATER_TYPE__HeadCoverHeater1,&HeaterInfo[i++]);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index 30a99ac86..7530408c9 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -198,7 +198,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, false,ProcessParams->headzone3temp);
     }
-    if(Head_Type != HEAD_TYPE_STAPLE_SPUN)
+    if(Head_Type != HEAD_TYPE_ARC)
     {
         Trigger_HeaterWriting();
         if (ProcessParams->headzone4temp>1)
@@ -230,7 +230,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, true,ProcessParams->dryerzone1temp);
     else
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, false,ProcessParams->dryerzone1temp);
-    if(Head_Type == HEAD_TYPE_SYLKO)
+    if(Head_Type == HEAD_TYPE_FLAT)
     {
         if (ProcessParams->headzone7temp>1)
         {
@@ -283,7 +283,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
             status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, false,ProcessParams->headzone12temp);
         }
     }
-    if(Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    if(Head_Type == HEAD_TYPE_ARC)
     {
         Trigger_HeaterWriting();
         if (ProcessParams->rblowertemp>1)
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index ec743ea4a..52e9a6e85 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -113,7 +113,7 @@ void initializeArrays(void)
         HeaterId2PT100Id[i] = 0xFF;
         HeaterId2CurrentId[i] = NUM_OF_CURRENT_HEATERS;
     }
-    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
     {
         HeaterId2PT100Id[HEATER_TYPE__DryerAirHeater] =       DRYER_AIR_PT100;
         HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater] =      DRYER_MAIN_PT100;
@@ -466,7 +466,7 @@ uint32_t HeatersSingleHeaterEnd(int HeaterId)
             HeaterCmd[HeaterId].targettemperatue = 0;
             HeaterReady[HeaterId] = true;
             HeaterAtTemp[HeaterId] = true;
-            if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+            if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
                 Disable_Reading_Heaters_ADC(HeaterId2CurrentId[HeaterId]);
             else
                 Disable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
@@ -722,7 +722,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     HeaterAtTemp[HeaterId] = false;
     if (BlowerCfg.enabled == true)
     {
-        if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+        if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
         {
             WHS_Set_SetPoint_Q_value(headairflow*2/3);
         }
@@ -786,7 +786,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
 
     if (HeaterPreviousRead[HeaterId] < HeaterCmd[HeaterId].targettemperatue )
     {
-        if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+        if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
             Enable_Reading_Heaters_ADC(HeaterId2CurrentId[HeaterId]);
         else
             Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
@@ -1244,7 +1244,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
             /*if (BlowerCfg.enabled == true)
             {
-                if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+                if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
                 {
                     WHS_Set_SetPoint_Q_value(headairflow);
                 }
@@ -1281,7 +1281,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             IncreaseBlower = true;
             if (BlowerCfg.enabled == true)
             {
-                if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+                if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
                 {
                     WHS_Set_SetPoint_Q_value(headairflow);
                 }
@@ -1454,7 +1454,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             //DCInitialHeating[index] = false;
             HeatersControlStart();
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
-            if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+            if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
                 Disable_Reading_Heaters_ADC(HeaterId2CurrentId[index]);
             else
                 Disable_Reading_Heaters_Current(HeaterId2CurrentId[index]);
@@ -1560,9 +1560,9 @@ void EightMilliSecondHeatersInterrupt(UArg arg0)
         ROM_TimerLoadSet(Heater_timerBase, TIMER_A,OutputProportionalSingleStep);
     }
     else
-	{
+    {
         TimerDisable(Heater_timerBase, TIMER_A);
-	}
+    }
     //
     // Enable all interrupts.
     //
@@ -1649,7 +1649,7 @@ uint32_t DrierHeaterVoltageSetup(void)
     }
     Histeresis = 0;
 #ifndef VAC_TEST
-    if (Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD) //rapid/pp machines
+    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD) //rapid/pp machines
 #endif
     {
         DrierAcVoltage = ReadVAC();
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index 647797b69..a48e0df0c 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -49,8 +49,8 @@ void IDS_Dispenser_RefillEnded (char DispenserId,char  MicroSteps);
 //uint32_t IDS_Dispenser_Build_Pressure(int DispenserId, callback_fptr callback);
 
 uint32_t IDS_Cleaning_Move_Actuators(void);
-uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed);
-uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback);
+//uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed);
+//uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback);
 uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr callback);
 uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
index c9e9afdde..26ba52d76 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
@@ -51,7 +51,7 @@ int Tup = 4,Tdelay1 = 9,Tdelay2 = 29;
 
 uint32_t IDS_Cleaning_Move_Actuators()
 {
-   if(Head_Type != HEAD_TYPE_SYLKO)
+   if(Head_Type != HEAD_TYPE_FLAT)
        return OK;
    if (CleaningStageCounter == 1)
    {
@@ -83,7 +83,7 @@ uint32_t IDS_Cleaning_Move_Actuators()
 
    return OK;
 }
-uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed)
+/*uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed)
 {
     uint32_t status = OK;
     SaveLeftRockerSpeed = LeftRockerSpeed;
@@ -109,7 +109,7 @@ uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callbac
     Report("IDS_Cleaning_Center_And_Stop_Rockers actuator down", __FILE__, __LINE__, timeout, RpWarning,   123456, 0);
 
     return status;
-}
+}*/
 uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr callback)
 {
     uint32_t status = OK;
@@ -128,11 +128,10 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback)
     uint32_t status = OK;
     status = IDS_Dispenser_Close_Valve_And_Stop_Motor(CLEANER_DISPENSER,callback);
     Report("IDS_Cleaning_Stop_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning,   status, 0);
-    if(Head_Type == HEAD_TYPE_SYLKO)
-    {
-        Trigger_Head_Actuators_Control(ACTIN, LOW,false);
-        Report("IDS_Cleaning_MoveDown cleaning stop", __FILE__, __LINE__, Tdelay1, RpWarning,   CleaningStageCounter, 0);
-    }
+    HeadCard_Actuators_Relocate();
+    CleaningStageCounter = 0;
+    CleaningStage = CleaningStageIdle;
+    Report("IDS_Cleaning_Stop_Cleaning_Solution actuator relocate", __FILE__, __LINE__, CleaningStage, RpWarning,   CleaningStageCounter, 0);
 
     return status;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 311f16a19..c8e3d267e 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -583,7 +583,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              HW_Motor_Id = DispenserIdToMotorId[CLEANER_DISPENSER];
              MotorStop(HW_Motor_Id, Hard_Hiz);
              CurrentDispenserSpeed[CLEANER_DISPENSER] = 0;
-             Report("IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
+             //Report("IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
          }
 
          if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
@@ -1605,7 +1605,8 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
 #else
      Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
 #endif
-     IDS_Cleaning_Stop_Cleaning_Solution(NULL);
+     if (CurrentDispenserSpeed[CLEANER_DISPENSER]>0)
+         IDS_Cleaning_Stop_Cleaning_Solution(NULL);
      SegmentNumOfBrushStops = Segment->n_brushstops;
      BrushStopTime = Segment->length*1000/(double)SegmentNumOfBrushStops;  //brushstop in meters //brushstop in millisecond
      BrushStopTime = ((BrushStopTime*100)/dyeingspeed);//brushstop in seconds
@@ -1632,7 +1633,6 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
     if (DispenserPreSegmentControlId != 0xFF)
     {
         Report("IDS presegment not yet ended!!",__FILE__,DispenserPreSegmentControlId,(int)InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
-        //IDS_Cleaning_Stop_Cleaning_Solution (NULL);
         RemoveControlCallback(DispenserPreSegmentControlId, IDSPreSegmentStateCallbackRunner );
         DispenserPreSegmentControlId = 0xFF;
     }
@@ -1751,8 +1751,8 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      {
          Report("IDS_Valve_EndValveReady start homing",__FILE__,deviceID,(int)AutoHoming_Config,RpWarning,(int)AutoHoming_JobEnd_PowerOn_off,0);
 
-         //if (deviceID!=LUBRICANT_DISPENSER)
-         IDS_HomeDispenser (deviceID, 1000 , NULL);
+         if (deviceID!=LUBRICANT_DISPENSER)
+             IDS_HomeDispenser (deviceID, 1000 , NULL);
      }
      return OK;
  }
@@ -1826,6 +1826,7 @@ uint32_t IDS_StopLubrication(void)
     Lubricant_2Way_Valve (STOP);
     IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady);
     CurrentDispenserSpeed[LUBRICANT_DISPENSER] = 0;
-    REPORT_MSG (lubricant_speed, "IDS_StopLubrication");
+    IDS_HomeDispenser (LUBRICANT_DISPENSER, 1000 , NULL);
+    REPORT_MSG (lubricant_speed, "IDS_StopLubrication and home dispenser");
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
index 55d712412..1edc03264 100644
--- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
@@ -12,7 +12,7 @@
 #define MODULES_IFS_IFS_H_
 
 #define CARTRIDGE_INK_TIMEOUT           420
-#define MidTank_Pressure_EMPTY          0.5
+#define MidTank_Pressure_EMPTY          0.3
 #define CARTRIDGE_CAPATICY              1500
 
 typedef enum{
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index e14053ae3..f61eebfa8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -87,6 +87,13 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
     uint8_t ReadBackReg[1];
 
+
+    if(request->amount == 0xacc1e)
+        {
+            response.progress = IDS_Cleaning_Move_Actuators();
+            response.has_progress = true;
+        }
+        else
     if(request->amount == 0xC04f)
     {
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 01c70d42f..376b5f4a0 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -142,11 +142,8 @@
         //EEPROM_STORAGE_DRYER_CYCLES
         MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
 
-        Report("Read_Dryer_ENC_Position()",__FILE__,__LINE__,0,RpWarning,Read_Dryer_ENC_Position(),0);
-
-        Report("MotorMovetoEncoderPosition",__FILE__,__LINE__,LoadArmRounds,RpWarning,0,0);
+        Report("Read_Dryer_ENC_Position()",__FILE__,__LINE__,LoadArmRounds,RpWarning,Read_Dryer_ENC_Position(),0);
 
-        Report("Thread_Load_Init",__FILE__,__LINE__,LoadArmRounds,RpMessage,LoadArmRounds,0);
         StopInitSequence();
         memcpy (&ProcessParametersRecover,&ProcessParametersKeep,sizeof(ProcessParameters));
         //NumberOfDrierLoaderCycles = loadLoadArmParameters();
@@ -209,7 +206,7 @@
         }
         else
         {
-            if(Head_Type > HEAD_TYPE_SYLKO_WITHOUT_CARD)
+            if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
             {
                 WHS_Set_SetPoint_Q_value(headairflow*2/3);
             }
@@ -349,7 +346,7 @@
         //HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2,
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
         //DeActivateHeadMagnet();
-        if (Head_Type != HEAD_TYPE_STAPLE_SPUN)
+        if (Head_Type != HEAD_TYPE_ARC)
         {
             CallbackCounter++;
             MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
@@ -366,7 +363,7 @@
             direction = DRIER_LID_OPEN;
         }
         MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        if (Head_Type == HEAD_TYPE_SYLKO)
+        if (Head_Type == HEAD_TYPE_FLAT)
         {
             Report("Thread_Load_Lift_actuators",__FILE__,__LINE__,LOW,RpMessage,false,0);
             Trigger_Head_Actuators_Control(ACTOT, LOW,true);
@@ -500,7 +497,7 @@
         //Close Dyeing Head Cover And Dryer Lid
         //HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2,
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
-        if (Head_Type != HEAD_TYPE_STAPLE_SPUN)
+        if (Head_Type != HEAD_TYPE_ARC)
         {
             CallbackCounter++;
             MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
@@ -517,7 +514,7 @@
             direction = DRIER_LID_CLOSE;
         }
         MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, direction, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        if (Head_Type == HEAD_TYPE_SYLKO)
+        if (Head_Type == HEAD_TYPE_FLAT)
         {
             Report("Thread_Load_Close_actuators",__FILE__,__LINE__,LOW,RpMessage,true,0);
             Trigger_Head_Actuators_Control(ACTOT, LOW,false);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index 39ff91558..bbb3e4040 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -146,6 +146,10 @@ uint32_t MotorPidRequestMessage(HardwarePidControl* request)
 //    uint32_t MotorSamples[MAX_THREAD_MOTORS_NUM][MAX_CONTROL_SAMPLES];
     temp = 1<<(DancersCfg[ThreadMotorIdToDancerId[Motor_i]].resolutionbits);
     temp = (temp*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].maximalmovementmm);//*3/2);
+    if (Motor_i == WINDER_MOTOR)
+    {
+        temp = temp*3/2;
+    }
     DancerStopActivityLimit[Motor_i] = temp/(2*PI*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].armlength);
     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 c67619e20..ef80d3603 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -723,7 +723,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             {
                 if (calculated_speed>(CurrentControlledSpeed[index]+100))
                 {
-                        ReportWithPackageFilter(ThreadFilter,"limit acceleration",__FILE__,calculated_speed,CurrentControlledSpeed[index],RpError,CurrentControlledSpeed[index]+100,0);
+                        ReportWithPackageFilter(ThreadFilter,"limit acceleration",__FILE__,calculated_speed,CurrentControlledSpeed[index],RpError,index,0);
                         calculated_speed=CurrentControlledSpeed[index]+100;
                 }
                 CurrentControlledSpeed[index] = calculated_speed;
@@ -898,17 +898,18 @@ uint32_t Adjust_Right_TFU_Tension(double tension)
 
     return status;
 }
-uint32_t ThreadPrepare_TensionCallback (int DancerId, double tension)
+uint32_t ThreadPrepare_TensionCallback (int MotorId, double tension)
 {
+    MotorStop(MotorId,Hard_Hiz);
     if (PrepareWaitCount)
     {
-        ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_TensionCallback",__FILE__,__LINE__,DancerId,RpWarning,PrepareWaitCount,0);
+        ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_TensionCallback",__FILE__,__LINE__,MotorId,RpWarning,PrepareWaitCount,0);
         PrepareWaitCount--;
     }
     if ((PrepareWaitCount == 0)&&(PrepareState == true))
     {
         PrepareState = false;
-        ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_TensionCallback  Prepare Ready",__FILE__,__LINE__,DancerId,RpWarning,PrepareWaitCount,0);
+        ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_TensionCallback  Prepare Ready",__FILE__,__LINE__,MotorId,RpWarning,PrepareWaitCount,0);
         PrepareReady(Module_Thread,ModuleDone);
     }
     return OK;
@@ -1037,7 +1038,7 @@ uint32_t ThreadPrepareState(void *JobDetails)
 //    if ((FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) == LIMIT)&&(JoggingJobActive == false))
     if ((FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) != LIMIT)&&(JoggingJobActive == false))
     {
-        if(Head_Type != HEAD_TYPE_STAPLE_SPUN)
+        if(Head_Type != HEAD_TYPE_ARC)
         {
             ReportWithPackageFilter(ThreadFilter,"Dyeing head is wide open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpError,LIMIT,0);
             if (SkipOpenLids == false)
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h
index af4bd5e08..ee9f668db 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h
@@ -44,6 +44,7 @@ bool WHS_IsContainerFull();
 bool WHS_WasteCartridgeLowerPresent();
 bool WHS_WasteCartridgeMiddlePresent();
 bool WHS_IsEmptying();
+uint32_t Waste_Prepare(void);
 
 #endif
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
index d87ebd1a2..c0e51a143 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
@@ -500,27 +500,31 @@ void Waste_StateMachine(void)
             break;
     }
 }
-void Waste_Prepare(void)
+uint32_t Waste_Prepare(void)
 {
     //check if the waste is ready to run - waste level not above overflow level and no cartridge in the slots
     if (wasteLevel > wasteLevelOverflow)
     {
         Report("cannot start a job with waste tank overflow", __FILE__, __LINE__, wasteLevel, RpMessage, wasteLevelOverflow, 0);
         JobEndReason = JOB_SAFETY_CRITICAL_ALARM;
+        usnprintf(AlarmReasonStr, 100, "cannot start a job with waste tank overflow");
         AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_OVERFLOW,  true);
-        PrepareReady(Module_Waste,ModuleFail);
-        return;
+        //PrepareReady(Module_Waste,ModuleFail);
+        return JOB_SAFETY_CRITICAL_ALARM;
     }
     if ((WHS_IsEmptying())||(NoCartAvailable()))
     {
-        PrepareReady(Module_Waste,ModuleDone);
+        //PrepareReady(Module_Waste,ModuleDone);
+        return JOB_OK;
     }
     else
     {
         Report("cannot start a job with cartridges in the IFS", __FILE__, __LINE__, wasteLevel, RpMessage, wasteLevelOverflow, 0);
         JobEndReason = JOB_OTHER_ALARM;
         AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  true);
-        PrepareReady(Module_Waste,ModuleFail);
+        usnprintf(AlarmReasonStr, 100, "cannot start a job with cartridges in the IFS");
+        //PrepareReady(Module_Waste,ModuleFail);
+        return JOB_OTHER_ALARM;
     }
     return;
 
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
index 1dd81d011..30e43fe99 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
@@ -590,6 +590,7 @@ void InitSequenceSetStartHeating(bool StartHeating)
 uint32_t InitSequenceStartHeating(void)
 {
     SetMachineReadyForHeating(true);
+    HeadCard_Actuators_Relocate();
     //SetMachineStatus(MACHINE_STATE__Ready); //prevent job while waiting for the cooler
 
     if (InitialHeating)
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
index dfd9ffaa5..776d55080 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
@@ -409,7 +409,7 @@ uint32_t PowerOffWaitForTemperatureCallback(uint32_t IfIndex, uint32_t BusyFlag)
         readTemp = MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1);
         if ((readTemp>= MaxTemp)&&(readTemp < 27000))        MaxTemp = readTemp;
     }
-    if (Head_Type == HEAD_TYPE_STAPLE_SPUN)
+    if (Head_Type == HEAD_TYPE_ARC)
     {
         readTemp = MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0);
         if ((readTemp>= MaxTemp)&&(readTemp < 27000))        MaxTemp = readTemp;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
index 106d515ad..33face713 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -207,10 +207,10 @@ static ReturnCode PrepareState(void *JobDetails)
     {
         PrepareWaiting[Module_Thread] = ModuleWaiting;
     }
-    if (Configured[Module_Waste])
+    /*if (Configured[Module_Waste])
     {
         PrepareWaiting[Module_Waste] = ModuleWaiting;
-    }
+    }*/
     if (Configured[Module_Winder])
     {
         PrepareWaiting[Module_Winder] = ModuleWaiting;
@@ -243,8 +243,8 @@ static ReturnCode PrepareState(void *JobDetails)
            SendJobProgress(0.0, 0, false, "Winder prepare failed !!!!");
        }
     }
-    if (Configured[Module_Waste])
-        Waste_Prepare();
+    //if (Configured[Module_Waste])
+    //    Waste_Prepare();
 
 	return retcode;
 }