merge

1 files changed, 280 insertions, 1058 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index ffbb504db..c5cdb00d6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -16,9 +16,8 @@
 #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"
@@ -31,104 +30,64 @@
 #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
     {
-        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
+        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
         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,kval_upperValue;
+    int32_t keepkvalrun,keepkvalhold;
     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, 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 LoadingControlId = 0xFF,PullerControlId = 0xFF,WinderControlId = 0xFF;
     uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM LoadStages);
     uint32_t ThreadLoadControlCBFunction(uint32_t index, uint32_t ReadValue);
-    uint32_t ThreadLoadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue);
-    uint32_t ThreadUpdateCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
+    uint32_t Thread_Load_Dryer_UnLoading(void);
 
+    typedef struct
+    {
+        uint32_t LoadArmRounds;
+        uint32_t LoadArmBackLash;
+    }LoadArmInfoStruc;
+    LoadArmInfoStruc LoadArmInfo;
+    //char LoadArmPath[50] = "0://SysInfo//LoadArm.cfg";
 
-    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);
+    //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
     bool ThreadLoadingActive(void)
     {
         if ((LoadStages > THREAD_LOAD_INIT)&&(LoadStages < THREAD_LOAD_END))
@@ -136,46 +95,49 @@
         else
             return false;
     }
-    uint32_t Thread_Load_Init(THREAD_LOAD_STAGES_ENUM Stage)
+    uint32_t Thread_Load_Init(void)
     {
         //void* buffer = NULL;
         //uint32_t Bytes = 0;
         //FRESULT Fresult = FR_OK;
-        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Init");
-        load.color = BLINK;
-        LoadStatus = OK;
-        //LoadArmRounds = 0xFF;
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+
+        LoadArmInfo.LoadArmBackLash = 5;
+        //LoadArmInfo.LoadArmRounds = 0xFF;
         //EEPROM_STORAGE_DRYER_CYCLES
-        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
+        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);
 
-        Report("Read_Dryer_ENC_Position()",__FILE__,__LINE__,LoadArmRounds,RpWarning,Read_Dryer_ENC_Position(),0);
+        /*Fresult = f_mkdir(SW_INFO_DIR);
+        if ((Fresult == FR_OK)||(Fresult == FR_EXIST))
+        {
 
+            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();
-        if (Stage == THREAD_LOAD_INIT)
-        {
-            LoadStages++;
-            ThreadLoadStateMachine(LoadStages);
-        }
-        else
-        {
-            Report("Thread_Load_Init another state ",__FILE__,__LINE__,Stage,RpMessage,LoadArmRounds,0);
-        }
-        InitCalled = true;
+        LoadStages++;
+        ThreadLoadStateMachine(LoadStages);
 
         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 Thread_Load_Reduce_Heat");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step ");
         memcpy (&ProcessParametersClear,&ProcessParametersKeep,sizeof(ProcessParameters));
         ProcessParametersClear.dryerzone1temp = 0;
         ProcessParametersClear.dryerzone2temp = 0;
@@ -187,120 +149,122 @@
         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;
-        ProcessParametersClear.pullertension = ProcessParametersKeep.pullertension;
-        ProcessParametersClear.windertension = ProcessParametersKeep.windertension;
-
-        if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
+        if (HandleProcessParameters(&ProcessParametersClear)!= OK)
         {
-            LOG_ERROR (LoadStages, "Thread_Load_Reduce_Heat failed");
-            strcpy(LoadErrorMsg,"Thread_Load_Reduce_Heat failed");
-            load.color = fastBILNK;
-            LoadStatus = ERROR;
-            TryAgain = true;
-            //ThreadLoadButton(LoadStages);
+            LOG_ERROR (LoadStages, "Thread_Load_Init failed");
         }
         else
         {
-            if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
-            {
-                WHS_Set_SetPoint_Q_value(headairflow);
-            }
+            Turn_the_Blower_On();//Turn on with the Default_Voltage
+            if (BlowerCfg.heatingvoltage)
+                Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
             else
-            {
-                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_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_Stopper_OnError_Callback(uint32_t deviceID, uint32_t BusyFlag)
+    uint32_t Thread_Load_Set_Load_Arm_To_Start_Position_Callback(uint32_t deviceID, uint32_t BusyFlag)
     {
+       // Report("Thread Load State Machine Callback.",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
 
-        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);
+        /*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 );
 
+            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;
 
-        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)
+        if(PullerControlId != 0xFF)
         {
-            CallbackCounter--;
+            MotorStop(ThreadMotorIdToMotorId[POOLER_MOTOR],Hard_Hiz);
+            RemoveControlCallback(PullerControlId, ThreadLoadControlCBFunction );
+            PullerControlId = 0xFF;
         }
-        if (abs(angle)<10  ) // OK
+        if(WinderControlId != 0xFF)
         {
-            Report("Thread_Load_Set_Load_Arm_To_Stopper time",__FILE__,msec_millisecondCounter - UnloadingStart,msec_millisecondCounter,RpMessage,UnloadingStart,0);
-
-            Report("Thread_Load_Set_Load_Arm_To_Stopper_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
-            NumberOfDrierLoaderCycles=0;
-            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,0);
+            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);*/
 
