merge - fix

1 files changed, 1058 insertions, 280 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index c5cdb00d6..ffbb504db 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -16,8 +16,9 @@
 #include "Modules/Control/control.h"
 #include "Modules/General/process.h"
 #include "Modules/control/pidalgo.h"
-
+#include "Modules/AlarmHandling/AlarmHandling.h"
 #include "Modules/heaters/heaters_ex.h"
+#include "Modules/General/buttons.h"
 #include "StateMachines/Initialization/InitSequence.h"
 
 #include "PMR/Hardware/HardwareMotor.pb-c.h"
@@ -30,64 +31,104 @@
 #include "drivers/SSI_Comm/Dancer/Dancer.h"
 #include "drivers/motors/motor.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
+#include "Drivers/I2C_Communication/I2C.h"
+#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
+#include <Drivers/I2C_Communication/I2C_Task.h>
+#include "drivers/FPGA/FPGA_SPI_Comm.h"
+#include "drivers/FPGA/Full_Vme/FPGA_Programming_Up.h"
 
 #include "PMR/Stubs/StubHeatingTestRequest.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestResponse.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestPollRequest.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestPollResponse.pb-c.h"
+#include "PMR/ThreadLoading/StartThreadLoadingRequest.pb-c.h"
+#include "PMR/ThreadLoading/StartThreadLoadingResponse.pb-c.h"
+#include "PMR/ThreadLoading/ContinueThreadLoadingRequest.pb-c.h"
+#include "PMR/ThreadLoading/ContinueThreadLoadingResponse.pb-c.h"
+#include "PMR/ThreadLoading/TryThreadLoadingRequest.pb-c.h"
+#include "PMR/ThreadLoading/TryThreadLoadingResponse.pb-c.h"
+#include "PMR/ThreadLoading/StopThreadLoadingRequest.pb-c.h"
+#include "PMR/ThreadLoading/StopThreadLoadingResponse.pb-c.h"
+#include "PMR/ThreadLoading/AttemptThreadJoggingResponse.pb-c.h"
 
 //#include <stdint.h>
 //#include <stdbool.h>
+    static char* LoadStagesStr[15] = {
+    /*00*/ "Initialization",
+    /*01*/ "Heating stop",
+    /*02*/ "Rockers opening",
+    /*03*/ "Dryer unloading",
+    /*04*/ "Lids opening",
+    /*05*/ "Dancers opening",
+    /*06*/ "Initial tension building",
+    /*07*/ "Rockers closing",
+    /*08*/ "Dancers closing",
+    /*09*/ "Lids closing",
+    /*10*/ "Feeder jogging",
+    /*11*/ "Dryer loading",
+    /*12*/ "Heating resuming",
+    /*13*/ "Thread jogging" ,
+    /*14*/ "END"};
 
 /*    typedef enum
     {
-        0 THREAD_LOAD_INIT,
-        1 THREAD_LOAD_REDUCE_HEAT,                           //HEATERS OFF, DRYER BLOWER OFF, BLOWER LOW,
-        2 THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION,        //USE NOTATION HOW MANY ROTATIONS IN THE DRYER, OR CHECK AGAINST STOPPER. MOVE SLOWLY
-        3 THREAD_LOAD_OPEN_COVERS,                           //OPEN DYEING HEAD COVER AND DRYER LID
-        4 THREAD_LOAD_LIFT_DANCERS,
-        5 THREAD_LOAD_LIFT_ROCKERS,                          //MACHINE IS READY. SEND MESSAGE, START TIMER TO CLOSE LIDS, WAIT FOR OPERATOR RESPONSE
-        6 THREAD_LOAD_INITIAL_TENSION,                       //CHECK SPOOL PRESENCERUN WINDER UNTIL BREAK SENSOR IS IDENTIFIEING MOVEMENT FOR A SECOND
-        7 THREAD_LOAD_CLOSE_ROCKERS,
-        8 THREAD_LOAD_CLOSE_DANCERS,                         //SEND DANCER MOTORS TO PRESET LOCATION, CHECK THAT THE DANCERS ARE ON THE THREAD
-        9  THREAD_LOAD_CLOSE_LIDS,
-        10 THREAD_LOAD_JOG_FEEDER_TO_MIDDLE_POINT,           //JOG THE FEEDER MOTOR UNTIL THE FEEDER DANCER IS AT MIDDLE POSITION
-        11 THREAD_LOAD_DRYER_LOADING,                        //START FEEDER PID, ROTATE LOADING ARM COUNTER THREAD DIRECTION X CIRCLES ACCORDING TO RML. FEEDER SPEED IS 40
-                                                             //KEEP NOTATION HOW MANY ROTATIONS IN THE DRYER
+        00 THREAD_LOAD_INIT,
+        01 THREAD_LOAD_REDUCE_HEAT,  //HEATERS OFF, DRYER BLOWER OFF, BLOWER LOW,
+        02 THREAD_LOAD_LIFT_ROCKERS, //MACHINE IS READY. SEND MESSAGE, START TIMER TO CLOSE LIDS, WAIT FOR OPERATOR RESPONSE
+        03 THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION,//USE NOTATION HOW MANY ROTATIONS IN THE DRYER, OR CHECK AGAINST STOPPER. MOVE SLOWLY
+        04 THREAD_LOAD_OPEN_COVERS,  //OPEN DYEING HEAD COVER AND DRYER LID
+        05 THREAD_LOAD_LIFT_DANCERS,
+        06 THREAD_LOAD_INITIAL_TENSION,//CHECK SPOOL PRESENCERUN WINDER UNTIL BREAK SENSOR IS IDENTIFIEING MOVEMENT FOR A SECOND
+        07 THREAD_LOAD_CLOSE_ROCKERS,
+        08 THREAD_LOAD_CLOSE_DANCERS, //SEND DANCER MOTORS TO PRESET LOCATION, CHECK THAT THE DANCERS ARE ON THE THREAD
+        09 THREAD_LOAD_CLOSE_LIDS,
+        10 THREAD_LOAD_JOG_FEEDER_TO_MIDDLE_POINT,//JOG THE FEEDER MOTOR UNTIL THE FEEDER DANCER IS AT MIDDLE POSITION
+        11 THREAD_LOAD_DRYER_LOADING, //START FEEDER PID, ROTATE LOADING ARM COUNTER THREAD DIRECTION X CIRCLES ACCORDING TO RML. FEEDER SPEED IS 40
+                                    //KEEP NOTATION HOW MANY ROTATIONS IN THE DRYER
         12 THREAD_LOAD_RESUME_HEATING,
-        13 THREAD_LOAD_JOG_THREAD,                           //JOG THREAD SHORTLY TO MAKE SURE SPOOL IS RUNNING. REPORT END OF LOADING
+        13 THREAD_LOAD_JOG_THREAD, //JOG THREAD SHORTLY TO MAKE SURE SPOOL IS RUNNING. REPORT END OF LOADING
         14 THREAD_LOAD_END
     }THREAD_LOAD_STAGES_ENUM;*/
     THREAD_LOAD_STAGES_ENUM LoadStages = THREAD_LOAD_INIT;
     ProcessParameters ProcessParametersClear,ProcessParametersRecover;
 
+    uint32_t LoadStatus = OK;
+    char LoadErrorMsg[100];
     int32_t keepmicrostep;
-    int32_t keepkvalrun,keepkvalhold;
+    int32_t keepkvalrun,keepkvalhold,kval_upperValue;
     uint8_t CallbackCounter = 0;
     uint8_t TimeoutsCounter = 0;
+    bool SecondTry = false,TryAgain = false;
+    int MessageState = 0; //0 - none, 1 = start, 2 = continue
 
+    uint32_t UnloadingStart = 0;
     uint8_t NumberOfDrierLoaderCycles = 0;
     uint32_t status = OK;
-    uint32_t LoadingControlId = 0xFF,PullerControlId = 0xFF,WinderControlId = 0xFF;
+    uint32_t LoadingControlId = 0xFF,PullerControlId = 0xFF,WinderControlId = 0xFF, SpeedTControlId = 0xFF,ThreadLoadControlId = 0xFF;
+    uint32_t previousPosition = 0, currentPosition = 0,Tinitialpos = 0xFFFF;
+    uint32_t LoadCounter = 0;
+    double TotalLoadedLen = 0.0;
+    double LengthCalculationMultiplier;
+    float numberOfSteps = 0;
+    float numberOfCycles = 0;
+    double DrierPrevLocation = 0;
+    int DrierCenterLocation = 0;
+    FPGA_GPI_ENUM screw[2] = {GPI_LS_SCREW_RIGHT,GPI_LS_SCREW_LEFT};
+    int Screw_Dir = false;
+    bool InitCalled = false;
+    uint32_t LoadArmRounds;
+
+    int CurrentlyLoaded = 0;
     uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM LoadStages);
     uint32_t ThreadLoadControlCBFunction(uint32_t index, uint32_t ReadValue);
-    uint32_t Thread_Load_Dryer_UnLoading(void);
+    uint32_t ThreadLoadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue);
+    uint32_t ThreadUpdateCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
 
-    typedef struct
-    {
-        uint32_t LoadArmRounds;
-        uint32_t LoadArmBackLash;
-    }LoadArmInfoStruc;
-    LoadArmInfoStruc LoadArmInfo;
-    //char LoadArmPath[50] = "0://SysInfo//LoadArm.cfg";
-
-    //RUN MOTOR TO SWITCH WITH TIMEOUT
-    //RUN MOTOR TO BREAK SENSOR
-    //RUN MOTOR TO DANCER LOCATION (POOLER GOES TO THE OTHER DIRECTION)
 
-    //RUN MOTOR A FULL CYCLE
-    //RUN A MOTOR NUMBER OF STEPS
-    //RUN CONTROL FOR A SINGLE DANCER
+    uint32_t Thread_Load_Dryer_UnLoading(void);
+    uint32_t ThreadLoadingReport(void);
+    uint32_t ThreadLoadingRestartReport(void); //sending after a failure in the finalizing stage
+    bool ThreadLoaded(void);
     bool ThreadLoadingActive(void)
     {
         if ((LoadStages > THREAD_LOAD_INIT)&&(LoadStages < THREAD_LOAD_END))
@@ -95,49 +136,46 @@
         else
             return false;
     }
