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

17 files changed, 491 insertions, 214 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..2ca57e08e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -62,7 +62,7 @@ uint32_t Diagnostics_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t DispensersCollection(uint32_t IfIndex, uint32_t ReadValue);
 
-#define REDUCED_DIAGNOSTICS
+//#define REDUCED_DIAGNOSTICS
 
 DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT;
 #define DIAGNOSTICS_LIMIT 3
@@ -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..724db5480 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,55 @@ 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 = sttRDY ;    // to do
+                //pBtn->state = sttLOADFAIL ;
+                pBtn->color = fastBILNK ;    // to do
+            }
             break;
 //        case sttLOADSUCSESS ?????
 //            break;
@@ -596,7 +610,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..39e87ed6a 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -37,6 +37,9 @@ double headairflow = 0;
 double dryerairflow = 0;
 int32_t tableindex = 0;
 
+double dryerbufferMeters = 0;
+double dryerbufferCentimeters = 0;
+
 #define MAX_ALLOWED_TEMPERATURE 280
 
 char ProcessParamsConfigPath[50] = "0://SysInfo//ProcessP.cfg";
@@ -170,6 +173,11 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
     HeatersStopControlOnHeatersOff(ProcessParams);
     dyeingspeed = ProcessParams->dyeingspeed;
     dryerbufferlength = ProcessParams->dryerbufferlength;
+    dryerbufferMeters = dryerbufferlength*0.76+0.6;
+    dryerbufferCentimeters = dryerbufferlength*76+60;
+
+    Report("drier buffer length",__FILE__,(int)dryerbufferlength,(int)dryerbufferMeters*100,RpWarning,(int)dryerbufferCentimeters,0);
+
     mininkuptake = ProcessParams->mininkuptake;
     feedertension = ProcessParams->feedertension;
     pullertension = ProcessParams->pullertension;
@@ -191,7 +199,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/General/process.h b/Software/Embedded_SW/Embedded/Modules/General/process.h
index c67bd49b3..2b02c28c7 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.h
@@ -19,6 +19,9 @@ extern double headairflow;
 extern double dryerairflow;
 extern int32_t tableindex;
 
+extern double dryerbufferMeters;
+extern double dryerbufferCentimeters;
+
 extern ProcessParameters ProcessParametersKeep;
 
 extern void ProcessRequestFunc(MessageContainer* requestContainer);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index d60d5b840..8e185750f 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -87,7 +87,7 @@ uint32_t    DisasterControlId = 0xFF;
 #define DRYER_AIR_PT100  TEMP_SENSE_ANALOG_DRYER_TEMP1
 #define DRYER_MAIN_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP2
 #define DRYER_SECONDARY_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP3
-#define MINIMUM_HEATER_READ 8.5
+#define MINIMUM_HEATER_READ 9.0
 #define MAXIMUM_HEATER_READ 283
 
 //old uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,TEMP_SENSE_AN_ENCLOSURETEMP3};
@@ -538,6 +538,28 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
         //ReportWithPackageFilter(HeatersFilter,"PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
         HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);//MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
         HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);// = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+        if((HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain])||
+           (HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]))
+        {
+            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,RpError, 0,0);
+            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,RpError, 0,0);
+            if (ControlIdtoMaxHeaterId [HeaterId] != 0xFF)
+            {
+                RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
+                ControlIdtoMaxHeaterId [HeaterId] = 0xFF;
+            }
+            if (ControlIdtoHeaterId [HeaterId] != 0xFF)
+            {
+                RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
+                ControlIdtoHeaterId [HeaterId] = 0xFF;
+            }
+            DeActivateHeater(HeaterId);
+            HeaterCmd[HeaterId].targettemperatue = 0;
+            AlarmHandlingSetAlarm(HeaterEventType[HeaterId], true);
+
+            return ERROR;
+        }
+
     }
     //turn all alarms off
         AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false);
@@ -571,6 +593,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     if (SetTemperatue)
     {
         Control_Dryer_Fan(START,75);//use START or STOP,  0 - 100%
+        ReportWithPackageFilter(HeatersFilter,"Control_Dryer_Fan",__FILE__,__LINE__,START,RpError, 75,0);
     }
 }
 /*
@@ -583,6 +606,26 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
     if (DisasterControlId == 0xFF)
         DisasterControlId = AddControlCallback( HeatersDisasterControl, eOneSecond,TemplateDataReadCBFunction,0,0, 0);
 
+    HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
+    if((HeaterPreviousRead[HeaterId]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HeaterId]))
+    {
+        ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HeaterId,RpError, 0,0);
+        if (ControlIdtoMaxHeaterId [HeaterId] != 0xFF)
+        {
+            RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
+            ControlIdtoMaxHeaterId [HeaterId] = 0xFF;
+        }
+        if (ControlIdtoHeaterId [HeaterId] != 0xFF)
+        {
+            RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
+            ControlIdtoHeaterId [HeaterId] = 0xFF;
+        }
+        DeActivateHeater(HeaterId);
+        AlarmHandlingSetAlarm(HeaterEventType[HeaterId], true);
+        HeaterCmd[HeaterId].targettemperatue = 0;
+
+        return ERROR;
+    }
     if (ControlIdtoHeaterId [HeaterId] == 0xFF)
         ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
     //HeaterPIDConfig[HeaterId].m_params.dt *=10;
@@ -598,12 +641,6 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
 
     Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
 
-    HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
-    if((abs(HeaterPreviousRead[HeaterId]-MINIMUM_HEATER_READ)<1)||(abs(MAXIMUM_HEATER_READ-HeaterPreviousRead[HeaterId])<10))
-    {
-        ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HeaterId,RpError, 0,0);
-        return ERROR;
-    }
     //ReportWithPackageFilter(HeatersFilter,"PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
         ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index d0621125f..33033ad69 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -36,7 +36,6 @@ uint32_t IDS_Dispenser_EmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue);
     int      direction;
 
 }IDS_Dispenser_Data;*/
