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

16 files changed, 99 insertions, 69 deletions

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;