-            //storeLoadArmParameters();
-            LoadStages++;
+        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
 
-            ThreadLoadStateMachine(LoadStages);
+        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);
         }
-        else
+        else //number of circles is not known - compare to position of the motor to verify location at the stopper
         {
-            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);
+            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);
 
-            LoadStatus = ERROR;
-            ThreadLoadingReport();
-            TryAgain = true;
-            //ThreadLoadButton(LoadStages);
         }
-//move to exact location?
-//        Report("Thread Load State Machine Callback.",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+        //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);
+
         return OK;
     }
+
     uint32_t Thread_Load_HomingCallback(uint32_t MotorId, uint32_t ReadValue)
     {
-        Report("Thread_Load_HomingCallback",__FILE__,MotorId,LoadStages,RpMessage,CallbackCounter,0);
+        Report("Thread_Load_HomingCallback",__FILE__,__LINE__,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);
             }
@@ -318,20 +282,12 @@
             {
                 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);
@@ -340,12 +296,6 @@
                     {
                         ThreadLoadStateMachine(LoadStages);
                     }
-                    else
-                    {
-                        load.color = colorON;
-                        Pannel_Leds(THREAD_LOAD, MODE_ON);
-                        ThreadLoadingReport();
-                    }
                 }
             }
         }
@@ -353,62 +303,38 @@
             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 Thread_Load_Open_Covers");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         //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);
-        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
-        }
+        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 0, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,4000);
         return OK;
     }
     uint32_t Thread_Load_Lift_Dancers(void)
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Lift_Dancers");
-        /*keepkvalhold = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].kvalhold;
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
+        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, 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);
-        }
+        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);
 
         return OK;
     }
@@ -417,24 +343,15 @@
     {
         keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
         keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
-        /*if (keepkvalrun>=25)
-            keepkvalrun = 25;*/
-
-        Report("Read_Dryer_ENC_Position()",__FILE__,__LINE__,0,RpWarning,Read_Dryer_ENC_Position(),0);
-
+        if (keepkvalrun>=25)
+            keepkvalrun = 25;
         Report("Thread_Load_Lift_Rockers",__FILE__,__LINE__,keepkvalrun,RpMessage,keepmicrostep,0);
 
-        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");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 8);
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 8);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, kval_upperValue);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, kval_upperValue);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
         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);
@@ -445,12 +362,10 @@
     }
     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 Thread_Load_Initial_Tension");
-        load.color = BLINK;
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         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++;
@@ -463,108 +378,57 @@
     {
         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, kval_upperValue);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, kval_upperValue);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
 
-        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Close_Rockers");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         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
     {
-        uint32_t  current = 1;
-        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Close_Dancers");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         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 Thread_Load_Close_Lids");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         //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);
-        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);
-            }
-        }
+        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 2, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,4000);
 
         return OK;
     }
     uint32_t Thread_Load_Resume_Heating(void)
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Resume_Heating");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         ActivateHeadMagnet();
-        HeadCard_Actuators_Relocate();
 
-        if (HandleProcessParameters(&ProcessParametersRecover,false)!= OK)
+        if (HandleProcessParameters(&ProcessParametersRecover)!= OK)
         {
-            usnprintf(LoadErrorMsg, 100, "Stage %s error",LoadStagesStr[LoadStages]);
-            Report(LoadErrorMsg,__FILE__,__LINE__,LoadStages,RpWarning,TimeoutsCounter,0);
+            LOG_ERROR (LoadStages, "Thread_Load_Resume_Heating failed");
         }
         else
         {
@@ -574,50 +438,15 @@
         }
         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 Thread_Load_Jog_Feeder_To_Middle_Point");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
-        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);
+        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);
         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);
@@ -628,20 +457,11 @@
             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
                 {
@@ -656,103 +476,43 @@
     }
     uint32_t Thread_Load_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue)
     {
-        numberOfCycles++;
-
-        Report("Thread_Load_Dryer_Loading_Callback",__FILE__,(int)TotalLoadedLen,(int)DrierPrevLocation,RpMessage,numberOfCycles,0);
-
-        if ((fabs (TotalLoadedLen  -DrierPrevLocation)>50  )&&(ReadValue == NOTBUSY))
-        {
-            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
+        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)
         {
-            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);
-        }
+            MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);
+            RemoveControlCallback(LoadingControlId, ThreadLoadControlCBFunction );
+            LoadingControlId = 0xFF;
+        }*/
+        MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Thread_Load_Dryer_MovetoEncoderPosition_Callback,10000);
         return OK;
     }
 
     uint32_t Thread_Load_Dryer_Loading(void)
     {
-        REPORT_MSG(LoadStages, "Thread Load State Machine step Thread_Load_Dryer_Loading");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
 
         if (dryerbufferlength)
-            LoadArmRounds = (int)dryerbufferlength;
-        if (LoadArmRounds <= 2)
-            LoadArmRounds = 30;
+            LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
+        //if (LoadArmInfo.LoadArmRounds <= 2)
+        //    LoadArmInfo.LoadArmRounds = 20;
+        float 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;
 
-        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;
+        MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmInfo.LoadArmRounds);
 