-void IDS_Dispenser_Set_Flow_Params (char DispenserId,double NanoLitterPerPulse,char  MicroSteps);
 void IDS_Dispenser_RefillStarted (char DispenserId,char  MicroSteps);
 void IDS_Dispenser_RefillEnded (char DispenserId,char  MicroSteps);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 6d7f0df96..de7d12024 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -298,9 +298,12 @@ 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);
-    DispenserDataUpdated = false;
-    REPORT_MSG(msec_millisecondCounter - timing, "Updating dispensers file - time");
+    Status = FileWrite(IDS_Dispenser_Data,response_size,DispenserStorePath,BIOS_NO_WAIT);
+    if (Status == FR_OK)
+    {
+        DispenserDataUpdated = false;
+        REPORT_MSG(msec_millisecondCounter - timing, "Updating dispensers file - time");
+    }
     return Status;
 }
 void IDS_Dispenser_Content_Calculation (char DispenserId)
@@ -317,18 +320,20 @@ void IDS_Dispenser_Content_Calculation (char DispenserId)
     //double consumedintimeframe = (double)(CurrentDispenserSpeed[DispenserId]); //pulses only
     //consumedintimeframe = 10+DispenserId;
     IDS_Dispenser_Data[DispenserId].consumedinnanolitter += (CurrentDispenserSpeed[DispenserId]/10);//100 milliseconds ==> speed/10
+    if (IDS_Dispenser_Data[DispenserId].consumedinnanolitter<0)
+        IDS_Dispenser_Data[DispenserId].consumedinnanolitter = 0;
     if (CurrentDispenserSpeed[DispenserId]>0.1)
     {
         DispenserDataUpdated = true;
         IDS_Dispenser_Data[DispenserId].totalconsumedinnanolitter += (CurrentDispenserSpeed[DispenserId]/10);
-        if (seconds_counter%100 == 0)
+        if (seconds_counter%6000 == 0)
         {
             Report("IDS_Dispenser_Data ",__FILE__,DispenserId,(int)IDS_Dispenser_Data[DispenserId].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[DispenserId].totalconsumedinnanolitter,0);
         }
     }
     if (DispenserId == 0)
     {
-        if ((seconds_counter++>=600)&&(DispenserDataUpdated == true))//36000)// - one hour)
+        if ((seconds_counter++>=36000)&&(DispenserDataUpdated == true))//36000)// - one hour)
         {
             seconds_counter = 0;
             if (IDS_Dispenser_Data[DispenserId].consumedinnanolitter)
@@ -347,14 +352,6 @@ void DispensersCollectionCall(void)
         IDS_Dispenser_Content_Calculation(i);
     }
 }
-void IDS_Dispenser_Set_Flow_Params (char DispenserId,double nanolitterperpulse,char  microsteps)
-{
-    /*assert (DispenserId<MAX_SYSTEM_DISPENSERS);
-    IDS_Dispenser_Data[DispenserId].nanolitterperpulse = nanolitterperpulse;
-    IDS_Dispenser_Data[DispenserId].microsteps = microsteps;
-    IDS_Dispenser_Data[DispenserId].direction = 1;*/
-    Report("IDS_Dispenser_Set_Flow_Params",__FILE__,DispenserId,(int)nanolitterperpulse,RpWarning,microsteps,0);
-}
 void IDS_Dispenser_RefillStarted (char DispenserId,char  MicroSteps)
 {
     assert (DispenserId<MAX_SYSTEM_DISPENSERS);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 3dee2f7f6..9a0f23cbd 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -257,7 +257,7 @@ uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t DispenserId)
 
     MotorSetSpeed(motorId, 1000);
     CurrentDispenserSpeed[DispenserId] = 1000;
