for version 1.4.2.7 : syc file system with semaphore (needs testing!). add secondary pump and activation on init and after 8 hours.now config parameters, improved thread load

10 files changed, 128 insertions, 56 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index e3955793d..063d7c823 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -492,6 +492,8 @@ void setRapidPressureRead(bool value)
 {
     RapidPressureRead = value;
 }
+
+uint16_t PumpCounter = 0;
 uint32_t MillisecLowLoop(uint32_t tick)
 {
     uint8_t Motor_i,Disp_i,Heater_i,temp;
@@ -501,13 +503,14 @@ uint32_t MillisecLowLoop(uint32_t tick)
     //call all modules Millisec functions
     //test dancers and speed encoders
     //check all callback units (state machine waiting for completion of a change)
-    bool Ten_msTick, Hundred_msTick , m90msecTick, Onesecond_Tick,O900Millisecond_Tick,OneMinute_Tick;
+    bool Ten_msTick, Hundred_msTick , m90msecTick, Onesecond_Tick,O900Millisecond_Tick,OneMinute_Tick,OneHourTick;
     Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
     Hundred_msTick  =   (tick%eHundredMillisecond == 0)  ?true:false;
     m90msecTick  =   (tick%eHundredMillisecond == 90)  ?true:false;
     O900Millisecond_Tick  =   (tick%eOneSecond == 900)           ?true:false;
     Onesecond_Tick  =   (tick%eOneSecond == 0)           ?true:false;
     OneMinute_Tick  =   (tick%eOneMinute == 0)           ?true:false;
+    OneHourTick  =   (tick%eOneHour == 0)           ?true:false;
     //gather Motor data from FPGA
     //ROM_IntMasterDisable();
 
@@ -611,6 +614,16 @@ uint32_t MillisecLowLoop(uint32_t tick)
                 MotorGetStatusFromFPGA(Motor_i);
         }*/
     }
+    if (OneHourTick)
+    {
+#define PUMP_LIMIT 8
+        PumpCounter++;
+        if (PumpCounter>=PUMP_LIMIT)
+        {
+            PumpActivation(900);
+            PumpCounter = 0;
+        }
+    }
     //ROM_IntMasterEnable();
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index f8a57362a..4597efa93 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -268,6 +268,9 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
             else
                 Lubricant_2Way_Valve(STOP);//use START or STOP,  0 - 100%();
             break;
+        case INTERFACE_IOS__GPO_TFEED_BREAK_1:
+                Pumps_Control(WASTECH_PUMP2, request->value);
+            break;
         default:
             responseContainer.has_error = true;
             responseContainer.error = ERROR_CODE__GENERAL_ERROR;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index a22bfc815..98e760b32 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -115,7 +115,7 @@ DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS];
 HeaterState **heatersstates;
 HeaterState  HeaterInfo[HEATER_TYPE__MixerHeater+1];
 DigitalInterfaceState **digitalinterfacestates;
