PBU in pre-run preparations

5 files changed, 84 insertions, 124 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 4d103395c..404fbf3de 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -78,11 +78,8 @@ void IDS_Dispenser_SetPrepareValues(    uint32_t DispenserBuildPressureSpeed,
 }
 void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout)
 {
-    if (Special_Dispensers == false)
-    {
-        CloseValveTimeout = CloseTimeout;
-        OpenValveTimeout = OpenTimeout;
-    }
+     CloseValveTimeout = CloseTimeout;
+     OpenValveTimeout = OpenTimeout;
      ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetTimeOutValues ",__FILE__,__LINE__,OpenValveTimeout,RpWarning,(int)CloseValveTimeout,0);
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 9c422444f..90a2af771 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -92,14 +92,7 @@ AutoHoming_Config_enum AutoHoming_Config = AutoHoming_off;
 void IDS_Dispenser_SetAutoHoming_Config(AutoHoming_Config_enum Config)
 {
     ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_SetAutoHoming_Config ",__FILE__,__LINE__,Config,RpWarning,AutoHoming_Config,0);
-    if (Special_Dispensers == false)
-    {
-        AutoHoming_Config = Config;
-    }
-    else
-    {
-        AutoHoming_Config = AutoHoming_off;
-    }
+    AutoHoming_Config = Config;
 #ifdef DISPESER_TEST
     AutoHoming_Config = AutoHoming_off;
 #endif
@@ -190,10 +183,10 @@ uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId,  uint32_t timeo
     }
     return OK;
 }*/
-uint32_t IDS_Honing_Timeout_Callback(uint32_t DispenserId, uint32_t ReadValue)
+uint32_t IDS_Homing_Timeout_Callback(uint32_t DispenserId, uint32_t ReadValue)
 {
-    ReportWithPackageFilter(IDSFilter,"IDS_Honing_Timeout_Callback",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,2000,0);
-    SafeRemoveControlCallback(DispenserHomingTimeoutControlId[DispenserId], IDS_Honing_Timeout_Callback );
+    ReportWithPackageFilter(IDSFilter,"IDS_Homing_Timeout_Callback",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,2000,0);
+    SafeRemoveControlCallback(DispenserHomingTimeoutControlId[DispenserId], IDS_Homing_Timeout_Callback );
     AlarmHandlingSetAlarm (DispenserId+EVENT_TYPE__DISPENSER_1_REFILL_FAILURE,true);
     return OK;
 }
@@ -212,7 +205,7 @@ uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
         HomingRequestCallback[DispenserId](DispenserId,0);
         HomingRequestCallback[DispenserId] = NULL;
     }
-    RemoveControlCallback(DispenserHomingTimeoutControlId[DispenserId], IDS_Honing_Timeout_Callback );
+    RemoveControlCallback(DispenserHomingTimeoutControlId[DispenserId], IDS_Homing_Timeout_Callback );
     //    HomingActive[DispenserId]= false;
     IDS_Dispenser_RefillEnded ( DispenserId, MotorsCfg[motorId].microstep);
     ReportWithPackageFilter(IDSFilter,"Homing ended",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
@@ -312,7 +305,7 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
             CurrentDispenserSpeed[DispenserId] = speed/4;
             ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed/4,0);
             if (DispenserHomingTimeoutControlId[DispenserId] == 0xFF)
-                DispenserHomingTimeoutControlId[DispenserId] = AddControlCallback("IDS Homing Timeout", IDS_Honing_Timeout_Callback, eOneHour*4,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
+                DispenserHomingTimeoutControlId[DispenserId] = AddControlCallback("IDS Homing Timeout", IDS_Homing_Timeout_Callback, eOneHour*4,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
 
         }
         else
@@ -321,7 +314,7 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
             CurrentDispenserSpeed[DispenserId] = speed;
             ReportWithPackageFilter(IDSFilter,"IDS_HomeDispenser ",__FILE__,(int)(midTankContent*1000),(int)DispenserId,RpWarning,speed,0);
             if (DispenserHomingTimeoutControlId[DispenserId] == 0xFF)
-                DispenserHomingTimeoutControlId[DispenserId] = AddControlCallback("IDS Homing Timeout", IDS_Honing_Timeout_Callback, eOneHour,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
+                DispenserHomingTimeoutControlId[DispenserId] = AddControlCallback("IDS Homing Timeout", IDS_Homing_Timeout_Callback, eOneHour,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
         }
         CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]);
         DispenserLastMovementDown[DispenserId] = true;