-    IDS_Dispenser_RefillEnded ( DispenserId, MotorsCfg[motorId].microstep);
+    //IDS_Dispenser_RefillEnded ( DispenserId, MotorsCfg[motorId].microstep);
 
     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 edfc095c2..1983925b8 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -63,13 +63,16 @@ bool         DispenserPreSegmentReady[MAX_SYSTEM_DISPENSERS] = {true,true,true,t
 bool         DispenserSegmentReady[MAX_SYSTEM_DISPENSERS] = {true,true,true,true,true,true,true,true};
 bool         DispenserDistanceToSpoolReady[MAX_SYSTEM_DISPENSERS] = {true,true,true,true,true,true,true,true};
 bool         DispenserUsedInJob[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
+bool         DispenserUsedInSegment[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 bool         DispensersAlarmState[ MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 int JobBrushStopId = 0;
 int lInterSegmentLength = 0;
  int InterSegmentStepsLimit = 0,InterSegmentStepsCount = 0;
- uint32_t InterSegmentStartSprayCleaner;
- uint32_t InterSegmentStartRocking;
- uint32_t InterSegmentCenterRockers;
+ bool PreSegmentWCFStarted = false;
+
+ uint32_t InterSegmentStartSprayCleaner = 0;
+ uint32_t InterSegmentStartRocking = 0;
+ uint32_t InterSegmentCenterRockers = 0;
  uint32_t LeftRockerSpeed = 20;
  uint32_t RighttRockerSpeed = 20;
  uint32_t CleaningDispenserSpeed = 40;
@@ -83,6 +86,8 @@ int lInterSegmentLength = 0;
          InterSegmentStartWFCFDispensers = ids_presegment_wfcf_timebeforesegment;
      if (dispenserpresegmentwfcf)
          WFCF = dispenserpresegmentwfcf;
+     Report("IDS_Dispenser_SetPreSegmentWFCFValues ",__FILE__,__LINE__,dispenserpresegmentwfcf,RpWarning,(int)ids_presegment_wfcf_timebeforesegment,0);
+
  }
  void IDS_Dispenser_SetPreSegmentCleaningValues(double ids_cleaningspeed,double ids_cleaningstartspraypresegmenttime ,double ids_cleaningstopbeforesegmenttime,double ids_leftcleaningmotorspeed,double ids_rightcleaningmotorspeed)
  {
@@ -149,44 +154,7 @@ uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request)
  * on print stage - every 10/100 msec against the speed sensor
  *
  * */
-//Dispenser Pressure control
-//callback - calls printing stm with the result
-
-// registration - 10 msec, dispenser pressure sensor
-//    AddControlCallback(DeviceId2Dispenser[DispenserId], DispenserControlCBFunction, eHundredMillisecond);
-// start the dispenser pressure building - move up in a TBD speed, valve closed
-//Dispenser Speed control
-//callback - handles speed
-// registration - 10msec, dispenser speed senseo
-// start the dispensing - move up according to the segment defined speed and microstepping, valve opened
 //
-void DispenserPrepareReady(void)
-{
-    int i;
-    for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
-    {
-        if (DispenserReady[i] == false)
-        {
-            return; //not all configured Dispensers are ready
-        }
-    }
-    REPORT_MSG(Module_IDS,"All Dispensers Prepare Ready");
-    PrepareReady(Module_IDS,ModuleDone);
-}
-//********************************************************************************************************************
- uint32_t IDS_PrepareReady(uint32_t deviceID, uint32_t ReadValue)
- {
-     if (IDS_Active == false)
-     {
-        REPORT_MSG(deviceID,"IDS_Active false");
-        return ERROR;
-     }
-     DispenserReady[deviceID] = true;
-     REPORT_MSG(deviceID,"Dispenser prepare ready");
-     DispenserPrepareReady();
-
-     return OK; // all configured heaters are ready
- }
 /*
  void OpenJobFile();
 void CloseJobFile();
@@ -196,6 +164,9 @@ JobDescriptionFileBrushStop *GetNextBrushStopFromJobFile();
 void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
 
  */
+ //********************************************************************************************************************
+ //************************** IDS JOB BUILDUP *************************************************************************
+ //********************************************************************************************************************
  /************************************************************************************************************************************/
  uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails)
  {
@@ -570,11 +541,40 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
  }
 
 //********************************************************************************************************************
+//************************** IDS PREPARE BUILDUP *********************************************************************
+//********************************************************************************************************************
+//********************************************************************************************************************
  uint32_t DispenserPrepareControlId = 0xFF;
- double PrepeareSpeed = 0;
  int NumOfActiveDispensers = 0;
  int DispenserBuildTimeCounter = 0;
 #define PRESSURE_READ_TIME_GAP 100
+ void DispenserPrepareReady(void)
+ {
+     int i;
+     for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
+     {
+         if (DispenserReady[i] == false)
+         {
+             return; //not all configured Dispensers are ready
+         }
+     }
+     REPORT_MSG(Module_IDS,"All Dispensers Prepare Ready");
+     PrepareReady(Module_IDS,ModuleDone);
+ }
+ //********************************************************************************************************************
+  uint32_t IDS_PrepareReady(uint32_t deviceID, uint32_t ReadValue)
+  {
+      if (IDS_Active == false)
+      {
+         REPORT_MSG(deviceID,"IDS_Active false");
+         return ERROR;
+      }
+      DispenserReady[deviceID] = true;
+      REPORT_MSG(deviceID,"Dispenser prepare ready");
+      DispenserPrepareReady();
+
+      return OK; // all configured heaters are ready
+  }
  //********************************************************************************************************************
  uint32_t IDS_Prepare_Callback(uint32_t DispenserId, uint32_t ReadValue)
  {
@@ -605,15 +605,15 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
                  updatedSpeed = (tempSpeed*0.95>100)?tempSpeed*0.95:100;
                  MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                  CurrentDispenserSpeed[i] = updatedSpeed;
-                 Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+                 //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
              }
              else
              {
                  tempSpeed = CurrentDispenserSpeed[i];
-                 updatedSpeed = (tempSpeed*1.1>1000)?tempSpeed*1.1:100;
+                 updatedSpeed = (tempSpeed*1.1<1000)?tempSpeed*1.1:1000;
                  MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                  CurrentDispenserSpeed[i] = updatedSpeed;
-                 Report("IDS accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+                 //Report("IDS accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
              }
          }
      }
@@ -634,6 +634,8 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      return OK;
  }
  //********************************************************************************************************************
+
+ //********************************************************************************************************************
  uint32_t IDSPrepareState(void *JobDetails)
 {
     int Motor_i, HW_Motor_Id, Pid_Id;
@@ -672,10 +674,6 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
             //ValveCommand (Enable,MixerDirection);
     }
 