-    uint32_t Thread_Load_Init(void)
+    uint32_t Thread_Load_Init(THREAD_LOAD_STAGES_ENUM Stage)
     {
         //void* buffer = NULL;
         //uint32_t Bytes = 0;
         //FRESULT Fresult = FR_OK;
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
-
-        LoadArmInfo.LoadArmBackLash = 5;
-        //LoadArmInfo.LoadArmRounds = 0xFF;
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Init");
+        load.color = BLINK;
+        LoadStatus = OK;
+        //LoadArmRounds = 0xFF;
         //EEPROM_STORAGE_DRYER_CYCLES
-        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmInfo.LoadArmRounds);
-        if (LoadArmInfo.LoadArmRounds <= 2)
-                LoadArmInfo.LoadArmRounds = 20;
-        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmInfo.LoadArmRounds);
-        Report("MotorMovetoEncoderPosition",__FILE__,__LINE__,LoadArmInfo.LoadArmRounds,RpWarning,LoadArmInfo.LoadArmBackLash,0);
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
 
-        /*Fresult = f_mkdir(SW_INFO_DIR);
-        if ((Fresult == FR_OK)||(Fresult == FR_EXIST))
-        {
+        Report("Read_Dryer_ENC_Position()",__FILE__,__LINE__,LoadArmRounds,RpWarning,Read_Dryer_ENC_Position(),0);
 
-            Fresult = FileRead(LoadArmPath, &Bytes, &buffer);
-            if (Fresult == FR_OK)
-            {
-               if (Bytes>=sizeof(LoadArmInfo))
-                   memcpy (&LoadArmInfo,buffer,sizeof(LoadArmInfo));
-               free (buffer);
-            }
-        }*/
-
-        Report("Thread_Load_Init",__FILE__,__LINE__,LoadArmInfo.LoadArmRounds,RpMessage,LoadArmInfo.LoadArmRounds,0);
         StopInitSequence();
         memcpy (&ProcessParametersRecover,&ProcessParametersKeep,sizeof(ProcessParameters));
         //NumberOfDrierLoaderCycles = loadLoadArmParameters();
-        LoadStages++;
-        ThreadLoadStateMachine(LoadStages);
+        if (Stage == THREAD_LOAD_INIT)
+        {
+            LoadStages++;
+            ThreadLoadStateMachine(LoadStages);
+        }
+        else
+        {
+            Report("Thread_Load_Init another state ",__FILE__,__LINE__,Stage,RpMessage,LoadArmRounds,0);
+        }
+        InitCalled = true;
 
         return OK;
     }
     uint32_t Thread_Load_Reduce_Heat(void)
     {
 
+        if (Is_PP_Machine())
+            kval_upperValue = 28;
+        else
+            kval_upperValue = 70;
+
         //Heaters Off, Dryer Blower Off, Blower Low,
-        REPORT_MSG(LoadStages, "Thread Load State Machine step ");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Reduce_Heat");
         memcpy (&ProcessParametersClear,&ProcessParametersKeep,sizeof(ProcessParameters));
         ProcessParametersClear.dryerzone1temp = 0;
         ProcessParametersClear.dryerzone2temp = 0;
@@ -149,122 +187,120 @@
         ProcessParametersClear.headzone4temp  = 0;
         ProcessParametersClear.headzone5temp  = 0;
         ProcessParametersClear.headzone6temp  = 0;
+        ProcessParametersClear.headzone7temp  = 0;
+        ProcessParametersClear.headzone8temp  = 0;
+        ProcessParametersClear.headzone9temp  = 0;
+        ProcessParametersClear.headzone10temp  = 0;
+        ProcessParametersClear.headzone11temp  = 0;
+        ProcessParametersClear.headzone12temp  = 0;
+        ProcessParametersClear.rblowertemp  = 0;
+        ProcessParametersClear.lblowertemp  = 0;
+        ProcessParametersClear.rblowerflow  = 0;
+        ProcessParametersClear.lblowerflow  = 0;
         ProcessParametersClear.dyeingspeed = 40;
         ProcessParametersClear.dryerbufferlength = ProcessParametersKeep.dryerbufferlength;
-        if (HandleProcessParameters(&ProcessParametersClear)!= OK)
+        ProcessParametersClear.pullertension = ProcessParametersKeep.pullertension;
+        ProcessParametersClear.windertension = ProcessParametersKeep.windertension;
+
+        if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
         {
-            LOG_ERROR (LoadStages, "Thread_Load_Init failed");
+            LOG_ERROR (LoadStages, "Thread_Load_Reduce_Heat failed");
+            strcpy(LoadErrorMsg,"Thread_Load_Reduce_Heat failed");
+            load.color = fastBILNK;
+            LoadStatus = ERROR;
+            TryAgain = true;
+            //ThreadLoadButton(LoadStages);
         }
         else
         {
-            Turn_the_Blower_On();//Turn on with the Default_Voltage
-            if (BlowerCfg.heatingvoltage)
-                Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
+            if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
+            {
+                WHS_Set_SetPoint_Q_value(headairflow);
+            }
             else
-                Control_Voltage_To_Blower(BlowerCfg.voltage-500);
+            {
+                Turn_the_Blower_On();//Turn on with the Default_Voltage
+                if (BlowerCfg.heatingvoltage)
+                    Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
+                else
+                    Control_Voltage_To_Blower(BlowerCfg.voltage-500);
+            }
             Control_Dryer_Fan(STOP,75);//use START or STOP,  0 - 100%
             LoadStages++;
             ThreadLoadStateMachine(LoadStages);
         }
         return OK;
     }
-    uint32_t Thread_Load_Set_Load_Arm_To_Start_Position_Callback(uint32_t deviceID, uint32_t BusyFlag)
+    uint32_t Thread_Load_Set_Load_Arm_To_Stopper_OnError_Callback(uint32_t deviceID, uint32_t BusyFlag)
     {
-       // Report("Thread Load State Machine Callback.",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
 
-        /*NumberOfDrierLoaderCycles--;
-        if (NumberOfDrierLoaderCycles)
-        {
-            Report("Thread_Load_Set_Load_Arm_To_Start_Position_Callback",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
-            status |= MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
-                                            MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround, Thread_Load_Set_Load_Arm_To_Start_Position_Callback,1000);
-        }
-        else*/
-        {
-            Report("Thread_Load_Set_Load_Arm_To_Start_Position_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
-            //storeLoadArmParameters();
-            MotorMove(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,LoadArmInfo.LoadArmBackLash );
+        Report("Thread_Load_Set_Load_Arm_To_Stopper_OnError_Callback time",__FILE__,msec_millisecondCounter - UnloadingStart,msec_millisecondCounter,RpMessage,UnloadingStart,0);
+
+        Report("Thread_Load_Set_Load_Arm_To_Stopper_OnError_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+        NumberOfDrierLoaderCycles=0;
+        //storeLoadArmParameters();
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Stop);
+        SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
+        MotorAbortMovetoLimitSwitch(HARDWARE_MOTOR_TYPE__MOTO_SCREW);
 
-            SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
-            LoadStages++;
-            ThreadLoadStateMachine(LoadStages);
-        }
         return OK;
     }
     uint32_t Thread_Load_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_t BusyFlag)
     {
+        uint32_t temp = Read_Dryer_ENC_Position();
+        int angle;
 
-        if(PullerControlId != 0xFF)
+        ReportWithPackageFilter(DiagnosticsFilter,"Thread_Load_Set_Load_Arm_To_Stopper_Callback",__FILE__,(int)numberOfCycles,(int)DrierPrevLocation,RpMessage,temp,0);
+
+        angle = Calculate_Arm_Distance(DrierPrevLocation,temp);
+
+        DrierPrevLocation = temp;
+        if (CallbackCounter)
         {
-            MotorStop(ThreadMotorIdToMotorId[POOLER_MOTOR],Hard_Hiz);
-            RemoveControlCallback(PullerControlId, ThreadLoadControlCBFunction );
-            PullerControlId = 0xFF;
+            CallbackCounter--;
         }
-        if(WinderControlId != 0xFF)
+        if (abs(angle)<10  ) // OK
         {
-            MotorStop(ThreadMotorIdToMotorId[WINDER_MOTOR],Hard_Hiz);
-            RemoveControlCallback(WinderControlId, ThreadLoadControlCBFunction );
-            WinderControlId = 0xFF;
-        }
-        /*Task_sleep(5)
-        MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);
-        MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);*/
+            Report("Thread_Load_Set_Load_Arm_To_Stopper time",__FILE__,msec_millisecondCounter - UnloadingStart,msec_millisecondCounter,RpMessage,UnloadingStart,0);
 
-        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,Hard_Hiz);
-//move to exact location?
-//        Report("Thread Load State Machine Callback.",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
-        CallbackCounter = 0;
-        Report("Thread_Load_Set_Load_Arm_To_Stopper_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
-        NumberOfDrierLoaderCycles=0;
-        //storeLoadArmParameters();
-        LoadStages++;
-        SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
+            Report("Thread_Load_Set_Load_Arm_To_Stopper_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+            NumberOfDrierLoaderCycles=0;
+            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,0);
 
-        ThreadLoadStateMachine(LoadStages);
-        return OK;
-    }
-    uint32_t Thread_Load_Set_Load_Arm_To_Start_Position(void)
-    {
-        uint32_t numberOfSteps = 0;
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
-        if (LoadArmInfo.LoadArmRounds != 0xFF)
-        {
-            //Start Feeder Pid, Rotate Loading Arm Counter Thread Direction X Circles According To Rml. Feeder Speed Is 40
-            numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmInfo.LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
-            Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,numberOfSteps,RpMessage,NumberOfDrierLoaderCycles,0);
-            NumberOfDrierLoaderCycles = LoadArmInfo.LoadArmRounds;
-            status |= MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
-                                            numberOfSteps, Thread_Load_Set_Load_Arm_To_Start_Position_Callback,1000);
+            //storeLoadArmParameters();
+            LoadStages++;
+
+            ThreadLoadStateMachine(LoadStages);
         }
