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

10 files changed, 200 insertions, 49 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 78398119b..b5c24835a 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -835,7 +835,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     if (n_segments == 0)
     {
         ReportWithPackageFilter(AlarmFilter,"no segments in the job", __FILE__,__LINE__,0, DEBUG_LOG_CATEGORY__Warning, 222, 0);
-        return JOB_OK;
+        return JOB_FILE_PROBLEM;
     }
     if (AlarmItem == NULL)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index 284b2de6c..6d50eb926 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -50,3 +50,6 @@ void HeadBlowersInit();
 void HeadBlowersCfg();
 void HeadBlowersControlLoop ();
 uint32_t  HeadBlowerCommandRequestMessage(int blowerId, float flow);
+void HeadBlowersOff(int off);
+uint32_t HeadBlowersOffGet();
+
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index a6b7bff86..14bce9911 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -113,6 +113,7 @@ uint32_t    SecondDryerHeaterMaxTempControl = 0xFF;
 uint32_t    DisasterControlId = 0xFF;
 double      PressureSensorV0[2] = {0.0, 0.0};
 uint8_t     HeadBlowersCloseLoopTime[2] = {2, 2};
+uint8_t     HeadBlowersEnable = 1;
 
 #define DRYER_AIR_PT100  TEMP_SENSE_ANALOG_DRYER_TEMP1
 #define DRYER_MAIN_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP2
@@ -229,9 +230,13 @@ void initializeArrays(void)
         HeaterId2PT100Id[HEATER_TYPE__HeaterZone11] =         HEAD_PT100_ZONE_11_0X8A_0;
         HeaterId2PT100Id[HEATER_TYPE__HeaterZone12] =         HEAD_PT100_ZONE_12_0X8A_1;
         */
-        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater1] =     HEAD_PT100_AIR_HEATER_2_0X8C_1;//HEAD_PT100_ZONE_11_0X8A_0; 
-        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     HEAD_PT100_AIR_HEATER_1_0X8C_0 ;//HEAD_PT100_ZONE_12_0X8A_1; 
-
+#ifdef USE_TUNNEL_PT100
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater1] =     HEAD_PT100_ZONE_11_0X8A_0; //HEAD_PT100_AIR_HEATER_2_0X8C_1;
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     HEAD_PT100_ZONE_12_0X8A_1; //HEAD_PT100_AIR_HEATER_1_0X8C_0;
+#else
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater1] =     HEAD_PT100_AIR_HEATER_2_0X8C_1;  //notice HEAD_PT100_AIR_HEATER_2_0X8C_1 refer to HeadCoverHeater1
+        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     HEAD_PT100_AIR_HEATER_1_0X8C_0;  //notice HEAD_PT100_AIR_HEATER_1_0X8C_0 refer to HeadCoverHeater2
+#endif
         HeaterId2CurrentId[HEATER_TYPE__DryerAirHeater] =       NUM_OF_CURRENT_HEATERS;
         HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater] =      HEATER_DRYER_CURRENT_1;
         HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater] = HEATER_DRYER_CURRENT_2;