-DigitalInterfaceState DigitalOutputState[MAX_HEATERS_NUM+9];
+DigitalInterfaceState DigitalOutputState[MAX_HEATERS_NUM+10];
 /*double dispenser1motorfrequency[DIAGNOSTICS_LIMIT+1];
 double dispenser2motorfrequency[DIAGNOSTICS_LIMIT+1];
 double dispenser3motorfrequency[DIAGNOSTICS_LIMIT+1];
@@ -390,7 +390,7 @@ void Diagnostic100msecCollection(void)
         dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
         MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
         //MidTankpressure[i][0] = IDS_Dispenser_Data[i].totalconsumedinnanolitter;
-		MidTankpressure[i][0] = IDS_Dispenser_Data[i].consumedinnanolitter;
+		MidTankpressure[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
     }
 #ifndef REDUCED_DIAGNOSTICS
     for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 52f4a3447..7e6ce928a 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -459,7 +459,7 @@ uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
     ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, 4,&DataLen);
     ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH+4, DataLen, requestContainer->data.data);
 
-    FileWrite(requestContainer->data.data, requestContainer->data.len,HwConfigPath);
+    FileWrite(requestContainer->data.data, requestContainer->data.len,HwConfigPath,BIOS_WAIT_FOREVER);
 
     UploadHardwareConfigurationRequest* UploadRequest = upload_hardware_configuration_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
index 1c719d778..52f717626 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
@@ -538,14 +538,14 @@ uint32_t LoadStatMachine( button *pBtn)
     {
         case sttRDY :
             REPORT_MSG(parameter," ------------ load.state = sttRDY    ----------------- ");
-            switch (pBtn->Action)
+/*            switch (pBtn->Action)
             {
                 case (SHORTPB):
                 case (LONGPB):
                 case (REPLONGPB):
                     pBtn->state = sttPRELOAD;
-                    pBtn->color =  BLINK;
-                    if (ThreadLoadStateMachine( THREAD_LOAD_INIT))
+                    pBtn->color =  BLINK;*/
+                    if (ThreadLoadButton( THREAD_LOAD_INIT))
                     {
                         pBtn->state = sttPRELOAD ;    // to do
                         pBtn->color =  BLUE;
@@ -553,41 +553,54 @@ uint32_t LoadStatMachine( button *pBtn)
                     }
                     else
                     {
-                        pBtn->state = sttDISABLE ;
+                       // pBtn->state = sttDISABLE ;
                         Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+
                     }
-                    break;
+                    /*break;
                 default :
                     break;
-            }
+            }*/
             break;
         case sttPRELOAD:
             REPORT_MSG(parameter," ------------ load.state = sttPRELOAD    ----------------- ");
-            switch (pBtn->Action)
+            /*switch (pBtn->Action)
             {
                 case (SHORTPB):
                 case (LONGPB):
                 case (REPLONGPB):
                     pBtn->color =  BLUE;
-                    Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
-                    if (ThreadLoadStateMachine( THREAD_LOAD_INITIAL_TENSION))
+                    Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+*/
+                    if (ThreadLoadButton( THREAD_LOAD_INITIAL_TENSION))
                     {
-                        pBtn->state = sttLOADSUCSESS ;    // to do
+                        pBtn->state = sttRDY ;    // to do
                         pBtn->color =  BLUE;
                         Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                     }
                     else
                     {
-                        pBtn->state = sttLOADFAIL ;
+                        //pBtn->state = sttLOADFAIL ;
                         pBtn->color = fastBILNK ;    // to do
                     }
-                    break;
+                    /*break;
                 default :
                     break;
-            }
+            }*/
             break;
         case sttLOADING:
             REPORT_MSG(parameter," ------------ load.state = sttLOADING    ----------------- ");
+            pBtn->color =  fastBILNK;
+            Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
+            if (ThreadLoadButton( THREAD_LOAD_END))
+            {
+                pBtn->state = sttRDY ;    // to do
+                pBtn->color =  BLUE;
+                Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
+            }
+            else
+            {
+                //pBtn->state = sttLOADFAIL ;
+                pBtn->color = fastBILNK ;    // to do
+            }
             break;
 //        case sttLOADSUCSESS ?????
 //            break;
@@ -596,7 +609,8 @@ uint32_t LoadStatMachine( button *pBtn)
 
         default: //sttDISABLE
             REPORT_MSG(parameter," ------------ load.state = default    ----------------- ");
-            pBtn->color =  colorOFF;
+            pBtn->state = sttRDY ;    // to do
+            pBtn->color =  BREATHING;
             Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+
             break;
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index b968381c6..2c8788bdc 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -191,7 +191,7 @@ void ProcessRequestFunc(MessageContainer* requestContainer)
     ProcessParameters*  ProcessParams = request->processparameters;
     if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
     {
-        FileWrite(requestContainer->data.data, requestContainer->data.len,ProcessParamsConfigPath);
+        FileWrite(requestContainer->data.data, requestContainer->data.len,ProcessParamsConfigPath,BIOS_WAIT_FOREVER);
         Bytes = sizeof(ProcessParameters);
         EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH,Bytes+4);
         ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 6d7f0df96..88032f756 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -298,7 +298,7 @@ uint32_t IDS_Dispenser_Store_Data (void)
     ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH, 4,&response_size);
     ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH+4, response_size, IDS_Dispenser_Data);
 