-    PrepeareSpeed = JobTicket->processparameters->dyeingspeed*JobTicket->processparameters->maxinkuptake*1.30;
-    //REPORT_MSG((int)JobTicket->processparameters->dyeingspeed, "dyeing speed");
-    //REPORT_MSG((int)JobTicket->processparameters->maxinkuptake, "max ink uptake");
-
     if (HeaterCheckReady() == true)
     {
         REPORT_MSG(1,"heaters ready, starting");
@@ -705,13 +703,10 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      }
      if (NumOfActiveDispensers)
      {
-         PrepeareSpeed/=NumOfActiveDispensers;
          REPORT_MSG((int)NumOfActiveDispensers, "Num Of Active Dispensers");
          for (i = 0; i < MAX_DYE_DISPENSERS; i++)
          {
-             //dispenserspeed = PrepeareSpeed/MotorsCfg[DispenserIdToMotorId[i]].microstep;
              dispenserspeed = DispenserPrepareSpeed;
-             //IDS_StopHomeDispenser(i);
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
              {
                  Report("Prepare Speed",__FILE__,__LINE__,i,RpWarning,(int)dispenserspeed,0);
@@ -725,6 +720,138 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
 
  }
  //********************************************************************************************************************
+ //************************** IDS PRESEGMENT BUILDUP ******************************************************************
+ //********************************************************************************************************************
+
+ JobDescriptionFileBrushStop * FileBrushStop;
+ char IdsMessage[100];
+
+ //********************************************************************************************************************
+  uint32_t IDS_PreSegmentPrepare_Callback(uint32_t DispenserId, uint32_t ReadValue)
+  {
+      bool pressureReady = false;
+      int i;
+      int NumofReadyDispensers = 0;
+      TimerMotors_t  HW_Motor_Id;
+      float updatedSpeed,tempSpeed;
+      //REPORT_MSG((int)DispenserPrepareControlId, "Prepare Callback");
+
+      DispenserBuildTimeCounter+=PRESSURE_READ_TIME_GAP;
+
+      if (DispenserBuildTimeCounter<(1*eOneSecond))
+      {
+          REPORT_MSG(DispenserBuildTimeCounter,"waiting 1 seconds for pressure changes");
+          return OK;
+      }
+      if (PreSegmentWCFStarted == true)
+      {
+          REPORT_MSG(PreSegmentWCFStarted,"PreSegmentWCFStarted is true, stopping prepare stage");
+          //SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
+          setRapidPressureRead(false);
+		  return OK;
+      }
+      for (i = 0; i < MAX_DYE_DISPENSERS; i++)
+      {
+          //IDS_StopHomeDispenser(i);
+          if (DispenserUsedInSegment[i] == true) //we actually should check for all dispensers
+          {
+              HW_Motor_Id = DispenserIdToMotorId[i];
+              if (GetDispenserPressure(i) > DispenserPreparePressure)
+              {
+                  NumofReadyDispensers++;
+                  tempSpeed = CurrentDispenserSpeed[i];
+                  updatedSpeed = (tempSpeed*0.95>100)?tempSpeed*0.95:100;
+                  MotorSetSpeed(HW_Motor_Id, updatedSpeed);
+                  CurrentDispenserSpeed[i] = updatedSpeed;
+                  //Report("IDS PreSegment reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+              }
+              else
+              {
+                  tempSpeed = CurrentDispenserSpeed[i];
+                  updatedSpeed = (tempSpeed*1.1<1000)?tempSpeed*1.1:1000;
+                  MotorSetSpeed(HW_Motor_Id, updatedSpeed);
+                  CurrentDispenserSpeed[i] = updatedSpeed;
+                  //Report("IDS PreSegment accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+              }
+          }
+      }
+
+      if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
+          Report("IDS_PreSegmentPrepare_Callback",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+
+      if (NumofReadyDispensers>=NumOfActiveDispensers)
+          pressureReady = true;
+
+      if ((DispenserBuildTimeCounter >= DispenserPrepareTimeout)||(pressureReady == true))
+      {
+          SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
+          setRapidPressureRead(false);
+      }
+      return OK;
+  }
+  //********************************************************************************************************************
+ void IDSPresegmentPrepareStart(void)
+ {
+     int i;
+     int Dispenser_i,n_dispensers,DispenserId;
+     TimerMotors_t HW_Motor_Id;
+     double segmentfirst_speed;
+     JobDispenser **Dispensers;
+
+     for (Dispenser_i = 0; Dispenser_i < MAX_DYE_DISPENSERS; Dispenser_i++)
+     {
+         DispenserUsedInSegment[Dispenser_i] = false;
+     }
+     if (FileBrushStop)
+     {
+         Report("start dispensers pre segment pressure build",__FILE__,__LINE__,FileBrushStop->index,RpWarning,(int)FileBrushStop->n_dispensers,0);
+         NumOfActiveDispensers = FileBrushStop->n_dispensers;
+         Dispensers = FileBrushStop->dispensers;
+         n_dispensers = FileBrushStop->n_dispensers;
+         if (n_dispensers)
+         {
+             for (Dispenser_i = 0; Dispenser_i < n_dispensers; Dispenser_i++)
+             {
+                 DispenserId = Dispensers[Dispenser_i]->index;
+                 HW_Motor_Id = DispenserIdToMotorId[DispenserId];
+                 if (MotorsCfg[HW_Motor_Id].hardwaremotortype
+                         != DispenserIdToMotorId[DispenserId])
+                     continue;
+                 if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER))
+                 {
+                     continue;
+                 }
+                 //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius)
+                 segmentfirst_speed = Dispensers[Dispenser_i]->nanolitterpersecond
+                         / Dispensers[Dispenser_i]->nanoliterperpulse;
+                 if (segmentfirst_speed > MINIMAL_MOTOR_SPEED)
+                 {
+                     DispenserUsedInSegment[Dispenser_i] = true;
+                     MotorSetSpeed(HW_Motor_Id, DispenserPrepareSpeed);
+                     CurrentDispenserSpeed[Dispenser_i] = DispenserPrepareSpeed;
+                     usnprintf(IdsMessage, 80,"WFCF Prepare Dispenser %d speed %d",DispenserId,(int) segmentfirst_speed);
+                     //REPORT_MSG(segmentfirst_speed,IdsMessage);
+                     Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
+                     //SendJobProgress(0.0, 0, false, IdsMessage);
+                 }
+                 else
+                 {
+                     MotorStop(HW_Motor_Id, Hard_Hiz);
+                     CurrentDispenserSpeed[Dispenser_i] = 0;
+                     usnprintf(IdsMessage, 80,"WFCF Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
+                     Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
+
+                 }
+             }
+             DispenserBuildTimeCounter = 0;
+             //DispenserPrepareControlId = AddControlCallback( IDS_PreSegmentPrepare_Callback, PRESSURE_READ_TIME_GAP,TemplateDataReadCBFunction ,0, 0, 0 );
+             setRapidPressureRead(true);
+
+         }
+     }
+
+ }
+ //********************************************************************************************************************
  uint32_t IDS_Valve_PresegmentValveReady(uint32_t deviceID, uint32_t ReadValue)
  {
      //TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[deviceID];
@@ -756,8 +883,6 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
 
 
 //********************************************************************************************************************
- JobDescriptionFileBrushStop * FileBrushStop;
- char IdsMessage[100];
 
  uint32_t IDSPreSegmentStateCallbackRunner(uint32_t IfIndex, uint32_t ReadValue)
  {
@@ -802,29 +927,36 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          //IDS_Valve_PresegmentReady(1,0);
          Report("End of Pre-segment Handling",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
          SafeRemoveControlCallback(DispenserPreSegmentControlId,IDSPreSegmentStateCallbackRunner);
+         setRapidPressureRead(false);
      }
      if (EnableCleaning == true)
      {
-         if (InterSegmentStartSprayCleaner == InterSegmentStepsCount)
+         if (( InterSegmentStartSprayCleaner )&&(InterSegmentStartSprayCleaner == InterSegmentStepsCount))
          {
              Report("Start Spray Cleaner",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
-             //IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr callback);
+             IDS_Cleaning_Spray_Cleaning_Solution (CleaningDispenserSpeed,NULL);
          }
-         if (InterSegmentStartRocking == InterSegmentStepsCount)
+         /*if (InterSegmentStartRocking == InterSegmentStepsCount)
          {
              Report("Start cleaning rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
              //IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed);
-         }
-         if (InterSegmentCenterRockers == InterSegmentStepsCount)
+         }*/
+         if (( InterSegmentCenterRockers)&&(InterSegmentCenterRockers == (lInterSegmentLength-InterSegmentStepsCount)))
          {
              Report("Stop spray and center rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
-             //IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
+             IDS_Cleaning_Stop_Cleaning_Solution (NULL);
              //IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback);
          }
      }
+     if (PreSegmentWCFStarted == false)
+     {
+         IDS_PreSegmentPrepare_Callback(0,0);
+     }
      if ((InterSegmentStartWFCFDispensers > 0)&&(InterSegmentStartWFCFDispensers == InterSegmentStepsCount))
      {
          Report("start dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+         PreSegmentWCFStarted = true; // stop any presegment prepare stages, if still exist
+         setRapidPressureRead(false);
          if (FileBrushStop)
          {
              REPORT_MSG(FileBrushStop->index,"WFCFBrushStopRead Index");
@@ -852,16 +984,10 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                          //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
                          segmentfirst_speed /=
                                  Dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep
-                         IDS_Dispenser_Set_Flow_Params(
-                                 DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse,
-                                 Dispensers[Dispenser_i]->dispenserstepdivision);
                      }
                      else
                      {
                          segmentfirst_speed/=8;//MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
-                         IDS_Dispenser_Set_Flow_Params(
-                                 DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse,
-                                 MotorsCfg[HW_Motor_Id].microstep);
                      }
                      if (segmentfirst_speed > MINIMAL_MOTOR_SPEED)
                      {
@@ -962,14 +1088,14 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
                 return ERROR;
             }
             Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)IntersegmentLength,0);
-            if (EnableCleaning == true)
+            /*if (EnableCleaning == true)
             {
                 InterSegmentStartSprayCleaner = 500;
                 InterSegmentStartRocking = 1000;
                 InterSegmentCenterRockers = 3000;
-            }
+            }*/
 
-            InterSegmentStartWFCFDispensers = (lInterSegmentLength>5000)?lInterSegmentLength-5000:lInterSegmentLength;
+            //InterSegmentStartWFCFDispensers = (lInterSegmentLength>5000)?lInterSegmentLength-5000:lInterSegmentLength;
         }
     }
     /*if (SegmentId == 0)//first segment - running the DTS out of the drier
@@ -985,7 +1111,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
                 CurrentDispenserSpeed[Dispenser_i] = 0;
             }
         }
-        lInterSegmentLength = ((dryerbufferlength*100)*1000/dyeingspeed);
+        lInterSegmentLength = (dryerbufferCentimeters*1000/dyeingspeed);
         lInterSegmentLength-=(lInterSegmentLength%100);   //round to a 100 multiplication
         InterSegmentStepsCount = 0;
         DispenserPreSegmentControlId = AddControlCallback( IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
@@ -994,7 +1120,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
             return ERROR;
         }
-        Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)dryerbufferlength,0);
+        Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
         if (EnableCleaning == true)
         {
             InterSegmentStartSprayCleaner = 500;
@@ -1057,7 +1183,6 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             }
 
             //REPORT_MSG(DispenserId,"IDS_Valve_Presegment start");
-            IDS_Dispenser_Set_Flow_Params(DispenserId,0,0);
             if (Dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
             {
                 MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
@@ -1079,6 +1204,10 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
         }
     }
     //Task_sleep(5);
+    PreSegmentWCFStarted = false;
+    REPORT_MSG(PreSegmentWCFStarted,"START IDSPresegmentPrepareStart");
+
+    IDSPresegmentPrepareStart();
     return OK;
 }
 //********************************************************************************************************************
@@ -1114,17 +1243,10 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                 //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
                 segmentfirst_speed /=
                         Dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep
-                IDS_Dispenser_Set_Flow_Params(
-                        DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse,
-                        Dispensers[Dispenser_i]->dispenserstepdivision);
             }
             else
             {
                 segmentfirst_speed/=8;//MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
-
-                IDS_Dispenser_Set_Flow_Params(
-                        DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse,
-                        MotorsCfg[HW_Motor_Id].microstep);
             }
             if (segmentfirst_speed > MINIMAL_MOTOR_SPEED)
             {
@@ -1292,7 +1414,6 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
              if (DispenserUsedInJob[Dispenser_i]==false)//unconfigured dispenser
                  continue;
              DispenserDistanceToSpoolReady[Dispenser_i] = false;
-             IDS_Dispenser_Set_Flow_Params(Dispenser_i,0,0);
              //MotorStop(HW_Motor_Id,Hard_Hiz);
              //Control3WayValvesWithCallback ((Valves_t)Dispenser_i, MidTank_Dispenser, IDS_Valve_DistanceToSpoolValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
              IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_DistanceToSpoolValveReady);
@@ -1300,7 +1421,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
 
          //cleaning
 
-         lInterSegmentLength = ((dryerbufferlength*100)*1000/dyeingspeed);
+         lInterSegmentLength = (dryerbufferCentimeters*1000/dyeingspeed);
          lInterSegmentLength-=(lInterSegmentLength%100);   //round to a 100 multiplication
          InterSegmentStepsCount = 0;
          DispenserPreSegmentControlId = AddControlCallback( IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
@@ -1310,12 +1431,12 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
              return ERROR;
          }
          Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)IntersegmentLength,0);
-         if (EnableCleaning == true)
+         /*if (EnableCleaning == true)
          {
              InterSegmentStartSprayCleaner = 500;
              InterSegmentStartRocking = 1000;
              InterSegmentCenterRockers = 3000;
-         }
+         }*/
          InterSegmentStartWFCFDispensers = 0;
 
 
@@ -1353,7 +1474,6 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
             //MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
             //Control3WayValvesWithCallback (Dispenser_i, MidTank_Dispenser, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
             IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_EndValveReady);
-            IDS_Dispenser_Set_Flow_Params(Dispenser_i,0,0);
          }
          else
          {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 837221274..5984618d9 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -48,15 +48,21 @@
         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
+        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
                                                              //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
     }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;
@@ -93,7 +99,7 @@
         FRESULT Fresult = FR_OK;
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
 
-        LoadArmInfo.LoadArmBackLash = 10;
+        LoadArmInfo.LoadArmBackLash = 5;
         LoadArmInfo.LoadArmRounds = 0xFF;
         Fresult = f_mkdir(SW_INFO_DIR);
         if ((Fresult == FR_OK)||(Fresult == FR_EXIST))
@@ -133,6 +139,7 @@
         ProcessParametersClear.headzone5temp  = 0;
         ProcessParametersClear.headzone6temp  = 0;
         ProcessParametersClear.dyeingspeed = 40;
+        ProcessParametersClear.dryerbufferlength = ProcessParametersKeep.dryerbufferlength;
         if (HandleProcessParameters(&ProcessParametersClear)!= OK)
         {
             LOG_ERROR (LoadStages, "Thread_Load_Init failed");
@@ -163,7 +170,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 +180,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 +200,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 +233,21 @@
         //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_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 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 +266,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 +320,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, 8);
+        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 8);
+        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 +353,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,13 +407,20 @@
     {
         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_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);
         MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, 200);
+        if(ControlId != 0xFF)
+        {
+            MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);
+            RemoveControlCallback(ControlId, ThreadLoadControlCBFunction );
+            ControlId = 0xFF;
+        }
         if (CallbackCounter)
         {
             CallbackCounter--;
@@ -410,17 +436,18 @@
         else
             LOG_ERROR(MotorId, "Thread_Load_HomingCallback Callback is already 0");
 
+        return OK;
     }
     uint32_t Thread_Load_Dryer_Loading_Callback(uint32_t MotorId, uint32_t ReadValue)
     {
-        Report("Thread Load State Machine Callback.",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
-        if(ControlId != 0xFF)
+        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(ControlId != 0xFF)
         {
             MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz);
             RemoveControlCallback(ControlId, ThreadLoadControlCBFunction );
             ControlId = 0xFF;
-        }
-        //REPORT_MSG(MotorId, "Thread_Load_Dryer_Loading_Callback Motor Id");
+        }*/
         MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Thread_Load_Dryer_MovetoEncoderPosition_Callback,10000);
         return OK;
     }
