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

15 files changed, 214 insertions, 155 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c
index a404ca8ee..64c5dd9a2 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c
@@ -56,6 +56,7 @@ uint32_t ActivateVersionCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
     ActivateVersionResponse response = ACTIVATE_VERSION_RESPONSE__INIT;
     MessageContainer responseContainer;
     bool last = true;
+    double file_progress = (double)vme_index/CurrentFileSize;
 
     if (CurrentRunningFile<NumberOfFiles)
     {
@@ -63,7 +64,7 @@ uint32_t ActivateVersionCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
     }
     response.has_progress = true;
     response.has_total = true;
-    response.progress = CurrentRunningFile+(vme_index/CurrentFileSize);
+    response.progress = CurrentRunningFile+file_progress;
     response.total = NumberOfFiles;
 
 
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 3b8a71444..b5edc9554 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -55,14 +55,11 @@
 
 //#define VAC_TEST
 #define DISPENSER_VALVES_OPEN
+//#define DISPENSER_PBU_PRE_RUN
 //#define USE_TUNNEL_PT100
 //#define BTSR_NO_FEEDER_TFU
 //#define BTSR_NO_PULLER_TFU
 //#define IGNORE_SPIKE
-//#define SPECIAL_DISPENSERS
-extern bool Special_Dispensers;
-//#define Use_Head_Card //for real card only
-//#define Use_WHS_Card //for real card only
 
 #define USE_OLD_HEAD_EEPROM
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c b/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c
index 20c6d5a00..44f1ffe78 100644
--- a/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c
+++ b/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.c
@@ -45,6 +45,7 @@ uint32_t MCU_E2PromProgram(int Address,uint32_t Data)
     return (EEPROMProgram((uint32_t *)&Buffer, Address*4, 4));
 #endif
 }
+
 uint32_t MCU_E2PromRead(int Address,uint32_t *Data)
 {
     if (Address>=MAX_EEPROM_STORAGE)
@@ -60,6 +61,44 @@ uint32_t MCU_E2PromRead(int Address,uint32_t *Data)
     return OK;
 
 }
+
+uint32_t MCU_E2PromProgramFloat(int Address,float Data)
+{
+    float Buffer = Data;
+    if (Address>=MAX_EEPROM_STORAGE)
+    {
+        Report("MCU_E2PromProgram Error",__FILE__,__LINE__,Address,RpWarning,Data,0);
+        return ERROR;
+    }
+    if ((Address>=EEPROM_STORAGE_DANCER_0)&&(Address<=EEPROM_STORAGE_DANCER_2))
+    {
+        Report("~~~~~~Store dancers eeprom ",__FILE__,__LINE__,(int)Address,RpWarning,(int)Data,0);
+
+    }
+    Report("MCU_E2PromProgram",__FILE__,__LINE__,Address,RpWarning,(int)Data*1000,0);
+#ifdef EVALUATION_BOARD
+    return 0;
+#else
+    return (EEPROMProgram((float *)&Buffer, Address*4, 4));
+#endif
+}
+
+uint32_t MCU_E2PromReadFloat(int Address,float *Data)
+{
+    if (Address>=MAX_EEPROM_STORAGE)
+    {
+        Report("MCU_E2PromRead Error",__FILE__,__LINE__,Address,RpWarning,(int)(*Data)*1000,0);
+        //return ERROR;
+    }
+#ifndef EVALUATION_BOARD
+    EEPROMRead((float *)Data,Address*4, 4);
+#endif
+    Report("MCU_E2PromRead",__FILE__,__LINE__,Address,RpWarning,(int)(*Data)*1000,0);
+
+    return OK;
+
+}
+
 /**************************************************/
 uint32_t MCU_E2PromProgramChunk(int Address,uint16_t Length,uint32_t Data)
 {
@@ -362,6 +401,7 @@ void MainCardEEpromWriteRequestFunc(MessageContainer* requestContainer)
     stub_main_card_eeprom_write_request__free_unpacked(request,NULL);
 
 }