-        else //number of circles is not known - compare to position of the motor to verify location at the stopper
+        else
         {
-            Report("Thread_Load_Set_Load_Arm_To_Start_Position unknown cycles",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
-            status |= MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
-                                            MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/2, Thread_Load_Set_Load_Arm_To_Stopper_Callback,LoadArmInfo.LoadArmBackLash,1000);
+            load.color = fastBILNK;
+            usnprintf(LoadErrorMsg, 100, "^Stage %s - %s timeout",LoadStagesStr[LoadStages], MotorStr[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM]);
+            Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
 
+            LoadStatus = ERROR;
+            ThreadLoadingReport();
+            TryAgain = true;
+            //ThreadLoadButton(LoadStages);
         }
-        //Use Notation How Many Rotations In The Drier, Or Check Against Stopper. Move Slowly
-        return OK;
-    }
-    uint32_t Thread_Load_Jog_Feeder_To_Middle_Point_Callback(uint32_t deviceID, uint32_t BusyFlag)
-    {
-        CallbackCounter--;
-        Report("Thread_Load_Jog_Feeder_To_Middle_Point_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
-        //storeLoadArmParameters();
-        LoadStages++;
-        ThreadLoadStateMachine(LoadStages);
-
+//move to exact location?
+//        Report("Thread Load State Machine Callback.",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
         return OK;
     }
-
     uint32_t Thread_Load_HomingCallback(uint32_t MotorId, uint32_t ReadValue)
     {
-        Report("Thread_Load_HomingCallback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+        Report("Thread_Load_HomingCallback",__FILE__,MotorId,LoadStages,RpMessage,CallbackCounter,0);
 //        REPORT_MSG(MotorId, "Thread_Load_HomingCallback Motor Id");
         if ((LoadStages == THREAD_LOAD_CLOSE_ROCKERS)||(LoadStages == THREAD_LOAD_LIFT_ROCKERS))
         {
             if((MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)||(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING))
             {
+                if(LoadStages == THREAD_LOAD_CLOSE_ROCKERS)
+                {
+                    MotorMove(MotorId,MotorsCfg[MotorId].directionthreadwize,400);
+			        Report("Move rockers further down",__FILE__,__LINE__,MotorId,RpMessage,400,0);
+                    Task_sleep(200);
+                }
                 MotorSetMicroStep(MotorId, keepmicrostep);
                 MotorSetKvalRun(MotorId, keepkvalrun);
             }
@@ -282,12 +318,20 @@
             {
                 if (TimeoutsCounter)
                 {
-                    LOG_ERROR(LoadStages,"Load sequence timeout");
                     TimeoutsCounter = 0;
+                    load.color = fastBILNK;
+                    usnprintf(LoadErrorMsg, 100, "/Stage %s - %s timeout",LoadStagesStr[LoadStages], MotorStr[MotorId]);
+                    Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
+
+                    LoadStatus = ERROR;
+                    ThreadLoadingReport();
+                    TryAgain = true;
+                    //ThreadLoadButton(LoadStages);
                 }
                 else
                 {
                     LoadStages++;
+                    LoadStatus = OK;
                     if (LoadStages == THREAD_LOAD_CLOSE_DANCERS)
                     {
                         MotorSetKvalHold(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, keepkvalhold);
@@ -296,6 +340,12 @@
                     {
                         ThreadLoadStateMachine(LoadStages);
                     }
+                    else
+                    {
+                        load.color = colorON;
+                        Pannel_Leds(THREAD_LOAD, MODE_ON);
+                        ThreadLoadingReport();
+                    }
                 }
             }
         }
@@ -303,38 +353,62 @@
             LOG_ERROR(MotorId, "Thread_Load_HomingCallback Callback is already 0");
         return OK;
     }
-    /*uint32_t Thread_Load_Center_Head_Rockers(void)
-    {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
-        CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD].directionthreadwize, 80,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD], Thread_Load_HomingCallback,10000);
-        CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH].directionthreadwize, 80,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH], Thread_Load_HomingCallback,10000);
-        return OK;
-    }*/
     uint32_t Thread_Load_Open_Covers(void)
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Open_Covers");
         //Open Dyeing Head Cover And Dryer Lid
         //HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2,
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
         //DeActivateHeadMagnet();
         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);
-        CallbackCounter++;
         //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 0, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,4000);
+        int direction;
+        if (MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType == CombinrdMotDriver)//reverse direction for powerstep
+        {
+            direction = DRIER_LID_CLOSE;
+        }
+        else
+        {
+            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_ARC)
+        {
+            CallbackCounter++;
+            if (MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 300,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,20000)==ERROR)
+            {
+                Thread_Load_HomingCallback(HARDWARE_MOTOR_TYPE__MOTO_DH_LID,NO_LIMIT);
+            }
+        }
+        if (Head_Type == HEAD_TYPE_FLAT)
+        {
+            Report("Thread_Load_Lift right actuator",__FILE__,__LINE__,LOW,RpMessage,false,0);
+            Trigger_Head_Actuators_Control(ACTIN, LOW,true);//UP
+        }
         return OK;
     }
     uint32_t Thread_Load_Lift_Dancers(void)
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
-        keepkvalhold = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].kvalhold;
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Lift_Dancers");
+        /*keepkvalhold = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].kvalhold;
         MotorSetKvalHold(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, 40);
         CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 15,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,15000);
+        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 15,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,15000);*/
         CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 600,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
+        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 500,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
+        status |= MCU_E2PromProgram(EEPROM_WINDER_TENSION_POSITION,1);
+        if (Is_PP_Machine() == true) //PP machine - new LTFU
+        {
+            CallbackCounter++;
+            MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].directionthreadwize, 500,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2], Thread_Load_HomingCallback,25000);
+            status |= MCU_E2PromProgram(EEPROM_PULLER_TENSION_POSITION,1);
+
+        }
+        if (Head_Type == HEAD_TYPE_FLAT)
+        {
+            Report("Thread_Load_Lift left actuator",__FILE__,__LINE__,LOW,RpMessage,false,0);
+            Trigger_Head_Actuators_Stub(ACTOT, ENABLE, UP);
+        }
 
         return OK;
     }
@@ -343,15 +417,24 @@
     {
         keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
         keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
-        if (keepkvalrun>=25)
-            keepkvalrun = 25;
+        /*if (keepkvalrun>=25)
+            keepkvalrun = 25;*/
+
+        Report("Read_Dryer_ENC_Position()",__FILE__,__LINE__,0,RpWarning,Read_Dryer_ENC_Position(),0);
+
         Report("Thread_Load_Lift_Rockers",__FILE__,__LINE__,keepkvalrun,RpMessage,keepmicrostep,0);
 
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        Report("Thread_Load_Lift_right dancer",__FILE__,__LINE__,0,RpMessage,0,0);
+        keepkvalhold = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].kvalhold;
+        MotorSetKvalHold(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, 40);
+        CallbackCounter++;
+        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 22,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,15000);
+
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Lift_Rockers");
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 8);
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 8);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, kval_upperValue);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, kval_upperValue);
         Task_sleep(10);
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 250,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,35000);
@@ -362,10 +445,12 @@
     }
     uint32_t Thread_Load_Initial_Tension(void) //Check Spool Presence, run Winder Until Break Sensor Is Identifieing Movement For A Second
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Initial_Tension");
+        load.color = BLINK;
         if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
         {
             REPORT_MSG(LIMIT, "No cone in winder");
+            Thread_Load_HomingCallback(HARDWARE_MOTOR_TYPE__MOTO_WINDER,NO_LIMIT);
             //return ERROR;
         }
         CallbackCounter++;
@@ -378,57 +463,108 @@
     {
         keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
         keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
-        if (keepkvalrun>=25)
-            keepkvalrun = 25;
+        /*if (keepkvalrun>=25)
+            keepkvalrun = 25;*/
         Report("Thread_Load_Close_Rockers",__FILE__,__LINE__,keepkvalrun,RpMessage,keepmicrostep,0);
 
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 8);
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 8);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, kval_upperValue);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, kval_upperValue);
 
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Close_Rockers");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 250,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,25000);
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize, 250,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LLOADING], Thread_Load_HomingCallback,25000);
+        if (Head_Type == HEAD_TYPE_FLAT)
+        {
+            Report("Thread_Load_Close left actuator",__FILE__,__LINE__,LOW,RpMessage,true,0);
+            Trigger_Head_Actuators_Stub(ACTOT, ENABLE, DOWN);
+        }
 
         return OK;
     }
-
     uint32_t Thread_Load_Close_Dancers(void)
     //Send Dancer Motors To Preset Location, Check That The Dancers Are On The Thread
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        uint32_t  current = 1;
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Close_Dancers");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 15,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,10000);
-        CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 600,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
 
+        Report("Thread_Load_Close dancers tension",__FILE__,__LINE__,(int)windertension,RpMessage,(int)pullertension,0);
+
+//        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 500,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
+        status |= MCU_E2PromRead(EEPROM_WINDER_TENSION_POSITION,&current);
+
+        ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__LeftDancer, windertension);
+/*        if (current!=windertension)
+        {
+            CallbackCounter++;
+            MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1, 500);
+            MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, ((int)windertension*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].microstep), Thread_Load_HomingCallback,20000);
+            status |= MCU_E2PromProgram(EEPROM_WINDER_TENSION_POSITION,(int)windertension);
+        }*/
+        if (Is_PP_Machine() == true) //PP machine - new LTFU
+        {
+            ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__MiddleDancer, pullertension);
+            /*status |= MCU_E2PromRead(EEPROM_PULLER_TENSION_POSITION,&current);
+            if (current!=pullertension)
+            {
+                CallbackCounter++;
+                MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, 500);
+                MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_LDANCER2, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].directionthreadwize, ((int)pullertension*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER2].microstep), Thread_Load_HomingCallback,20000);
+                status |= MCU_E2PromProgram(EEPROM_PULLER_TENSION_POSITION,(int)pullertension);
+            }*/
+
+        }
+        if (Head_Type == HEAD_TYPE_FLAT)
+        {
+            Report("Thread_Load_Close right actuators",__FILE__,__LINE__,LOW,RpMessage,true,0);
+            HeadCard_Actuators_Relocate();
+        }
         return OK;
     }
     uint32_t Thread_Load_Close_Lids(void)
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Close_Lids");
         //Close Dyeing Head Cover And Dryer Lid
         //HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2,
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
         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);