@@ -428,14 +455,17 @@
     uint32_t Thread_Load_Dryer_Loading(void)
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
-        LoadArmInfo.LoadArmRounds = 20;
-        uint32_t numberOfSteps = 0;
+        LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
+        //LoadArmInfo.LoadArmRounds = 5;
+        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;
 
         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;
@@ -459,14 +489,16 @@
         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++;
+        Report("Thread_Load_Dryer_Loading",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
         MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
                                numberOfSteps,    Thread_Load_Dryer_Loading_Callback, 100000);
 
         //Keep Notation How Many Rotations In The Dryer
         //LoadArmInfo.LoadArmBackLash = 0;
-        LoadArmInfo.LoadArmRounds = 0xFF;
-        FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath);
+        LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
+        //FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
         return OK;
     }
     uint32_t Thread_Load_Jog_ThreadStop(uint32_t index, uint32_t ReadValue)
@@ -490,6 +522,25 @@
     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;
+        }
+        LoadStages = THREAD_LOAD_INIT;
         return OK;
     }
     uint32_t Thread_Load_Dryer_UnLoading(void)
@@ -507,7 +558,7 @@
         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 = MotorsControl[POOLER_MOTOR].integraltime;
+        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;
@@ -523,12 +574,13 @@
         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;
         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 = MotorsControl[WINDER_MOTOR].integraltime;
