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

5 files changed, 143 insertions, 89 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 5a1bb9063..c5cdb00d6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -29,6 +29,7 @@
 #include "drivers/I2C_Communication/DAC/Blower.h"
 #include "drivers/SSI_Comm/Dancer/Dancer.h"
 #include "drivers/motors/motor.h"
+#include "drivers/Flash_ram/MCU_E2Prom.h"
 
 #include "PMR/Stubs/StubHeatingTestRequest.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestResponse.pb-c.h"
@@ -78,7 +79,7 @@
         uint32_t LoadArmBackLash;
     }LoadArmInfoStruc;
     LoadArmInfoStruc LoadArmInfo;
-    char LoadArmPath[50] = "0://SysInfo//LoadArm.cfg";
+    //char LoadArmPath[50] = "0://SysInfo//LoadArm.cfg";
 
     //RUN MOTOR TO SWITCH WITH TIMEOUT
     //RUN MOTOR TO BREAK SENSOR
@@ -96,14 +97,21 @@
     }
     uint32_t Thread_Load_Init(void)
     {
-        void* buffer = NULL;
-        uint32_t Bytes = 0;
-        FRESULT Fresult = FR_OK;
+        //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;
-        Fresult = f_mkdir(SW_INFO_DIR);
+        //LoadArmInfo.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);
+
+        /*Fresult = f_mkdir(SW_INFO_DIR);
         if ((Fresult == FR_OK)||(Fresult == FR_EXIST))
         {
 
@@ -114,9 +122,9 @@
                    memcpy (&LoadArmInfo,buffer,sizeof(LoadArmInfo));
                free (buffer);
             }
-        }
+        }*/
 
-        Report("Thread_Load_Init",__FILE__,__LINE__,LoadArmInfo.LoadArmBackLash,RpMessage,LoadArmInfo.LoadArmRounds,0);
+        Report("Thread_Load_Init",__FILE__,__LINE__,LoadArmInfo.LoadArmRounds,RpMessage,LoadArmInfo.LoadArmRounds,0);
         StopInitSequence();
         memcpy (&ProcessParametersRecover,&ProcessParametersKeep,sizeof(ProcessParameters));
         //NumberOfDrierLoaderCycles = loadLoadArmParameters();
@@ -175,6 +183,8 @@
         {
             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);
@@ -228,7 +238,7 @@
         }
         else //number of circles is not known - compare to position of the motor to verify location at the stopper
         {
-            Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,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);
 
@@ -251,6 +261,15 @@
     {
         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))
+            {
+                MotorSetMicroStep(MotorId, keepmicrostep);
+                MotorSetKvalRun(MotorId, keepkvalrun);
+            }
+        }
+
         if (CallbackCounter)
         {
             CallbackCounter--;
@@ -269,13 +288,6 @@
                 else
                 {
                     LoadStages++;
-                    if (LoadStages == THREAD_LOAD_CLOSE_ROCKERS)
-                    {
-                        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING,  keepmicrostep);
-                        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, keepmicrostep);
-                        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, keepkvalrun);
-                        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, keepkvalrun);
-                    }
                     if (LoadStages == THREAD_LOAD_CLOSE_DANCERS)
                     {
                         MotorSetKvalHold(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, keepkvalhold);
@@ -322,7 +334,7 @@
         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);
         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);
+        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;
     }
@@ -331,6 +343,10 @@
     {
         keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
         keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+        if (keepkvalrun>=25)
+            keepkvalrun = 25;
+        Report("Thread_Load_Lift_Rockers",__FILE__,__LINE__,keepkvalrun,RpMessage,keepmicrostep,0);
+
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 8);
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 8);
@@ -350,7 +366,7 @@
         if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
         {
             REPORT_MSG(LIMIT, "No cone in winder");
-            return ERROR;
+            //return ERROR;
         }
         CallbackCounter++;
         MotorMovetoBreakSensor (HARDWARE_MOTOR_TYPE__MOTO_WINDER,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].directionthreadwize, 500,  Thread_Load_HomingCallback,10000);
@@ -360,6 +376,17 @@
     }
     uint32_t Thread_Load_Close_Rockers(void)
     {
+        keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
+        keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+        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);
+
         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);
@@ -376,7 +403,7 @@
         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, 500,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
+        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);
 
         return OK;
     }