-    Status = FileWrite(IDS_Dispenser_Data,response_size,DispenserStorePath);
+    Status = FileWrite(IDS_Dispenser_Data,response_size,DispenserStorePath,BIOS_NO_WAIT);
     DispenserDataUpdated = false;
     REPORT_MSG(msec_millisecondCounter - timing, "Updating dispensers file - time");
     return Status;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 837221274..366f4b163 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -45,18 +45,24 @@
         5 THREAD_LOAD_LIFT_DANCERS,
         6 THREAD_LOAD_LIFT_ROCKERS,                          //MACHINE IS READY. SEND MESSAGE, START TIMER TO CLOSE LIDS, WAIT FOR OPERATOR RESPONSE
         7 THREAD_LOAD_INITIAL_TENSION,                       //CHECK SPOOL PRESENCERUN WINDER UNTIL BREAK SENSOR IS IDENTIFIEING MOVEMENT FOR A SECOND
-        8 THREAD_LOAD_CLOSE_ROCKERS,
         9 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_RESUME_HEATING,
-        12 THREAD_LOAD_JOG_FEEDER_TO_MIDDLE_POINT,           //JOG THE FEEDER MOTOR UNTIL THE FEEDER DANCER IS AT MIDDLE POSITION
-        13 THREAD_LOAD_DRYER_LOADING,                        //START FEEDER PID, ROTATE LOADING ARM COUNTER THREAD DIRECTION X CIRCLES ACCORDING TO RML. FEEDER SPEED IS 40
+        12 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
+        8 THREAD_LOAD_CLOSE_ROCKERS,
+        11 THREAD_LOAD_JOG_FEEDER_TO_MIDDLE_POINT,           //JOG THE FEEDER MOTOR UNTIL THE FEEDER DANCER IS AT MIDDLE POSITION
+        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
     }THREAD_LOAD_STAGES_ENUM;*/
     THREAD_LOAD_STAGES_ENUM LoadStages = THREAD_LOAD_INIT;
     ProcessParameters ProcessParametersClear,ProcessParametersRecover;
+
+    int32_t keepmicrostep;
+    int32_t keepkvalrun;
+    uint8_t CallbackCounter = 0;
+    uint8_t TimeoutsCounter = 0;
+
     uint8_t NumberOfDrierLoaderCycles = 0;
     uint32_t status = OK;
     uint32_t ControlId = 0xFF,PullerControlId = 0xFF,WinderControlId = 0xFF;
@@ -163,7 +169,7 @@
         }
         else*/
         {
-            Report("Thread_Load_Set_Load_Arm_To_Start_Position_Callback",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+            Report("Thread_Load_Set_Load_Arm_To_Start_Position_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
             //storeLoadArmParameters();
             SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
             LoadStages++;
@@ -173,6 +179,7 @@
     }
     uint32_t Thread_Load_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_t BusyFlag)
     {
+
         if(PullerControlId != 0xFF)
         {
             MotorStop(ThreadMotorIdToMotorId[POOLER_MOTOR],Hard_Hiz);
@@ -192,7 +199,8 @@
         MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,Hard_Hiz);
 
 //        Report("Thread Load State Machine Callback.",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
-        Report("Thread_Load_Set_Load_Arm_To_Stopper_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++;
@@ -224,13 +232,11 @@
         //Use Notation How Many Rotations In The Drier, Or Check Against Stopper. Move Slowly
         return OK;
     }
-    uint8_t CallbackCounter = 0;
-    uint8_t TimeoutsCounter = 0;
 
     uint32_t Thread_Load_HomingCallback(uint32_t MotorId, uint32_t ReadValue)
     {
-        Report("Thread Load State Machine Callback.",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
-        REPORT_MSG(MotorId, "Thread_Load_HomingCallback Motor Id");
+        Report("Thread_Load_HomingCallback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+//        REPORT_MSG(MotorId, "Thread_Load_HomingCallback Motor Id");
         if (CallbackCounter)
         {
             CallbackCounter--;
@@ -249,12 +255,12 @@
                 else
                 {
                     LoadStages++;
-                    if (LoadStages == THREAD_LOAD_LIFT_ROCKERS)
+                    if (LoadStages == THREAD_LOAD_CLOSE_ROCKERS)
                     {
-                        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING,  MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep);
-                        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING,  MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].microstep);
-                        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep);
-                        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].microstep);
+                        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_INITIAL_TENSION) //on this stage we should wait for user call
                     {
@@ -303,16 +309,18 @@
     uint32_t Thread_Load_Lift_Rockers(void)
     //Machine Is Ready. Send Message, Start Timer To Close Lids, Wait For Operator Response
     {
+        keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
+        keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
-        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 1);
-        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 1);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 35);
-        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 35);
+        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 2);
+        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 2);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
         Task_sleep(10);
         CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 50,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,25000);