+        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;
@@ -544,6 +596,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,19 +606,23 @@
         //MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
         //                       numberOfSteps,    Thread_Load_Dryer_Loading_Callback, 100000);
         Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+        LoadArmInfo.LoadArmBackLash = 5;
+
         status |= MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
                                         MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4, Thread_Load_Set_Load_Arm_To_Stopper_Callback,LoadArmInfo.LoadArmBackLash,1000);
 
         //Keep Notation How Many Rotations In The Dryer
         //LoadArmInfo.LoadArmBackLash = 0;
-        LoadArmInfo.LoadArmRounds = 0xFF;
-        FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath);
+        LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
+        FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
         return OK;
     }
 
     uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM ReadValue)
     {
         REPORT_MSG(ReadValue,"ThreadLoadStateMachine");
+        if (LoadStages!=ReadValue)
+            LoadStages = ReadValue;
         switch (ReadValue)
         {
         case THREAD_LOAD_INIT:
@@ -613,10 +670,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 +679,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,6 +697,20 @@
     }
     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);
+    }
+    return OK;
+}
+uint32_t LoadCounter = 0;
 
 uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
@@ -699,6 +770,11 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         CurrentControlledSpeed[index] = calculated_speed;
         MotorSetSpeed(ThreadMotorIdToMotorId[index], calculated_speed);
     }
