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

15 files changed, 172 insertions, 36 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 3b010247d..2d14f972e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -420,12 +420,22 @@ return OK;
 }
 uint32_t Diagnostics_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_t BusyFlag)
 {
+    MessageContainer responseContainer;
+    MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
 
     Report("Diagnostics_Set_Load_Arm_To_Stopper time",__FILE__,__LINE__,msec_millisecondCounter,RpMessage,0,0);
 
     //NumberOfDrierLoaderCycles=0;
     //storeLoadArmParameters();
     SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
+    responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
+    responseContainer.has_continuous = true;
+    responseContainer.continuous = true;
+    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    my_free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+    HomingToken[deviceID][0] = 0;
 
     return OK;
 }
@@ -489,8 +499,19 @@ uint32_t Diagnostics_Dryer_UnLoading(void)
 }
 uint32_t Diagnostics_Dryer_MovetoEncoderPosition_Callback(uint32_t MotorId, uint32_t ReadValue)
 {
+    MessageContainer responseContainer;
+    MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
+
     //Report("Diagnostics_Dryer_MovetoEncoderPosition_Callback",__FILE__,__LINE__,0,RpMessage,CallbackCounter,0);
     MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
+    responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[MotorId], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
+    responseContainer.has_continuous = true;
+    responseContainer.continuous = true;
+    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    my_free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+    HomingToken[MotorId][0] = 0;
 
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
index 5b8866a28..0bb16c623 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
@@ -39,6 +39,7 @@
 uint32_t MotorJoggingRequestFunc(MessageContainer* requestContainer)
 {
     uint32_t status = OK;
+    bool allowedInJob  =true;
 
     MessageContainer responseContainer;
 
@@ -51,9 +52,23 @@ uint32_t MotorJoggingRequestFunc(MessageContainer* requestContainer)
     int speed = request->speed;
     if (speed == 0) speed = 150;
 
+    if (JobIsActive() == true)
+    {
+        switch (MotorId)
+        {
+            case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4:
+            case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7:case HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8:
+            case HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING:case HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM:case HARDWARE_MOTOR_TYPE__MOTO_SCREW:case HARDWARE_MOTOR_TYPE__MOTO_WINDER:
+            case HARDWARE_MOTOR_TYPE__MOTO_LDRIVING:case HARDWARE_MOTOR_TYPE__MOTO_LLOADING:case HARDWARE_MOTOR_TYPE__MOTO_RDRIVING:case HARDWARE_MOTOR_TYPE__MOTO_RLOADING:
+                allowedInJob = false;
+                break;
+            default:
+                break;
+        }
+    }
     if (MotorId <= NUM_OF_MOTORS)
     {
-        if ((JobIsActive() == false)&&(isMotorConfigured(MotorId) == true))
+        if ((allowedInJob == true)&&(isMotorConfigured(MotorId) == true))
         {
             {
                 switch (request->direction)
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 39d10bfc2..ae946ce1d 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -42,6 +42,7 @@
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "Drivers/I2C_Communication/I2C.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
+#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
 
 #include "StateMachines/Printing/PrintingSTM.h"
 #include "StateMachines/Initialization/InitSequence.h"
@@ -396,6 +397,13 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         LOG_ERROR (0, "Wrong Data Allocation");
         return ERROR;
     }
+    /*if (InitFailures > 3)
+    {
+        Report("HWConfigurationInit repeated failure",__FILE__,__LINE__,(int)InitFailures,RpWarning,(int)EEPROM_INIT_FAILURE_COUNTER,0);
+        AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED,ON);
+        return ERROR;
+    }*/
+
     HardwareConfiguration *request =    UploadRequest->hardwareconfiguration;
 
     if (JobIsActive())
@@ -461,8 +469,12 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
             else if ((request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__MotorDryer)&&
                     (request->pidcontrols[PID_i]->hardwarepidcontroltype < HARDWARE_PID_CONTROL_TYPE__Dispenser1))
                 status += MotorPidRequestMessage(request->pidcontrols[PID_i]);
-            else if (request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__Dispenser1)
+            else if ((request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__Dispenser1)&&
+                (request->pidcontrols[PID_i]->hardwarepidcontroltype < HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7))
                 status += IDS_DispenserPidRequestMessage(request->pidcontrols[PID_i]);
+            else if (request->pidcontrols[PID_i]->hardwarepidcontroltype == HARDWARE_PID_CONTROL_TYPE__WasteControl)
+                status += WHS_PidRequestMessage(request->pidcontrols[PID_i]);
+
         }
     }
     else
@@ -528,6 +540,15 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
 
                 break;
             }
+            if((request->blowers[Dispenser_i]->enabled)&&(request->blowers[Dispenser_i]->hardwareblowertype == HARDWARE_BLOWER_TYPE__WHSSmallFans))
+            {
+                SmallFansCfg = request->blowers[Dispenser_i]->voltage;
+            }
+            if((request->blowers[Dispenser_i]->enabled)&&(request->blowers[Dispenser_i]->hardwareblowertype == HARDWARE_BLOWER_TYPE__WHSLargeFans))
+            {
+                LargeFansCfg = request->blowers[Dispenser_i]->voltage;
+            }
+
         }
     }
     ControlStart();
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index 1e04ccb83..7bf72ba8c 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -125,6 +125,11 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
             ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
             REPORT_MSG(Bytes,"Bytes write to flash");
         }
