merge

14 files changed, 119 insertions, 67 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 5cccc5b45..cd40afd9c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -648,7 +648,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
         for (Sensor_i = 0;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
 #endif
         {
-            MillisecReadFromTempSensor(Sensor_i, NULL);
+  //          MillisecReadFromTempSensor(Sensor_i, NULL);
         }
     }
     if (Hundred_msTick)
@@ -691,7 +691,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
         DispensersCollectionCall();
 
 #ifdef Use_Head_Card
-    Head_Read_IO_Reg(0x46, HIGH);//READ HEAD CARD LS
+    //Head_Read_IO_Reg(0x46, HIGH);//READ HEAD CARD LS
 #endif
 
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 598c5df8a..960cbaa42 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -369,7 +369,7 @@ uint32_t GenHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
 uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
 {
     uint32_t status  = 0;
-    int Dancer_i, Dispenser_i,PID_i;
+    int Dancer_i, Dispenser_i,PID_i,tempheaterId;
 
     if (UploadRequest == NULL)
     {
@@ -428,7 +428,16 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         for (PID_i = 0; PID_i < request->n_pidcontrols ; PID_i++)
         {
             if (isHeater(request->pidcontrols[PID_i]->hardwarepidcontroltype))
+            {
                 status += HeaterConfigRequestMessage(request->pidcontrols[PID_i]);
+                if ((request->pidcontrols[PID_i]->hardwarepidcontroltype>=HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1)&&
+                        (request->pidcontrols[PID_i]->hardwarepidcontroltype<=HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6))
+                {
+                    tempheaterId = (request->pidcontrols[PID_i]->hardwarepidcontroltype-HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1+HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7);
+                    request->pidcontrols[PID_i]->hardwarepidcontroltype = tempheaterId;
+                    status += HeaterConfigRequestMessage(request->pidcontrols[PID_i]);
+                }
+            }
             else if ((request->pidcontrols[PID_i]->hardwarepidcontroltype >= HARDWARE_PID_CONTROL_TYPE__MotorDryer)&&
                     (request->pidcontrols[PID_i]->hardwarepidcontroltype < HARDWARE_PID_CONTROL_TYPE__Dispenser1))
                 status += MotorPidRequestMessage(request->pidcontrols[PID_i]);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index 4305fac0e..e376a99fe 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -109,53 +109,65 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
                 HARDWARE_PID_CONTROL_TYPE__MixerHeater, false,
                 ProcessParams->mixertemp);
     if (ProcessParams->headzone1temp>1)
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, true,
-                ProcessParams->headzone1temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, true,ProcessParams->headzone1temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, true,ProcessParams->headzone1temp);
+    }
     else
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, false,
-                ProcessParams->headzone1temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, false,ProcessParams->headzone1temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, false,ProcessParams->headzone1temp);
+    }
     if (ProcessParams->headzone2temp>1)
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, true,
-                ProcessParams->headzone2temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, true,ProcessParams->headzone2temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, true,ProcessParams->headzone2temp);
+    }
     else
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, false,
-                ProcessParams->headzone2temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, false,ProcessParams->headzone2temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, false,ProcessParams->headzone2temp);
+    }
     if (ProcessParams->headzone3temp>1)
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, true,
-                ProcessParams->headzone3temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, true,ProcessParams->headzone3temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, true,ProcessParams->headzone3temp);
+    }
     else
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, false,
-                ProcessParams->headzone3temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, false,ProcessParams->headzone3temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, false,ProcessParams->headzone3temp);
+    }
     if (ProcessParams->headzone4temp>1)
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, true,
-                ProcessParams->headzone4temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, true,ProcessParams->headzone4temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, true,ProcessParams->headzone4temp);
+    }
     else
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, false,
-                ProcessParams->headzone4temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, false,ProcessParams->headzone4temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, false,ProcessParams->headzone4temp);
+    }
     if (ProcessParams->headzone5temp>1)
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, true,
-                ProcessParams->headzone5temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, true,ProcessParams->headzone5temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, true,ProcessParams->headzone5temp);
+    }
     else
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, false,
-                ProcessParams->headzone5temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, false,ProcessParams->headzone5temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, false,ProcessParams->headzone5temp);
+    }
     if (ProcessParams->headzone6temp>1)
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, true,
-                ProcessParams->headzone6temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, true,ProcessParams->headzone6temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, true,ProcessParams->headzone6temp);
+    }
     else