-        CallbackCounter++;
 //        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 2, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,4000);
+        int direction;
+        if (MotorDriverResponse[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].DriverType == CombinrdMotDriver)//reverse direction for powerstep
+        {
+            direction = DRIER_LID_OPEN;
+        }
+        else
+        {
+            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_ARC)
+        {
+            CallbackCounter++;
+            if(MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 300,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,20000)==ERROR)
+            {
+                Thread_Load_HomingCallback(HARDWARE_MOTOR_TYPE__MOTO_DH_LID,NO_LIMIT);
+            }
+        }
 
         return OK;
     }
     uint32_t Thread_Load_Resume_Heating(void)
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Resume_Heating");
         ActivateHeadMagnet();
+        HeadCard_Actuators_Relocate();
 
-        if (HandleProcessParameters(&ProcessParametersRecover)!= OK)
+        if (HandleProcessParameters(&ProcessParametersRecover,false)!= OK)
         {
-            LOG_ERROR (LoadStages, "Thread_Load_Resume_Heating failed");
+            usnprintf(LoadErrorMsg, 100, "Stage %s error",LoadStagesStr[LoadStages]);
+            Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
         }
         else
         {
@@ -438,15 +574,50 @@
         }
         return OK;
     }
+    uint32_t Thread_Load_Jog_Feeder_To_Middle_Point_Callback(uint32_t deviceID, uint32_t Condition)
+    {
+        if (Condition == true)
+        {
+            CallbackCounter--;
+            Report("Thread_Load_Jog_Feeder_To_Middle_Point_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+            //storeLoadArmParameters();
+            LoadStages++;
+            ThreadLoadStateMachine(LoadStages);
+        }
+        else
+        {
+            CallbackCounter--;
+            Report("Thread_Load_Jog_Feeder_To_Middle_Point TimeOut!",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+            //storeLoadArmParameters();
+            if (SecondTry == true)
+            {
+                LoadStages++;
+                ThreadLoadStateMachine(LoadStages);
+                LoadStatus = OK;
+            }
+            else
+            {
+                TimeoutsCounter = 0;
+                load.color = fastBILNK;
+                usnprintf(LoadErrorMsg, 100, "Thread_Load_Jog_Feeder_To_Middle_Point TimeOut!");
+                Report("Thread_Load_Jog_Feeder_To_Middle_Point TimeOut!",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+                LoadStatus = ERROR;
+                ThreadLoadingReport();
+                TryAgain = true;
+                //ThreadLoadButton(LoadStages);
+            }
+        }
+
+        return OK;
+    }
     uint32_t Thread_Load_Jog_Feeder_To_Middle_Point(void)
     //Jog The Feeder Motor Until The Feeder Dancer Is At Middle Position
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Jog_Feeder_To_Middle_Point");
         CallbackCounter++;
-        MotorMovetoDancerPosition (HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize, 100, FEEDER_DANCER ,true, Thread_Load_Jog_Feeder_To_Middle_Point_Callback,2000);
+        MotorMovetoDancerPosition (HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize, 400, FEEDER_DANCER ,true, Thread_Load_Jog_Feeder_To_Middle_Point_Callback,6000);
         return OK;
     }
-
     uint32_t Thread_Load_Dryer_MovetoEncoderPosition_Callback(uint32_t MotorId, uint32_t ReadValue)
     {
         Report("Thread_Load_Dryer_MovetoEncoderPosition_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
@@ -457,11 +628,20 @@
             RemoveControlCallback(LoadingControlId, ThreadLoadControlCBFunction );
             LoadingControlId = 0xFF;
         }
+        if (SpeedTControlId != 0xFF)
+        {
+           RemoveControlCallback(SpeedTControlId, ThreadLoadLengthCBFunction );
+           SpeedTControlId = 0xFF;
+        }
+        Report("Total Feeder load",__FILE__,__LINE__,dryerbufferCentimeters,RpMessage,TotalLoadedLen,0);
+
         if (CallbackCounter)
         {
             CallbackCounter--;
             if (CallbackCounter == 0)
             {
+                LoadStatus = OK;
+
                 LoadStages++;
                 if (LoadStages != THREAD_LOAD_INITIAL_TENSION) //on this satge we should wait for user call
                 {
@@ -476,43 +656,103 @@
     }
     uint32_t Thread_Load_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue)
     {
-        Report("Thread_Load_Dryer_Loading_Callback",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
-        Report("Thread_Load_Dryer_Loading_Callback details",__FILE__,__LINE__,MotorId,RpMessage,CallbackCounter,0);
-        /*if(LoadingControlId != 0xFF)
+        numberOfCycles++;
+
+        Report("Thread_Load_Dryer_Loading_Callback",__FILE__,(int)TotalLoadedLen,(int)DrierPrevLocation,RpMessage,numberOfCycles,0);
+
+        if ((fabs (TotalLoadedLen  -DrierPrevLocation)>50  )&&(ReadValue == NOTBUSY))
         {
-            MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);
-            RemoveControlCallback(LoadingControlId, ThreadLoadControlCBFunction );
-            LoadingControlId = 0xFF;
-        }*/
-        MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Thread_Load_Dryer_MovetoEncoderPosition_Callback,10000);
+            DrierPrevLocation = TotalLoadedLen ;
+            //Report("Thread_Load_Dryer_Loading_Callback",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+            //Report("Thread_Load_Dryer_Loading_Callback details",__FILE__,(int)(TotalLoadedLen),numberOfCycles,RpMessage,CallbackCounter,0);
+            if (LoadStages != THREAD_LOAD_DRYER_LOADING)
+            {
+                return OK;
+            }
+            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,numberOfCycles+CurrentlyLoaded);
+            if (numberOfCycles<LoadArmRounds)
+            {
+                MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+                                       numberOfSteps,    Thread_Load_Dryer_Loading_Callback, 10000);
+            }
+            else
+            {
+                MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Thread_Load_Dryer_MovetoEncoderPosition_Callback,30000,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,40);
+                Report("Store Number of cycles in dryer",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
+            }
+        }
+        else
+        {
+            TryAgain = true;
+            SecondTry = false;
+            Report("Loading dryer - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
+            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,numberOfCycles+CurrentlyLoaded);
+            TimeoutsCounter = 0;
+            CallbackCounter = 0;
+            load.color = fastBILNK;
+            usnprintf(LoadErrorMsg, 100, "$Stage %s - Dryer load arm timeout",LoadStagesStr[LoadStages]);
+            Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
+            LoadStatus = ERROR;
+            MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
+            if(LoadingControlId != 0xFF)
+            {
+                MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);
+                RemoveControlCallback(LoadingControlId, ThreadLoadControlCBFunction );
+                LoadingControlId = 0xFF;
+            }
+            if (SpeedTControlId != 0xFF)
+            {
+               RemoveControlCallback(SpeedTControlId, ThreadLoadLengthCBFunction );
+               SpeedTControlId = 0xFF;
+            }
+            Report("Total Feeder load",__FILE__,__LINE__,dryerbufferCentimeters,RpMessage,TotalLoadedLen,0);
+
+            ThreadLoadingReport();
+            //ThreadLoadButton(LoadStages);
+        }
         return OK;
     }
 
     uint32_t Thread_Load_Dryer_Loading(void)
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Dryer_Loading");
 
         if (dryerbufferlength)
-            LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
-        //if (LoadArmInfo.LoadArmRounds <= 2)
-        //    LoadArmInfo.LoadArmRounds = 20;
-        float numberOfSteps = 0;
+            LoadArmRounds = (int)dryerbufferlength;
+        if (LoadArmRounds <= 2)
+            LoadArmRounds = 30;
         //Start Feeder Pid, Rotate Loading Arm Counter Thread Direction X Circles According To Rml. Feeder Speed Is 40
         SetOriginMotorSpeed(19);
 //        OriginalMotorSpd_2PPS[FEEDER_MOTOR] = 1000;
 //        CurrentControlledSpeed[FEEDER_MOTOR] = 1000;
 
-        MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmInfo.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;
+        }
+        if (LoadArmRounds == CurrentlyLoaded)
+        {
+            Report("Thread_Load_Dryer_Loading no need for cycles",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+            LoadStages++;
+            ThreadLoadStateMachine(LoadStages);
+            return OK;
+        }
+        ThreadMotorIdToMotorId[FEEDER_MOTOR] = HARDWARE_MOTOR_TYPE__MOTO_RDRIVING ;
+        ThreadMotorIdToMotorId[DRYER_MOTOR] = HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING;
 
-        numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmInfo.LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
-        numberOfSteps -= 100;
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&DrierPrevLocation);
+        numberOfCycles = 0;
+        numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/**LoadArmRounds*/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
+//        numberOfSteps -= 100;
         //numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*3.3*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
         Report("Thread Load State Machine step.",__FILE__,LoadStages,numberOfSteps,RpMessage,(int)(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius),0);
         MotorControlConfig[FEEDER_MOTOR].m_params.MAX = 1;
         MotorControlConfig[FEEDER_MOTOR].m_params.MIN = MotorsControl[FEEDER_MOTOR].outputproportionalpowerlimit*-1;
         MotorControlConfig[FEEDER_MOTOR].m_params.Kd = MotorsControl[FEEDER_MOTOR].derivativetime;
         MotorControlConfig[FEEDER_MOTOR].m_params.Kp = MotorsControl[FEEDER_MOTOR].proportionalgain;
