Version 1.3.8.12 printing function calls with segments info. ids - no valves. improved winding. dispensers pressure build on startup. try not to touch valves during job

9 files changed, 158 insertions, 101 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 0529cfb89..b9120ddef 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -416,7 +416,7 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
     }
 
     //usnprintf(ACheatstr, 254, "HeaterCommandRequestMessage(Id %d,OnOff %d,Temperature %d)",HeaterId,  OnOff,  Temperature);
-    Report("HeaterCommandRequestMessage",__FILE__,Temperature,HeaterId,RpWarning,HeaterState,  0);
+    //Report("HeaterCommandRequestMessage",__FILE__,Temperature,HeaterId,RpWarning,HeaterState,  0);
     //Report("HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, 0, 0);
 
     return OK;
@@ -433,7 +433,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
         ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
         //HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id);
         HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//
-        Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0);
+        Report("PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
         HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);//TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
         HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);// = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
     }
@@ -497,7 +497,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
         LOG_ERROR (HeaterId,"PT100 not working properly");
         return ERROR;
     }
-    Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0);
+    Report("PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
         ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
@@ -518,7 +518,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
         return ERROR;
     }
 
-    Report("PrepareHeater ", __FILE__,__LINE__,HeaterId, SetTemperatue, 0, 0);
+    //Report("PrepareHeater ", __FILE__,__LINE__,HeaterId, SetTemperatue, 0, 0);
 
     //start thread control for all motors
     HeaterPIDConfig[HeaterId].m_params.MAX = HeaterControl[HeaterId].outputproportionalpowerlimit*100;