+        else
+        {
+            ProcessParams->headairflow = headairflow;
+            ReportWithPackageFilter(InitFilter,"HandleProcessParameters temp off blower on",__FILE__,(int)__LINE__,(int)ProcessParams->headairflow,RpWarning,(int)ProcessParametersKeep.headairflow,0);
+        }
     }
     HeatersStopControlOnHeatersOff(ProcessParams);
     dyeingspeed = ProcessParams->dyeingspeed;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.h b/Software/Embedded_SW/Embedded/Modules/General/process.h
index 6318596f1..7cd592aad 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.h
@@ -25,6 +25,8 @@ extern int32_t tableindex;
 extern double dryerbufferMeters;
 extern double dryerbufferCentimeters;
 
+extern bool MachineReadyForHeating;
+
 extern ProcessParameters ProcessParametersKeep;
 
 extern void ProcessRequestFunc(MessageContainer* requestContainer);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 380eb99ca..53501e3db 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -1149,7 +1149,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 
     if ((readValue>(HeaterCmd[index].targettemperatue+800))&&(getIdleState() == false))
     {
-        ReportWithPackageFilter(HeatersFilter, "AC OverHeating in progress",__FILE__,readValue,HeaterReady[index],RpError, HeaterAtTemp[index],0);
+        ReportWithPackageFilter(HeatersFilter, "AC OverHeating in progress",__FILE__,readValue,GetHeaterState(HEATER_TYPE__DryerMainHeater),RpError, GetHeaterState(HEATER_TYPE__DryerSecondaryHeater),0);
         ReportWithPackageFilter(HeatersFilter, "AC OverHeating PID",__FILE__,(int)HeaterPIDConfig[index].m_calculatedError,(int)HeaterPIDConfig[index].m_SetParam,RpError, (int)HeaterPIDConfig[index].m_integral,0);
     }
     // check if the read value is within the proportional band