+
 uint32_t BtsrSaveParamsToEeprom(void *Data)
 {
     BTSRParameters* BtsrPrameters = Data;
@@ -373,17 +413,17 @@ uint32_t BtsrSaveParamsToEeprom(void *Data)
     if (memcmp(BtsrPrameters,&ExistingBtsrPrameters,sizeof(ExistingBtsrPrameters)))
     {
         data = BtsrPrameters->feedingtension;
-        status |= MCU_E2PromProgram(EEPROM_BTSR_FEEDING_TENSION, data);
+        status |= MCU_E2PromProgramFloat(EEPROM_BTSR_FEEDING_TENSION, data);
         status |= MCU_E2PromProgram(EEPROM_BTSR_TYPE, BtsrPrameters->btsryarntype);
         status |= MCU_E2PromProgram(EEPROM_BTSR_APPLICATION, BtsrPrameters->btsrapplicationtype);
         data = BtsrPrameters->threadlengthfactor;
-        status |= MCU_E2PromProgram(EEPROM_BTSR_LENGTH_OFFSET, data);
+        status |= MCU_E2PromProgramFloat(EEPROM_BTSR_LENGTH_OFFSET, data);
         data = BtsrPrameters->tensionerror;
-        status |= MCU_E2PromProgram(EEPROM_BTSR_TENSION_ERROR, data);
+        status |= MCU_E2PromProgramFloat(EEPROM_BTSR_TENSION_ERROR, data);
         data = BtsrPrameters->spooltension;
-        status |= MCU_E2PromProgram(EEPROM_BTSR_SPOOL_TENSION, data);
+        status |= MCU_E2PromProgramFloat(EEPROM_BTSR_SPOOL_TENSION, data);
         data = BtsrPrameters->exittension;
-        status |= MCU_E2PromProgram(EEPROM_BTSR_EXIT_TENSION, data);
+        status |= MCU_E2PromProgramFloat(EEPROM_BTSR_EXIT_TENSION, data);
     }
     return status;
 }
@@ -393,22 +433,24 @@ uint32_t BtsrReadParamsFromEeprom(void *Data)
     BTSRParameters* BtsrPrameters = Data;
     uint32_t status = 0;
     float data;
-    status |= MCU_E2PromRead(EEPROM_BTSR_FEEDING_TENSION, &data);
+    uint32_t value;
+
+    status |= MCU_E2PromReadFloat(EEPROM_BTSR_FEEDING_TENSION, &data);
     BtsrPrameters->feedingtension = data;
-    status |= MCU_E2PromRead(EEPROM_BTSR_TYPE, &data);
-    BtsrPrameters->btsryarntype = data;
-    status |= MCU_E2PromRead(EEPROM_BTSR_APPLICATION, &data);
-    BtsrPrameters->btsrapplicationtype = data;
-    status |= MCU_E2PromRead(EEPROM_BTSR_LENGTH_OFFSET, &data);
+    status |= MCU_E2PromRead(EEPROM_BTSR_TYPE, &value);
+    BtsrPrameters->btsryarntype = value;
+    status |= MCU_E2PromRead(EEPROM_BTSR_APPLICATION, &value);
+    BtsrPrameters->btsrapplicationtype = value;
+    status |= MCU_E2PromReadFloat(EEPROM_BTSR_LENGTH_OFFSET, &data);
     BtsrPrameters->threadlengthfactor = data;
-    status |= MCU_E2PromRead(EEPROM_BTSR_TENSION_ERROR, &data);
+    status |= MCU_E2PromReadFloat(EEPROM_BTSR_TENSION_ERROR, &data);
     BtsrPrameters->tensionerror = data;
-    status |= MCU_E2PromRead(EEPROM_BTSR_SPOOL_TENSION, &data);
+    status |= MCU_E2PromReadFloat(EEPROM_BTSR_SPOOL_TENSION, &data);
     BtsrPrameters->spooltension = data;
-    status |= MCU_E2PromRead(EEPROM_BTSR_EXIT_TENSION, &data);
+    status |= MCU_E2PromReadFloat(EEPROM_BTSR_EXIT_TENSION, &data);
     BtsrPrameters->exittension = data;
-    Report("BtsrReadParamsFromEeprom",__FILE__,__LINE__,(int)(BtsrPrameters->feedingtension*1000),RpWarning,(int)(BtsrPrameters->tensionerror*1000),(int)(BtsrPrameters->exittension*1000));
-    Report("BtsrReadParamsFromEeprom",__FILE__,__LINE__,(int)(BtsrPrameters->btsrapplicationtype),RpWarning,(int)(BtsrPrameters->btsryarntype),(int)(BtsrPrameters->threadlengthfactor*1000));
+    Report("BtsrReadParamsFromEeprom",__FILE__,(int)(BtsrPrameters->feedingtension*1000),(int)(BtsrPrameters->tensionerror*1000),RpWarning,(int)(BtsrPrameters->exittension*1000), 0);
+    Report("BtsrReadParamsFromEeprom",__FILE__,BtsrPrameters->btsrapplicationtype,BtsrPrameters->btsryarntype,RpWarning,(int)(BtsrPrameters->threadlengthfactor*1000), 0);
     return status;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.h b/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.h
