head type name change

24 files changed, 124 insertions, 111 deletions

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 626ad9293..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
@@ -441,11 +441,11 @@ bool FPGA_Read_limit_Switches(FPGA_GPI_ENUM Limit_Switch)
                 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_STAPLE_SPUN)
+            if(Head_Type == HEAD_TYPE_ARC)
                 LM_Status = !(Head_I2C_EXP4_0x46.bits.INPUT_LS_ARC_TUNNEL_COVER);
                 break;
         default :
@@ -532,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
@@ -551,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
@@ -582,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/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 c222521e7..2ce1ac909 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;
@@ -586,6 +586,9 @@ uint32_t HeadCard_Actuators_Stub(ACTUATORS Act_ID, bool Enable, bool Direction)/
             Head_I2C_EXP4_0x46.bits.OUTPUT_ACTLOW_ACTOT_ON  = LOW;
         }
 
+        status |= Head_Write_IO_Reg(0x42,HIGH);
+        status |= Head_Write_IO_Reg(0x46,LOW_AND_HIGH);
+
         //100msec delay - (need short command - Active LOW )
         if (ActControlId == 0xFF)
             ActControlId = AddControlCallback("ctuatorControl", HeadCard_ActStubCallBackFunction, (eHundredMillisecond), TemplateDataReadCBFunction,Act_ID,0, 0 );
@@ -602,17 +605,14 @@ uint32_t HeadCard_Actuators_Stub(ACTUATORS Act_ID, bool Enable, bool Direction)/
         {
             Head_I2C_EXP4_0x46.bits.OUTPUT_ACTLOW_ACTOT_ON  = HIGH;
         }
-        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);
-        }
-    }
+        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);
+        status |= Head_Write_IO_Reg(0x42,HIGH);
+        status |= Head_Write_IO_Reg(0x46,HIGH);
+    }
 
     return status;
 }
@@ -740,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:
@@ -787,18 +787,13 @@ uint32_t HeadCard_Actuators_Relocate_callback(uint32_t IfIndex, uint32_t BusyFla
 }
 uint32_t HeadCard_Actuators_Relocate(void)
 {
-    //if ((ActuatorLocating == ActuatorIdle)||(ActuatorLocating == ActuatorLocated))
+    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/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/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..da103cced 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -280,11 +280,11 @@ 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
    }
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 0e91f4211..ed817f9cc 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -425,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];
@@ -441,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];
@@ -478,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];
@@ -613,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];
@@ -622,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++)
             {
@@ -853,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;
@@ -898,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));
@@ -908,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));
@@ -927,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));
@@ -1208,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++]);
@@ -1231,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_Cleaning.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
index c6be46bca..8347c5ee9 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,10 +128,11 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback)
     uint32_t status = OK;
     status = IDS_Dispenser_Close_Valve_And_Stop_Motor(CLEANER_DISPENSER,callback);
     Report("IDS_Cleaning_Stop_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning,   status, 0);
-    HeadCard_Actuators_Relocate();
-    CleaningStageCounter = 0;
-    CleaningStage = CleaningStageIdle;
-    Report("IDS_Cleaning_Stop_Cleaning_Solution actuator relocate", __FILE__, __LINE__, CleaningStage, RpWarning,   CleaningStageCounter, 0);
+    if(Head_Type == HEAD_TYPE_FLAT)
+    {
+        Trigger_Head_Actuators_Control(ACTIN, LOW,false);
+        Report("IDS_Cleaning_MoveDown cleaning stop", __FILE__, __LINE__, Tdelay1, RpWarning,   CleaningStageCounter, 0);
+    }
 
     return status;
 
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..b81c2e602 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -209,7 +209,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 +349,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 +366,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 +500,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 +517,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_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index f403eeeab..09ab89f24 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -1037,7 +1037,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/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;