+/*    LoadCounter++;
+    if ((LoadCounter % 5001) == 0)
+    {
+          Report("MotorSpeedUpdated",__FILE__,index,abs(TranslatedReadValue),RpWarning,(int)CurrentControlledSpeed[index],0);
+    }*/
  return OK;
 }
 void ThreadLoadRequest(MessageContainer* requestContainer)
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 510168ab8..7e1312464 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -321,7 +321,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         {
             ScrewNumberOfSteps--;
             WindingConeLocation--;
-            ReportWithPackageFilter(ThreadFilter,"Head Backing",__FILE__,__LINE__,CalculationDirectionChangeCounter,RpWarning,ScrewNumberOfSteps, 0);
+  //          ReportWithPackageFilter(ThreadFilter,"Head Backing",__FILE__,__LINE__,CalculationDirectionChangeCounter,RpWarning,ScrewNumberOfSteps, 0);
         }
     }
     else //next time going back
@@ -329,7 +329,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         if ((CalculationDirectionChangeCounter/2)%InternalWinderCfg.SpoolBottomBackingRate == 0)
         {
             ScrewNumberOfSteps++;
-            Report("Bottom Backing ",__FILE__,__LINE__,CalculationDirectionChangeCounter,RpWarning,ScrewNumberOfSteps, 0);
+    //        Report("Bottom Backing ",__FILE__,__LINE__,CalculationDirectionChangeCounter,RpWarning,ScrewNumberOfSteps, 0);
         }
     }
    /* if (WinderMotorSpeedRollOver)
@@ -364,11 +364,11 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         ScrewRunningTime = temp;//(SYS_CLK_FREQ*Steps)/ScrewSpeed;
         //ROM_IntMasterEnable();
         //usnprintf(TempScrewStr, 100, "Winder: Horizon,Rotation, PPR, RPP{ %d, %d ,%d, %d} ",(int)screw_horizontal_speed,(int)RotationsPerSecond,(int)InternalWinderCfg.NumberOfRotationPerPassage,(int)MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround);
-        usnprintf(ScrewStr, 100, "Winder: Steps,Speed, Time, WinderSpeed{ %d, %d ,%d, %d} ",(int)ScrewNumberOfSteps,(int)ScrewSpeed,(int)temp,(int)WinderReferenceSpeed);
+//        usnprintf(ScrewStr, 100, "Winder: Steps,Speed, Time, WinderSpeed{ %d, %d ,%d, %d} ",(int)ScrewNumberOfSteps,(int)ScrewSpeed,(int)temp,(int)WinderReferenceSpeed);
         //        Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);
         //        #warning PID is now only proportional (above)
         //Report(TempScrewStr,__FILE__,__LINE__,0,RpWarning,0, 0);
-        Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0);
+//        Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0);
         //REPORT_MSG(temp , "new winder speed");
         //Report("new winder speed",__FILE__,ScrewNumberOfSteps,temp,RpWarning,ScrewSpeed,0);
     }
@@ -535,7 +535,7 @@ uint32_t ScrewDTSCallback(uint32_t deviceID, uint32_t BusyFlag)
 }
 uint32_t WinderDistanceToSpoolState(void )
 {
-    double DTS_Time = ((dryerbufferlength*100)/dyeingspeed)*1000;//distance to spool time in milliseconds
+    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);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 167616afe..fabb823fc 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -50,25 +50,25 @@ uint32_t Winder_End(void);
 
 typedef enum
 {
-    THREAD_LOAD_INIT,
-    THREAD_LOAD_REDUCE_HEAT,  //HEATERS OFF, DRYER BLOWER OFF, BLOWER LOW,
-    THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION,//USE NOTATION HOW MANY ROTATIONS IN THE DRYER, OR CHECK AGAINST STOPPER. MOVE SLOWLY
-    THREAD_LOAD_CENTER_HEAD_ROCKERS,  //puthead cleaning rockers to middle position
-    THREAD_LOAD_OPEN_COVERS,  //OPEN DYEING HEAD COVER AND DRYER LID
-    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
+    /*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_CENTER_HEAD_ROCKERS,  //puthead cleaning rockers to middle position
+    /*05*/ THREAD_LOAD_OPEN_COVERS,  //OPEN DYEING HEAD COVER AND DRYER LID
+    /*06*/ THREAD_LOAD_LIFT_DANCERS,
+    /*07*/ THREAD_LOAD_LIFT_ROCKERS, //MACHINE IS READY. SEND MESSAGE, START TIMER TO CLOSE LIDS, WAIT FOR OPERATOR RESPONSE
+    /*08*/ THREAD_LOAD_INITIAL_TENSION,//CHECK SPOOL PRESENCERUN WINDER UNTIL BREAK SENSOR IS IDENTIFIEING MOVEMENT FOR A SECOND
+    /*09*/ THREAD_LOAD_CLOSE_ROCKERS,
+    /*10*/ THREAD_LOAD_CLOSE_DANCERS, //SEND DANCER MOTORS TO PRESET LOCATION, CHECK THAT THE DANCERS ARE ON THE THREAD
+    /*11*/ THREAD_LOAD_CLOSE_LIDS,
+    /*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
                                 //KEEP NOTATION HOW MANY ROTATIONS IN THE DRYER
-    THREAD_LOAD_JOG_THREAD, //JOG THREAD SHORTLY TO MAKE SURE SPOOL IS RUNNING. REPORT END OF LOADING
-    THREAD_LOAD_END
+    /*14*/ THREAD_LOAD_RESUME_HEATING,
+    /*15*/ THREAD_LOAD_JOG_THREAD, //JOG THREAD SHORTLY TO MAKE SURE SPOOL IS RUNNING. REPORT END OF LOADING
+    /*16*/ 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++)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 528b83c1c..a88ce61a5 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -259,32 +259,38 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         return 0xFFFFFFFF;
     }
     PoolerCurrentPosition = MotorGetPosition(ThreadMotorIdToMotorId[index]);