index 24f229b2c..297ce1efe 100644
--- a/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.h
+++ b/Software/Embedded_SW/Embedded/Drivers/flash_ram/MCU_E2Prom.h
@@ -68,7 +68,7 @@ typedef enum {
     ORIFICE3_ZERO_VALUE_ADDR,
 }EEPROM_ADDRESSES;*/
 
-#define EEPROM_RESET_REASON_HEAD_ADDRESS 160
+#define EEPROM_RESET_REASON_HEAD_ADDRESS 300
 #define EEPROM_RESET_REASON_MAX_DATA 80
 
 #define DISPENSERS_MAP_IN_EEPROM 0x200
@@ -82,6 +82,8 @@ void MCU_E2PromUpdateResetReason(int i);
 
 uint32_t MCU_E2PromProgram(int Address,uint32_t Data);
 uint32_t MCU_E2PromRead(int Address,uint32_t *Data);
+uint32_t MCU_E2PromProgramFloat(int Address,float Data);
+uint32_t MCU_E2PromReadFloat(int Address,float *Data);
 void MCU_E2PromProgramMidTank(int midtankId,float a,float b);
 float MCU_E2PromReadMidtank_A(int MidtankId);
 float MCU_E2PromReadMidtank_B(int MidtankId);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
index e6c596d15..5bce161ae 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
@@ -263,7 +263,7 @@ uint32_t CartridgeStateUpdate(CartridgeSlot Slot, int32_t index, CartridgeState
     CartridgeStatus.has_state = true;
     CartridgeStatus.state = State;
     CartridgeStatus.cartridge = &CartData;
-    if (percentage>1)
+    //if (percentage>0.1)
     {
         CartridgeStatus.has_progresspercentage = true;
         CartridgeStatus.progresspercentage = percentage;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 4d103395c..99d5faf07 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);
 }
 
@@ -403,12 +400,12 @@ void IDS_Dispenser_Content_Calculation (char DispenserId)
         {
             ReportWithPackageFilter(IDSFilter,"IDS_Dispenser_Data ",__FILE__,DispenserId,(int)IDS_Dispenser_Data[DispenserId].consumedinnanolitter,RpWarning,(int)CurrentDispenserSpeed[DispenserId],0);
         }
-        if ((Dispenser_Id_to_LS_50_Id[DispenserId])&&(DispenserDirectionFlag_50[DispenserId]==false))
+        if ((Dispenser_Id_to_LS_50_Id[DispenserId] == LIMIT)&&(DispenserDirectionFlag_50[DispenserId]==false))
         {
             DispenserDirectionFlag_50[DispenserId]= true;
             ReportWithPackageFilter(IDSFilter,"Dispenser at 50% ",__FILE__,DispenserId,(int)IDS_Dispenser_Data[DispenserId].consumedinnanolitter,RpWarning,(int)65000000,0);
         }
-        if ((Dispenser_Id_to_LS_25_Id[DispenserId])&&(DispenserDirectionFlag_25[DispenserId]==false))
+        if ((Dispenser_Id_to_LS_25_Id[DispenserId] == LIMIT)&&(DispenserDirectionFlag_25[DispenserId]==false))
         {
             DispenserDirectionFlag_25[DispenserId]= true;
             ReportWithPackageFilter(IDSFilter,"Dispenser at 25% ",__FILE__,DispenserId,(int)IDS_Dispenser_Data[DispenserId].consumedinnanolitter,RpWarning,(int)32500000,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..97c37cc4f 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,14 @@ 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, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+                 ReportWithPackageFilter(IDSFilter,"Opening Dispenser valve for PBU",__FILE__,__LINE__,i,RpWarning,(int)(pressure*100),0);
+                 DispenserPBUReady[i] = true;
+             }
+#endif
              //IDS_StopHomeDispenser(i);
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
              {
@@ -642,8 +650,18 @@ 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;
+                             ReportWithPackageFilter(IDSFilter,"Dispenser ready  PBU",__FILE__,__LINE__,i,RpWarning,(int)NumofReadyDispensers,0);
+
+                         }
+#else
                          NumofReadyDispensers++;
                          DispenserReady[i] = true;
+#endif
                      }
                  }
                  //ReportWithPackageFilter(IDSFilter,"IDS prepare",__FILE__,i,(int)DispenserTotalPrepareSteps[i],RpWarning,(int)(CurrentDispenserSpeed[i]*100),0);