@@ -464,15 +491,19 @@
     uint32_t Thread_Load_Dryer_Loading(void)
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
-        LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
-        if (LoadArmInfo.LoadArmRounds <= 2)
-            LoadArmInfo.LoadArmRounds = 20;
+
+        if (dryerbufferlength)
+            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_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmInfo.LoadArmRounds);
+
         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;
@@ -498,7 +529,7 @@
 
         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(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
+        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);
         CallbackCounter++;
         Report("Thread_Load_Dryer_Loading",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
@@ -507,7 +538,7 @@
 
         //Keep Notation How Many Rotations In The Dryer
         //LoadArmInfo.LoadArmBackLash = 0;
-        LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
+        //LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
         //FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
         return OK;
     }
@@ -526,7 +557,7 @@
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
         ThreadJoggingFunc(20);
-        LoadingControlId = AddControlCallback(Thread_Load_Jog_ThreadStop, eOneSecond*5,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)
@@ -592,7 +623,7 @@
         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(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+POOLER_MOTOR),POOLER_DANCER,POOLER_MOTOR);
+        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;
@@ -614,7 +645,7 @@
         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);
 
-        WinderControlId = AddControlCallback(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+WINDER_MOTOR),WINDER_DANCER,WINDER_MOTOR);
+        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);
 
 ////////////////////////
@@ -631,9 +662,9 @@
                                         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
-        //LoadArmInfo.LoadArmBackLash = 0;
+        LoadArmInfo.LoadArmBackLash = 5;
         LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
-        FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
+        //FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
         return OK;
     }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 9d57cd29f..a93387e0a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -547,7 +547,7 @@ uint32_t Winder_Presegment(void *SegmentDetails, uint32_t SegmentId)
    }
     if (SegmentId == 0)
     {
-            ScrewControlId = AddControlCallback(Screw100msecDirectionChange, eHundredMillisecond,TemplateDataReadCBFunction,0,0,0);
+            ScrewControlId = AddControlCallback("screw control",Screw100msecDirectionChange, eHundredMillisecond,TemplateDataReadCBFunction,0,0,0);
     }
     PreSegmentReady(Module_Winder,ModuleDone);
 
@@ -583,7 +583,7 @@ uint32_t WinderDistanceToSpoolState(void )
     double DTS_Time = (dryerbufferCentimeters/dyeingspeed)*1000;//distance to spool time in milliseconds
     REPORT_MSG ((int)DTS_Time,"WinderDistanceToSpoolState");
 