@@ -400,12 +405,12 @@ uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValu
     {
         if (InternalAlarmActive[index] == false)
         {
-            if(InternalOverHeatCounter[index]++ >=Overheat_Count_Limit)
+            ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature",__FILE__,index,readValue,RpWarning,  InternalOverHeatCounter[index],0);
+            if(InternalOverHeatCounter[index]++ >=Overheat_Count_Limit*10)
             {
                 InternalOverHeatCounter[index] = Overheat_Count_Limit;
 
                     InternalAlarmActive[index] = true;
-                    ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature, heater turned off",__FILE__,index,readValue,RpWarning,  0,0);
                     AlarmHandlingSetAlarm(InternalTempEventType[index], true);
                     if (JobIsActive())
                     {
@@ -424,11 +429,12 @@ uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValu
     {
         if (InternalAlarmActive[index] == true)
         {
+            ReportWithPackageFilter(HeatersFilter,"Internal Under the max temperature",__FILE__,index,readValue,RpWarning,  InternalOverHeatCounter[index],0);
             if(InternalOverHeatCounter[index]-- <= 0)
             {
                 InternalOverHeatCounter[index] = 0;
 
-                InternalAlarmActive[index] = true;
+                InternalAlarmActive[index] = false;
                 ReportWithPackageFilter(HeatersFilter,"Internal Under the max temperature, alarm turned off",__FILE__,index,readValue,RpWarning,  0,0);
                 AlarmHandlingSetAlarm(InternalTempEventType[index], false);
             }
@@ -1098,6 +1104,8 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=HEATER_TYPE_MAX_HEATERS;
+    uint32_t BlowerPt100Read = 0;
+
     if (IfIndex>>8 != IfTypeHeaters)
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
@@ -1107,9 +1115,29 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]);
     if (HeaterControl[index].sensormaxvalue == 0)
         return OK;
-    if ((HeaterPreviousRead[index]) >= HeaterControl[index].sensormaxvalue)
+#ifndef USE_TUNNEL_PT100
+        if (Head_Type == HEAD_TYPE_ARC) {
+            if (index == HEATER_TYPE__HeadCoverHeater1) {
+                BlowerPt100Read = MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1);
+            }
+            if (index == HEATER_TYPE__HeadCoverHeater2) {
+                BlowerPt100Read = MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0);
+            }
+        }
+#else
+        if (Head_Type == HEAD_TYPE_ARC) {
+            if (index == HEATER_TYPE__HeadCoverHeater1) {
+                BlowerPt100Read = MillisecGetTemperatures(HEAD_PT100_ZONE_11_0X8A_0);
+            }
+            if (index == HEATER_TYPE__HeadCoverHeater2) {
+                BlowerPt100Read = MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1);
+            }
+        }
+#endif
+
+    if ((HeaterPreviousRead[index] >= HeaterControl[index].sensormaxvalue) || (BlowerPt100Read > 25000))
     {
-        if(OverHeatCounter[index]++ >=Overheat_Count_Limit)
+        if(OverHeatCounter[index]++ >= Overheat_Count_Limit)
         {
             OverHeatCounter[index] = Overheat_Count_Limit;
             //?????HeaterReady[index] = false;
@@ -1301,7 +1329,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             if ((HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)&&(HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] == false))
             {
-                ReportWithPackageFilter(HeatersFilter,"AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+                //ReportWithPackageFilter(HeatersFilter,"AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
                 ActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
                 ActivateHeater(HEATER_TYPE__DryerMainHeater);
                 HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,100);
@@ -2049,6 +2077,22 @@ bool HeadBlowerFlowControl(double Q_value, uint8_t blowerId)
     return OK;
 }
 
+void HeadBlowersOff(int off)
+{
+    if (off == 1)
+        HeadBlowersEnable = 0;
+    else
+        HeadBlowersEnable = 1;
+    ReportWithPackageFilter(HeatersFilter,"HeadBlowersOff",__FILE__,__LINE__,off,RpError, 0,0);
+    return;
+}
+
+uint32_t HeadBlowersOffGet()
+{
+    ReportWithPackageFilter(HeatersFilter,"HeadBlowersOffGet",__FILE__,__LINE__,HeadBlowersEnable,RpError, 0,0);
+    return HeadBlowersEnable;
+}
+
 void HeadBlowersControlLoop ()
 {
     int blowerId;
@@ -2056,6 +2100,9 @@ void HeadBlowersControlLoop ()
     if (GetMachineState() < MACHINE_STATE_WAIT_FOR_COOLER)
         return; //do not start before controller is initialized and running
 
+    if (!HeadBlowersEnable) {
+        return;
+    }
     for (blowerId = 0; blowerId <= 1; blowerId++) {
         if (count[blowerId] == HeadBlowersCloseLoopTime[blowerId]) {
             count[blowerId] = 0;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
index 256d25aa5..07cc5774d 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c
@@ -28,6 +28,7 @@ typedef enum
     CleaningStageActuatorDown,
     CleaningStageDelay2,
 }CleaningStageEnum;
+TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DH_LID;
 
 /*
  *Cleaning sequence:
@@ -51,42 +52,55 @@ int CleaningStageCounter = 8;//Tdelay1 - 1 to start with stage moving down
 
 void Init_CleaningStageCounter()
 {
-    CleaningStageCounter = Tdelay1 - 1;
+    if(Head_Type == HEAD_TYPE_FLAT) {
+        CleaningStageCounter = Tdelay1 - 1;
+    } else {
+        CleaningStageCounter = 0;
+    }
+}
+
+uint32_t cleaningMotorCBFunction (uint32_t deviceID, uint32_t Parameter1)
+{
+    CleaningStageCounter = 0;
+    return 0;
 }
 
 uint32_t IDS_Cleaning_Move_Actuators()
 {
-   if(Head_Type != HEAD_TYPE_FLAT)
+   if((Head_Type != HEAD_TYPE_FLAT) && (Head_Type != HEAD_TYPE_ARC))
        return OK;
-   if (CleaningStageCounter == 1)
-   {
-       Trigger_Head_Actuators_Stub(ACTIN, ENABLE, UP);
-       //Trigger_Head_Actuators_Control(ACTIN, LOW,true);
-       ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Move_ActuatorUp", __FILE__, __LINE__, 1, RpWarning,   CleaningStageCounter, 0);
-   }
-   else if (CleaningStageCounter == Tup)
-   {
-       Trigger_Head_Actuators_Stub(ACTIN, DISABLE, DONTCARE);
-       //Trigger_Head_Actuators_Disable();
-       ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_Actuator", __FILE__, __LINE__, Tup, RpWarning,   CleaningStageCounter, 0);
-   }
-   else if (CleaningStageCounter == Tdelay1)
-   {
-       Trigger_Head_Actuators_Stub(ACTIN, ENABLE, DOWN);
-       //Trigger_Head_Actuators_Control(ACTIN, LOW,false);
-       ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_MoveDown", __FILE__, __LINE__, Tdelay1, RpWarning,   CleaningStageCounter, 0);
-   }
-   else if (CleaningStageCounter == Tdelay2)
-   {
-       CleaningStageCounter = 0;
-       Trigger_Head_Actuators_Stub(ACTIN, DISABLE, DONTCARE);
-       ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_delay", __FILE__, __LINE__, Tdelay2, RpWarning,   CleaningStageCounter, 0);
+   if(Head_Type == HEAD_TYPE_FLAT) {
+       if (CleaningStageCounter == 1)
+       {
+           Trigger_Head_Actuators_Stub(ACTIN, ENABLE, UP);
+           //Trigger_Head_Actuators_Control(ACTIN, LOW,true);
+           ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Move_ActuatorUp", __FILE__, __LINE__, 1, RpWarning,   CleaningStageCounter, 0);
+       }
+       else if (CleaningStageCounter == Tup)
+       {
+           Trigger_Head_Actuators_Stub(ACTIN, DISABLE, DONTCARE);
+           //Trigger_Head_Actuators_Disable();
+           ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_Actuator", __FILE__, __LINE__, Tup, RpWarning,   CleaningStageCounter, 0);
+       }
+       else if (CleaningStageCounter == Tdelay1)
+       {
+           Trigger_Head_Actuators_Stub(ACTIN, ENABLE, DOWN);
+           //Trigger_Head_Actuators_Control(ACTIN, LOW,false);
+           ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_MoveDown", __FILE__, __LINE__, Tdelay1, RpWarning,   CleaningStageCounter, 0);
+       }
+       else if (CleaningStageCounter == Tdelay2)
+       {
+           CleaningStageCounter = 0;
+           Trigger_Head_Actuators_Stub(ACTIN, DISABLE, DONTCARE);
+           ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_delay", __FILE__, __LINE__, Tdelay2, RpWarning,   CleaningStageCounter, 0);
+       }
+   } else { //arc
+       if (CleaningStageCounter == 0) {
+           MotorSetSpeed(MotorId, 750);
+           ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Motor_Run", __FILE__, __LINE__, 1, RpWarning,   CleaningStageCounter, 0);
+       }
    }
-
-
-
    CleaningStageCounter++;
-
    return OK;
 }
 /*uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed)
@@ -135,8 +149,18 @@ 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);
     ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_Cleaning_Solution", __FILE__, __LINE__, CLEANER_DISPENSER, RpWarning,   status, 0);
-    HeadCard_Actuators_Relocate();
-    Init_CleaningStageCounter();
+    if(Head_Type == HEAD_TYPE_FLAT)
+    {
+        HeadCard_Actuators_Relocate();
+        Init_CleaningStageCounter();
+    }
+    if(Head_Type == HEAD_TYPE_ARC)
+    {
+        MotorStop(MotorId,Hard_Hiz);
+        MotorMovetoLimitSwitch(MotorId,1-MotorsCfg[MotorId].directionthreadwize, 50,  Motor_Id_to_LS_IdDown[MotorId], cleaningMotorCBFunction,30000);
+    }
+
+    ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Motor_Homing", __FILE__, __LINE__, 1, RpWarning,   CleaningStageCounter, 0);
     CleaningStage = CleaningStageIdle;
     ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Stop_Cleaning_Solution actuator relocate", __FILE__, __LINE__, CleaningStage, RpWarning,   CleaningStageCounter, 0);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index 9973e4c7c..57d3ff5e2 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -117,5 +117,6 @@ void DispenserDataRequestFunc(MessageContainer* requestContainer);
 
 void IDS_Start_Pid_Testing(int DispenserId);
 void IDS_Stop_Pid_Testing(int DispenserId);
+uint32_t cleaningMotorCBFunction (uint32_t deviceID, uint32_t Parameter1);
 
 #endif /* MODULES_IDS_IDS_EX_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index d40f3c00b..d508c2ed2 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -348,6 +348,11 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
          FreeSegmentFileData(Segment);
          CloseJobFile();
      }
+     else
+     {
+         ReportWithPackageFilter(IDSFilter,"Error Opening the file", __FILE__, __LINE__, Fresult, RpWarning,   0, 0);
+         return false;
+     }
      //GeneralHwReady = true;
      int ActiveDispensers = 0;
      for (Dispenser_i = 0; Dispenser_i < MAX_DYE_DISPENSERS; Dispenser_i++)
@@ -529,7 +534,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
             updatedSpeed = tempSpeed*0.98;
             MotorSetSpeed(HW_Motor_Id, updatedSpeed);
             CurrentDispenserSpeed[DispenserId] = updatedSpeed;
-            ReportWithPackageFilter(IDSFilter,"IDS decrease speed",__FILE__,DispenserId,(int)updatedSpeed,RpWarning,(int)(pressure*100),0);
+            //ReportWithPackageFilter(IDSFilter,"IDS decrease speed",__FILE__,DispenserId,(int)updatedSpeed,RpWarning,(int)(pressure*100),0);
             //return true; //ready
     }
     else if (pressure < RefMaxPressure*0.97)
@@ -539,7 +544,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
         updatedSpeed = (tempSpeed * 1.02 < InitialDispenserSpeed) ? tempSpeed * 1.02 : InitialDispenserSpeed;
         MotorSetSpeed(HW_Motor_Id, updatedSpeed);
         CurrentDispenserSpeed[DispenserId] = updatedSpeed;
-        ReportWithPackageFilter(IDSFilter,"IDS increase speed",__FILE__,DispenserId,(int)updatedSpeed,RpWarning,(int)(pressure*100),0);
+        //ReportWithPackageFilter(IDSFilter,"IDS increase speed",__FILE__,DispenserId,(int)updatedSpeed,RpWarning,(int)(pressure*100),0);
         //return false; //not ready
     }
     if ((pressure>RefMaxPressure)&&(pressure<(RefMaxPressure+0.1)))
@@ -599,7 +604,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                      if (AdjustDispenserSpeedToPressure(i,DispenserPreparePressure,pressure) == true)
                          NumofReadyDispensers++;
                  }
-                 ReportWithPackageFilter(IDSFilter,"IDS prepare",__FILE__,i,(int)DispenserTotalPrepareSteps[i],RpWarning,(int)(CurrentDispenserSpeed[i]*100),0);
+                 //ReportWithPackageFilter(IDSFilter,"IDS prepare",__FILE__,i,(int)DispenserTotalPrepareSteps[i],RpWarning,(int)(CurrentDispenserSpeed[i]*100),0);
              }
          }
          pressure = GetDispenserPressure(CLEANER_DISPENSER);
@@ -1312,7 +1317,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
     /* wait for all dispensers  to get to the required pressure
      * move the presegment ready when all dispensers are ready.
      */
-    REPORT_MSG(Segment->n_brushstops,"IDSPreSegmentState");
+    ReportWithPackageFilter(IDSFilter,"IDSPreSegmentState",__FILE__,__LINE__,(int)Segment->n_brushstops,RpError,(int)SegmentId,0);
     if (JobBrushStopId>=Segment->n_brushstops)
     {
         ReportWithPackageFilter(IDSFilter,"Error JobBrushStopId",__FILE__,__LINE__,(int)Segment->n_brushstops,RpError,(int)0,0);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 5da52f590..f3624bb6b 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -28,6 +28,7 @@
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "Modules/IFS/ifs.h"
 #include "Modules/IDS/ids_ex.h"
+#include "Modules/IDS/ids.h"
 #include "Modules/Control/MillisecTask.h"
 #include "modules/thread/thread_ex.h"
 #include "modules/heaters/heaters_ex.h"
@@ -85,6 +86,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     uint8_t port = 0;
     uint8_t pin  = 0;
     uint8_t value= 0;
+    uint32_t enable;
 
     uint8_t ReadBackReg[1];
 
@@ -1142,6 +1144,56 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
+    if(request->amount == 0xB14)
+    {
+        LOG_ERROR(request->amount,"IDS_Cleaning_Move_Actuators");
+        Init_CleaningStageCounter();
+        IDS_Cleaning_Move_Actuators();
+
+        response.progress = 0xB14;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB15)
+    {
+        TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DH_LID;
+        LOG_ERROR(request->amount,"MotorMovetoLimitSwitch");
+        MotorStop(MotorId,Hard_Hiz);
+        MotorMovetoLimitSwitch(MotorId,1 - MotorsCfg[MotorId].directionthreadwize, 50,  Motor_Id_to_LS_IdDown[MotorId], cleaningMotorCBFunction,30000);
+        ReportWithPackageFilter(IDSFilter,"IDS_Cleaning_Motor_Homing", __FILE__, __LINE__, 1, RpWarning, 0, 0);
+
+        response.progress = 0xB15;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB16)
+    {
+        LOG_ERROR(request->amount,"ThreadCheckArcHeadCovers");
+        ThreadCheckArcHeadCovers();
+        ReportWithPackageFilter(IDSFilter,"ThreadCheckArcHeadCovers", __FILE__, __LINE__, 1, RpWarning, 0, 0);
+
+        response.progress = 0xB16;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB17)
+    {
+        LOG_ERROR(request->delay,"HeadBlowersOff");
+        HeadBlowersOff(request->delay);
+
+        response.progress = 0xB17;
+        response.has_progress = true;
+    }
+    else
+    if(request->amount == 0xB18)
+    {
+        enable = HeadBlowersOffGet();
+        LOG_ERROR(enable, "HeadBlowersOffGet");
+
+        response.progress = 0xB18;
+        response.has_progress = true;
+    }
+    else
     if(request->amount == 0xC3)  //suspend I2C task
     {
         if (request->delay == 0)
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 554e4d1ef..d5c186893 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -1407,6 +1407,8 @@ uint32_t ThreadLoadingReport(void)
 
     if (ThreadLoadingToken[0] == 0)
         return OK;
+    if (LoadStages == THREAD_LOAD_INIT)
+        return OK;
 
     if (MessageState == 0)
     {
@@ -1485,7 +1487,7 @@ uint32_t ThreadLoadingRestartReport(void) //sending after a failure in the final
     response.has_state = true;
     response.state = THREAD_LOADING_STATE__ReadyForLoading;
     response.errorreason = DefaultErrSrt;
-    Report("ThreadLoadingReport",__FILE__,MessageState,response.state,RpWarning,(int)LoadStages,0);
+    Report("ThreadLoadingRestartReport",__FILE__,MessageState,response.state,RpWarning,(int)LoadStages,0);
     //-------------------------------------------------------------------------------------------
     responseContainer = createContainer(MESSAGE_TYPE__StartThreadLoadingResponse, ThreadLoadingToken, false, &response, &start_thread_loading_response__pack, &start_thread_loading_response__get_packed_size);
     responseContainer.has_continuous = true;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index c3f181b52..5d69e2980 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -88,7 +88,7 @@ uint32_t StartThreadLoadingFunc(MessageContainer* requestContainer);
 uint32_t ContinueThreadLoadingFunc(MessageContainer* requestContainer);
 uint32_t StopThreadLoadingFunc(MessageContainer* requestContainer);
 uint32_t TryThreadLoadingFunc(MessageContainer* requestContainer);
-
+void ThreadCheckArcHeadCovers(void);
 uint32_t Thread_Load_End(void);
 
 #endif
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index d7bfb1b6e..4f77104d4 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -1142,6 +1142,14 @@ uint32_t ThreadPrepareState(void *JobDetails)
             }
         }
     }
+    if ((Head_Type == HEAD_TYPE_ARC) && (JoggingJobActive == false)) {
+        if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_ARC) != LIMIT) {
+            ReportWithPackageFilter(ThreadFilter,"Dyeing head arc is open!!!",__FILE__,__LINE__,0,RpError,LIMIT,0);
+        }
+        if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_TUNNEL_ARC) != LIMIT) {
+            ReportWithPackageFilter(ThreadFilter,"Dyeing head arc tunnel is open!!!",__FILE__,__LINE__,0,RpError,LIMIT,0);
+        }
+    }
 //    if ((FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID]) == LIMIT)&&(JoggingJobActive == false))
     if ((FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID]) != LIMIT)&&(JoggingJobActive == false))
     {
@@ -1616,8 +1624,17 @@ char Endstr[150];
     return OK;
 }
 
-
-
+void ThreadCheckArcHeadCovers(void)
+{
+    if ((Head_Type == HEAD_TYPE_ARC) && (JoggingJobActive == false)) {
+         if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_ARC) != LIMIT) {
+             ReportWithPackageFilter(ThreadFilter,"Dyeing head arc is open!!!",__FILE__,__LINE__,0,RpError,LIMIT,0);
+         }
+         if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_TUNNEL_ARC) != LIMIT) {
+             ReportWithPackageFilter(ThreadFilter,"Dyeing head arc tunnel is open!!!",__FILE__,__LINE__,0,RpError,LIMIT,0);
+         }
+     }
+}
 //********************************************************************************************************************
 
 void ThreadStartPrinting(void)