@@ -661,6 +679,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 +771,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 +829,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 +888,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 +928,7 @@ bool AdjustDispenserSpeedToPressure(int DispenserId, double RefMaxPressure,doubl
  {
      int i;
      double dispenserspeed = 0;
+     double pressure;
 
      if (IDS_Active == false)
      {
@@ -930,6 +955,17 @@ 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
+                 ReportWithPackageFilter(IDSFilter,"Closing Dispenser valve for PBU",__FILE__,__LINE__,i,RpWarning,(int)(pressure*100),0);
+                 DispenserPBUReady[i] = false;
+             }
+             else
+                 DispenserPBUReady[i] = true;
+#endif
          }
          else
          {
@@ -962,10 +998,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 +1006,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 +1023,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 +1162,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 +1430,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 +1549,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 +1622,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 +1641,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 +1851,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 +1939,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/Procedure.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Procedure.c
index c84dc5fb5..d1ba28d7e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Procedure.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Procedure.c
@@ -72,8 +72,10 @@ void Stub_ProcedureRequest(MessageContainer* requestContainer)
     bool ResetNeeded = false;
 
     ProcedureRequest* request = procedure_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
-    int i,n_param = request->n_param;
+    int rc, i,n_param = request->n_param;
     ProcedureResponse response = PROCEDURE_RESPONSE__INIT;
+    BTSRParameters *BtsrPrameters = NULL;
+    char str[200];
 /*  protobuf_c_boolean has_type;
   int32_t type;
   protobuf_c_boolean has_timeout;
@@ -89,6 +91,50 @@ void Stub_ProcedureRequest(MessageContainer* requestContainer)
     {
         switch (request->type)
         {
+        case 1:
+            BtsrPrameters = my_malloc(sizeof(BTSRParameters));
+            BtsrPrameters->btsryarntype = request->param[0];
+            BtsrPrameters->btsrapplicationtype = request->param[1];
+            BtsrPrameters->feedingtension = request->param[2];
+            BtsrPrameters->exittension =  request->param[3];
+            BtsrPrameters->tensionerror = request->param[4];
+            BtsrPrameters->threadlengthfactor = request->param[5];
+            rc = BtsrSaveParamsToEeprom(BtsrPrameters);
+            free(BtsrPrameters);
+            response.replymessage = request->testname;
+            if (n_param)
+            {
+                response.replyvalue = (float*)my_malloc(sizeof(float *)*(request->n_param));
+                response.n_replyvalue = request->n_param;
+                for(i=0;i<n_param;i++)
+                {
+                    Report(request->testname,__FILE__,__LINE__,(int)request->type,RpWarning,(int) request->n_param,0);
+                    response.replyvalue[i] = request->param[i];
+                }
+            }
+            response.time = msec_millisecondCounter;
+            response.type = request->type;
+            break;
+        case 2:
+            BtsrPrameters = my_malloc(sizeof(BTSRParameters));
+            rc = BtsrReadParamsFromEeprom(BtsrPrameters);
+            sprintf(str, "type = %d, app = %d, tension = %f, exittension = %f, tensionerror = %f, lengthfactor = %f", BtsrPrameters->btsryarntype,
+                    BtsrPrameters->btsrapplicationtype, BtsrPrameters->feedingtension, BtsrPrameters->exittension, BtsrPrameters->tensionerror, BtsrPrameters->threadlengthfactor);
+            response.replymessage = str;
+            if (n_param)
+            {
+                response.replyvalue = (float*)my_malloc(sizeof(float *)*(request->n_param));
+                response.n_replyvalue = request->n_param;
+                for(i=0;i<n_param;i++)
+                {
+                    Report(request->testname,__FILE__,__LINE__,(int)request->type,RpWarning,(int) request->n_param,0);
+                    response.replyvalue[i] = request->param[i];
+                }
+            }
+            response.time = msec_millisecondCounter;
+            response.type = request->type;
+            free(BtsrPrameters);
+            break;
             default:
                 response.replymessage = request->testname;
                 if (n_param)
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/Waste/Waste_maint.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
index b8f7024fb..374977065 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_maint.c
@@ -274,9 +274,9 @@ bool RdWasteTankOverFlowSensor()
     return 0;
 }
 
-int WHS_GetCartridgeFillPercent()
+float WHS_GetCartridgeFillPercent()
 {
-    return (((wasteLevel - wasteLevelEmpty) * 100) / WASTE_CARTRIDGE_SIZE);
+    return (100 - (((wasteLevel - wasteLevelEmpty) * 100) / WASTE_CARTRIDGE_SIZE));
 }
 int WHS_GetCartridgeFill()
 {
diff --git a/Software/Embedded_SW/Embedded/Software Release Notes.txt b/Software/Embedded_SW/Embedded/Software Release Notes.txt
index 55bb213d2..d5db2f317 100644
--- a/Software/Embedded_SW/Embedded/Software Release Notes.txt
+++ b/Software/Embedded_SW/Embedded/Software Release Notes.txt
@@ -9,6 +9,16 @@ IDS - gradient brushstop offset size from the file
 store real time and use in error log
 BTSR Support
 
+Embedded SW Release note - Version 1.5.3(5) - Pack 3+  (Mid-Alpha)
+=============================================================
+fix file system bug (file delete when there is no existing file)
+fix alarm report - dispenser Id
+pull down cleaner dispenser on pressure rise during segment
+fix cartridge percentage
+fix INIT reporting (BIT skipping)
+fix idle head blowers setting (1.2 m^3/H) and arc head setting (60c)
+build lubricant pressure before job (to 0.01)
+
 Embedded SW Release note - Version 1.5.3(4) - Pack 3
 =============================================================
 remove ErrFile.txt handling (storing logs while report is disconnected) - from release version
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
index 06dac8fdc..7f1b9ffb5 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/InitSequence.c
@@ -783,14 +783,13 @@ uint32_t PowerUpUpdate(MACHINE_STATE_STAGES_ENUM stage)
         case MACHINE_STATE_BUILT_IN_FAILED:
             response.state = POWER_UP_STATE__BuiltInTest;
             response.progresspercentage = 15.0;
-            response.message = "Built In Test";
+            response.message = "Built In Test failed";
+            Error = ERROR_CODE__POWER_UP_BUILT_IN_FAILED;
             break;
         case MACHINE_STATE_BUILT_IN_TEST:
             response.state = POWER_UP_STATE__BuiltInTest;
             response.progresspercentage = 15.0;
             response.message = "Built In Test";
-            //response.message = "Built In Test failed";
-            //Error = ERROR_CODE__POWER_UP_BUILT_IN_FAILED;
             break;
         case MACHINE_STATE_INITIAL_BLOWER_ACTIVATION:
             response.state = POWER_UP_STATE__InitialBlowerActivation;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
index b5ebdee17..a77b22c47 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
@@ -484,11 +484,9 @@ uint32_t PowerOffTurnOffDryerFan(void)
     int i;
     Control_Dryer_Fan(STOP,75);//use START or STOP,  0 - 100%
     PowerOffMachineState++;
-    if (Special_Dispensers == false)
-    {
-        for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
-            Control3WayValvesWithCallback ((Valves_t)i, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-    }
+
+    for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
+        Control3WayValvesWithCallback ((Valves_t)i, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
 
     //TBD
     return OK;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
index 9f5151117..ab246dbc3 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -1197,10 +1197,10 @@ void SendJobProgress(double ProcessedLength, int SegmentId, bool done, char *Mes
         if ((heaterRatio>0.99)&&(dispenserRatio>0.99))
         {
             wfcf_count+=1.00;
-            Report("prepare_progress wfcf" ,__FILE__,(int)(wfcf_count),(int)(heaterRatio*100),RpWarning,(int)(dispenserRatio*100),0);
+            //Report("prepare_progress wfcf" ,__FILE__,(int)(wfcf_count),(int)(heaterRatio*100),RpWarning,(int)(dispenserRatio*100),0);
         }
         prepare_progress = (0.9*heaterRatio)+(0.08*dispenserRatio) + (0.02*wfcf_count/25.0);
-        Report("prepare_progress" ,__FILE__,(int)(prepare_progress*1000),(int)(heaterRatio*1000),RpWarning,(int)(dispenserRatio*1000),0);
+        //Report("prepare_progress" ,__FILE__,(int)(prepare_progress*1000),(int)(heaterRatio*1000),RpWarning,(int)(dispenserRatio*1000),0);
     }
     else
         wfcf_count = 0;