+        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 400,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,20000);
         CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LLOADING,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize, 50,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LLOADING], Thread_Load_HomingCallback,25000);
+        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LLOADING,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize, 400,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LLOADING], Thread_Load_HomingCallback,20000);
 
         return OK;
     }
@@ -334,9 +342,9 @@
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 300,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,12000);
+        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 300,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,20000);
         CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize, 300,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LLOADING], Thread_Load_HomingCallback,12000);
+        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize, 300,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LLOADING], Thread_Load_HomingCallback,20000);
 
         return OK;
     }
@@ -388,7 +396,7 @@
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
-        MotorMovetoDancerPosition (HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize, 200, FEEDER_DANCER ,true, Thread_Load_HomingCallback,10000);
+        MotorMovetoDancerPosition (HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize, 100, FEEDER_DANCER ,true, Thread_Load_HomingCallback,2000);
         return OK;
     }
 
@@ -459,6 +467,7 @@
         MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4);
 
         ControlId = AddControlCallback(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
+        Report("AddControlCallback feeder",__FILE__,__LINE__,ControlId,RpMessage,IfTypeThread*0x100+FEEDER_MOTOR,0);
         CallbackCounter++;
         MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
                                numberOfSteps,    Thread_Load_Dryer_Loading_Callback, 100000);
@@ -466,7 +475,7 @@
         //Keep Notation How Many Rotations In The Dryer
         //LoadArmInfo.LoadArmBackLash = 0;
         LoadArmInfo.LoadArmRounds = 0xFF;
-        FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath);
+        FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
         return OK;
     }
     uint32_t Thread_Load_Jog_ThreadStop(uint32_t index, uint32_t ReadValue)
@@ -490,6 +499,24 @@
     uint32_t Thread_Load_End(void)
     {
         REPORT_MSG(LoadStages,"Loading Ended");
+        if(ControlId != 0xFF)
+        {
+            MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);
+            RemoveControlCallback(ControlId, ThreadLoadControlCBFunction );
+            ControlId = 0xFF;
+        }
+        if(PullerControlId != 0xFF)
+        {
+            MotorStop(ThreadMotorIdToMotorId[POOLER_MOTOR],Hard_Hiz);
+            RemoveControlCallback(PullerControlId, ThreadLoadControlCBFunction );
+            PullerControlId = 0xFF;
+        }
+        if(WinderControlId != 0xFF)
+        {
+            MotorStop(ThreadMotorIdToMotorId[WINDER_MOTOR],Hard_Hiz);
+            RemoveControlCallback(WinderControlId, ThreadLoadControlCBFunction );
+            WinderControlId = 0xFF;
+        }
         return OK;
     }
     uint32_t Thread_Load_Dryer_UnLoading(void)
@@ -523,6 +550,7 @@
         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);
+        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;
@@ -544,6 +572,7 @@
         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);
+        Report("AddControlCallback Winder",__FILE__,__LINE__,WinderControlId,RpMessage,IfTypeThread*0x100+WINDER_MOTOR,0);
 
 ////////////////////////
         MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING].directionthreadwize);
@@ -553,13 +582,15 @@
         //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 = 10;
+
         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
         //LoadArmInfo.LoadArmBackLash = 0;
         LoadArmInfo.LoadArmRounds = 0xFF;