-        status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, false,
-                ProcessParams->headzone6temp);
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, false,ProcessParams->headzone6temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, false,ProcessParams->headzone6temp);
+    }
     if (ProcessParams->dryerzone1temp>1)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, true,
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 50796d3c9..f748c9e51 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -459,10 +459,12 @@ int GetFilteredHeaterRead(int HeaterId)
  * initialized all global data
  *************************************************************************************/
 bool HeaterRestarted[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false};
-uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
+uint32_t  HeaterCommandRequestMessage(int HeaterNum, bool OnOff, int Temperature)
 {
     //uint32_t status = NOT_SUPPORTED;
     //MessageContainer responseContainer;
+    int HeaterId = getHeaterId(HeaterNum);
+
     if (HeaterControl[HeaterId].configured == false)
     {
         ReportWithPackageFilter(HeatersFilter,"HeaterControl not configured",__FILE__,__LINE__,HeaterId,RpError, 0,0);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 3d1ba6e78..e2c2b3b1c 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -159,8 +159,8 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
     DispenserControlId[DispenserId] = AddControlCallback(NULL, IDS_Dispenser_StopMotorCallback, CloseValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
     if (DispenserControlId[DispenserId] == 0xFF)
         Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
-    else
-        Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+    //else
+    //    Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
 
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 00d740c7e..d8db2c4a5 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -1299,7 +1299,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
     //Task_sleep(5);
     PreSegmentWCFStarted = false;
     PreSegmentPrepareStarted = false;
-    REPORT_MSG(PreSegmentWCFStarted,"START IDSPresegmentPrepareStart");
+    //REPORT_MSG(PreSegmentWCFStarted,"START IDSPresegmentPrepareStart");
 
 //    IDSPresegmentPrepareStart();
     return OK;
@@ -1458,7 +1458,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
 #else
      Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
 #endif
-     IDS_Cleaning_Stop_Cleaning_Solution(NULL);
+     //IDS_Cleaning_Stop_Cleaning_Solution(NULL);
      SegmentNumOfBrushStops = Segment->n_brushstops;
      BrushStopTime = Segment->length*1000/(double)SegmentNumOfBrushStops;  //brushstop in meters //brushstop in millisecond
      BrushStopTime = ((BrushStopTime*100)/dyeingspeed);//brushstop in seconds
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
index 908362c6d..78ae257ac 100644
--- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
@@ -402,7 +402,7 @@ uint32_t MidTankReading(void)
     MidTankCounter = 0;
     if (IFS_info.Ink.time_out > 0)
         return ERROR;
-    MidTankReadControlId = AddControlCallback( "MidTankRead",MidTankCallBackFunction, 300/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
+    MidTankReadControlId = AddControlCallback("MidTankReading", MidTankCallBackFunction, 300/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
 
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
index 11ae5b008..36542a1a9 100644
--- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
@@ -52,6 +52,7 @@ bool MidTankValvesAction(bool action); //Cartridge_MidTank_ON of Cartridge_MidTa
 bool ColorMatch();
 bool IFS_TimeOutAlarm(bool status);
 void ResponseDemo(int MidtankId);
+bool IFS_MidTankFilling(void);
 
 bool CartridgeValidationResponseFunc(MessageContainer* requestContainer);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 013d22968..ea2ad594a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -30,6 +30,8 @@
 #include <Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h>
 #include "drivers/adc_sampling/adc.h"
 
+extern double NumberOfRotationPerPassage;  // how many rotations per spool passage
+
 //#include "graphics_adapter.h"
 extern uint8_t Input_Voltage;
 extern uint8_t Test_Read_Buf[4];
@@ -124,10 +126,14 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
                         {
                             Disconnect_Mixer_and_12_Heaters_Latch();
                             HeadCard_Control_Heaters((request -> delay & 0xFF00)>>8, TRUE);
+                            //Write_Head_Card_Heaters_Commands();
                             Connect_Mixer_and_12_Heaters_Latch();
                         }
                         else
+                        {
                             HeadCard_Control_Heaters((request -> delay & 0xFF00)>>8, FALSE);
+                            //Write_Head_Card_Heaters_Commands();
+                        }
                     }
 
     }
@@ -293,7 +299,7 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     if(request->amount == 0xF1)
     {
         LOG_ERROR(request->delay,"NumberOfRotationPerPassage");
-        NumberOfRotationPerPassage = (float)(request->delay)/1000;
+        //NumberOfRotationPerPassage = (float)(request->delay)/1000;
     }
     else
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_FPGARWReg.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_FPGARWReg.c
index 8ebf51aac..5dcabc576 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_FPGARWReg.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_FPGARWReg.c
@@ -97,7 +97,7 @@ void Stub_FpgaWriteRegRequest(MessageContainer* requestContainer)
         ptr = (volatile short *) (request->address);
         if (request->address == (FPGA3_BASE | 0x3D0))
         {
-            ctlId = AddControlCallback( "ResetCallBackFunction",ResetCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,ptr,ptr, 0 );
+            ctlId = AddControlCallback("Reset", ResetCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,ptr,ptr, 0 );
         }
         else
             *ptr = (request->value & 0xFFFF);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 40000b8bb..0aff26320 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -359,6 +359,7 @@
                 else
                 {
                     LoadStages++;
+                    LoadStatus = OK;
                     if (LoadStages == THREAD_LOAD_CLOSE_DANCERS)
                     {
                         MotorSetKvalHold(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, keepkvalhold);
@@ -558,6 +559,8 @@
             CallbackCounter--;
             if (CallbackCounter == 0)
             {
+                LoadStatus = OK;
+
                 LoadStages++;
                 if (LoadStages != THREAD_LOAD_INITIAL_TENSION) //on this satge we should wait for user call
                 {
@@ -681,7 +684,8 @@
         //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;
-        SpeedTControlId = AddControlCallback(NULL,ThreadLoadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+HARDWARE_MOTOR_TYPE__MOTO_RDRIVING),HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,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);
@@ -709,12 +713,13 @@
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
         ThreadJoggingFunc(20);
-        LoadingControlId = AddControlCallback(NULL,Thread_Load_Jog_ThreadStop, eOneSecond*25,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
+        LoadingControlId = AddControlCallback("Load jog",Thread_Load_Jog_ThreadStop, eOneSecond*25,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
         return OK;
     }
     uint32_t Thread_Load_End(void)
     {
         REPORT_MSG(LoadStages,"Loading Ended");
+        ThreadLoadingReport();
         if(LoadingControlId != 0xFF)
         {
             MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);
@@ -752,6 +757,7 @@
             usnprintf(LoadErrorMsg, 100, "Load sequence stopped by user on stage %d",LoadStages);
             LoadStatus = ERROR;
         }
+
         LoadStages = THREAD_LOAD_INIT;
         load.color = colorON;
         return OK;
@@ -766,21 +772,19 @@
             return OK;
         }
         Screw_Dir = 1-Screw_Dir;
-        status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,Screw_Dir, 80, screw[Screw_Dir], Thread_Load_switchCallback,30000);
+        status = MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,Screw_Dir, 80, screw[Screw_Dir], Thread_Load_switchCallback,13000);
 
         return OK;
     }
     uint32_t Thread_Load_Dryer_UnLoading_Callback(uint32_t MotorId, uint32_t ReadValue)
     {
         numberOfCycles++;
-        uint32_t temp = Control_Read_Dryer_Position(0,0);
-        Report("Thread_Load_Dryer_Loading_Callback",__FILE__,ReadValue,temp,RpMessage,DrierPrevLocation,0);
-        //Report("Thread_Load_Dryer_Loading_Callback details",__FILE__,(int)(TotalLoadedLen),numberOfCycles,RpMessage,CallbackCounter,0);
-        if ((abs (temp -DrierPrevLocation)>20  )&&(ReadValue == NOTBUSY))
+        uint32_t temp = Read_Dryer_ENC_Position();
+        Report("Thread_Load_Dryer_UnLoading_Callback",__FILE__,ReadValue,temp,RpMessage,DrierPrevLocation,0);
+        //Report("Thread_Load_Dryer_UnLoading_Callback details",__FILE__,(int)(TotalLoadedLen),numberOfCycles,RpMessage,CallbackCounter,0);
+        if ((abs (temp -DrierPrevLocation)>1000  )&&(ReadValue == NOTBUSY))
         {
             DrierPrevLocation = temp;
-            //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_SET_LOAD_ARM_TO_START_POSITION)
             {
                 return OK;
@@ -801,7 +805,7 @@
         {
             LOG_ERROR(LoadStages,"Load sequence timeout - drier Unloading");
             Report("Store Number of cycles in drier - halted",__FILE__,__LINE__,numberOfCycles,RpMessage,LoadArmInfo.LoadArmRounds,0);
-            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmInfo.LoadArmRounds-numberOfCycles);
+            MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmInfo.LoadArmRounds-(numberOfCycles-2));//it takes two cycles to identify a stop of the arm
             TimeoutsCounter = 0;
             CallbackCounter = 0;
             if(PullerControlId != 0xFF)
@@ -826,12 +830,14 @@
             load.color = fastBILNK;
             usnprintf(LoadErrorMsg, 100, "Load sequence timeout %d motor %d",LoadStages, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);
             LoadStatus = ERROR;
+            TryAgain = true;
             ThreadLoadingReport();
         }
         return OK;
     }
     uint32_t Thread_Load_Dryer_UnLoading(void)
     {
+        uint32_t temp;
         REPORT_MSG(LoadStages, "Thread UnLoad State Machine step");
         //LoadArmInfo.LoadArmRounds = 0;
         //uint32_t numberOfSteps = 0;
@@ -899,9 +905,10 @@
         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;
         numberOfCycles = 0;
 
-        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&DrierPrevLocation);
-
-        Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,UnloadingStart,LoadStages,RpMessage, LoadArmInfo.LoadArmRounds,0);
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CENTER,&temp);
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmInfo.LoadArmRounds);
+        DrierPrevLocation = temp;
+        Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,UnloadingStart,DrierPrevLocation,RpMessage, LoadArmInfo.LoadArmRounds,0);
         MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4*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,LoadArmInfo.LoadArmBackLash,1000);