@@ -779,7 +779,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
-        Report("Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        Report("AC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         if (readValue > HeaterCmd[index].targettemperatue)
         {
             DeActivateHeater(index);
@@ -910,7 +910,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
-        Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index);
+        Report("DC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         if (readValue > HeaterCmd[index].targettemperatue)
         {
             DeActivateHeater(index);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index abfabe17d..0fcd73b59 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -23,9 +23,9 @@
 
 uint32_t CloseValveTimeout = 250;
 uint32_t OpenValveTimeout = 250;
-#define DISPENSER_BUILD_PRESSURE_SPEED 500
+#define DISPENSER_BUILD_PRESSURE_SPEED 900
 #define DISPENSER_BUILD_PRESSURE_LIMIT 1.5
-#define DISPENSER_BUILD_PRESSURE_TIMEOUT 20000
+#define DISPENSER_BUILD_PRESSURE_TIMEOUT 60000
 #define DISPENSER_BUILD_PRESSURE_LAG 50
 
 uint32_t DispenserPrepareSpeed = DISPENSER_BUILD_PRESSURE_SPEED;
@@ -92,7 +92,7 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
  uint32_t IDS_Dispenser_Build_Pressure(int DispenserId, callback_fptr callback)
 {
     DispenserCallback[DispenserId] = callback;
-    //Report("Control3WayValvesWithCallback called  ",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)0,0);
+    Report("IDS_Dispenser_Build_Pressure called  ",__FILE__,__LINE__,(int)DispenserPrepareSpeed,RpWarning,DispenserPrepareTimeLag,0);
 
     Control3WayValvesWithCallback ((Valves_t)DispenserId, CloseValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
     if (DispenserControlId[DispenserId] != 0xFF)
@@ -106,6 +106,7 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
         //Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
         DispenserPrepareTime[DispenserId]=0;
         TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
+        MotorSetDirection(HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize);
         MotorSetSpeed(HW_Motor_Id, DispenserPrepareSpeed);
         CurrentDispenserSpeed[DispenserId] = DispenserPrepareSpeed;
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index b201e6611..ded3642a0 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -29,15 +29,20 @@ typedef enum {
       LimitSwitchAlarmLow_8, //MOTO_DISPENSER_8 = 13,
 }LimitSwitchAlarms;
 
+extern bool EnableLubrication;
+extern bool EnableIntersegment;
+extern double IntersegmentLength;
+
+
 void IDS_ModuleInit (void);
 void Calculateinit(void);
 void IDS_Dispenser_Content_Init (void);
 
 uint32_t IDSPrepareState(void *JobDetails);
-uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId);
-uint32_t IDSSegmentState(void *JobDetails, int SegmentId);
+uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId);
+uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId);
 uint32_t IDSDistanceToSpoolState(void);
-uint32_t IDSEndState(void *JobDetails);
+uint32_t IDSEndState(void);
 
 uint32_t IDS_StartLubrication(void);
 uint32_t IDS_StopLubrication(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index adce14143..38c139141 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -229,22 +229,18 @@ void DispenserPrepareReady(void)
     DispenserPrepareReady();
     return OK;
 }
-bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int SegmentId)
+bool IDS_isDispenserUsedNextSegment(void *SegmentDetails,int DispenserId, int SegmentId)
 {
-    JobTicket* JobTicket = JobDetails;
+    JobSegment* Segment = SegmentDetails;
     int Dispenser_i,n_dispensers;
-    if (JobTicket->n_segments == 0)
-        return false;
-    if (JobTicket->n_segments <= SegmentId)
-        return false;
-    if (JobTicket->segments[SegmentId]->brushstops[0]->n_dispensers)
+    if (Segment->brushstops[0]->n_dispensers)
     {
-        n_dispensers = JobTicket->segments[SegmentId]->brushstops[0]->n_dispensers;
+        n_dispensers = Segment->brushstops[0]->n_dispensers;
         for (Dispenser_i = 0;Dispenser_i < n_dispensers;Dispenser_i++)
         {
-            if (DispenserId == JobTicket->segments[SegmentId]->brushstops[0]->dispensers[Dispenser_i]->index) //dispenser is in use next segment
+            if (DispenserId == Segment->brushstops[0]->dispensers[Dispenser_i]->index) //dispenser is in use next segment
             {
-                if (JobTicket->segments[SegmentId]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond>0)
+                if (Segment->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond>0)
                 {
                     return true;
                 }
@@ -289,7 +285,7 @@ bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int Segmen
   return OK; // all configured heaters are ready
  }
 
- int InterSegmentLength = 0;
+ int lInterSegmentLength = 0;
  int InterSegmentStepsLimit = 0,InterSegmentStepsCount = 0;
  int InterSegmentWFCFTime;
  uint32_t DispenserPreSegmentControlId = 0xFF;
@@ -317,7 +313,7 @@ This means that for each Pre-segment we must calculate: TW,TU,Tending,
 This means that for each segment we must calculate: Tx,Ty.
 
   */
-     InterSegmentStepsLimit = InterSegmentLength*10;//100 millisec steps
+     //InterSegmentStepsLimit = lInterSegmentLength*10;//100 millisec steps
      InterSegmentStepsCount++;
      if (InterSegmentStepsCount == InterSegmentStepsLimit)
      {
@@ -327,10 +323,10 @@ This means that for each segment we must calculate: Tx,Ty.
      return OK;
  }
 
-uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
+uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
 {
+    JobSegment* Segment = SegmentDetails;
 //set the speed only before the first segment, speed is constant accros job
-    JobTicket* JobTicket = JobDetails;
     int Dispenser_i,n_dispensers,DispenserId;
     TimerMotors_t HW_Motor_Id;
 
@@ -340,25 +336,19 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
     /* wait for all dispensers  to get to the required pressure
      * move the presegment ready when all dispensers are ready.
      */
-    if (JobTicket->n_segments == 0)
-        return OK;
-    if (SegmentId>=JobTicket->n_segments)
-        {
-            LOG_ERROR(SegmentId,"Error Segment");
-            return ERROR;
-        }
-
     REPORT_MSG(SegmentId,"IDSPreSegmentState");
-    if (JobBrushStopId>=JobTicket->segments[SegmentId]->n_brushstops)
+    if (JobBrushStopId>=Segment->n_brushstops)
     {
         LOG_ERROR(JobBrushStopId,"Error JobBrushStopId");
         return ERROR;
     }
-    if (( JobTicket->enableintersegment == true)&&(JobTicket->intersegmentlength>0))
+
+
+    if ((EnableIntersegment == true)&&(IntersegmentLength>0))
     {
         Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste); //if intersegment is defined throw the ink away
-        InterSegmentLength = (((JobTicket->intersegmentlength)*100)/dyeingspeed);
-        InterSegmentStepsLimit = InterSegmentLength*10;//100 millisec steps
+        lInterSegmentLength = ((IntersegmentLength*100)/dyeingspeed);
+        InterSegmentStepsLimit = lInterSegmentLength*10;//100 millisec steps
         InterSegmentStepsCount = 0;
         /*DispenserPreSegmentControlId = AddControlCallback( IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
         if (DispenserPreSegmentControlId == 0xFF)
@@ -368,12 +358,12 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
         }*/
     }
 
-    if (JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->n_dispensers)
+    if (Segment->brushstops[JobBrushStopId]->n_dispensers)
     {
-        n_dispensers = JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->n_dispensers;
+        n_dispensers = Segment->brushstops[JobBrushStopId]->n_dispensers;
         for (Dispenser_i = 0;Dispenser_i < n_dispensers;Dispenser_i++)
         {
-            DispenserId = JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->index;
+            DispenserId = Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->index;
             HW_Motor_Id = DispenserIdToMotorId[DispenserId];
             if (MotorsCfg[HW_Motor_Id].hardwaremotortype != DispenserIdToMotorId[DispenserId])//unconfigured dispenser
             {
@@ -381,30 +371,43 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
                 continue;
             }
             DispenserPreSegmentReady[DispenserId] = false;
+        }
+        for (Dispenser_i = 0;Dispenser_i < n_dispensers;Dispenser_i++)
+        {
+            DispenserId = Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->index;
+            HW_Motor_Id = DispenserIdToMotorId[DispenserId];
+            if (MotorsCfg[HW_Motor_Id].hardwaremotortype != DispenserIdToMotorId[DispenserId])//unconfigured dispenser
+            {
+                REPORT_MSG(DispenserId,"Dispenser PreSegment not configured");
+                continue;
+            }
             REPORT_MSG(DispenserId,"IDS_Valve_Presegment start");
             IDS_Dispenser_Set_Flow_Params(DispenserId,0,0);
-            if (JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
+            if (Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
             {
-                MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
+                MotorSetMicroStep(HW_Motor_Id, Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
             }
             else
             {
                 MotorSetMicroStep(HW_Motor_Id, MotorsCfg[HW_Motor_Id].microstep);
             }
 
-            if (JobTicket->segments[SegmentId]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond==0)
+            if (Segment->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond==0)
             {
-                //MotorStop(HW_Motor_Id,Hard_Hiz);
+                MotorStop(HW_Motor_Id,Hard_Hiz); //26/03/19 test  without valves
+                IDS_Valve_PresegmentReady(DispenserId,0);
                 //Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, IDS_Valve_PresegmentValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
-                IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,IDS_Valve_PresegmentValveReady);
+                //IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,IDS_Valve_PresegmentValveReady);
                 REPORT_MSG(DispenserId,"Dispenser Not Used Next Segment");
             }
             else
             {
-                if ((JobTicket->intersegmentlength)&&(SegmentId>0)) //there is an intersegment, stop all the dispensers. otherwise stop only dispensers that are not in use in the next segment.
+                if (IntersegmentLength&&(SegmentId>0)) //there is an intersegment, stop all the dispensers. otherwise stop only dispensers that are not in use in the next segment.
                 {
                     //Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, IDS_Valve_PresegmentValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
-                    IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,IDS_Valve_PresegmentValveReady);
+                    MotorStop(HW_Motor_Id,Hard_Hiz); //26/03/19 test  without valves
+                    IDS_Valve_PresegmentReady(DispenserId,0);
+                    //IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,IDS_Valve_PresegmentValveReady);
                     REPORT_MSG(DispenserId,"Dispenser Used Next Segment with intersegment");
                 }
                 else
@@ -437,48 +440,37 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
 
  char IdsMessage[100];
 //********************************************************************************************************************
- uint32_t IDSSegmentState(void *JobDetails, int SegmentId)
+uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
 {
-     JobTicket* JobTicket = JobDetails;
+     JobSegment* Segment = SegmentDetails;
      int Dispenser_i,n_dispensers,DispenserId;
      TimerMotors_t HW_Motor_Id;
      double segmentfirst_speed;
-     int CurrentSegment = SegmentId;
 
-     if (CurrentSegment>=JobTicket->n_segments)
-         {
-             LOG_ERROR(CurrentSegment,"Error Segment");
-             return ERROR;
-         }
-     if (JobBrushStopId>=JobTicket->segments[CurrentSegment]->n_brushstops)
-     {
-         LOG_ERROR(JobBrushStopId,"Error JobBrushStopId");
-         return ERROR;
-     }
      Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
-     if (JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->n_dispensers)
+     if (Segment->brushstops[JobBrushStopId]->n_dispensers)
      {
-         n_dispensers = JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->n_dispensers;
+         n_dispensers = Segment->brushstops[JobBrushStopId]->n_dispensers;
          for (Dispenser_i = 0;Dispenser_i < n_dispensers;Dispenser_i++)
          {
-             DispenserId = JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->index;
+             DispenserId = Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->index;
              HW_Motor_Id = DispenserIdToMotorId[DispenserId];
              if (MotorsCfg[HW_Motor_Id].hardwaremotortype != DispenserIdToMotorId[DispenserId])//unconfigured dispenser
                  continue;
              //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius)
-             segmentfirst_speed = JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanolitterpersecond/
-                     JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse;
-             if (JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
+             segmentfirst_speed = Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanolitterpersecond/
+                     Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse;
+             if (Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
              {
-                 //MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
-                 segmentfirst_speed/=JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision;  //the dye supply is calculated based on a 1/8 microstep
-                 IDS_Dispenser_Set_Flow_Params ( DispenserId, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse
-                                                 ,  JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
+                 //MotorSetMicroStep(HW_Motor_Id, Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
+                 segmentfirst_speed/=Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision;  //the dye supply is calculated based on a 1/8 microstep
+                 IDS_Dispenser_Set_Flow_Params ( DispenserId, Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse
+                                                 ,  Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
              }
              else
              {
                  //segmentfirst_speed/=MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
-                 IDS_Dispenser_Set_Flow_Params ( DispenserId, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse
+                 IDS_Dispenser_Set_Flow_Params ( DispenserId, Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse
                                                  ,MotorsCfg[HW_Motor_Id].microstep);
              }
              if ((int)segmentfirst_speed > 0)
@@ -486,8 +478,8 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
                      DispenserSegmentReady[DispenserId] = false;
                      //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
                      IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed,NULL);
-                     usnprintf(IdsMessage, 80, "Dispenser %d nl/sec %d nl/pulse %d speed %d",Dispenser_i,(int)JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanolitterpersecond,
-                               (int)JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse,(int)segmentfirst_speed);
+                     usnprintf(IdsMessage, 80, "Dispenser %d nl/sec %d nl/pulse %d speed %d",Dispenser_i,(int)Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanolitterpersecond,
+                               (int)Segment->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse,(int)segmentfirst_speed);
                      //REPORT_MSG(segmentfirst_speed,IdsMessage);
                      Report(IdsMessage,__FILE__,__LINE__,Dispenser_i,RpWarning,segmentfirst_speed,0);
                      SendJobProgress(0.0,0,false, IdsMessage);
@@ -553,7 +545,7 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
      return OK;
  }
 //********************************************************************************************************************
- uint32_t IDSEndState(void *JobDetails)
+ uint32_t IDSEndState(void )
 {
      int Dispenser_i;
      IDS_Active = false;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
index 638611c8b..3e2a6aa40 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
@@ -64,6 +64,8 @@ extern int MotorSamplePointer[MAX_THREAD_MOTORS_NUM];
 extern double NormalizedErrorCoEfficient[MAX_THREAD_MOTORS_NUM];
 extern int DancerStopActivityLimit[MAX_THREAD_MOTORS_NUM];
 extern    MotorControlConfig_t MotorControlConfig[MAX_THREAD_MOTORS_NUM];
+extern int32_t MotorSpeedSamples[MAX_THREAD_MOTORS_NUM][MAX_CONTROL_SAMPLES];
+extern int MotorSpeedSamplePointer[MAX_THREAD_MOTORS_NUM];
 
 
 uint32_t InternalWinderConfigMessage(HardwareWinder* request);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index d8a96a4d9..faee55608 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -40,8 +40,8 @@ void ScrewsStartControlTimer (void);
 bool     Winder_ScrewHoming = false;
 bool     ScrewCurrentDirection = false;  //holds current screw direction
 uint32_t ScrewDirectionChangeCounter = 1; //holds the current number of runs of the screw  - will be used to build the cone
-uint32_t ScrewChangeCounter = 0;
-uint32_t ScrewChangeLimit = 0;
+//uint32_t ScrewChangeCounter = 0;
+//uint32_t ScrewChangeLimit = 0;
 uint32_t CalculationDirectionChangeCounter = 1; //holds the current number of runs of the screw  - will be used to build the cone
 uint16_t WinderMotorSpeed[MAX_WINDER_SPEED_CALCULATION];
 uint16_t WinderMotorSpeedCounter = 0;
@@ -77,7 +77,7 @@ uint32_t InternalWindingConfigMessage(JobSpool* request)
     InternalWinderCfg.spoolbackingrate = request->backingrate;
     InternalWinderCfg.startoffsetpulses = request->startoffsetpulses;
     InternalWinderCfg.SpoolBottomBackingRate =  request->bottombackingrate;
-    InternalWinderCfg.NumberOfRotationPerPassage = request->rotationsperpassage;
+    InternalWinderCfg.NumberOfRotationPerPassage = 3.1415926*2;//request->rotationsperpassage;
     InternalWinderCfg.diameter = request->diameter;
 
     return status;
@@ -198,6 +198,8 @@ char ScrewStr[100];
 //char TempScrewStr[100];
 double WinderReferenceSpeed=0;
 int32_t  TotalWinderSpeed=0;
+bool Add100 = false;
+double Rotations = 6.0;
 uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 {
     //uint32_t Steps;
@@ -206,14 +208,18 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
     double RotationsPerSecond;
     int32_t Averagewinderspeed = 0;
 
-    ScrewChangeCounter++;
-    if ((ScrewChangeCounter>3)&&(ScrewChangeCounter<(ScrewChangeLimit-2))) //do not take the winder speed near the limits
+    //ScrewChangeCounter++;
+    //if ((ScrewChangeCounter>3)&&(ScrewChangeCounter<(ScrewChangeLimit-2))) //do not take the winder speed near the limits
     {
         TotalWinderSpeed-=WinderMotorSpeed[WinderMotorSpeedCounter];
         WinderMotorSpeed[WinderMotorSpeedCounter] = CurrentControlledSpeed[WINDER_MOTOR];
         TotalWinderSpeed+=WinderMotorSpeed[WinderMotorSpeedCounter];
         if (WinderMotorSpeedCounter++>=MAX_WINDER_SPEED_CALCULATION)
         {
+            if (WinderMotorSpeedRollOver == false)
+            {
+                Add100 = true;
+            }
             WinderMotorSpeedCounter=0;
             WinderMotorSpeedRollOver=true;
         }
@@ -227,6 +233,12 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 
     if (ScrewCurrentDirection == 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize) //next time going out
     {
+        if (Add100 == true) //once per job
+        {
+            ScrewNumberOfSteps += 100;
+            Add100 = false;
+        }
+
         if ((CalculationDirectionChangeCounter/2)%InternalWinderCfg.spoolbackingrate == 0)
         {
             ScrewNumberOfSteps--;
@@ -254,7 +266,9 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 
         WinderReferenceSpeed = Averagewinderspeed;
     }
-    screw_horizontal_speed = ScrewNumberOfSteps /  InternalWinderCfg.NumberOfRotationPerPassage;
+    screw_horizontal_speed = ScrewNumberOfSteps /  Rotations;//InternalWinderCfg.NumberOfRotationPerPassage;
+    if (Rotations > 7.0)
+        Rotations = 6.0;
     RotationsPerSecond =  WinderReferenceSpeed / (double)MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround;
     tempScrewSpeed = screw_horizontal_speed*RotationsPerSecond;
     //ROM_IntMasterDisable();
@@ -288,7 +302,7 @@ uint32_t WinderPresegmentReady(uint32_t deviceID, uint32_t ReadValue)
     return PreSegmentReady(Module_Winder,ModuleDone);
 }
 
-uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId)
+uint32_t Winder_Presegment(void *SegmentDetails, uint32_t SegmentId)
 {
     //JobTicket* JobTicket = JobDetails;
     double screw_horizontal_speed = 0;
@@ -330,6 +344,7 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId)
     //     * 4. start move of travel length
     //     * 5. register motor nBusy callback. this callback will flip between move(traverse length, hardstop) and goto(0), with handline og the coneshape and adjusting maxspeed
         ScrewNumberOfSteps = InternalWinderCfg.segmentoffsetpulses;//*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep;
+        ScrewNumberOfSteps -= 100;
         temp = SYS_CLK_FREQ;
         temp *= InternalWinderCfg.segmentoffsetpulses;
         temp /= ScrewSpeed;
@@ -349,6 +364,7 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId)
         WinderMotorSpeedCounter=0;
         TotalWinderSpeed = 0;
         WinderMotorSpeedRollOver=false;
+        Add100 = false;
    }
     PreSegmentReady(Module_Winder,ModuleDone);
 
@@ -429,8 +445,8 @@ void ScrewTimerInterrupt(int ARG0)
         ROM_TimerLoadSet(Screw_timerBase, TIMER_A,(int)ScrewRunningTime);
         MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection);
         MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed+random);
-        ScrewChangeCounter = 0;
-        ScrewChangeLimit = ScrewRunningTime/12000000;
+      //  ScrewChangeCounter = 0;
+      //  ScrewChangeLimit = ScrewRunningTime/12000000;
         ScrewDirectionChangeCounter++;
     }
     else
@@ -438,9 +454,10 @@ void ScrewTimerInterrupt(int ARG0)
         TimerDisable(Screw_timerBase, TIMER_A);
     }
     ROM_IntMasterEnable();
-    random++;
+    Rotations+=0.1;
+    /*random++;
     if (random >= 2)
-        random = -1;
+        random = -1;*/
     //Report("ScrewTimerInterrupt dir, duration, speed", __FILE__,ScrewCurrentDirection,ScrewRunningTime, RpMessage, ScrewSpeed, 0);
     //
     // Enable all interrupts.
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index cd71c73b1..69ac4b6ad 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -31,10 +31,10 @@ uint32_t ThreadConfigBreakSensor(void *request);
 uint32_t ThreadGetMotorSpeed(threadMotorsEnum MotorId);
 double ThreadGetMotorCalculatedError(int DancerId);
 uint32_t ThreadPrepareState(void *JobDetails);
-uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId);
-uint32_t ThreadSegmentState(void *JobDetails, int SegmentId);
+uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId);
+uint32_t ThreadSegmentState(void *SegmentDetails, int SegmentId);
 uint32_t ThreadDistanceToSpoolState(void);
-uint32_t ThreadEndState(void *JobDetails);
+uint32_t ThreadEndState();
 uint32_t ThreadInitialTestStub();
 
 uint32_t StoreDancerConfigMessage(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index c277dd5df..4454565c1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -22,6 +22,9 @@
 MotorDriverConfigStruc  MotorsCfg[NUM_OF_MOTORS]={0};
 HardwarePidControl MotorsControl[MAX_THREAD_MOTORS_NUM] = {0};
 
+int32_t MotorSpeedSamples[MAX_THREAD_MOTORS_NUM][MAX_CONTROL_SAMPLES] = {0};
+int MotorSpeedSamplePointer[MAX_THREAD_MOTORS_NUM] = {0};
+
 int32_t MotorSamples[MAX_THREAD_MOTORS_NUM][MAX_CONTROL_SAMPLES] = {0};
 int MotorSamplePointer[MAX_THREAD_MOTORS_NUM] = {0};
 double NormalizedErrorCoEfficient[MAX_THREAD_MOTORS_NUM] = {0};
@@ -104,7 +107,10 @@ uint32_t MotorPidRequestMessage(HardwarePidControl* request)
     MotorsControl[Motor_i].pvinputfilterfactormode = 10; //test longer control
 #endif
     for (i = 0;i < MotorsControl[Motor_i].pvinputfilterfactormode; i++)
+    {
         MotorSamples[Motor_i][i] = 0;  //reset the samples value for control beginning
+        MotorSpeedSamples[Motor_i][i] = 0;
+    }
     NormalizedErrorCoEfficient[Motor_i] = (2*PI*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].armlength);
     temp = 1<<(DancersCfg[ThreadMotorIdToDancerId[Motor_i]].resolutionbits);
     temp=(10*(temp-1)*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].maximalmovementmm);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index a6ca46246..4131fbca5 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -68,6 +68,12 @@ double TempPoolerTotalProcessedLength = 0.0;
 double TempTotalProcessedLength = 0.0;
 
 bool PrepareState = false;
+// job parameters
+bool EnableLubrication = false;
+bool EnableIntersegment = false;
+double IntersegmentLength = 0;
+
+
 int CurrentSegmentId = 0;
 typedef  void (* ProcessedLengthFunc)(void);
 ProcessedLengthFunc ProcessedLengthFuncPtr = NULL;
@@ -354,7 +360,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     //read value is the dancer angle
     int i,index=MAX_THREAD_MOTORS_NUM;
     int DancerId;
-    int32_t TranslatedReadValue, avreageSampleValue = 0;
+    int32_t TranslatedReadValue, avreageSampleValue = 0,avreageMotorSampleValue = 0;
     //double tempcalcspeed = 0;
     uint32_t calculated_speed;
     double NormalizedError;
@@ -373,6 +379,8 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 
     if(MotorControlConfig[index].m_isEnabled )
     {
+        //if (MotorDriverResponse[ThreadMotorIdToMotorId[index]].Busy == true)
+        //    return OK;
         DancerId = ThreadMotorIdToDancerId[index];
         if (ReadValue < 10)
         {
@@ -487,7 +495,23 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         {
             //KeepNormalizedError = NormalizedError;
         }
+        if ((JobCounter % 1000) == 0)
+        {
+            if (JobCounter >= 20000)
+            {
+                MotorSpeedSamples[index][MotorSpeedSamplePointer[index]] = CurrentControlledSpeed[index];//(-1 * TranslatedReadValue);
+                MotorSpeedSamplePointer[index]++;
+                if (MotorSpeedSamplePointer[index] >= MAX_CONTROL_SAMPLES)
+                    MotorSpeedSamplePointer[index] = 0;
+                for (i=0;i<MAX_CONTROL_SAMPLES;i++)
+                    avreageMotorSampleValue += MotorSpeedSamples[index][i];
+                avreageMotorSampleValue = avreageMotorSampleValue / MAX_CONTROL_SAMPLES;
+                //Report("MotorSpeedUpdated",__FILE__,index,OriginalMotorSpd_2PPS[index],RpWarning,avreageMotorSampleValue,0);
+                OriginalMotorSpd_2PPS[index] = avreageMotorSampleValue;
+            }
+        }
         calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*OriginalMotorSpd_2PPS[index];
+        //calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*CurrentControlledSpeed[index];
         if (abs(calculated_speed-CurrentControlledSpeed[index])> MotorControlConfig[index].m_ingnoreValue)
         {
             /*if (keepdata == true)
@@ -552,6 +576,7 @@ bool InitialProcess = false;
  uint32_t ThreadPrepareState(void *JobDetails)
 {
     int Motor_i, HW_Motor_Id, Pid_Id;
+    JobTicket* JobTicket = JobDetails;
     CurrentSegmentId = 0;
 
     JobCounter = 0;
@@ -564,6 +589,11 @@ bool InitialProcess = false;
     AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,false);
     AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,false);
 
+    EnableLubrication = JobTicket->enablelubrication;
+    EnableIntersegment = JobTicket->enableintersegment;
+    IntersegmentLength = JobTicket->intersegmentlength;
+
+
     //start thread control for all motors
     for (Motor_i = 0;Motor_i < MAX_THREAD_MOTORS_NUM;Motor_i++)
     {
@@ -660,7 +690,7 @@ bool InitialProcess = false;
 
 void SetOriginMotorSpeed(float process_speed)
 {
-    int Motor_i, HW_Motor_Id;
+    int i,Motor_i, HW_Motor_Id;
     for (Motor_i = 0; Motor_i <= WINDER_MOTOR; Motor_i++)
     {
         HW_Motor_Id = ThreadMotorIdToMotorId[Motor_i];
@@ -672,14 +702,16 @@ void SetOriginMotorSpeed(float process_speed)
         //MotorControlConfig[Motor_i].m_SetParam = motor_speed;
         OriginalMotorSpd_2PPS[Motor_i] = (int) motor_speed;
         CurrentControlledSpeed[Motor_i] = (int) motor_speed;
+        for (i = 0; i <= MAX_CONTROL_SAMPLES; i++)
+            MotorSpeedSamples[Motor_i][i] = motor_speed;
     }
 }
 
 //********************************************************************************************************************
-uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId)
+uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
 {
 //set the speed only before the first segment, speed is constant across all job segments and intersegments
-    JobTicket* JobTicket = JobDetails;
+    JobSegment* Segment = SegmentDetails;
 
     float process_speed = dyeingspeed;
     if (dyeingspeed == 0)
@@ -709,7 +741,7 @@ uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId)
             MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize);
             MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 1);
         }
-        if (JobTicket->enablelubrication == true)
+        if (EnableLubrication == true)
         {
             IDS_StartLubrication();
         }
@@ -718,9 +750,10 @@ uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId)
     //set speed for both rocker motors
     //wait for all motors to get to the required speed (set the target speed for the control to check)
     //call the job state machine when the thread system is ready
-    if ((InitialProcess==false) && JobTicket->enableintersegment == true)
+    if ((InitialProcess==false) && (EnableIntersegment == true) && (IntersegmentLength >= 1.0)) //fix - avoid intersegment length 0
     {
-        ThreadUpdateProcessLength (JobTicket->intersegmentlength,(void *)ThreadInterSegmentEnded);
+        ThreadUpdateProcessLength (IntersegmentLength,(void *)ThreadInterSegmentEnded);
+        REPORT_MSG (IntersegmentLength," ThreadPreSegmentState IntersegmentLength");
     }
     else
     {
@@ -736,11 +769,12 @@ int REPSegmentId = 0;
 void ThreadInterSegmentEnded(void)
 {
     REPORT_MSG (REPSegmentId,"ThreadInterSegmentEnded");
+    //ThreadUpdateProcessLength (0,(void *)NULL);
     PreSegmentReady(Module_Thread,ModuleDone);
 }
 void ThreadSegmentEnded(void)
 {
-    REPORT_MSG (REPSegmentId," ThreadSegmentState");
+    REPORT_MSG (REPSegmentId," ThreadSegmentEnded");
     SegmentReady(Module_Thread,ModuleDone);
 }
 void ThreadDistanceToSpoolEnded(void)
@@ -750,11 +784,11 @@ void ThreadDistanceToSpoolEnded(void)
 }
 double seglength = 0.0;
 //********************************************************************************************************************
-uint32_t ThreadSegmentState(void *JobDetails, int SegmentId)
+uint32_t ThreadSegmentState(void *SegmentDetails, int SegmentId)
 {
-    JobTicket* JobTicket = JobDetails;
+    JobSegment* Segment = SegmentDetails;
     REPSegmentId = SegmentId;
-    seglength = JobTicket->segments[SegmentId]->length;
+    seglength = Segment->length;
     CurrentSegmentId = SegmentId;
     REPORT_MSG (seglength," ThreadSegmentState");
     ThreadUpdateProcessLength (seglength,(void *)ThreadSegmentEnded);
@@ -772,7 +806,7 @@ uint32_t ThreadDistanceToSpoolState(void )
 
 char Endstr[150];
 //********************************************************************************************************************
- uint32_t ThreadEndState(void *JobDetails)
+ uint32_t ThreadEndState(void )
 {
      int Motor_i;
      ThreadControlActive = false;