-//    if (CurrentPosition == 0)
-//        return OK; //unusable data
-    if (Poolerinitialpos == 0xFFFF)
-    {
+    //if (PoolerCurrentPosition != 0)
+    //{
+        if (Poolerinitialpos == 0xFFFF)
+        {
+            PoolerPreviousPosition = PoolerCurrentPosition;
+            Poolerinitialpos = 0;
+        }
+        prevprev = PoolerPreviousPosition;
+        positionDiff = Control_Delta_Position_Pass(PoolerCurrentPosition,PoolerPreviousPosition);
+        //positionDiff = positionDiff / MotorsCfg[ThreadMotorIdToMotorId[index]].microstep;
         PoolerPreviousPosition = PoolerCurrentPosition;
-        Poolerinitialpos = 0;
-    }
-    prevprev = PreviousPosition;
-    positionDiff = Control_Delta_Position_Pass(PoolerCurrentPosition,PoolerPreviousPosition);
-    //positionDiff = positionDiff / MotorsCfg[ThreadMotorIdToMotorId[index]].microstep;
-    PoolerPreviousPosition = PoolerCurrentPosition;
 
-    length = (double)(positionDiff)*PoolerLengthCalculationMultiplier;
-    //if (InitialProcess == false)
-    {
-        PoolerTotalProcessedLength+= (length/100);
-        TempPoolerTotalProcessedLength = PoolerTotalProcessedLength;
-    }
-    if (length > 1000)
-    {
-        usnprintf(Lenstr, 100, "pooler length huge: length %d, diff 0x%x, pos 0x%x prev 0x%x",(int)length*100,(int)positionDiff,PreviousPosition,prevprev);
-        SendJobProgress(0.0,0,false, Lenstr);
-        Report(Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
-        length = 0;
+        // total length = (position diff / full cycle) * pulley perimeter
+        //(positionDiff/pulseperround)*((2*PI*motor_Radius)
 
-    }
+        //positionDiff = positionDiff / MotorsCfg[ThreadMotorIdToMotorId[index]].microstep;
+        length = (double)(positionDiff)*PoolerLengthCalculationMultiplier;
+
+        if (length > 1000)
+        {
+            usnprintf(Lenstr, 100, "length huge: length %d, diff 0x%x, pos 0x%x prev 0x%x",(int)length*100,(int)positionDiff,PreviousPosition,prevprev);
+            SendJobProgress(0.0,0,false, Lenstr);
+            Report(Lenstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
+            length = 0;
+
+        }
+
+    //}
+
+    length = (double)(positionDiff)*PoolerLengthCalculationMultiplier;
+    PoolerTotalProcessedLength+= (length/100);
+    TempPoolerTotalProcessedLength = PoolerTotalProcessedLength;
 #ifndef FEEDER_LENGTH_CALCULATION
     CurrentProcessedLength+=length;
 
@@ -914,8 +920,8 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
     }
     /*else if (InitialProcess==true)
     {
-        ThreadUpdateProcessLength (dryerbufferlength,(void *)ThreadPreSegmentEnded);
-        REPORT_MSG (dryerbufferlength," ThreadPreSegmentState DTS length (sample)");
+        ThreadUpdateProcessLength (dryerbufferMeters,(void *)ThreadPreSegmentEnded);
+        REPORT_MSG (dryerbufferCentimeters," ThreadPreSegmentState DTS length (sample)");
         SegmentState = false;
         PreSegmentState = true;
         DTSState = false;
@@ -977,7 +983,7 @@ uint32_t ThreadSegmentState(void *SegmentDetails, int SegmentId)
 //********************************************************************************************************************
 uint32_t ThreadDistanceToSpoolState(void )
 {
-    seglength = dryerbufferlength;
+    seglength = dryerbufferMeters;
     REPORT_MSG (seglength,"ThreadDistanceToSpoolState");
 //#ifdef FEEDER_LENGTH_CALCULATION
     ThreadUpdateProcessLength (seglength,(void *)ThreadDistanceToSpoolEnded);