@@ -1002,7 +1009,6 @@
             ThreadLoadingReport();
             break;
         case THREAD_LOAD_END:
-            MessageState = 0;
             LoadStages = THREAD_LOAD_END;
             Thread_Load_End();
             break;
@@ -1025,23 +1031,27 @@ uint32_t ThreadLoadButton(THREAD_LOAD_STAGES_ENUM ReadValue)
         return ERROR;
     }
     Report("ThreadLoadButton",__FILE__,__LINE__,LoadStages,RpMessage,ReadValue,0);
+    Report("ThreadLoadButton params",__FILE__,LoadStatus,TryAgain,RpMessage,SecondTry,0);
     if (LoadStatus == ERROR)
     {
         if ((SecondTry == false)&&(TryAgain == true))
         {
             LoadStatus = OK;
             SecondTry = true;
+            Report("Calling State machine",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
             ThreadLoadStateMachine(LoadStages);
         }
         else
         {
             SecondTry = false;
+            Report("Calling State machine",__FILE__,LoadStages,LoadStatus,RpMessage,SecondTry,0);
             ThreadLoadStateMachine(LoadStages+1);
         }
     }
     else
     {
-        ThreadLoadStateMachine(ReadValue);
+        Report("Calling State machine status OK",__FILE__,ReadValue,LoadStatus,RpMessage,SecondTry,0);
+        ThreadLoadStateMachine(LoadStages);
     }
     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 f0b709ff2..78092ae2b 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -61,6 +61,7 @@ static bool KeepWindingCone = false;
 static uint32_t WindingConeLocation;
 static uint32_t WinderBackToBaseTime = 800;
 
+float NumberOfRotationPerPassage = 0.0;
 InternalWinderConfigStruc InternalWinderCfg = {0};
 //#define READ_SCREW_ENCODER
 #ifdef READ_SCREW_ENCODER
@@ -106,12 +107,17 @@ uint32_t InternalWindingConfigMessage(JobSpool* request)
     InternalWinderCfg.spoolbackingrate = request->backingrate;
     InternalWinderCfg.startoffsetpulses = request->startoffsetpulses;
     InternalWinderCfg.SpoolBottomBackingRate =  request->bottombackingrate;
-    InternalWinderCfg.NumberOfRotationPerPassage = 3.1415926*2;//request->rotationsperpassage;
+    InternalWinderCfg.NumberOfRotationPerPassage = 3.1415926*3;//request->rotationsperpassage;
     if (request->rotationsperpassage > 6.1)
         InternalWinderCfg.NumberOfRotationPerPassage = request->rotationsperpassage;
+    if (NumberOfRotationPerPassage > 1)
+    {
+        InternalWinderCfg.NumberOfRotationPerPassage = NumberOfRotationPerPassage;
+        Report("Rotation per passage set from stub",__FILE__,__LINE__,(int)(request->rotationsperpassage*1000),RpWarning,(int)(InternalWinderCfg.NumberOfRotationPerPassage*1000), 0);
+    }
     InternalWinderCfg.diameter = request->diameter;
     usnprintf(ScrewStr, 150, "WindingConfig start,offset,head,tail {, %d, %d, %d, %d, %d}",InternalWinderCfg.startoffsetpulses,(int)InternalWinderCfg.segmentoffsetpulses,
-              (int)InternalWinderCfg.spoolbackingrate,(int)InternalWinderCfg.SpoolBottomBackingRate);
+              (int)InternalWinderCfg.spoolbackingrate,(int)InternalWinderCfg.SpoolBottomBackingRate,(int)(InternalWinderCfg.NumberOfRotationPerPassage*1000));
     Report(ScrewStr,__FILE__,__LINE__,(int)InternalWinderCfg.diameter,RpWarning,(int)(InternalWinderCfg.NumberOfRotationPerPassage*1000), 0);
 
     return status;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index dd9395248..420b782b5 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -42,6 +42,8 @@ uint32_t StoreDancerConfigMessage(void);
 uint32_t LoadDancerConfigMessage(void);
 
 //uint32_t MotorPidRequestMessage(HardwarePidControl* request);