-        MotorControlConfig[FEEDER_MOTOR].m_params.Ki = MotorsControl[FEEDER_MOTOR].integraltime;
+        MotorControlConfig[FEEDER_MOTOR].m_params.Ki = 0;//MotorsControl[FEEDER_MOTOR].integraltime;
         MotorControlConfig[FEEDER_MOTOR].m_params.IntegralErrorMultiplier = MotorsControl[FEEDER_MOTOR].setpointramprateorsoftstartramp;
         MotorControlConfig[FEEDER_MOTOR].m_params.ProportionalErrorMultiplier = MotorsControl[FEEDER_MOTOR].outputonoffhysteresisvalue;
         MotorControlConfig[FEEDER_MOTOR].m_params.epsilon = MotorsControl[FEEDER_MOTOR].epsilon;
@@ -527,42 +767,54 @@
         MotorControlConfig[FEEDER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage
         MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize);
 
-        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
+        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
+        //6 seconds per round
 
         LoadingControlId = AddControlCallback(NULL,ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
         Report("AddControlCallback feeder",__FILE__,__LINE__,LoadingControlId,RpMessage,IfTypeThread*0x100+FEEDER_MOTOR,0);
+        if (SpeedTControlId != 0xFF)
+        {
+            RemoveControlCallback(SpeedTControlId,ThreadLoadLengthCBFunction);
+            SpeedTControlId = 0xFF;
+        }
+        //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
+        LengthCalculationMultiplier = (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].pulleyradius*2*PI)/(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].pulseperround*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].microstep);
+        TotalLoadedLen = 0;
+        DrierPrevLocation = 200; //initial safe value
+        SpeedTControlId = AddControlCallback("Thread length",ThreadLoadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+HARDWARE_MOTOR_TYPE__MOTO_RDRIVING),HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,0);
+        Tinitialpos = 0xFFFF;previousPosition = 0; currentPosition = 0;
         CallbackCounter++;
         Report("Thread_Load_Dryer_Loading",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
         MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
-                               numberOfSteps,    Thread_Load_Dryer_Loading_Callback, 100000);
-
-        //Keep Notation How Many Rotations In The Dryer
-        //LoadArmInfo.LoadArmBackLash = 0;
-        //LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
-        //FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
+                               numberOfSteps-800,    Thread_Load_Dryer_Loading_Callback, 10000);
         return OK;
     }
+    double keepfeedertension = 0;
     uint32_t Thread_Load_Jog_ThreadStop(uint32_t index, uint32_t ReadValue)
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Jog_ThreadStop");
         SafeRemoveControlCallback(LoadingControlId, Thread_Load_Jog_ThreadStop );
         LoadingControlId = 0xFF;
         ThreadAbortJoggingFunc();
         LoadStages++;
+        ProcessParametersKeep.feedertension = keepfeedertension;
         ThreadLoadStateMachine(LoadStages);
         return OK;
     }
     uint32_t Thread_Load_Jog_Thread(void)
     //Jog Thread Shortly To Make Sure Spool Is Running. Report End Of Loading
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Jog_Thread");
+        keepfeedertension = feedertension;
+        ProcessParametersKeep.feedertension = 0.0;
         ThreadJoggingFunc(20);
-        LoadingControlId = AddControlCallback(NULL,Thread_Load_Jog_ThreadStop, eOneSecond*5,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
+        LoadingControlId = AddControlCallback("Load jog",Thread_Load_Jog_ThreadStop, eOneSecond*25,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
         return OK;
     }
     uint32_t Thread_Load_End(void)
     {
         REPORT_MSG(LoadStages,"Loading Ended");
+        ThreadLoadingReport();
         if(LoadingControlId != 0xFF)
         {
             MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);
@@ -581,7 +833,18 @@
             RemoveControlCallback(WinderControlId, ThreadLoadControlCBFunction );
             WinderControlId = 0xFF;
         }
+        if (SpeedTControlId != 0xFF)
+        {
+           RemoveControlCallback(SpeedTControlId, ThreadLoadLengthCBFunction );
+           SpeedTControlId = 0xFF;
+        }
+        if (ThreadLoadControlId != 0xFF)
+        {
+           RemoveControlCallback(ThreadLoadControlId, ThreadUpdateCallBackFunction );
+           ThreadLoadControlId = 0xFF;
+        }
 
+        LoadingStopArmReset();
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_RLOADING);
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_LLOADING);
@@ -589,99 +852,194 @@
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_LDANCER1);
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID);
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_DH_LID);
-        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Stop);
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,Hard_Stop);
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_WINDER,Hard_Hiz);
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_SCREW,Hard_Hiz);
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,Hard_Hiz);
+        if (LoadStages!=THREAD_LOAD_END)
+        {
+            usnprintf(LoadErrorMsg, 100, "Load sequence stopped by user on stage %d",LoadStages);
+            LoadStatus = ERROR;
+        }
+
         LoadStages = THREAD_LOAD_INIT;
+        load.color = colorON;
+        Pannel_Leds(THREAD_LOAD, MODE_ON);
         return OK;
     }