-    ScrewDTSControlId = AddControlCallback(ScrewDTSCallback, DTS_Time-WinderBackToBaseTime,TemplateDataReadCBFunction,0,0,0);
+    ScrewDTSControlId = AddControlCallback("screw DTS",ScrewDTSCallback, DTS_Time-WinderBackToBaseTime,TemplateDataReadCBFunction,0,0,0);
     REPORT_MSG ((int)msec_millisecondCounter,"ScrewDTSCallback start");
 
     return OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 99117ca5d..29876549e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -50,22 +50,22 @@ uint32_t Winder_End(void);
 
 typedef enum
 {
-    /*01*/ THREAD_LOAD_INIT,
-    /*02*/ THREAD_LOAD_REDUCE_HEAT,  //HEATERS OFF, DRYER BLOWER OFF, BLOWER LOW,
-    /*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_LIFT_ROCKERS, //MACHINE IS READY. SEND MESSAGE, START TIMER TO CLOSE LIDS, WAIT FOR OPERATOR RESPONSE
-    /*07*/ THREAD_LOAD_INITIAL_TENSION,//CHECK SPOOL PRESENCERUN WINDER UNTIL BREAK SENSOR IS IDENTIFIEING MOVEMENT FOR A SECOND
-    /*08*/ THREAD_LOAD_CLOSE_ROCKERS,
-    /*09*/ THREAD_LOAD_CLOSE_DANCERS, //SEND DANCER MOTORS TO PRESET LOCATION, CHECK THAT THE DANCERS ARE ON THE THREAD
-    /*10*/ THREAD_LOAD_CLOSE_LIDS,
-    /*11*/ THREAD_LOAD_JOG_FEEDER_TO_MIDDLE_POINT,//JOG THE FEEDER MOTOR UNTIL THE FEEDER DANCER IS AT MIDDLE POSITION
-    /*12*/ THREAD_LOAD_DRYER_LOADING, //START FEEDER PID, ROTATE LOADING ARM COUNTER THREAD DIRECTION X CIRCLES ACCORDING TO RML. FEEDER SPEED IS 40
+    /*00*/ THREAD_LOAD_INIT,
+    /*01*/ THREAD_LOAD_REDUCE_HEAT,  //HEATERS OFF, DRYER BLOWER OFF, BLOWER LOW,
+    /*02*/ THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION,//USE NOTATION HOW MANY ROTATIONS IN THE DRYER, OR CHECK AGAINST STOPPER. MOVE SLOWLY
+    /*03*/ THREAD_LOAD_OPEN_COVERS,  //OPEN DYEING HEAD COVER AND DRYER LID
+    /*04*/ THREAD_LOAD_LIFT_DANCERS,
+    /*05*/ THREAD_LOAD_LIFT_ROCKERS, //MACHINE IS READY. SEND MESSAGE, START TIMER TO CLOSE LIDS, WAIT FOR OPERATOR RESPONSE
+    /*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
-    /*13*/ THREAD_LOAD_RESUME_HEATING,
-    /*14*/ THREAD_LOAD_JOG_THREAD, //JOG THREAD SHORTLY TO MAKE SURE SPOOL IS RUNNING. REPORT END OF LOADING
-    /*15*/ THREAD_LOAD_END
+    /*12*/ THREAD_LOAD_RESUME_HEATING,
+    /*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;
 uint32_t ThreadLoadButton(THREAD_LOAD_STAGES_ENUM ReadValue);
 bool ThreadLoadingActive(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index 8c42735cb..416b53494 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -148,12 +148,13 @@ char DancerConfigPath[50] = "0://SysInfo//DancCfg.cfg";
 
 uint32_t StoreDancerConfigMessage()
 {
-    FRESULT Fresult = FR_OK;
-    HardwareConfiguration DancerConfig;
-    HardwareDancer Dancers[MAX_SYSTEM_DANCERS];
-    uint8_t* response_buffer;
-    size_t response_size = 0;
-    int Dancer_i;
+    uint32_t status = OK;
+  /*  FRESULT Fresult = FR_OK;
+  //  HardwareConfiguration DancerConfig;
+  //  HardwareDancer Dancers[MAX_SYSTEM_DANCERS];
+  //  uint8_t* response_buffer;
+  //  size_t response_size = 0;
+  //  int Dancer_i;
 
     hardware_configuration__init(&DancerConfig);
     DancerConfig.dancers = (HardwareDancer**)my_malloc(sizeof(HardwareDancer*)*MAX_SYSTEM_DANCERS);
@@ -168,11 +169,12 @@ uint32_t StoreDancerConfigMessage()
         DancerConfig.n_dancers++;
         DancersCfg[Dancer_i].zeropoint = DancerConfig.dancers[Dancer_i]->zeropoint;
     }
-    MCU_E2PromProgram(EEPROM_STORAGE_DANCER_0,DancersCfg[0].zeropoint);
-    MCU_E2PromProgram(EEPROM_STORAGE_DANCER_1,DancersCfg[1].zeropoint);
-    MCU_E2PromProgram(EEPROM_STORAGE_DANCER_2,DancersCfg[2].zeropoint);
+    */
+    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_0,DancersCfg[0].zeropoint);
+    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_1,DancersCfg[1].zeropoint);
+    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_2,DancersCfg[2].zeropoint);
     Report("Store eeprom 0",__FILE__,DancersCfg[0].zeropoint,(int)DancersCfg[1].zeropoint,RpWarning,(int)DancersCfg[2].zeropoint,0);