+extern float NumberOfRotationPerPassage; //debug for rotation per passage trials
+
 uint32_t Winder_Init(void);
 uint32_t Winder_Prepare(void *JobDetails);
 uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 0a3a9e149..45ab2cb19 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -41,7 +41,11 @@
 
 double CurrentControlledSpeed[MAX_THREAD_MOTORS_NUM] = {0};
 
+#ifndef DRIER_CONTROL_TEST
+TimerMotors_t ThreadMotorIdToMotorId[MAX_THREAD_MOTORS_NUM] = {HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,HARDWARE_MOTOR_TYPE__MOTO_WINDER,HARDWARE_MOTOR_TYPE__MOTO_SCREW};
+#else
 TimerMotors_t ThreadMotorIdToMotorId[MAX_THREAD_MOTORS_NUM] = {HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,HARDWARE_MOTOR_TYPE__MOTO_WINDER,HARDWARE_MOTOR_TYPE__MOTO_SCREW};
+#endif
 HardwareDancerType ThreadMotorIdToDancerId[MAX_THREAD_MOTORS_NUM] = {FEEDER_DANCER,NUM_OF_DANCERS,POOLER_DANCER,WINDER_DANCER,NUM_OF_DANCERS};
 uint32_t    ControlIdtoMotorId [MAX_THREAD_MOTORS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF};
 uint32_t    SpeedControlId=0xFF;