@@ -343,7 +336,7 @@ uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
 
     TimerMotors_t MotorId = (DispenserId)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
     MotorAbortMovetoLimitSwitch(MotorId);
-    RemoveControlCallback(DispenserHomingTimeoutControlId[DispenserId], IDS_Honing_Timeout_Callback );
+    RemoveControlCallback(DispenserHomingTimeoutControlId[DispenserId], IDS_Homing_Timeout_Callback );
     //close dry air valve in the dispenser
     Disable_MidTank_Pressure_Reading(DispenserId);
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
@@ -609,14 +602,6 @@ void IDS_Dispenser_Init(uint8_t DispenserId)
     HomingActive[DispenserId]= false;
     PrimingActive[DispenserId]= false;
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
-/*#ifdef DISPENSER_VALVES_OPEN
-    Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-#else
-    Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-#endif*/
-    //if (Special_Dispensers == true)
-    {
-        if (ControlIdtoInactiveDispenserId[DispenserId] == 0xFF)
-            ControlIdtoInactiveDispenserId[DispenserId] = AddControlCallback("IDS_Check_Pressure", IDS_Check_Pressure_Callback, eOneMinute,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
-    }
+    if (ControlIdtoInactiveDispenserId[DispenserId] == 0xFF)
+        ControlIdtoInactiveDispenserId[DispenserId] = AddControlCallback("IDS_Check_Pressure", IDS_Check_Pressure_Callback, eOneMinute,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index eb5f12136..504b3bb0c 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -57,7 +57,6 @@ bool    DispenserReady[MAX_SYSTEM_DISPENSERS] = {true};
 bool IDS_Active = false;
 bool ActuatorsCleaningSequence = true;
 
-bool Special_Dispensers = false;
 /******************** STRUCTURES AND ENUMs  ********************************************/
 uint32_t IDS_Valve_DistanceToSpoolReady(uint32_t deviceID, uint32_t ReadValue);
 uint32_t IDS_Valve_PresegmentReady(uint32_t deviceID, uint32_t ReadValue);
@@ -462,6 +461,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
  double TargetNumberOfStepsPreRun = 120000,MaximalPressurePreRun = 4;
  int DispenserTotalPrepareSteps[MAX_SYSTEM_DISPENSERS];
  bool DispenserLastMovementDown[MAX_SYSTEM_DISPENSERS];
+ bool DispenserPBUReady[MAX_SYSTEM_DISPENSERS];
 
  #define PRESSURE_READ_TIME_GAP 100
  //this function returns preparation ratio for the most cool heater (current temperature/ target temerature)
@@ -620,6 +620,13 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
          for (i = 0; i < MAX_DYE_DISPENSERS; i++)
          {
              pressure = GetDispenserPressure(i);
+#ifdef DISPENSER_PBU_PRE_RUN
+             if ((pressure>3.0)&&(DispenserPBUReady[i]==false))
+             {
+                 Control3WayValvesWithCallback ((Valves_t)i, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+                 DispenserPBUReady[i] = true;
+             }
+#endif
              //IDS_StopHomeDispenser(i);
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
              {
@@ -642,8 +649,16 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                  {
                      if (AdjustDispenserSpeedToPressure(i,DispenserPreparePressure,pressure) == true)
                      {
+#ifdef DISPENSER_PBU_PRE_RUN
+                         if(DispenserPBUReady[i] == true)
+                         {
+                             NumofReadyDispensers++;
+                             DispenserReady[i] = true;
+                         }
+#else
                          NumofReadyDispensers++;
                          DispenserReady[i] = true;
+#endif
                      }
                  }
                  //ReportWithPackageFilter(IDSFilter,"IDS prepare",__FILE__,i,(int)DispenserTotalPrepareSteps[i],RpWarning,(int)(CurrentDispenserSpeed[i]*100),0);
@@ -661,6 +676,16 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                  ReportWithPackageFilter(IDSFilter,"IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(pressure*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
              CurrentDispenserSpeed[CLEANER_DISPENSER] = 0;
          }
+
+         pressure = GetDispenserPressure(LUBRICANT_DISPENSER);
+         if ((pressure > 0.01)&&(lubricant_speed > 0.1))
+         {
+             HW_Motor_Id = DispenserIdToMotorId[LUBRICANT_DISPENSER];
+             MotorStop(HW_Motor_Id, Hard_Hiz);
+             if (CurrentDispenserSpeed[LUBRICANT_DISPENSER])
+                 ReportWithPackageFilter(IDSFilter,"IDS stop lubricant",__FILE__,LUBRICANT_DISPENSER,(int)(pressure*100),RpWarning,(int)CurrentDispenserSpeed[LUBRICANT_DISPENSER] ,0);
+             CurrentDispenserSpeed[LUBRICANT_DISPENSER] = 0;
+         }
 #endif
          if ((NumofReadyDispensers)&&(DispenserBuildTimeCounter%1000 == 0))
          {
@@ -743,14 +768,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                              segmentfirst_speed /= 100;
                              DispenserSegmentReady[DispenserId] = false;
                              //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-                             if (Special_Dispensers == true)
-                             {
-                                 IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed,NULL);
-                             }
-                             else
-                             {
-                                 MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
-                             }
+                             MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
                              CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
 
                              /*usnprintf(IdMessage, 80,
@@ -808,6 +826,14 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
              CurrentDispenserSpeed[CLEANER_DISPENSER] = 0;
              ReportWithPackageFilter(IDSFilter,"IDS stop cleaner",__FILE__,CLEANER_DISPENSER,(int)(pressure*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
          }
+         if (CurrentDispenserSpeed[LUBRICANT_DISPENSER])
+         {
+             HW_Motor_Id = DispenserIdToMotorId[LUBRICANT_DISPENSER];
+             MotorStop(HW_Motor_Id, Hard_Hiz);
+             if (CurrentDispenserSpeed[LUBRICANT_DISPENSER])
+                 ReportWithPackageFilter(IDSFilter,"IDS stop lubricant",__FILE__,LUBRICANT_DISPENSER,(int)(pressure*100),RpWarning,(int)CurrentDispenserSpeed[LUBRICANT_DISPENSER] ,0);
+             CurrentDispenserSpeed[LUBRICANT_DISPENSER] = 0;
+         }
 #endif
          SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
          DispenserPrepareControlId = 0xFF;
@@ -859,11 +885,6 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
     TargetNumberOfStepsPreRun = InitialDispenserTimeout;
     MaximalPressurePreRun = InitialDispenserPressure;
 
-    if(Head_Type == HEAD_TYPE_ARC)
-    {
-        MotorMovetoLimitSwitch(HARDWARE_MOTOR_TYPE__MOTO_DH_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 30,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], NULL,30000);
-    }
-
     for (Motor_i = 0;Motor_i < MAX_SYSTEM_DISPENSERS;Motor_i++)
     {
         TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[Motor_i];
@@ -904,6 +925,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
  {
      int i;
      double dispenserspeed = 0;
+     double pressure;
 
      if (IDS_Active == false)
      {
@@ -930,6 +952,16 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
              }
              DispenserTotalPrepareSteps[i] = 0;
              ReportWithPackageFilter(IDSFilter,"Dispenser total prepare steps zero",__FILE__,i,DispenserTotalPrepareSteps[i],RpWarning,IDS_Dispenser_Data[i].consumedinnanolitter,0);
+#ifdef DISPENSER_PBU_PRE_RUN
+             pressure = GetDispenserPressure(i);
+             if (pressure<3.0)
+             {
+                 Control3WayValvesWithCallback ((Valves_t)i, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+                 DispenserPBUReady[i] = false;
+             }
+             else
+                 DispenserPBUReady[i] = true;
+#endif
          }
          else
          {
@@ -962,10 +994,6 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
          for (i = 0; i < MAX_DYE_DISPENSERS; i++)
          {
              dispenserspeed = DispenserPrepareSpeed;
-             if (Special_Dispensers == true)
-             {
-                 dispenserspeed = 300;
-             }
              TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[i];
 
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
@@ -974,14 +1002,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                  {
                      ReportWithPackageFilter(IDSFilter,"Prepare Speed",__FILE__,HomingActive[i],i,RpWarning,(int)dispenserspeed,0);
                      MotorSetDirection((TimerMotors_t)HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize); //set the dispenser to the
-                     if (Special_Dispensers == true)
-                     {
-                         MotorSetSpeed((TimerMotors_t)HW_Motor_Id,dispenserspeed); //set the dispenser to the
-                     }
-                     else
-                     {
-                         IDS_Dispenser_Start_Motor_and_Open_Valve(i,dispenserspeed, NULL);
-                     }
+                     MotorSetSpeed((TimerMotors_t)HW_Motor_Id,dispenserspeed); //set the dispenser to the
                  }
                  /*else
                  {
@@ -998,6 +1019,16 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
              CurrentDispenserSpeed[CLEANER_DISPENSER] = INITIAL_CLEANER_SPEED;
          }
          ReportWithPackageFilter(IDSFilter,"IDS start cleaner",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
+         if (lubricant_speed > 0.1)
+         {
+             if (GetDispenserPressure(LUBRICANT_DISPENSER) < 0.01)
+             {
+                 TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[LUBRICANT_DISPENSER];
+                 MotorSetSpeed((TimerMotors_t)HW_Motor_Id,INITIAL_CLEANER_SPEED ); //set the dispenser to the
+                 CurrentDispenserSpeed[LUBRICANT_DISPENSER] = INITIAL_CLEANER_SPEED;
+             }
+             ReportWithPackageFilter(IDSFilter,"IDS start lubricant",__FILE__,CLEANER_DISPENSER,(int)(GetDispenserPressure(CLEANER_DISPENSER)*100),RpWarning,(int)CurrentDispenserSpeed[CLEANER_DISPENSER] ,0);
+         }
 #endif
 
      }
@@ -1127,14 +1158,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
                  {
                      if (DispenserUsedInJob[DispenserId] == true)
                      {
-                         if (Special_Dispensers == true)
-                         {
-                             IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
-                         }
-                         else
-                         {
-                             MotorStop(HW_Motor_Id, Hard_Hiz);
-                         }
+                         IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
                          CurrentDispenserSpeed[DispenserId] = 0;
                          //usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
                          //ReportWithPackageFilter(IDSFilter,IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
@@ -1402,7 +1426,7 @@ uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
             }//for brushstops
         }
     }
-    ReportWithPackageFilter(IDSFilter,"Unhandled brushstops result",__FILE__,__LINE__,(int)Brush_i,RpWarning,(int)PrevSegment->brushstopscount,0);
+    ReportWithPackageFilter(IDSFilter,"Unhandled brushstops result",__FILE__,__LINE__,(int)Brush_i,RpWarning,(int)PrevSegment,0);
     return OK;
 }
 uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
@@ -1521,14 +1545,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             {
                 if (DispenserUsedInJob[DispenserId] == true)
                 {
-                    if (Special_Dispensers == true)
-                    {
-                        IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
-                    }
-                    else
-                    {
-                        MotorStop(HW_Motor_Id,Soft_Hiz); //26/03/19 test  without valves
-                    }
+                    IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
                     CurrentDispenserSpeed[DispenserId] = 0;
                     DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped
                     REPORT_MSG(DispenserId,"Dispenser stopped pre Segment");
@@ -1601,15 +1618,7 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                 /*IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,
                                                          segmentfirst_speed,
                                                          NULL);*/
-                //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-                if (Special_Dispensers == true)
-                {
-                    IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed, NULL);
-                }
-                else
-                {
-                    MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
-                }
+                IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed, NULL);
                 CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
                 /*usnprintf(IdsMessage, 80,
                           "Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d steps %d/%d",
@@ -1628,14 +1637,7 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                 //IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);*/
                 if (DispenserUsedInJob[DispenserId] == true)
                 {
-                    if (Special_Dispensers == true)
-                    {
-                        IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
-                    }
-                    else
-                    {
-                        MotorStop(HW_Motor_Id, Hard_Hiz);
-                    }
+                    IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
                     CurrentDispenserSpeed[DispenserId] = 0;
                 }
                 //ReportWithPackageFilter(IDSFilter,"inActive dispenser stopped", __FILE__, __LINE__, DispenserId, RpWarning,   segmentfirst_speed, 0);
@@ -1845,14 +1847,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
              {
                  DispenserDistanceToSpoolReady[Dispenser_i] = false;
                  dispenserCount++;
-                 if (Special_Dispensers == true)
-                 {
-                     IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
-                 }
-                 else
-                 {
-                     MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
-                 }
+                 IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
                  Control3WayValvesWithCallback ((Valves_t)Dispenser_i, MidTank_Dispenser, IDS_Valve_DistanceToSpoolValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
                  CurrentDispenserSpeed[Dispenser_i] = 0;
                  //IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_DistanceToSpoolValveReady);
@@ -1940,14 +1935,8 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          if (DispenserUsedInJob[Dispenser_i] == true)
          {
              AlarmHandlingSetAlarm (EVENT_TYPE__DISPENSER_1_UNDERPRESSURE+Dispenser_i,OFF);  //handle alarm detection and operation
-             if (Special_Dispensers == true)
-             {
-                 IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
-             }
-             else
-             {
-                 MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
-             }
+             TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[Dispenser_i];
+             MotorStop(HW_Motor_Id,Hard_Hiz);
 #ifdef DISPENSER_VALVES_OPEN
              Control3WayValvesWithCallback (Dispenser_i, Dispenser_Mixer, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
 #else
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 659a308db..6a3c2074f 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -1018,17 +1018,6 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
-    if(request->amount == 0xE5)  //fast refresh for pressure
-    {
-        if (request->delay<=1)
-        {
-            Report("Set special dispensers ",__FILE__,__LINE__,request->delay,RpWarning,Special_Dispensers,0);
-            Special_Dispensers = request->delay;
-        }
-        response.progress = (double)OK;
-        response.has_progress = true;
-    }
-    else
     if(request->amount == 0xE6)  //fast refresh for pressure
     {
         Report("HeaterSafetyTestSetLimits ",__FILE__,__LINE__,request->delay,RpWarning,0,0);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 697f1bd5d..40748b0ee 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -1114,6 +1114,12 @@ uint32_t ThreadPrepareState(void *JobDetails)
 
     PrepareWaitCount = 0;
 
+    status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__LeftDancer, windertension);
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Winder",__FILE__,HARDWARE_DANCER_TYPE__LeftDancer,PrepareWaitCount,RpWarning,(int)windertension,0);
+#ifndef BTSR_NO_PULLER_TFU
+    status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__MiddleDancer, pullertension);
+    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Puller",__FILE__,HARDWARE_DANCER_TYPE__MiddleDancer,PrepareWaitCount,RpWarning,(int)pullertension,0);
+#endif
 #ifdef UFEEDER_BTSR
     status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__LeftDancer, JobTicket->btsrparameters->exittension);
     ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Winder",__FILE__,HARDWARE_DANCER_TYPE__LeftDancer,PrepareWaitCount,RpWarning,(int)JobTicket->btsrparameters->exittension,0);
@@ -1122,17 +1128,11 @@ uint32_t ThreadPrepareState(void *JobDetails)
     BTSR_Read_Length(RUFeeder1, HIGHEST);
     ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension BTSR",__FILE__,application,type,RpError,tension,tension_err);
 #else
-    status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__LeftDancer, windertension);
-    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Winder",__FILE__,HARDWARE_DANCER_TYPE__LeftDancer,PrepareWaitCount,RpWarning,(int)windertension,0);
-#endif
-#ifndef BTSR_NO_PULLER_TFU
-    status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__MiddleDancer, pullertension);
-    ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Puller",__FILE__,HARDWARE_DANCER_TYPE__MiddleDancer,PrepareWaitCount,RpWarning,(int)pullertension,0);
-#endif
 #ifndef BTSR_NO_FEEDER_TFU
     status = ThreadPrepare_Tension (HARDWARE_DANCER_TYPE__RightDancer, feedertension);
     ReportWithPackageFilter(ThreadFilter,"ThreadPrepare_Tension Feeder",__FILE__,HARDWARE_DANCER_TYPE__RightDancer,PrepareWaitCount,RpWarning,(int)feedertension,0);
 #endif
+#endif
 
     FirstCalcInJob = true;
     if(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].speedmaster == false)