-        FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath);
+        FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
         return OK;
     }
 
@@ -613,10 +644,6 @@
             //LoadStages++;
             Thread_Load_Close_Lids();
             break;
-        case THREAD_LOAD_RESUME_HEATING:
-            //LoadStages++;
-            Thread_Load_Resume_Heating();
-            break;
         case THREAD_LOAD_JOG_FEEDER_TO_MIDDLE_POINT://JOG THE FEEDER MOTOR UNTIL THE FEEDER DANCER IS AT MIDDLE POSITION
             //LoadStages++;
             Thread_Load_Jog_Feeder_To_Middle_Point();
@@ -626,6 +653,10 @@
             //LoadStages++;
             Thread_Load_Dryer_Loading();
             break;
+        case THREAD_LOAD_RESUME_HEATING:
+            //LoadStages++;
+            Thread_Load_Resume_Heating();
+            break;
         case THREAD_LOAD_JOG_THREAD: //JOG THREAD SHORTLY TO MAKE SURE SPOOL IS RUNNING. REPORT END OF LOADING
             //LoadStages++;
             Thread_Load_Jog_Thread();
@@ -640,7 +671,18 @@
     }
     return OK;
 }
-
+uint32_t ThreadLoadButton(THREAD_LOAD_STAGES_ENUM ReadValue)
+{
+    Report("ThreadLoadButton",__FILE__,__LINE__,LoadStages,RpMessage,ReadValue,0);
+    if (LoadStages > ReadValue)
+    {
+        ThreadLoadStateMachine(LoadStages+1);
+    }
+    else
+    {
+        ThreadLoadStateMachine(ReadValue);
+    }
+}
 uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
     //read value is the dancer angle
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 167616afe..1544af59e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -58,17 +58,17 @@ typedef enum
     THREAD_LOAD_LIFT_DANCERS,
     THREAD_LOAD_LIFT_ROCKERS, //MACHINE IS READY. SEND MESSAGE, START TIMER TO CLOSE LIDS, WAIT FOR OPERATOR RESPONSE
     THREAD_LOAD_INITIAL_TENSION,//CHECK SPOOL PRESENCERUN WINDER UNTIL BREAK SENSOR IS IDENTIFIEING MOVEMENT FOR A SECOND
-    THREAD_LOAD_CLOSE_ROCKERS,
     THREAD_LOAD_CLOSE_DANCERS, //SEND DANCER MOTORS TO PRESET LOCATION, CHECK THAT THE DANCERS ARE ON THE THREAD
     THREAD_LOAD_CLOSE_LIDS,
-    THREAD_LOAD_RESUME_HEATING,
-    THREAD_LOAD_JOG_FEEDER_TO_MIDDLE_POINT,//JOG THE FEEDER MOTOR UNTIL THE FEEDER DANCER IS AT MIDDLE POSITION
     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
+    THREAD_LOAD_CLOSE_ROCKERS,
+    THREAD_LOAD_JOG_FEEDER_TO_MIDDLE_POINT,//JOG THE FEEDER MOTOR UNTIL THE FEEDER DANCER IS AT MIDDLE POSITION
+    THREAD_LOAD_RESUME_HEATING,
     THREAD_LOAD_JOG_THREAD, //JOG THREAD SHORTLY TO MAKE SURE SPOOL IS RUNNING. REPORT END OF LOADING
     THREAD_LOAD_END
 }THREAD_LOAD_STAGES_ENUM;
-uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM ReadValue);
+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 500ba9a39..38c0f86f1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -174,7 +174,7 @@ uint32_t StoreDancerConfigMessage()
     {
         response_size = hardware_configuration__pack(&DancerConfig, response_buffer);
     }
-    Fresult = FileWrite(response_buffer,response_size,DancerConfigPath);
+    Fresult = FileWrite(response_buffer,response_size,DancerConfigPath,BIOS_WAIT_FOREVER);
     EraseFlashSection(DANCERS_MAP_IN_FLASH,1024);
     for (Dancer_i = 0; Dancer_i < MAX_SYSTEM_DANCERS; Dancer_i++)
     {