-    uint32_t Thread_Load_Dryer_UnLoading(void)
+    uint32_t Thread_Load_switchCallback(uint32_t deviceID, uint32_t BusyFlag)
     {
-        REPORT_MSG(LoadStages, "Thread UnLoad State Machine step");
-        LoadArmInfo.LoadArmRounds = 0;
-        //uint32_t numberOfSteps = 0;
-        //Start Feeder Pid, Rotate Loading Arm Counter Thread Direction X Circles According To Rml. Feeder Speed Is 40
-        SetOriginMotorSpeed(19);
-//        OriginalMotorSpd_2PPS[FEEDER_MOTOR] = 1000;
-//        CurrentControlledSpeed[FEEDER_MOTOR] = 1000;
+        if ((LoadStages != THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION)||(LoadStatus == ERROR))
+        {
+            return OK;
+        }
+        Screw_Dir = 1-Screw_Dir;
+        // movement of the screw while unloading the thread from the dryer to the spool
+        AlarmHandlingSetAlarm (EVENT_TYPE__SCREW_MOTOR_LIMIT_TIMEOUT,OFF);  //handle alarm detection and operation
+        status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,Screw_Dir, 80, screw[Screw_Dir], Thread_Load_switchCallback,20000);
+
+        return OK;
+    }
+    /*uint32_t Thread_Load_Dryer_UnLoading_Callback(uint32_t MotorId, uint32_t ReadValue)
+    {
+        bool direction;
+        numberOfCycles++;
+        uint32_t temp = Read_Dryer_ENC_Position();
+        Report("Thread_Load_Dryer_UnLoading_Callback",__FILE__,AccumulatedArmMovement,temp,RpMessage,DrierPrevLocation,0);
+        //Report("Thread_Load_Dryer_UnLoading_Callback details",__FILE__,(int)(TotalLoadedLen),numberOfCycles,RpMessage,CallbackCounter,0);
+        if (LoadStages != THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION)
+        {
+            Report("Thread_Load_Dryer_UnLoading_Callback wrong state",__FILE__,__LINE__,LoadStages,RpMessage,DrierPrevLocation,0);
+            return OK;
+        }
+        if ((AccumulatedArmMovement>8000  )&&(ReadValue == NOTBUSY)) // OK - take another round
+        {
+            DrierPrevLocation = temp;
+            Report("Thread_Load_Dryer_UnLoading cycles",__FILE__,numberOfCycles,LoadArmRounds,RpMessage,0,0);
+            if (numberOfCycles<LoadArmRounds)
+            {
+                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-numberOfCycles);
+                MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+                                       numberOfSteps,    Thread_Load_Dryer_UnLoading_Callback, 10000);
+            }
+            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,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,40);
+                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,0);
+                Report("Store Number of cycles in dryer",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
+            }
+        }
+        else  //timeout or no movement
+        {
+            Report("Unloading dryer - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmRounds,0);
+            if (SecondTry == true)
+                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,0);
+            else
+                MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmRounds-numberOfCycles);
+            if (abs(temp -DrierCenterLocation)<200)
+            {
+                if (temp<DrierCenterLocation)
+                    direction = 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize;
+                else
+                    direction = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize;
+                MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Thread_Load_Set_Load_Arm_To_Stopper_OnError_Callback,3000,direction,10);
+
+            }
+            else
+                MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Stop);
 
-        //numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmInfo.LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
-        MotorControlConfig[POOLER_MOTOR].m_params.MAX = 1;
-        MotorControlConfig[POOLER_MOTOR].m_params.MIN = MotorsControl[POOLER_MOTOR].outputproportionalpowerlimit*-1;
-        MotorControlConfig[POOLER_MOTOR].m_params.Kd = MotorsControl[POOLER_MOTOR].derivativetime;
-        MotorControlConfig[POOLER_MOTOR].m_params.Kp = MotorsControl[POOLER_MOTOR].proportionalgain;
-        MotorControlConfig[POOLER_MOTOR].m_params.Ki = 0;//MotorsControl[POOLER_MOTOR].integraltime;
-        MotorControlConfig[POOLER_MOTOR].m_params.IntegralErrorMultiplier = MotorsControl[POOLER_MOTOR].setpointramprateorsoftstartramp;
-        MotorControlConfig[POOLER_MOTOR].m_params.ProportionalErrorMultiplier = MotorsControl[POOLER_MOTOR].outputonoffhysteresisvalue;
-        MotorControlConfig[POOLER_MOTOR].m_params.epsilon = MotorsControl[POOLER_MOTOR].epsilon;
-        MotorControlConfig[POOLER_MOTOR].m_params.dt = MotorsControl[POOLER_MOTOR].controloutputtype;
-        MotorControlConfig[POOLER_MOTOR].m_ingnoreValue =  MotorsControl[POOLER_MOTOR].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
-        MotorControlConfig[POOLER_MOTOR].m_calculatedError = 0;
-        MotorControlConfig[POOLER_MOTOR].m_integral = 0;
-        MotorControlConfig[POOLER_MOTOR].m_isEnabled = true;
-        MotorControlConfig[POOLER_MOTOR].m_isReady = true;
-        MotorControlConfig[POOLER_MOTOR].m_mesuredParam = 0;
-        MotorControlConfig[POOLER_MOTOR].m_preError = 0;
-        MotorControlConfig[POOLER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage
-        MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDRIVING].directionthreadwize);
 
-        PullerControlId = AddControlCallback(NULL,ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+POOLER_MOTOR),POOLER_DANCER,POOLER_MOTOR);
-        Report("AddControlCallback Puller",__FILE__,__LINE__,PullerControlId,RpMessage,IfTypeThread*0x100+POOLER_MOTOR,0);
-////////////////////////
-        MotorControlConfig[WINDER_MOTOR].m_params.MAX = 1;
-        MotorControlConfig[WINDER_MOTOR].m_params.MIN = MotorsControl[WINDER_MOTOR].outputproportionalpowerlimit*-1;
-        MotorControlConfig[WINDER_MOTOR].m_params.Kd = MotorsControl[WINDER_MOTOR].derivativetime;
-        MotorControlConfig[WINDER_MOTOR].m_params.Kp = MotorsControl[WINDER_MOTOR].proportionalgain;
-        MotorControlConfig[WINDER_MOTOR].m_params.Ki = 0;//MotorsControl[WINDER_MOTOR].integraltime;
-        MotorControlConfig[WINDER_MOTOR].m_params.IntegralErrorMultiplier = MotorsControl[WINDER_MOTOR].setpointramprateorsoftstartramp;
-        MotorControlConfig[WINDER_MOTOR].m_params.ProportionalErrorMultiplier = MotorsControl[WINDER_MOTOR].outputonoffhysteresisvalue;
-        MotorControlConfig[WINDER_MOTOR].m_params.epsilon = MotorsControl[WINDER_MOTOR].epsilon;
-        MotorControlConfig[WINDER_MOTOR].m_params.dt = MotorsControl[WINDER_MOTOR].controloutputtype;
-        MotorControlConfig[WINDER_MOTOR].m_ingnoreValue =  MotorsControl[WINDER_MOTOR].sensorcorrectionadjustment; // the minimal change required to change the motor speed in pulses
-        MotorControlConfig[WINDER_MOTOR].m_calculatedError = 0;
-        MotorControlConfig[WINDER_MOTOR].m_integral = 0;
-        MotorControlConfig[WINDER_MOTOR].m_isEnabled = true;
-        MotorControlConfig[WINDER_MOTOR].m_isReady = true;
-        MotorControlConfig[WINDER_MOTOR].m_mesuredParam = 0;
-        MotorControlConfig[WINDER_MOTOR].m_preError = 0;
-        MotorControlConfig[WINDER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage
-        MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_WINDER,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].directionthreadwize);
+            TimeoutsCounter = 0;
+            CallbackCounter = 0;
+            if(WinderControlId != 0xFF)
+            {
+                MotorStop(ThreadMotorIdToMotorId[WINDER_MOTOR],Hard_Hiz);
+                RemoveControlCallback(WinderControlId, ThreadLoadControlCBFunction );
+                WinderControlId = 0xFF;
+            }
 
-        WinderControlId = AddControlCallback(NULL,ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+WINDER_MOTOR),WINDER_DANCER,WINDER_MOTOR);
-        Report("AddControlCallback Winder",__FILE__,__LINE__,WinderControlId,RpMessage,IfTypeThread*0x100+WINDER_MOTOR,0);
+            MotorAbortMovetoLimitSwitch(HARDWARE_MOTOR_TYPE__MOTO_SCREW);
 
-////////////////////////
-        MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING].directionthreadwize);
-        MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING, OriginalMotorSpd_2PPS[DRYER_MOTOR]);
+            MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,Hard_Hiz);
+            load.color = fastBILNK;
+            usnprintf(LoadErrorMsg, 100, "&Stage %s - Dryer load arm timeout",LoadStagesStr[LoadStages]);
+            Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
+            Report("Dryer unloading timeout(1) or no movement",__FILE__,temp,DrierPrevLocation,RpWarning,ReadValue,0);
+            LoadStatus = ERROR;
+            TryAgain = true;
+            ThreadLoadingReport();
+            //ThreadLoadButton(LoadStages);
+        }
+        return OK;
+    }*/
+    uint32_t Thread_Load_Dryer_UnLoading(void)
+    {
+        uint32_t temp;
+        REPORT_MSG(LoadStages, "Thread Load State Machine step Dryer Unloading");
+        //LoadArmRounds = 0;
+        //uint32_t numberOfSteps = 0;
 
         CallbackCounter++;
-        //MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
-        //                       numberOfSteps,    Thread_Load_Dryer_Loading_Callback, 100000);
-        Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
-        LoadArmInfo.LoadArmBackLash = 5;
 
-        status |= MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
-                                        MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4, Thread_Load_Set_Load_Arm_To_Stopper_Callback,LoadArmInfo.LoadArmBackLash,1000);
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&temp);
+        DrierCenterLocation = DrierPrevLocation;
+        DrierPrevLocation = temp;
+        UnloadingStart = msec_millisecondCounter;
+        //numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/**LoadArmRounds*/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
+        //numberOfCycles = 0;
+        LoadingArmReset(Thread_Load_Set_Load_Arm_To_Stopper_Callback,300000);
+        /*if (SecondTry == true)
+        {
+            MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
+            if (LoadArmRounds == 0) //prev trial stopped
+            {
+                LoadArmRounds = (int)dryerbufferlength;
+            }
+            //LoadArmRounds = 30;
+        }
+        else
+        {
+            MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
+            if (LoadArmRounds == 0) //prev trial stopped
+            {
+                LoadArmRounds = (int)dryerbufferlength;
+            }
+        }*/
+        /*MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&temp);
+        DrierCenterLocation = DrierPrevLocation;
+        DrierPrevLocation = temp;
+        Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,UnloadingStart,DrierPrevLocation,RpMessage, LoadArmRounds,0);
+        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
+//        status |= MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
+//                                        MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4, Thread_Load_Set_Load_Arm_To_Stopper_Callback,0,1000);
+        MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
+                               numberOfSteps-800,    Thread_Load_Dryer_UnLoading_Callback, 10000);
+
+        Screw_Dir = 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize;
+
+        // movement of the screw while unloading the thread from the dryer to the spool
+        status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,Screw_Dir, 80, screw[Screw_Dir], Thread_Load_switchCallback,20000);
 
         //Keep Notation How Many Rotations In The Dryer
-        LoadArmInfo.LoadArmBackLash = 5;
-        LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
-        //FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
+        //LoadArmRounds = (int)dryerbufferlength;
+         *
+         */
+        load.color = BLINK;
         return OK;
     }
 