@@ -1636,9 +1636,10 @@ uint32_t DrierHeaterVoltageSetup(void)
         }
         else
         {
-            Z1Current = Get_Heaters_Current(HEATER_DRYER_CURRENT_1);
+            Z1Current = GetZone1RMSCurrent(DrierAcVoltage); //changed to assumed current as calculated on init
             Z2AssumedCurrent = GetZone2RMSCurrent(DrierAcVoltage);
             LimitCurrent = TotalCurrentLimit(DrierAcVoltage);
+            //hysteresis: activate
             if ((Z2AssumedCurrent+Z1Current)>LimitCurrent)
             {
                 UseSecondaryDrierHeater = false;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 2ffce8e46..81f4f9e7d 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -551,7 +551,7 @@ void IDS_Dispenser_Init(uint8_t DispenserId)
     PrimingActive[DispenserId]= false;
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-    if (Special_Dispensers == true)
+    //if (Special_Dispensers == true)
     {
         if (ControlIdtoInactiveDispenserId[DispenserId] == 0xFF)
             ControlIdtoInactiveDispenserId[DispenserId] = AddControlCallback("IDS_Check_Pressure", IDS_Check_Pressure_Callback, eOneMinute,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 1c43872cc..a713ce355 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -725,6 +725,11 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
         Report("Setting pressure from RML feeder tension",__FILE__,__LINE__,(int)(cleanerFlow),RpWarning,(int)CleaningDispenserSpeed,0);
         CleaningDispenserSpeed = cleanerFlow;
     }
+    else if (cleanerFlow <= 10)
+    {
+        CleaningDispenserSpeed = 0;
+        EnableCleaning = false;
+    }
 
     for (Motor_i = 0;Motor_i < MAX_SYSTEM_DISPENSERS;Motor_i++)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
index e89efdb13..7baced344 100644
--- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
@@ -24,6 +24,7 @@
 #define CartridgeInkTimeOutCallBackTime (eOneSecond * SECONDS_5)
 #define CartridgeInkCallBackTime        eOneSecond
 #define MidTank_Pressure_EMPTY          0.3  //todo get from Moti the correct number  (Oleg -> 300cc)
+#define MidTank_PP_Pressure_EMPTY       0.6  //todo get from Moti the correct number  (Oleg -> 300cc)
 #define CARTRIDGE_CAPATICY 1500 //todo get from Moti the correct number
 #define FULL 1000   //todo get from Moti the correct number
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 8d736f352..d28ca4f21 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -243,32 +243,32 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
             if (WHS_Type == WHS_TYPE_NEW)
             {
-                display_byte = ((request->delay & 0x3000)>>12);
+                /*display_byte = ((request->delay & 0x3000)>>12);
                 switch (display_byte)
                 {
                 case 0:
-                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x0000); //
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x0000); //
                     SetLeftDisplayView (HeadAVERAGE);
                     SetWriteDisplayView(DrierAVERAGE);
                     SetDisplayView (AVERAGE);
                     break;
                 case 1:
-                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x1000); //
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x1000); //
                     SetLeftDisplayView (HeadAVERAGE);
                     SetWriteDisplayView(HeadCURRENT);
                     break;
                 case 2:
-                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x2000); //
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x2000); //
                     SetLeftDisplayView (DrierAVERAGE);
                     SetWriteDisplayView(DrierCURRENT);
                     break;
                 case 3:
-                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, /*DisplayView =*/0x3000); //
+                    //stubManager.Run<ProgressResponse>("ProgressRequest" ,0x3EA, 0x3000); //
                     SetLeftDisplayView (HeadCURRENT);
                     SetWriteDisplayView(DrierCURRENT);
                     SetDisplayView (CURRENT);
                     break;
-                }
+                }*/
 
                 A2D_data = (request->delay & 0x0FFF);
                 switch(A2D_data )// get A2D
@@ -306,11 +306,11 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                     case 12:
                         temp_double = get_Q(DRIER_FLOW_METER);
                         break;
-                    case 20:
-                        temp_double = get_average_Q(HEAD_FLOW_METER); //HEAD
+                    /*case 20:
+                        //temp_double = get_average_Q(HEAD_FLOW_METER); //HEAD
                         break;
                     case 22:
-                        temp_double = get_average_Q(DRIER_FLOW_METER); //Drier
+                        //temp_double = get_average_Q(DRIER_FLOW_METER); //Drier
                         break;
 
                     case 11:
@@ -333,7 +333,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                         break;
                     case 18:
                         //tempu16 = 0;  //get_cur_vlv2(&tempu16);
-                        break;
+                        break;*/
                     default :
                         tempu16 = 0x500;  //get_cur_vlv2(&tempu16);
                         break;
@@ -611,9 +611,44 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
         if((request -> delay & 0xFFF000) == 0xCAF000)//Actuator
         {
-            //HeadCard_Actuators_Control((ACTUATORS)(((request -> delay) & 0x100)>>8), /*(bool)((request -> delay & 0x10)>>4), */(bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
-            Trigger_Head_Actuators_Control((ACTUATORS)(((request -> delay) & 0x100)>>8), (bool)((request -> delay & 0x10)>>4), (bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
-            //response.progress = HeadCard_Actuators_Status((ACTUATORS)((request -> delay) & 0x100)>>8);
+            if((request -> delay & 0x00000F) >1)
+            {
+                if((request -> delay & 0xFFFFFF) == 0xCAF002)//ACTUATOR-IN down without delay and without stop the actuator
+                {
+                    Trigger_Head_Actuators_Stub(ACTIN, true, false);
+                }
+                else
+                if((request -> delay & 0xFFFFFF) == 0xCAF003)//ACTUATOR-IN up without delay and without stop the actuator
+                {
+                    Trigger_Head_Actuators_Stub(ACTIN, true, true);
+                }
+                else
+                if((request -> delay & 0xFFFFFF) == 0xCAF008)//Stop  ACTUATOR-IN
+                {
+                    Trigger_Head_Actuators_Stub(ACTIN, false, true);
+                }
+                else
+                if((request -> delay & 0xFFFFFF) == 0xCAF102)//ACTUATOR-OUT  down without delay and without stop the actuator
+                {
+                    Trigger_Head_Actuators_Stub(ACTOT, true, false);
+                }
+                else
+                if((request -> delay & 0xFFFFFF) == 0xCAF103)//ACTUATOR-OUT  up without delay and without stop the actuator
+                {
+                    Trigger_Head_Actuators_Stub(ACTOT, true, true);
+                }
+                else
+                if((request -> delay & 0xFFFFFF) == 0xCAF108)//Stop  ACTUATOR-OUT
+                {
+                    Trigger_Head_Actuators_Stub(ACTOT, false, true);
+                }
+            }
+            else
+            {
+                //HeadCard_Actuators_Control((ACTUATORS)(((request -> delay) & 0x100)>>8), /*(bool)((request -> delay & 0x10)>>4), */(bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
+                Trigger_Head_Actuators_Control((ACTUATORS)(((request -> delay) & 0x100)>>8), (bool)((request -> delay & 0x10)>>4), (bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
+                //response.progress = HeadCard_Actuators_Status((ACTUATORS)((request -> delay) & 0x100)>>8);
+            }
             response.has_progress = true;
         }
         else
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 349215d7d..c1d547f59 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -190,6 +190,9 @@
         ProcessParametersClear.lblowerflow  = 0;
         ProcessParametersClear.dyeingspeed = 40;
         ProcessParametersClear.dryerbufferlength = ProcessParametersKeep.dryerbufferlength;
+        ProcessParametersClear.pullertension = ProcessParametersKeep.pullertension;
+        ProcessParametersClear.windertension = ProcessParametersKeep.windertension;
+
         if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
         {
             LOG_ERROR (LoadStages, "Thread_Load_Reduce_Heat failed");
@@ -286,7 +289,7 @@
                 {
                     TimeoutsCounter = 0;
                     load.color = fastBILNK;
-                    usnprintf(LoadErrorMsg, 100, "Stage %s - motor %s timeout",LoadStagesStr[LoadStages], MotorStr[MotorId]);
+                    usnprintf(LoadErrorMsg, 100, "Stage %s - %s timeout",LoadStagesStr[LoadStages], MotorStr[MotorId]);
                     Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
 
                     LoadStatus = ERROR;
@@ -647,6 +650,7 @@
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Dryer_Loading");
 
+        int CurrentlyLoaded = 0;
         if (dryerbufferlength)
             LoadArmRounds = (int)dryerbufferlength;
         if (LoadArmRounds <= 2)
@@ -656,7 +660,12 @@
 //        OriginalMotorSpd_2PPS[FEEDER_MOTOR] = 1000;
 //        CurrentControlledSpeed[FEEDER_MOTOR] = 1000;
 
-        //MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds);
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&CurrentlyLoaded);
+        Report("Thread_Load_Dryer_Loading cycles",__FILE__,LoadArmRounds,CurrentlyLoaded,RpMessage,LoadArmRounds-CurrentlyLoaded,0);
+        if (CurrentlyLoaded)
+        {
+            LoadArmRounds -= CurrentlyLoaded;
+        }
         ThreadMotorIdToMotorId[FEEDER_MOTOR] = HARDWARE_MOTOR_TYPE__MOTO_RDRIVING ;
         ThreadMotorIdToMotorId[DRYER_MOTOR] = HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING;
 
@@ -806,14 +815,14 @@
             else //done enough cycles, go to the center point
             {
                 MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Thread_Load_Set_Load_Arm_To_Stopper_Callback,30000);
-                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-numberOfCycles);
+                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,0);
                 Report("Store Number of cycles in drier",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
             }
         }
         else  //timeout or no movement
         {
             Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
-            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-(numberOfCycles-1));
+            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-numberOfCycles);
             TimeoutsCounter = 0;
             CallbackCounter = 0;
             /*if(PullerControlId != 0xFF)
@@ -919,7 +928,12 @@
 
         if (SecondTry == true)
         {
-            LoadArmRounds = 30;
+            MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
+            if (LoadArmRounds == 0) //prev trial stopped
+            {
+                LoadArmRounds = (int)dryerbufferlength;
+            }
+            //LoadArmRounds = 30;
         }
         else
         {
@@ -1048,7 +1062,7 @@
 }
 uint32_t ThreadLoadButton(THREAD_LOAD_STAGES_ENUM ReadValue)
 {
-    if (JobIsActive())
+    if (JobIsActive()||(MachineReadyForHeating == false))
     {
         Report("ThreadLoadButton called on job",__FILE__,__LINE__,LoadStages,RpMessage,ReadValue,0);
         return ERROR;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 9ee2e1f37..ca41a8e70 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -149,12 +149,12 @@ uint32_t Winder_Prepare(void *JobDetails)
     if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
     {
         REPORT_MSG(LIMIT, "No cone in winder");
-        if (Is_PP_Machine())
+        /*if (Is_PP_Machine())
         {
             PrepareReady(Module_Winder,ModuleFail);
             AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
             return ERROR;
-        }
+        }*/
     }
 
 #ifdef READ_SCREW_ENCODER
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 1e730e252..5c9b360f6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -81,6 +81,7 @@ void ThreadLoadRequest(MessageContainer* requestContainer);
 uint32_t StartThreadLoadingFunc(MessageContainer* requestContainer);
 uint32_t ContinueThreadLoadingFunc(MessageContainer* requestContainer);
 uint32_t StopThreadLoadingFunc(MessageContainer* requestContainer);
+uint32_t TryThreadLoadingFunc(MessageContainer* requestContainer);
 
 uint32_t Thread_Load_End(void);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 545fb40e6..efcbd5030 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -217,6 +217,7 @@ uint32_t ThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     if (FeederSpeedIndex>=SPEED_STORE_SIZE)
     {
         FeederSpeedIndex = 0;
+        FeederSpeedAverage = 0;
         for (Speed_i = 0;Speed_i<SPEED_STORE_SIZE;Speed_i++)
             FeederSpeedAverage+=FeederSpeedStore[Speed_i];
         FeederSpeedAverage = FeederSpeedAverage/SPEED_STORE_SIZE;
@@ -316,6 +317,7 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         if (PullerSpeedIndex>=SPEED_STORE_SIZE)
         {
             PullerSpeedIndex = 0;
+            PullerSpeedAverage = 0;
             for (Speed_i = 0;Speed_i<SPEED_STORE_SIZE;Speed_i++)
                 PullerSpeedAverage+=PullerSpeedStore[Speed_i];
             PullerSpeedAverage = PullerSpeedAverage/SPEED_STORE_SIZE;
@@ -976,16 +978,19 @@ uint32_t ThreadPrepare_Tension (int DancerId, double tension)
         //return ERROR;
     }*/
 
-    if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) == LIMIT)
+    if ((FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) == LIMIT)&&(JoggingJobActive == false))
     {
-        ReportWithPackageFilter(ThreadFilter,"Dyeing head is wide open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpFatalError,LIMIT,0);
-        JobEndReason = JOB_LIDS_OPEN;
-        PrepareReady(Module_Thread,ModuleFail);
-        return ERROR;
+        if(Head_Type != HEAD_TYPE_STAPLE_SPUN)
+        {
+            ReportWithPackageFilter(ThreadFilter,"Dyeing head is wide open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpError,LIMIT,0);
+            JobEndReason = JOB_LIDS_OPEN;
+            PrepareReady(Module_Thread,ModuleFail);
+            return ERROR;
+        }
     }
-    if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID]) == LIMIT)
+    if ((FPGA_Read_limit_Switches(Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID]) == LIMIT)&&(JoggingJobActive == false))
     {
-        ReportWithPackageFilter(ThreadFilter,"Dryer lid is wide open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,RpFatalError,LIMIT,0);
+        ReportWithPackageFilter(ThreadFilter,"Dryer lid is wide open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,RpError,LIMIT,0);
         JobEndReason = JOB_LIDS_OPEN;
         PrepareReady(Module_Thread,ModuleFail);
         return ERROR;
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index 906a0d458..cf9fb3b7b 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -38,6 +38,7 @@
 #define STOPCOUNT   0
 #define PUMPTIMEOUT 1200 //  seconds; 20 minutes, per Moty,  15/4/19
 
+float MidTankEmptyLimit = MidTank_Pressure_EMPTY;
 
 /*------------Waste Tank function-----------------------*/
 bool initWHS_WasteTank();
@@ -775,16 +776,16 @@ bool WasteTankCBFunction()
                     ReportWithPackageFilter(WasteFilter,"------------ WHS, change INK cartridge status to color Used -------------", __FILE__, __LINE__, IFS_info.INK_isOK_flag, RpMessage, 0, 0);
                     // test the Mid-tank capacity is not at Nadav sequence
                     MidTank_Pressure = Get_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);
-                    if ( MidTank_Pressure > MidTank_Pressure_EMPTY )
+                    if ( MidTank_Pressure > MidTankEmptyLimit )
                     {
-                        ReportWithPackageFilter(WasteFilter,"------------ close door  MidTank_Pressure > MidTank_Pressure_EMPTY -----------------", __FILE__,__LINE__,(int)(MidTank_Pressure_EMPTY*1000), RpMessage, (int)(MidTank_Pressure*1000), 0);
+                        ReportWithPackageFilter(WasteFilter,"------------ close door  MidTank_Pressure > MidTankEmptyLimit -----------------", __FILE__,__LINE__,(int)(MidTankEmptyLimit*1000), RpMessage, (int)(MidTank_Pressure*1000), 0);
                         MidTankValvesAction(Cartridge_MidTank_OFF);
                         //Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
                         ReportWithPackageFilter(WasteFilter,"------------ WHS, Mid-tank not empty -------------", __FILE__, __LINE__, 0, RpMessage, 0, 0);
                         break;
                     }
                     IFS_info.MidTank_capacity = MidTank_Pressure;
-                    ReportWithPackageFilter(WasteFilter,"------------ Mid-tank filling in process -----------------", __FILE__,__LINE__,(int)(MidTank_Pressure_EMPTY*1000), RpMessage, (int)(MidTank_Pressure*1000), 0);
+                    ReportWithPackageFilter(WasteFilter,"------------ Mid-tank filling in process -----------------", __FILE__,__LINE__,(int)(MidTankEmptyLimit*1000), RpMessage, (int)(MidTank_Pressure*1000), 0);
                     Pannel_Leds(CART_1, MODE_ON);
                     cart1.color  = BLINK;
                     MidTankValvesAction(Cartridge_MidTank_ON);
@@ -1271,6 +1272,15 @@ U8 WHS_init(void)
     InitCartStatus();
     initWHS_WasteTank();
 
+    if (Is_PP_Machine())
+    {
+        MidTankEmptyLimit = MidTank_PP_Pressure_EMPTY;
+    }
+    else
+    {
+        MidTankEmptyLimit = MidTank_Pressure_EMPTY;
+    }
+
     return 0;
 }