-
+/*
     response_buffer = my_malloc(hardware_configuration__get_packed_size(&DancerConfig));
     if (response_buffer)
     {
@@ -187,43 +189,23 @@ uint32_t StoreDancerConfigMessage()
 
 
     my_free(response_buffer);
-
-    return Fresult;
+*/
+    return status;
 }
 uint32_t LoadDancerConfigMessage()
 {
-    void* buffer = NULL;
-    uint32_t Bytes = 0;
-    FRESULT Fresult = FR_OK;
-
-    HardwareConfiguration *DancerConfig;
-    int Dancer_i;
-    HardwareDancer DancersCfg1[MAX_SYSTEM_DANCERS] = {0};
-    HardwareDancer DancersCfg2[MAX_SYSTEM_DANCERS] = {0};
+    uint32_t status = OK;
 
-    memcpy(DancersCfg1,(void *)DANCERS_MAP_IN_FLASH,sizeof(DancersCfg1));
-
-    Fresult = FileRead(DancerConfigPath, &Bytes, &buffer);
-    if (Fresult == FR_OK)
-    {
-        DancerConfig = hardware_configuration__unpack(NULL, Bytes, buffer);
-        for (Dancer_i = 0; Dancer_i < DancerConfig->n_dancers ; Dancer_i++)
-        {
-            DancersCfg2[Dancer_i].zeropoint = DancerConfig->dancers[Dancer_i]->zeropoint;
-        }
-        hardware_configuration__free_unpacked(DancerConfig,NULL);
-        free (buffer);
-    }
     MCU_E2PromRead(EEPROM_STORAGE_DANCER_0,&DancersCfg[0].zeropoint);
     MCU_E2PromRead(EEPROM_STORAGE_DANCER_1,&DancersCfg[1].zeropoint);
     MCU_E2PromRead(EEPROM_STORAGE_DANCER_2,&DancersCfg[2].zeropoint);
 
 
-    Report("Dancer 0 Store data flash, internal flash, eeprom ",__FILE__,DancersCfg[0].zeropoint,(int)DancersCfg1[0].zeropoint,RpWarning,(int)DancersCfg2[0].zeropoint,0);
-    Report("Dancer 1 Store data flash, internal flash, eeprom ",__FILE__,DancersCfg[1].zeropoint,(int)DancersCfg1[1].zeropoint,RpWarning,(int)DancersCfg2[1].zeropoint,0);
-    Report("Dancer 2 Store data flash, internal flash, eeprom ",__FILE__,DancersCfg[2].zeropoint,(int)DancersCfg1[2].zeropoint,RpWarning,(int)DancersCfg2[2].zeropoint,0);
+    status |= Report("Dancer 0 Store data eeprom ",__FILE__,__LINE__,0,RpWarning,(int)DancersCfg[0].zeropoint,0);
+    status |= Report("Dancer 1 Store data eeprom ",__FILE__,__LINE__,1,RpWarning,(int)DancersCfg[1].zeropoint,0);
+    status |= Report("Dancer 2 Store data eeprom ",__FILE__,__LINE__,2,RpWarning,(int)DancersCfg[2].zeropoint,0);
 
-    return Fresult;
+    return status;
 
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 47fc37081..41d98e892 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -49,6 +49,7 @@ uint32_t    PoolerSpeedControlId=0xFF;
 
 double DancerError[NUM_OF_DANCERS] = {0.0};
 double OriginalMotorSpd_2PPS[MAX_THREAD_MOTORS_NUM] = {0};
+double InitialDryerSpeed = 0.0;
 uint32_t JobCounter = 0;
 
 MotorControlConfig_t MotorControlConfig[MAX_THREAD_MOTORS_NUM];
@@ -731,6 +732,20 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
 
     MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, Hard_Stop);
 
+    if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) != LIMIT)
+    {
+        ReportWithPackageFilter(ThreadFilter,"Dyeing head is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpFatalError,LIMIT,0);
+        JobEndReason = JOB_LIDS_OPEN;
+        PrepareReady(Module_Thread,ModuleFail);
+        return ERROR;
+    }
+    if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID]) != LIMIT)
+    {
+        ReportWithPackageFilter(ThreadFilter,"Dryer lid is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,RpFatalError,LIMIT,0);
+        JobEndReason = JOB_LIDS_OPEN;
+        PrepareReady(Module_Thread,ModuleFail);
+        return ERROR;
+    }
 
     //start thread control for all motors
     for (Motor_i = 0;Motor_i < MAX_THREAD_MOTORS_NUM;Motor_i++)
@@ -767,7 +782,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                 }
                 //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
                 LengthCalculationMultiplier = (MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulleyradius*2*PI)/(MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulseperround*MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].microstep);