-        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*LoadArmInfo.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 = 0;//MotorsControl[FEEDER_MOTOR].integraltime;
+        MotorControlConfig[FEEDER_MOTOR].m_params.Ki = 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;
@@ -767,54 +527,42 @@
         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/6*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
-        //6 seconds per round
+        MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
 
         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-800,    Thread_Load_Dryer_Loading_Callback, 10000);
+                               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);
         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 Thread_Load_Jog_ThreadStop");
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         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 Thread_Load_Jog_Thread");
-        keepfeedertension = feedertension;
-        ProcessParametersKeep.feedertension = 0.0;
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         ThreadJoggingFunc(20);
-        LoadingControlId = AddControlCallback("Load jog",Thread_Load_Jog_ThreadStop, eOneSecond*25,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
+        LoadingControlId = AddControlCallback(NULL,Thread_Load_Jog_ThreadStop, eOneSecond*5,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);
@@ -833,18 +581,7 @@
             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);
@@ -852,194 +589,99 @@
         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_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;
-        }
-
+        MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Stop);
         LoadStages = THREAD_LOAD_INIT;
-        load.color = colorON;
-        Pannel_Leds(THREAD_LOAD, MODE_ON);
-        return OK;
-    }
-    uint32_t Thread_Load_switchCallback(uint32_t deviceID, uint32_t BusyFlag)
-    {
-        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)
+    uint32_t Thread_Load_Dryer_UnLoading(void)
     {
-        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);
+        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;
 
+        //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);
 
-            TimeoutsCounter = 0;
-            CallbackCounter = 0;
-            if(WinderControlId != 0xFF)
-            {
-                MotorStop(ThreadMotorIdToMotorId[WINDER_MOTOR],Hard_Hiz);
-                RemoveControlCallback(WinderControlId, ThreadLoadControlCBFunction );
-                WinderControlId = 0xFF;
-            }
+        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);
 
-            MotorAbortMovetoLimitSwitch(HARDWARE_MOTOR_TYPE__MOTO_SCREW);
+        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);
 
-            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;
+////////////////////////
+        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]);
 
         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;
 
-        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);
+        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);
 
         //Keep Notation How Many Rotations In The Dryer
-        //LoadArmRounds = (int)dryerbufferlength;
-         *
-         */
-        load.color = BLINK;
+        LoadArmInfo.LoadArmBackLash = 5;
+        LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
+        //FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
         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++;
-            MessageState = 1;
-
-            Thread_Load_Init(ReadValue);
+            Thread_Load_Init();
             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++;
@@ -1094,135 +736,37 @@
         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()||(MachineReadyForHeating == false)||(FPGABurningActive==true))
+    if (JobIsActive())
     {
         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);
-    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)
+    if (LoadStages > ReadValue)
     {
-        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;
-        }
+        ThreadLoadStateMachine(LoadStages+1);
     }
     else
     {
-        Report("Calling State machine status OK",__FILE__,ReadValue,LoadStatus,RpMessage,SecondTry,0);
-        //if (LoadStages > THREAD_LOAD_INITIAL_TENSION)
-        //    ThreadLoadingRestartReport();
-        ThreadLoadStateMachine(LoadStages);
-        SecondTry = false;
+        ThreadLoadStateMachine(ReadValue);
     }
     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
@@ -1242,11 +786,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;
@@ -1257,11 +801,6 @@ 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]++;
@@ -1274,7 +813,7 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 
     NormalizedError = avreageSampleValue*NormalizedErrorCoEfficient[index];
     MotorControlConfig[index].m_mesuredParam = NormalizedError;
-    MotorControlConfig[index].m_calculatedError = PIDAlgorithmCalculation((float)MotorControlConfig[index].m_SetParam , (float)MotorControlConfig[index].m_mesuredParam,
+    MotorControlConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation((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
     {
@@ -1286,37 +825,6 @@ 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)
     {
@@ -1324,33 +832,6 @@ 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
@@ -1364,16 +845,10 @@ 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;
-    if (request->hardwarepidcontrol1!=NULL)
-    {
-        UpdatePidDuringRun(request->hardwarepidcontrol1);
-    }
-    else
-    {
-        LoadStages = LoadStage;
-        ThreadLoadStateMachine(LoadStage);
-    }
+    LoadStages = LoadStage;
+    ThreadLoadStateMachine(LoadStage);
 
     /*if (status)
     {
@@ -1416,256 +891,3 @@ 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;
-}
-