+    double percentage;
     uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM ReadValue)
     {
         REPORT_MSG(ReadValue,"ThreadLoadStateMachine");
+        //ThreadLoaded();
+        percentage = ReadValue*7;
+        ThreadLoadingReport();
+
         if (LoadStages!=ReadValue)
             LoadStages = ReadValue;
         switch (ReadValue)
         {
         case THREAD_LOAD_INIT:
             //LoadStages++;
-            Thread_Load_Init();
+            MessageState = 1;
+
+            Thread_Load_Init(ReadValue);
             break;
         case THREAD_LOAD_REDUCE_HEAT:  //HEATERS OFF, DRYER BLOWER OFF, BLOWER LOW,
             //LoadStages++;
+            MessageState = 1;
+            if (InitCalled == false)
+            {
+                REPORT_MSG(ReadValue,"Thread_Load_Init called from 1");
+                Thread_Load_Init(ReadValue);
+            }
+            else
+            {
+                REPORT_MSG(ReadValue,"Thread_Load_Init called from 0");
+            }
             Thread_Load_Reduce_Heat();
+            InitCalled = false;
             break;
         case THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION://USE NOTATION HOW MANY ROTATIONS IN THE DRYER, OR CHECK AGAINS STOPPER. MOVE SLOWLY
             //LoadStages++;
@@ -736,37 +1094,135 @@
         case THREAD_LOAD_JOG_THREAD: //JOG THREAD SHORTLY TO MAKE SURE SPOOL IS RUNNING. REPORT END OF LOADING
             //LoadStages++;
             Thread_Load_Jog_Thread();
+            ThreadLoadingReport();
             break;
         case THREAD_LOAD_END:
             LoadStages = THREAD_LOAD_END;
+            percentage = 100.0;
             Thread_Load_End();
             break;
         default:
             LOG_ERROR(LoadStages,"ERROR IN LOAD STATE MACHINE");
             break;
     }
+
     return OK;
 }
 uint32_t ThreadLoadButton(THREAD_LOAD_STAGES_ENUM ReadValue)
 {
-    if (JobIsActive())
+    if (JobIsActive()||(MachineReadyForHeating == false)||(FPGABurningActive==true))
     {
         Report("ThreadLoadButton called on job",__FILE__,__LINE__,LoadStages,RpMessage,ReadValue,0);
         return ERROR;
     }
+    if (CallbackCounter)
+    {
+        Report("ThreadLoadButton called when the loading is active",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+        return ERROR;
+    }
     Report("ThreadLoadButton",__FILE__,__LINE__,LoadStages,RpMessage,ReadValue,0);
-    if (LoadStages > ReadValue)
+    Report("ThreadLoadButton params",__FILE__,LoadStatus,TryAgain,RpMessage,SecondTry,0);
+    if (LoadStages == THREAD_LOAD_INITIAL_TENSION) //on this satge we should wait for user call
+        MessageState = 2;
+    ThreadLoadingReport();
+    if (LoadStatus == ERROR)
     {
-        ThreadLoadStateMachine(LoadStages+1);
+        if ((SecondTry == false)&&(TryAgain == true))
+        {
+            LoadStatus = OK;
+            SecondTry = true;
+            load.color = BLINK;
+            //if (LoadStages > THREAD_LOAD_INITIAL_TENSION)
+            //    ThreadLoadingRestartReport();
+            Report("Calling State machine retry",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
+            ThreadLoadStateMachine(LoadStages);
+        }
+        else if (SecondTry == true)
+        {
+            SecondTry = false;
+            Report("Calling State machine  2nd try",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
+            load.color = BLINK;
+            LoadStatus = OK;
+            if (LoadStages == THREAD_LOAD_LIFT_DANCERS)
+            {
+                LoadStages++;
+            }
+            else
+                ThreadLoadStateMachine(LoadStages+1);
+        }
+        else //((SecondTry == false)&&(TryAgain == false))???????
+        {
+            Report("State ERROR with wrong parameters",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
+            SecondTry = false;
+        }
     }
     else
     {
-        ThreadLoadStateMachine(ReadValue);
+        Report("Calling State machine status OK",__FILE__,ReadValue,LoadStatus,RpMessage,SecondTry,0);
+        //if (LoadStages > THREAD_LOAD_INITIAL_TENSION)
+        //    ThreadLoadingRestartReport();
+        ThreadLoadStateMachine(LoadStages);
+        SecondTry = false;
     }
     return OK;
 }
-uint32_t LoadCounter = 0;
 
+uint32_t ThreadLoadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
+{
+    uint32_t positionDiff = 0,prevprev;
+    double length = 0.0;
+    char lenstr[150];
+    static int counter = 0;
+    int index = MAX_THREAD_MOTORS_NUM;
+    if (IfIndex>>8 != IfTypeThread)
+    {
+        LOG_ERROR (IfIndex, "Wrong  Interface type");
+        return 0xFFFFFFFF;
+    }
+    index = IfIndex&0xFF;
+//    if (CurrentRequestedLength == 0.0)
+//        return OK;
+    if (index != HARDWARE_MOTOR_TYPE__MOTO_RDRIVING)
+    {
+        LOG_ERROR (IfIndex, "Wrong Motor");
+        return 0xFFFFFFFF;
+    }
+    currentPosition = MotorGetPosition(HARDWARE_MOTOR_TYPE__MOTO_RDRIVING);
+    if (currentPosition != 0)
+    {
+        if (Tinitialpos == 0xFFFF)
+        {
+            previousPosition = currentPosition;
+            Tinitialpos = 0;
+        }
+        prevprev = previousPosition;
+        if (Extended_Motor_Param[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING] == true) //powerstep driver reverses the direction
+            positionDiff = Control_Delta_Position_Pass(previousPosition,currentPosition);
+        else
+            positionDiff = Control_Delta_Position_Pass(currentPosition,previousPosition);
+        //positionDiff = positionDiff / MotorsCfg[ThreadMotorIdToMotorId[index]].microstep;
+        previousPosition = currentPosition;
+
+        // total length = (position diff / full cycle) * pulley perimeter
+        //(positionDiff/pulseperround)*((2*PI*motor_Radius)
+
+        //positionDiff = positionDiff / MotorsCfg[ThreadMotorIdToMotorId[index]].microstep;
+        length = (double)(positionDiff)*LengthCalculationMultiplier;
+
+        if (counter++ % 50 == 0)
+        {
+            usnprintf(lenstr, 100, " length %d, diff 0x%x, pos 0x%x prev 0x%x TotalLoadedLen %d",(int)length*100,(int)positionDiff,previousPosition,prevprev, (int)TotalLoadedLen);
+//            SendJobProgress(0.0,0,false, lenstr);
+            ReportWithPackageFilter(ThreadFilter,lenstr,__FILE__,__LINE__,(int)TotalLoadedLen,RpWarning,(int)TotalLoadedLen,0);
+//            length = 0;
+
+        }
+
+    }
+    TotalLoadedLen += length;
+
+    return OK;
+}
 uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
     //read value is the dancer angle
@@ -786,11 +1242,11 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     index = IfIndex&0xFF;
 
     DancerId = ThreadMotorIdToDancerId[index];
-    if (ReadValue < 10)
+    /*if (ReadValue < 10)
     {
         Report("Dancer value read too small.",__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
         return OK;
-    }
+    }*/
     if (ReadValue == 0x3FFF)
     {
         return OK;
@@ -801,6 +1257,11 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         //pooler dancer is right sided: data is opposite
         TranslatedReadValue = (-1*TranslatedReadValue);
     }
+    if (abs(TranslatedReadValue) > 0x2000)
+    {
+        TranslatedReadValue = 0x3FFF- TranslatedReadValue; //overcome zero environment
+    }
+
     //TranslatedReadValue = 0;//test
     MotorSamples[index][MotorSamplePointer[index]] = TranslatedReadValue;//(-1 * TranslatedReadValue);
     MotorSamplePointer[index]++;
@@ -813,7 +1274,7 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 
     NormalizedError = avreageSampleValue*NormalizedErrorCoEfficient[index];
     MotorControlConfig[index].m_mesuredParam = NormalizedError;
-    MotorControlConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation((float)MotorControlConfig[index].m_SetParam , (float)MotorControlConfig[index].m_mesuredParam,
+    MotorControlConfig[index].m_calculatedError = PIDAlgorithmCalculation((float)MotorControlConfig[index].m_SetParam , (float)MotorControlConfig[index].m_mesuredParam,
                                                                           &MotorControlConfig[index].m_params,   &MotorControlConfig[index].m_preError, &MotorControlConfig[index].m_integral);
     if (index != FEEDER_MOTOR) //feeder unit handles errors opposite to left unit
     {
@@ -825,6 +1286,37 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         CurrentControlledSpeed[index] = calculated_speed;
         MotorSetSpeed(ThreadMotorIdToMotorId[index], calculated_speed);
     }
+   /*
+
+     if (index == POOLER_MOTOR)
+    {
+        if ((TranslatedReadValue)<(-1200))
+        {
+            if(PullerControlId != 0xFF)
+            {
+                Report("Puller stoped",__FILE__,__LINE__,ReadValue,RpWarning,(int)DancersCfg[DancerId].zeropoint,0);
+                MotorStop(ThreadMotorIdToMotorId[POOLER_MOTOR],Hard_Hiz);
+                RemoveControlCallback(PullerControlId, ThreadLoadControlCBFunction );
+                PullerControlId = 0xFF;
+            }
+        }
+
+    }
+    if (index == WINDER_MOTOR)
+    {
+        if ((TranslatedReadValue)<(-1200))
+        {
+            if(WinderControlId != 0xFF)
+            {
+                Report("Winder stoped",__FILE__,__LINE__,ReadValue,RpWarning,(int)DancersCfg[DancerId].zeropoint,0);
+                MotorStop(ThreadMotorIdToMotorId[WINDER_MOTOR],Hard_Hiz);
+                RemoveControlCallback(WinderControlId, ThreadLoadControlCBFunction );
+                WinderControlId = 0xFF;
+            }
+
+        }
+
+    }*/
 /*    LoadCounter++;
     if ((LoadCounter % 5001) == 0)
     {
@@ -832,6 +1324,33 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     }*/
  return OK;
 }
+bool ThreadLoaded(void)
+{
+   /* uint32_t ReadValue;
+
+    int32_t PoolerValue,WinderValue,FeederValue;
+    //this function tests if there is a thread in the machine. all dancers are in lowermost position then there is no thread.
+
+    ReadValue = Control_Read_Dancer_Position(FEEDER_DANCER,0);
+    FeederValue = ReadValue - DancersCfg[FEEDER_DANCER].zeropoint;
+    Report("Feeder out",__FILE__,abs(FeederValue),ReadValue,RpWarning,(int)DancersCfg[FEEDER_DANCER].zeropoint,0);
+    ReadValue = Control_Read_Dancer_Position(WINDER_DANCER,0);
+    WinderValue = ReadValue - DancersCfg[WINDER_DANCER].zeropoint;
+    Report("Winder out",__FILE__,abs(WinderValue),ReadValue,RpWarning,(int)DancersCfg[WINDER_DANCER].zeropoint,0);
+    ReadValue = Control_Read_Dancer_Position(POOLER_DANCER,0);
+    PoolerValue = ReadValue - DancersCfg[POOLER_DANCER].zeropoint;
+        //pooler dancer is right sided: data is opposite
+    PoolerValue = (-1*PoolerValue);
+    Report("Puller out",__FILE__,abs(PoolerValue),ReadValue,RpWarning,(int)DancersCfg[POOLER_DANCER].zeropoint,0);
+
+    if (((PoolerValue)<(-1200))&&((WinderValue)<(-1200))&&((FeederValue)<(-1200)))
+    {
+        Report("Thread is out",__FILE__,(-1*PoolerValue),(-1*WinderValue),RpWarning,(-1*FeederValue),0);
+        return true;
+    }
+    else*/
+        return false;
+}
 void ThreadLoadRequest(MessageContainer* requestContainer)
 {
 //#ifdef DEBUG_TEST_FUNCTIONS
@@ -845,10 +1364,16 @@ void ThreadLoadRequest(MessageContainer* requestContainer)
     responseContainer = createContainer(MESSAGE_TYPE__StubHeatingTestResponse, requestContainer->token, false, &response, &stub_heating_test_response__pack, &stub_heating_test_response__get_packed_size);
     container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
 
-
     int LoadStage = (int)request->dryerzone1temp;
-    LoadStages = LoadStage;
-    ThreadLoadStateMachine(LoadStage);
+    if (request->hardwarepidcontrol1!=NULL)
+    {
+        UpdatePidDuringRun(request->hardwarepidcontrol1);
+    }
+    else
+    {
+        LoadStages = LoadStage;
+        ThreadLoadStateMachine(LoadStage);
+    }
 
     /*if (status)
     {
@@ -891,3 +1416,256 @@ void ThreadLoadPollRequest(MessageContainer* requestContainer)
     SendChars(container_buffer, container_size);
     stub_heating_test_poll_request__free_unpacked(request,NULL);
 }
+char ThreadLoadingToken[36+1] = {0};
+char DefaultErrSrt[] = "OK";
+uint32_t ThreadLoadingReport(void)
+{
+    MessageContainer responseContainer;
+    bool last = false;
+    StartThreadLoadingResponse response = START_THREAD_LOADING_RESPONSE__INIT;
+
+    if (ThreadLoadingToken[0] == 0)
+        return OK;
+
+    if (MessageState == 0)
+    {
+        response.has_state = true;
+        response.state = THREAD_LOADING_STATE__None;
+        response.errorreason = DefaultErrSrt;
+
+    }
+    else if (MessageState == 1)
+    {
+        response.has_state = true;
+        if (LoadStatus == OK)
+        {
+            response.state = THREAD_LOADING_STATE__Preparing;
+            if (LoadStages == THREAD_LOAD_INITIAL_TENSION)
+            {
+                response.state = THREAD_LOADING_STATE__ReadyForLoading;
+                response.errorreason = DefaultErrSrt;
+            }
+        }
+        else
+        {
+            response.state = THREAD_LOADING_STATE__PreparationError;
+            response.errorreason = LoadErrorMsg;
+        }
+    }
+    else if (MessageState == 2)
+    {
+        response.has_state = true;
+        if (LoadStatus == OK)
+        {
+            response.state = THREAD_LOADING_STATE__Finalizing;
+            if (LoadStages > THREAD_LOAD_JOG_THREAD)
+            {
+                response.state = THREAD_LOADING_STATE__Completed;
+                response.errorreason = DefaultErrSrt;
+                //last = true;
+            }
+        }
+        else
+        {
+            response.state = THREAD_LOADING_STATE__FinalizationError;
+            response.errorreason = LoadErrorMsg;
+        }
+    }
+    else
+    {
+        Report("ThreadLoadingReport ERROR",__FILE__,MessageState,response.state,RpWarning,(int)LoadStages,0);
+        return ERROR;
+    }
+    Report("ThreadLoadingReport",__FILE__,MessageState,response.state,RpWarning,(int)LoadStages,0);
+    response.has_progresspercentage = true;
+    response.progresspercentage =  percentage;
+    //-------------------------------------------------------------------------------------------
+    responseContainer = createContainer(MESSAGE_TYPE__StartThreadLoadingResponse, ThreadLoadingToken, last, &response, &start_thread_loading_response__pack, &start_thread_loading_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((char*)container_buffer, container_size);
+
+    return OK;
+
+}
+bool ThreadLoadingRestartFlag = false;
+uint32_t ThreadLoadingRestartReport(void) //sending after a failure in the finalizing stage
+{
+    MessageContainer responseContainer;
+    StartThreadLoadingResponse response = START_THREAD_LOADING_RESPONSE__INIT;
+
+    if (ThreadLoadingToken[0] == 0)
+        return OK;
+    if (LoadStages == THREAD_LOAD_INIT)
+        return OK;
+    ThreadLoadingRestartFlag = true;
+
+    response.has_state = true;
+    response.state = THREAD_LOADING_STATE__ReadyForLoading;
+    response.errorreason = DefaultErrSrt;
+    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;
+    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((char*)container_buffer, container_size);
+
+    return OK;
+
+}
+
+uint32_t TryThreadLoadingFunc(MessageContainer* requestContainer)
+{
+    TryThreadLoadingResponse Cresponse = TRY_THREAD_LOADING_RESPONSE__INIT;
+    MessageContainer responseContainer;
+    //MessageState = 2;
+    ThreadLoadingReport();
+    Report("TryThreadLoadingFunc",__FILE__,__LINE__,MESSAGE_TYPE__TryThreadLoadingResponse,RpWarning,(int)LoadStages,0);
+
+    if (requestContainer)
+    {
+        responseContainer = createContainer(MESSAGE_TYPE__TryThreadLoadingResponse, requestContainer->token, true, &Cresponse, &try_thread_loading_response__pack, &try_thread_loading_response__get_packed_size);
+        responseContainer.continuous = false;
+        if (JobIsActive()||(MachineReadyForHeating == false)||(FPGABurningActive==true))
+        {
+            responseContainer.has_error = true;
+            responseContainer.error = ERROR_CODE__GENERAL_ERROR;
+            responseContainer.errormessage = "The machine is not ready for loading";
+        }
+        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((char*)container_buffer, container_size);
+    }
+
+    ThreadLoadButton(LoadStages);
+    return OK;
+}
+uint32_t ThreadUpdateCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+{
+
+    if(ThreadLoadingActive())
+        ThreadLoadingReport();
+    return OK;
+}
+
+uint32_t StartThreadLoadingFunc(MessageContainer* requestContainer)
+{
+    StartThreadLoadingRequest *request = start_thread_loading_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    ustrncpy (ThreadLoadingToken, requestContainer->token,36);
+    //MessageState = 1;
+    ThreadLoadControlId = AddControlCallback("ThreadLoad", ThreadUpdateCallBackFunction, 4* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
+    Report("StartThreadLoadingFunc",__FILE__,__LINE__,0,RpWarning,(int)LoadStages,0);
+    ThreadLoadingReport();
+    return OK;
+
+}
+
+uint32_t ContinueThreadLoadingFunc(MessageContainer* requestContainer)
+{
+    ContinueThreadLoadingRequest *request = continue_thread_loading_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    ContinueThreadLoadingResponse Cresponse = CONTINUE_THREAD_LOADING_RESPONSE__INIT;
+    MessageContainer responseContainer;
+    MessageState = 2;
+    ThreadLoadingReport();
+    if (ThreadLoadingRestartFlag == false)
+    {
+        if (request->processparameters)
+        {
+            dryerbufferlength = request->processparameters->dryerbufferlength;
+            LoadArmRounds = (int)(request->processparameters->dryerbufferlength);
+            windertension = request->processparameters->windertension;
+            pullertension = request->processparameters->pullertension;
+            memcpy (&ProcessParametersRecover,request->processparameters,sizeof(ProcessParameters));
+
+        }
+        Report("ContinueThreadLoadingFunc",__FILE__,__LINE__,(int)(request->processparameters->dryerbufferlength),RpWarning,(int)LoadStages,0);
+    }
+
+    responseContainer = createContainer(MESSAGE_TYPE__ContinueThreadLoadingResponse, requestContainer->token, true, &Cresponse, &continue_thread_loading_response__pack, &continue_thread_loading_response__get_packed_size);
+    responseContainer.continuous = false;
+    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((char*)container_buffer, container_size);
+    if (LoadStages == THREAD_LOAD_INITIAL_TENSION) //on this satge we should wait for user call
+    {
+        ThreadLoadStateMachine(LoadStages);
+    }
+    return OK;
+
+}
+uint32_t StopThreadLoadingFunc(MessageContainer* requestContainer)
+{
+    StopThreadLoadingRequest *request = stop_thread_loading_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    StopThreadLoadingResponse Cresponse = STOP_THREAD_LOADING_RESPONSE__INIT;
+    MessageContainer responseContainer;
+    MessageState = 2;
+    Thread_Load_End();
+    MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,numberOfCycles);
+    Report("StopThreadLoadingFunc",__FILE__,__LINE__,0xFF,RpWarning,(int)LoadStages,0);
+
+    responseContainer = createContainer(MESSAGE_TYPE__StopThreadLoadingResponse, requestContainer->token, true, &Cresponse, &stop_thread_loading_response__pack, &stop_thread_loading_response__get_packed_size);
+    responseContainer.continuous = false;
+    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((char*)container_buffer, container_size);
+    return OK;
+
+}
+uint8_t attemptJogCounter = 0;
+#define ATTEMPT_JOG_TIMEOUT 18
+char AttemptJoggingToken[36+1] = {0};
+
+uint32_t AttemptThreadJoggingCallback(uint32_t index, uint32_t ReadValue)
+{
+    AttemptThreadJoggingResponse response = ATTEMPT_THREAD_JOGGING_RESPONSE__INIT;
+    MessageContainer responseContainer;
+
+    attemptJogCounter++;
+    Report("AttemptThreadJoggingCallback",__FILE__,attemptJogCounter,JobEndReason,RpWarning,(int)JobIsActive(),0);
+    if (attemptJogCounter<ATTEMPT_JOG_TIMEOUT)
+    {
+        if (JobIsActive() == true)//jog still preparing/running
+            return OK;
+    }
+    if (JobEndReason == JOB_OK)
+        ThreadAbortJoggingFunc();
+    else
+    {
+        responseContainer.has_error = true;
+        responseContainer.error = getJobError_to_ErrorCode(JobEndReason);
+    }
+    SafeRemoveControlCallback(LoadingControlId, AttemptThreadJoggingCallback );
+    LoadingControlId = 0xFF;
+
+    if (AttemptJoggingToken[0])
+    {
+        responseContainer = createContainer(MESSAGE_TYPE__AttemptThreadJoggingResponse, AttemptJoggingToken, true, &response, &attempt_thread_jogging_response__pack, &attempt_thread_jogging_response__get_packed_size);
+        responseContainer.continuous = false;
+        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((char*)container_buffer, container_size);
+    }
+    return OK;
+
+}
+uint32_t AttemptThreadJoggingFunc(MessageContainer* requestContainer)
+{
+        attemptJogCounter = 0;
+        if(requestContainer)
+            ustrncpy (AttemptJoggingToken, requestContainer->token,36);
+        Report("AttemptThreadJoggingFunc",__FILE__,__LINE__,0xFF,RpWarning,(int)ATTEMPT_JOG_TIMEOUT,0);
+        LoadingControlId = AddControlCallback("Load jog",AttemptThreadJoggingCallback, eOneSecond,TemplateDataReadCBFunction,0,0,0);
+        ThreadJoggingFunc(30);
+        return OK;
+}
+