-                SpeedControlId = AddControlCallback(ThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
+                SpeedControlId = AddControlCallback(NULL,ThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
             }
             if (Motor_i == POOLER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
             {
@@ -780,7 +795,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                 }
                 //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
                 PoolerLengthCalculationMultiplier = (MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulleyradius*2*PI)/(MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulseperround*MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].microstep);
-                PoolerSpeedControlId = AddControlCallback(PoolerThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
+                PoolerSpeedControlId = AddControlCallback(NULL,PoolerThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
             }
             if (Motor_i == FEEDER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
             {
@@ -792,8 +807,8 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                     CurrentControlledSpeed[Motor_i] = 0;
                 }
 #ifndef TEST_PID_THREAD
-                ControlIdtoMotorId[Motor_i] = AddControlCallback(ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
-                //AddControlCallback(ThreadControlSpeedReadFunction, eHundredMillisecond,MotorGetSpeedFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
+                ControlIdtoMotorId[Motor_i] = AddControlCallback(NULL,ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
+                //AddControlCallback(NULL,ThreadControlSpeedReadFunction, eHundredMillisecond,MotorGetSpeedFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
 #endif
             }
             if (Motor_i == POOLER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will n//ot be controlled
@@ -806,7 +821,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                     ControlIdtoMotorId[Motor_i] = 0xFF;
                 }
 #ifndef TEST_PID_THREAD
-                ControlIdtoMotorId[Motor_i] = AddControlCallback(ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
+                ControlIdtoMotorId[Motor_i] = AddControlCallback(NULL,ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
 #endif
             }
             if (Motor_i == WINDER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will n//ot be controlled
@@ -820,7 +835,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                     ControlIdtoMotorId[Motor_i] = 0xFF;
                 }
 #ifndef TEST_PID_THREAD
-                ControlIdtoMotorId[Motor_i] = AddControlCallback(ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
+                ControlIdtoMotorId[Motor_i] = AddControlCallback(NULL,ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
 #endif
             }
 //            if (HW_Motor_Id == HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
@@ -852,6 +867,7 @@ void SetOriginMotorSpeed(float process_speed)
                 / (2 * PI * MotorsCfg[HW_Motor_Id].pulleyradius);
         //MotorControlConfig[Motor_i].m_SetParam = motor_speed;
         OriginalMotorSpd_2PPS[Motor_i] = (int) motor_speed;
+        InitialDryerSpeed = 0.0;
         CurrentControlledSpeed[Motor_i] = (int) motor_speed;
         //Report("Original Speed",__FILE__,Motor_i,motor_speed,RpWarning,process_speed,0);
 
@@ -865,6 +881,25 @@ void ThreadPreSegmentEnded(void)
     REPORT_MSG (0,"First ThreadPreSegmentEnded");
     PreSegmentReady(Module_Thread,ModuleDone);
 }
+#define DRYER_RAMPUP 1
+#ifdef DRYER_RAMPUP
+uint32_t ThreadDryerRampUp(uint32_t IfIndex, uint32_t BusyFlag)
+{
+    InitialDryerSpeed += (OriginalMotorSpd_2PPS[DRYER_MOTOR]/10);
+    if (InitialDryerSpeed >= OriginalMotorSpd_2PPS[DRYER_MOTOR])
+    {
+        InitialDryerSpeed = OriginalMotorSpd_2PPS[DRYER_MOTOR];
+        SafeRemoveControlCallback(ControlIdtoMotorId[DRYER_MOTOR], ThreadDryerRampUp );
+        ControlIdtoMotorId[DRYER_MOTOR] = 0xFF;
+    }
+
+    MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,InitialDryerSpeed );
+    Report("ThreadDryerRampUp",__FILE__,ControlIdtoMotorId[DRYER_MOTOR],(int)InitialDryerSpeed,RpWarning,(int)OriginalMotorSpd_2PPS[DRYER_MOTOR],0);
+
+
+    return OK;
+}
+#endif
 
 //********************************************************************************************************************
 uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
@@ -886,7 +921,13 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
         PrepareState = false;
 #ifndef TEST_PID_THREAD
         // set the new speed in the dryer motor to the speed of the new segment
+#ifndef DRYER_RAMPUP
         MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING, OriginalMotorSpd_2PPS[DRYER_MOTOR]);
+#else
+        InitialDryerSpeed = OriginalMotorSpd_2PPS[DRYER_MOTOR]/10;
+        MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,InitialDryerSpeed );
+        ControlIdtoMotorId[DRYER_MOTOR] = AddControlCallback("DryerRampUp",ThreadDryerRampUp, 200,TemplateDataReadCBFunction,0,0,0);
+#endif
 #endif
 #ifdef HUNDRED_MICROSECONDS_DANCER_READ
      MillisecLogInit();