@@ -848,7 +852,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
             }
 //            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
 //                AddControlCallback(ThreadSpeedControlCBFunction, eOneMillisecond,TemplateDataReadCBFunction,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],0);
-            if (Motor_i == 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
+            if (Motor_i == ThreadMotorIdToMotorId[DRYER_MOTOR]) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
                 continue;
     }
 #ifdef TEST_PID_THREAD
@@ -897,7 +901,7 @@ uint32_t ThreadDryerRampUp(uint32_t IfIndex, uint32_t BusyFlag)
         ControlIdtoMotorId[DRYER_MOTOR] = 0xFF;
     }
 
-    MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,InitialDryerSpeed );
+    MotorSetSpeed(ThreadMotorIdToMotorId[DRYER_MOTOR],InitialDryerSpeed );
     //ReportWithPackageFilter(ThreadFilter,"ThreadDryerRampUp",__FILE__,ControlIdtoMotorId[DRYER_MOTOR],(int)InitialDryerSpeed,RpWarning,(int)OriginalMotorSpd_2PPS[DRYER_MOTOR],0);
 
 
@@ -927,7 +931,7 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
         DrierDivider = dyeingspeed/5;  //ramp up drier in 5 cm/sec steps
         ReportWithPackageFilter(ThreadFilter,"Drier ramp up",__FILE__,__LINE__,(int)dyeingspeed,RpWarning,(int)DrierDivider,0);
         InitialDryerSpeed = OriginalMotorSpd_2PPS[DRYER_MOTOR]/DrierDivider;
-        MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,InitialDryerSpeed );
+        MotorSetSpeed(ThreadMotorIdToMotorId[DRYER_MOTOR],InitialDryerSpeed );
         ControlIdtoMotorId[DRYER_MOTOR] = AddControlCallback("DryerRampUp",ThreadDryerRampUp, 200,TemplateDataReadCBFunction,0,0,0);
 #endif
 #ifdef HUNDRED_MICROSECONDS_DANCER_READ