update mastrer with latest changes in Alpha + embedded version

22 files changed, 485 insertions, 254 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 44caacc55..6d5dc00b2 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -215,21 +215,21 @@ AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
 /*	7006	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE},
 /*	7007	*/     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE},
 
-/*	8000	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_1_LOW_LEVEL},
-/*	8001	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_2_LOW_LEVEL},
-/*	8002	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_3_LOW_LEVEL},
-/*	8003	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_4_LOW_LEVEL},
-/*	8004	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_5_LOW_LEVEL},
-/*	8005	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_6_LOW_LEVEL},
-/*	8006	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_7_LOW_LEVEL},
-/*	8007	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_8_LOW_LEVEL},
+/*	8000	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_1_LOW_LEVEL},
+/*	8001	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_2_LOW_LEVEL},
+/*	8002	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_3_LOW_LEVEL},
+/*	8003	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_4_LOW_LEVEL},
+/*	8004	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_5_LOW_LEVEL},
+/*	8005	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_6_LOW_LEVEL},
+/*	8006	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_7_LOW_LEVEL},
+/*	8007	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,300/*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_8_LOW_LEVEL},
 /*	8008	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY},
 /*	8009	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY},
 /*	8010	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY},
 /*	8011	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY},
 /*	8012	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY},
 /*	8013	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_EMPTY},
-/*	8014	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_EMPTY},
+/*	8014	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_EMPTY},
 /*	8015	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY},
 
 /*	8016	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_OVERFLOW},
@@ -238,7 +238,7 @@ AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
 /*	8019	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_OVERFLOW},
 /*	8020	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_OVERFLOW},
 /*	8021	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_OVERFLOW},
-/*	8022	*/     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_OVERFLOW},
+/*	8022	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_OVERFLOW},
 /*	8023	*/     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_OVERFLOW},
 
 
@@ -989,7 +989,8 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
 {
     int Alarm_i;
     uint32_t value;
-    uint32_t valueL;
+    double doubleValue = 0.0;
+/*    uint32_t valueL;
     uint32_t valueR;
     uint32_t valueN;
     uint32_t drawer_big;
@@ -997,8 +998,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
     uint32_t drawer_small1;
     uint32_t drawer_small2;
     uint32_t drawer_small3;
-
-    double doubleValue = 0.0;
+*/
 
 
 
@@ -1126,6 +1126,11 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
             case ALARM_SOURCE_TYPE__MotorAlarm:
                 if (CheckMotorAlarms)
                 {
+                    if (FPGA_WD_Occurred == true)
+                    {
+                        Status = false;
+                        break;
+                    }
                     if (isMotorConfigured((TimerMotors_t)AlarmItem[Alarm_i].DeviceId) == false)
                     {
                         Status = false;
@@ -1189,12 +1194,12 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                             if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
                             {
                                 value = getSystemFansStatus();
-                                valueR = value & MASKSYSTEMRIGHT;
+/*                                valueR = value & MASKSYSTEMRIGHT;
                                 valueL = value & MASKSYSTEMLEFT;
                                 valueN = value & MASKSYSTEMnotUSED;
 
 
-                                /*if (valueR)
+                                if (valueR)
                                       ReportWithPackageFilter(AlarmFilter,"----------- Right FAN System is not connected----------------", __FILE__,__LINE__,valueR, RpMessage, value, 0);
                                 else
                                       ReportWithPackageFilter(AlarmFilter,"----------- Right FAN System is connected----------------", __FILE__,__LINE__,valueR, RpMessage, value, 0);
@@ -1217,12 +1222,12 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                             if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
                             {
                                 value = getDrawerFansStatus();
-                                drawer_big    = value & MASKDRYERBIG;
+/*                                drawer_big    = value & MASKDRYERBIG;
                                 drawer_small0 = value & MASKDRYERSMALL0;
                                 drawer_small1 = value & MASKDRYERSMALL1;
                                 drawer_small2 = value & MASKDRYERSMALL2;
                                 drawer_small3 = value & MASKDRYERSMALL3;
-/*
+
                                 if (drawer_big)
                                     ReportWithPackageFilter(AlarmFilter,"----------- drawer_big FAN is not connected----------------", __FILE__,__LINE__,drawer_big, RpMessage, value, 0);
                                 else
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 28febe8f2..2f4a1e2d2 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -41,6 +41,7 @@
 #include "Drivers/I2C_Communication/I2C.h"
 
 #include "modules/thread/thread_ex.h"
+#include "modules/ifs/ifs.h"
 #include "modules/ids/ids_ex.h"
 #include "modules/Diagnostics/Diagnostics.h"
 #include "Modules/General/MachineStatus.h"
@@ -662,6 +663,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
             PumpActivation(900);
             PumpCounter = 0;
         }
+        MidTankReading();
     }
     //ROM_IntMasterEnable();
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index b7d117efe..1f5e008d3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -172,6 +172,8 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
             ACTIVITY_GREEN_LED_ON;
             HWConfigurationInit();
         }
+		else
+            ACTIVITY_GREEN_LED_OFF;
 
         if(power.color == fastBILNK)
             Pannel_Leds(POWER_ON_OFF,MODE_OFF);
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 497556878..38f9b73ba 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -58,7 +58,7 @@ return OK;
 uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
 {
     uint32_t numberOfSteps = 0;
-    uint32_t LoadArmRounds = 0;
+    uint32_t LoadArmRounds = (int)dryerbufferlength;
 
     MessageContainer responseContainer;
 
@@ -67,14 +67,8 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
     MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
 
     TimerMotors_t MotorId = (TimerMotors_t)request->motortype;
-
-    if (dryerbufferlength)
-        LoadArmRounds = (int)dryerbufferlength;
-    else
-        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
-
     if (LoadArmRounds <= 2)
-            LoadArmRounds = 20;
+            LoadArmRounds = 30;
 
     int speed = request->speed;
     if (speed == 0) speed = 150;
@@ -96,8 +90,11 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                     {
                         numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
                         Report("MotorHomingRequestFunc Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,numberOfSteps,RpMessage,LoadArmRounds,0);
-                        MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
-                                                        numberOfSteps, MotorHomingRequestCallback,1000);
+                        MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
+                                                        MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/2, MotorHomingRequestCallback,0,1000);
+
+                        //MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
+                        //                                numberOfSteps, MotorHomingRequestCallback,1000);
                         return OK;
                     }
                     if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI)
@@ -120,7 +117,7 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
                     if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM)
                     {
                         if (LoadArmRounds <= 2)
-                                LoadArmRounds = 20;
+                                LoadArmRounds = 30;
 
                         numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
                         numberOfSteps -= 100;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 40bc50b4f..fab62d6ee 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -184,7 +184,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->has_dispenserbuildpressurelimit = true;
             EmbeddedParameters->dispenserbuildpressurelimit=1.0 ;
             EmbeddedParameters->has_dispenserbuildpressuretimeout = true;
-            EmbeddedParameters->dispenserbuildpressuretimeout=60000;
+            EmbeddedParameters->dispenserbuildpressuretimeout=150000;
             EmbeddedParameters->has_dispenserbuildpressurelag = true;
             EmbeddedParameters->dispenserbuildpressurelag=50;
             EmbeddedParameters->has_acheatersloweroperationlimit = true;
@@ -212,7 +212,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
                 EmbeddedParameters->generalparameters[4] = 800.0; //Winder homing time at end of job
                 EmbeddedParameters->generalparameters[5] = 1000.0; //Dispenser initial pressure speed
                 EmbeddedParameters->generalparameters[6] = Diagnostic_Extended_Mode; //Diagnostic Mode SetDiagnosticMode
-                EmbeddedParameters->generalparameters[7] = AutoHoming_PowerOn_off; //
+                EmbeddedParameters->generalparameters[7] = AutoHoming_JobEnd_PowerOn_off; //
             }
             EmbeddedParameters->has_currentalarmlowlimit = true;
             EmbeddedParameters->currentalarmlowlimit = 0.78;
@@ -295,7 +295,7 @@ uint32_t EmbeddedParametersInit(void)
     }
     else
     {
-        IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,900);
+        IDS_Dispenser_SetBackLashValues(EmbeddedParameters->initialdispenserpressure, EmbeddedParameters->initialdispensertimeout, EmbeddedParameters->initialdispensertimelag,1000);
     }
 
     IDS_Dispenser_SetTimeOutValues(EmbeddedParameters->closevalvetimeout, EmbeddedParameters->openvalvetimeout);
@@ -437,6 +437,8 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
     {
         for (Dispenser_i = 0; Dispenser_i < request->n_dispensers ; Dispenser_i++)
         {
+            Valve_Set(IDS_Id_to_AirValve[Dispenser_i], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
+            Valve_Set(IDS_Id_to_CartrideValve[Dispenser_i], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
             status += DispenserConfigMessage(request->dispensers[Dispenser_i]);
             if (Check_Dispenser_Type(request->dispensers[Dispenser_i]->index) == LS_STATUS_ERROR)
             {
@@ -565,12 +567,13 @@ uint32_t MidTankDataSetupFunc(MessageContainer* requestContainer)
         Report("MidTankData Read", __FILE__,__LINE__,(int)(a*1000), RpMessage, (int)(b*1000), 0);
     }
     //debug only
+    /*
     Task_sleep(1000);
     MCU_E2PromSerialNumProgram ("Take me to the sky");
     memset (Serial,0,20);
     MCU_E2PromSerialNumRead(&Serial);
     Report(Serial, __FILE__,__LINE__,22, RpMessage, 21, 0);
-
+    */
 
     MidTankDataSetupResponse response = MID_TANK_DATA_SETUP_RESPONSE__INIT;
 
@@ -642,8 +645,14 @@ void HWSystemResetRequest(MessageContainer* requestContainer)
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
     SendChars((char*)container_buffer, container_size);
+    Report("HWSystemResetRequest before sleep", __FILE__,__LINE__,0, RpMessage, 2, 0);
+
+    //ROM_SysCtlDelay(SYS_CLK_FREQ);
+    Task_sleep(2000);
+    Report("HWSystemResetRequest after sleep", __FILE__,__LINE__,2, RpMessage, 4, 0);
 
-    ROM_SysCtlDelay(SYS_CLK_FREQ);
+    //ROM_SysCtlDelay(SYS_CLK_FREQ);
+    Task_sleep(2000);
 
     SysCtlReset();
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/Safety.c b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
index 73736f8d4..139763c75 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/Safety.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
@@ -39,9 +39,10 @@ void Safety_Init(void)
 uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
 {
    int Disp_i;
+   bool Indication = false;
    bool AllDispensersInSafety = true;
    bool AnyDispensersInSafety = false;
-   bool DispenserBypass = false;
+   //bool DispenserBypass = false;
    bool mDrierDoorAlarmState = false;
    bool mAirFlowAlarmState = false;
    bool mAirFilterAlarmState = false;
@@ -50,8 +51,9 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
    {
        if (isMotorConfigured(Disp_i + HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)==true)
        {
-           AllDispensersInSafety &= Check_Disp_Safety_Stop_Indication(Disp_i);
-           AnyDispensersInSafety |= Check_Disp_Safety_Stop_Indication(Disp_i);
+           Indication = Check_Disp_Safety_Stop_Indication(Disp_i);
+           AllDispensersInSafety &= Indication;
+           AnyDispensersInSafety |= Indication;
        }
    }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index b74ba79b3..d7de5797d 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -65,9 +65,9 @@ void HeatersStopControlOnHeatersOff(ProcessParameters* ProcessParams)
         REPORT_MSG(temp_sum,"Heating control off - temperatures off");
     }
 }
-uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
+uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
 {
-    uint32_t status = 0;
+    uint32_t status = 0,Bytes = 0;
     if (ProcessParams==NULL)
         {
             status = ERROR_CODE__INVALID_PARAMETER;
@@ -89,7 +89,19 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
     {
         memcpy (&ProcessParametersKeep,ProcessParams,sizeof(ProcessParameters));
     }
-    if (ProcessParams->mixertemp)
+    if (saveData == true)
+    {
+        if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
+        {
+            Bytes = sizeof(ProcessParameters);
+            FileWrite(ProcessParams,Bytes,ProcessParamsConfigPath,BIOS_WAIT_FOREVER);
+            EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH,Bytes+4);
+            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
+            ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
+            REPORT_MSG(Bytes,"Bytes write to flash");
+        }
+    }
+    if (ProcessParams->mixertemp>1)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__MixerHeater, true,
                 ProcessParams->mixertemp);
@@ -97,7 +109,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__MixerHeater, false,
                 ProcessParams->mixertemp);
-    if (ProcessParams->headzone1temp)
+    if (ProcessParams->headzone1temp>1)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, true,
                 ProcessParams->headzone1temp);
@@ -105,7 +117,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, false,
                 ProcessParams->headzone1temp);
-    if (ProcessParams->headzone2temp)
+    if (ProcessParams->headzone2temp>1)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, true,
                 ProcessParams->headzone2temp);
@@ -113,7 +125,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, false,
                 ProcessParams->headzone2temp);
-    if (ProcessParams->headzone3temp)
+    if (ProcessParams->headzone3temp>1)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, true,
                 ProcessParams->headzone3temp);
@@ -121,7 +133,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, false,
                 ProcessParams->headzone3temp);
-    if (ProcessParams->headzone4temp)
+    if (ProcessParams->headzone4temp>1)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, true,
                 ProcessParams->headzone4temp);
@@ -129,7 +141,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, false,
                 ProcessParams->headzone4temp);
-    if (ProcessParams->headzone5temp)
+    if (ProcessParams->headzone5temp>1)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, true,
                 ProcessParams->headzone5temp);
@@ -137,7 +149,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, false,
                 ProcessParams->headzone5temp);
-    if (ProcessParams->headzone6temp)
+    if (ProcessParams->headzone6temp>1)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, true,
                 ProcessParams->headzone6temp);
@@ -145,7 +157,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, false,
                 ProcessParams->headzone6temp);
-    if (ProcessParams->dryerzone1temp)
+    if (ProcessParams->dryerzone1temp>1)
         status |= HeaterCommandRequestMessage(
                 HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, true,
                 ProcessParams->dryerzone1temp);
@@ -193,20 +205,9 @@ void ProcessRequestFunc(MessageContainer* requestContainer)
     MessageContainer responseContainer;
     uint8_t* container_buffer;
     uint32_t status = 0;
-    uint32_t Bytes = 0;
 
     UploadProcessParametersRequest* request = upload_process_parameters_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
     ProcessParameters*  ProcessParams = request->processparameters;
-    if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
-    {
-        FileWrite(requestContainer->data.data, requestContainer->data.len,ProcessParamsConfigPath,BIOS_WAIT_FOREVER);
-        Bytes = sizeof(ProcessParameters);
-        EraseFlashSection(PROCESS_PARAMETERS_MAP_IN_FLASH,Bytes+4);
-        ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
-        ReadAppAndProgram(PROCESS_PARAMETERS_MAP_IN_FLASH+4, Bytes, ProcessParams);
-        REPORT_MSG(Bytes,"Bytes write to flash");
-
-    }
     ////////////////////////////////////////////////////////////////////////
     /*UploadProcessParametersRequest* requesttest;
     uint8_t* buffer = NULL;
@@ -234,7 +235,7 @@ void ProcessRequestFunc(MessageContainer* requestContainer)
     PowerIdleOutOfIdleState();
 
     if (status == 0)
-        status = HandleProcessParameters(ProcessParams);
+        status = HandleProcessParameters(ProcessParams,true);
     if (status)
     {
         responseContainer.has_error = true;
@@ -255,10 +256,9 @@ uint32_t LoadProcessParamsFromFile(void)
     Fresult = FileRead(ProcessParamsConfigPath, &Bytes, &buffer);
     if (Fresult == FR_OK)
     {
-        UploadProcessParametersRequest* request = upload_process_parameters_request__unpack(NULL, Bytes, buffer);
-        ProcessParameters*  ProcessParams = request->processparameters;
+        ProcessParameters*  ProcessParams = (ProcessParameters*)buffer;
 
-        if ((request!= NULL)&&(ProcessParams!=NULL))
+        if (ProcessParams!=NULL)
         {
             if ((ProcessParams->dryerzone1temp > 0.1)&&(ProcessParams->headzone2temp > 0.1)&&(ProcessParams->headzone3temp > 0.1)&&(ProcessParams->headzone4temp > 0.1))//NOT turning off heaters
             {
@@ -272,7 +272,7 @@ uint32_t LoadProcessParamsFromFile(void)
         }
         else
         {
-            Report("process parameters not loaded",__FILE__,__LINE__,(int)request,RpWarning,(int)request,0);
+            Report("process parameters not loaded",__FILE__,__LINE__,(int)0,RpWarning,(int)0,0);
             return ERROR;
         }
     }
@@ -290,7 +290,7 @@ uint32_t ProcessParamsInit(void)
     if ((Bytes)&&(Bytes < 1000))
     {
         ProcessParameters*  ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4);
-        Fresult = HandleProcessParameters(ProcessParams);
+        Fresult = HandleProcessParameters(ProcessParams,false);
     }
     else
     {
@@ -302,7 +302,7 @@ uint32_t ProcessParamsInit(void)
             if ((Bytes)&&(Bytes < 1000))
             {
                 ProcessParameters*  ProcessParams = (ProcessParameters *)(PROCESS_PARAMETERS_MAP_IN_FLASH+4);
-                Fresult = HandleProcessParameters(ProcessParams);
+                Fresult = HandleProcessParameters(ProcessParams,false);
             }
         }
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.h b/Software/Embedded_SW/Embedded/Modules/General/process.h
index 2b02c28c7..97d28f1ef 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.h
@@ -25,7 +25,7 @@ extern double dryerbufferCentimeters;
 extern ProcessParameters ProcessParametersKeep;
 
 extern void ProcessRequestFunc(MessageContainer* requestContainer);
-extern uint32_t HandleProcessParameters(ProcessParameters* ProcessParams);
+extern uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData);
 uint32_t ProcessParamsInit(void);
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index b05f236c5..4d1fbddba 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -37,6 +37,7 @@
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 
 #include "StateMachines/Printing/PrintingSTM.h"
+#include "StateMachines/Initialization/PowerIdle.h"
 
 
 /******************** Data Structures  ********************************************/
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index 3e2cf6ecb..eba93d445 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -12,10 +12,10 @@ extern uint32_t DispenserPrepareSpeed ;
 extern double   DispenserPreparePressure ;
 extern uint32_t DispenserPrepareTimeout ;
 extern uint32_t DispenserPrepareTimeLag ;
+extern uint32_t InitialDispenserSpeed;
 
 extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
 extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
-extern bool JobStartStopBackLash[MAX_SYSTEM_DISPENSERS];
 extern float DispenserPressure[MAX_SYSTEM_DISPENSERS];
 uint32_t DispenserConfigMessage(HardwareDispenser * request);
 
@@ -26,6 +26,7 @@ extern bool DispensersAlarmState[ MAX_SYSTEM_DISPENSERS];
 extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 
 extern bool HomingActive[MAX_SYSTEM_DISPENSERS];
+extern bool PrimingActive[MAX_SYSTEM_DISPENSERS];
 
 uint32_t IDS_Dispenser_EmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 9c15885fc..3d1ba6e78 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -189,7 +189,7 @@ uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpee
     DispenserCallback[DispenserId] = callback;
 
     TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
-    if (CurrentDispenserSpeed[DispenserId]) //motor already running
+    /*if (CurrentDispenserSpeed[DispenserId]) //motor already running
     {
         MotorSetSpeed(HW_Motor_Id, MotorSpeed);
         CurrentDispenserSpeed[DispenserId] = MotorSpeed;
@@ -200,7 +200,7 @@ uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpee
         }
     }
     else
-    {
+    {*/
         MotorSetSpeed(HW_Motor_Id, MotorSpeed);
         CurrentDispenserSpeed[DispenserId] = MotorSpeed;
         if (DispenserControlId[DispenserId] != 0xFF)
@@ -212,7 +212,7 @@ uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpee
             Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
         //else
         //    Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
-    }
+    //}
 
     return OK;
 }
@@ -224,7 +224,7 @@ char DispenserStorePath[50] = "0://SysInfo//DispStor.cfg";
 void IDS_Dispenser_Content_Init (void)
 {
     int i;
-    FRESULT Fresult = FR_OK;
+    //FRESULT Fresult = FR_OK;
     void* buffer = NULL;
     TimerMotors_t HW_Motor_Id;
     uint32_t Bytes = 0;
@@ -287,7 +287,7 @@ uint16_t seconds_counter = 0;
 bool DispenserDataUpdated = false;
 uint32_t IDS_Dispenser_Store_Data (void)
 {
-    uint32_t timing =  msec_millisecondCounter;
+    //uint32_t timing =  msec_millisecondCounter;
     FRESULT Status = FR_OK;
     IDSDispenserData.n_dispenserinfo = MAX_SYSTEM_DISPENSERS;
     IDSDispenserData.dispenserinfo = dispenserdata;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index ac3928c3e..9074f867a 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -68,9 +68,11 @@ uint32_t IDS_StopLubrication(void);
 uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request);
 uint32_t IDS_DispenserControlInit();
 
+void IDS_Dispenser_Init(uint8_t DispenserId);
 uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback);
 uint32_t IDS_StopHomeDispenser (uint32_t deviceID);
 uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId,  uint32_t timeout , callback_fptr callback);
+bool     IDS_IsHomingActive(uint32_t DispenserId);
 
 uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback);
 uint32_t IDS_Dispenser_Alarm_On (uint8_t deviceID);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index db6184fdb..5fe02bb71 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -143,16 +143,16 @@ uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId,  uint32_t timeo
     return OK;
 }
 
-uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue)
+/*uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue)
 {
     uint8_t DispenserId = motorId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
-    if ((GetDispenserPressure(DispenserId)>=InitialDispenserPressure)||(DispenserHomingTime[DispenserId]>InitialDispenserTimeout)||(JobStartStopBackLash[DispenserId] == true))
+    if ((GetDispenserPressure(DispenserId)>=InitialDispenserPressure)||(DispenserHomingTime[DispenserId]>InitialDispenserTimeout))
     {
         MotorStop(motorId,Hard_Hiz);
         CurrentDispenserSpeed[DispenserId] = 0;
         if (Extended_Motor_Param == true)
             Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
-        MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
+        //MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
         HomingActive[DispenserId]= false;
         PrimingActive[DispenserId]= false;
         Control_TCA9534ByPass(DispenserId,DISABLE);// use ENABLE or DISABLE
@@ -161,8 +161,6 @@ uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue)
         Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
         Disable_MidTank_Pressure_Reading(DispenserId);
 
-        if (JobStartStopBackLash[DispenserId] == true)
-            JobStartStopBackLash[DispenserId] = false;
         Report("End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
         if (SafeRemoveControlCallback(DispenserHomingControlId[DispenserId], IDS_HomeDispenserBackMoveCallback )==OK)
             DispenserHomingControlId[DispenserId] = 0xFF;
@@ -175,23 +173,16 @@ uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue)
         DispenserHomingTime[DispenserId]+=InitialDispenserTimeLag;
     }
     return OK;
-}
+}*/
 uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
 {
     uint8_t DispenserId = motorId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
 
-    MotorStop(motorId,Hard_Hiz);
-    CurrentDispenserSpeed[DispenserId] = 0;
-    if (Extended_Motor_Param == true)
-        Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
     Read_MidTank_Pressure_Sensor(DispenserId);
     //close dry air valve in the dispenser
-    Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
-    Disable_MidTank_Pressure_Reading(DispenserId);
-    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
-    HomingActive[DispenserId]= false;
-    PrimingActive[DispenserId]= false;
-    Control_TCA9534ByPass(DispenserId,DISABLE);// use ENABLE or DISABLE
+    //Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
+    //Disable_MidTank_Pressure_Reading(DispenserId);
+    //    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     if (HomingRequestCallback[DispenserId])
     {
         HomingRequestCallback[DispenserId](DispenserId,0);
@@ -199,16 +190,31 @@ uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
     }
 //    HomingActive[DispenserId]= false;
     IDS_Dispenser_RefillEnded ( DispenserId, MotorsCfg[motorId].microstep);
-    Report("End homing no backlash backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
-    /*Report("Start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
-    DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
+    Report("Homing ended",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+//    DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
     MotorSetDirection(motorId,MotorsCfg[motorId].directionthreadwize);
     Task_sleep(10);
-    MotorSetSpeed(motorId, InitialDispenserSpeed);
-    CurrentDispenserSpeed[DispenserId] = InitialDispenserSpeed;*/
+//    MotorSetSpeed(motorId, InitialDispenserSpeed);
+    CurrentDispenserSpeed[DispenserId] = 0;
+/////////////////////////////////////////////////////////////
+    if (Extended_Motor_Param == true)
+        Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
+    //MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
+    HomingActive[DispenserId]= false;
+    PrimingActive[DispenserId]= false;
+    Control_TCA9534ByPass(DispenserId,DISABLE);// use ENABLE or DISABLE
+
+    //close dry air valve in the dispenser
+    Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
+    Disable_MidTank_Pressure_Reading(DispenserId);
+
+    ////////////////////////////////////////////////////////
     return OK;
 }
-
+bool     IDS_IsHomingActive(uint32_t DispenserId)
+{
+    return HomingActive[DispenserId];
+}
 uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr callback)
 {
     assert(DispenserId < MAX_SYSTEM_DISPENSERS);
@@ -219,11 +225,17 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
     if (FPGA_Read_limit_Switches(Dispenser_Id_to_LS_Id[DispenserId]) == LIMIT)
     {
         Report("IDS_HomeDispenser - Disp is full",__FILE__,Dispenser_Id_to_LS_Id[DispenserId],(int)DispenserId,RpWarning,LIMIT,0);
-        return OK;
+        return ERROR;
     }
     if (Get_MidTank_Pressure_Sensor(DispenserId)<0.2)
     {
-        Report("IDS_HomeDispenser - Midtank is empty",__FILE__,Get_MidTank_Int1000_Sensor(DispenserId),(int)DispenserId,RpWarning,LIMIT,0);
+        Report("IDS_HomeDispenser - Midtank is empty",__FILE__,Get_MidTank_Int100_Sensor(DispenserId),(int)DispenserId,RpWarning,LIMIT,0);
+        return ERROR;
+    }
+    midTankContent = Read_MidTank_Pressure_Sensor(DispenserId);
+    if (midTankContent < 0.2) //midtank is empty - abort!!!!
+    {
+        Report("IDS_HomeDispenser - Mid Tank Empty!!! ",__FILE__,__LINE__,(int)(midTankContent * 1000),RpWarning,DispenserId,0);
         return ERROR;
     }
     //if Safety is active
@@ -233,8 +245,6 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
         Report("IDS_HomeDispenser - Homing/priming already active",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
         return ERROR;
     }
-    else
-        HomingActive[DispenserId] = true;
 
     if (Check_Disp_Safety_Stop_Indication(DispenserId) == true)
     {
@@ -249,62 +259,35 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
     TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
     if ( Dispenser_Id_to_LS_Id[DispenserId] != MAX_GPI)
     {
+        HomingActive[DispenserId] = true;
         //open dispenser valve dispenser to midtank direction
         Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-        KeepMicrostep[DispenserId] = MotorsCfg[MotorId].microstep;
         if (Extended_Motor_Param == true)
             Power_Step_01_Dispenser_Mode(DispenserId,Current);
-        MotorSetMicroStep(MotorId, 1);
-        SysCtlDelay(180000);
+        KeepMicrostep[DispenserId] = MotorsCfg[MotorId].microstep;
+        //MotorSetMicroStep(MotorId, 1);
         //open dry air valve in the dispenser
         Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_ON);
         Enable_MidTank_Pressure_Reading(DispenserId);
-        SysCtlDelay(1200000);
-        midTankContent = Read_MidTank_Pressure_Sensor(DispenserId);
-        if (midTankContent < 0.2) //midtank is empty - abort!!!!
-        {
-            Report("IDS_HomeDispenser - Mid Tank Empty!!! ",__FILE__,__LINE__,(int)(midTankContent * 1000),RpWarning,DispenserId,0);
-            Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
-            STATUS_GREEN_LED_OFF;
-            STATUS_RED_LED_ON;
-
-            return ERROR;
-        }
 
         IDS_Dispenser_RefillStarted(DispenserId,1);
-        MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
-        CurrentDispenserSpeed[DispenserId] = speed;
+        if (DispenserId== LUBRICANT_DISPENSER)
+        {
+            MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed/2,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
+            CurrentDispenserSpeed[DispenserId] = speed/2;
+            Report("IDS_HomeDispenser ",__FILE__,__LINE__,(int)DispenserId,RpWarning,speed/2,0);
+        }
+        else
+        {
+            MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
+            CurrentDispenserSpeed[DispenserId] = speed;
+            Report("IDS_HomeDispenser ",__FILE__,__LINE__,(int)DispenserId,RpWarning,speed,0);
+        }
         CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]);
-        Report("IDS_HomeDispenser ",__FILE__,__LINE__,(int)DispenserId,RpWarning,speed,0);
         return OK;
     }
     return ERROR;
 }
-uint32_t IDS_Dispenser_Alarm_On (uint8_t DispenserId)
-{
-    uint32_t status = OK;
-    Report("IDS_Dispenser_Alarm_On",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
-    DispensersAlarmState[DispenserId] = true;
-    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
-    status |= MotorAbortMovetoLimitSwitch(MotorId);
-    Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
-    Enable_MidTank_Pressure_Reading(DispenserId);
-    if (Extended_Motor_Param == true)
-        Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
-    status |= MotorSetMicroStep(MotorId, KeepMicrostep[DispenserId]);
-    status |= MotorStop(DispenserId, Hard_Hiz);
-    CurrentDispenserSpeed[DispenserId] = 0;
-    JobEndReason = JOB_OUT_OF_DYE;
-    return status;
-}
-uint32_t IDS_Dispenser_Alarm_Off (uint8_t DispenserId)
-{
-    uint32_t status = OK;
-    DispensersAlarmState[DispenserId] = false;
-    Report("IDS_Dispenser_Alarm_Off",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
-    return status;
-}
-
 uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
 {
     assert(DispenserId < MAX_SYSTEM_DISPENSERS);
@@ -323,24 +306,24 @@ uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
 
-    if (HomingActive[DispenserId] == true)
+/*    if (HomingActive[DispenserId] == true)
     {
         IDS_StopHomeDispenserBuildPressure(DispenserId);
-    }
-    if (PrimingActive[DispenserId] == true)
+    }*/
+    if (HomingActive[DispenserId] == true)
     {
         if (DispenserId == LUBRICANT_DISPENSER)
         {
             Lubricant_2Way_Valve (STOP);
         }
-        PrimingActive[DispenserId] = false;
-        Control_TCA9534ByPass(DispenserId,DISABLE);// use ENABLE or DISABLE
-        if (Extended_Motor_Param == true)
-            Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
-        MotorSetMicroStep(MotorId, KeepMicrostep[DispenserId]);
-        CurrentDispenserSpeed[DispenserId] = 0;
-        CurrentDispenserSpeed[DispenserId] = 0;
     }
+    HomingActive[DispenserId] = false;
+    PrimingActive[DispenserId] = false;
+    Control_TCA9534ByPass(DispenserId,DISABLE);// use ENABLE or DISABLE
+    if (Extended_Motor_Param == true)
+        Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
+    //MotorSetMicroStep(MotorId, KeepMicrostep[DispenserId]);
+    CurrentDispenserSpeed[DispenserId] = 0;
     return OK;
 }
 uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t DispenserId)
@@ -365,25 +348,15 @@ uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t DispenserId)
     //close dry air valve in the dispenser
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Disable_MidTank_Pressure_Reading(DispenserId);
-    CurrentDispenserSpeed[DispenserId] = 0;
-    if (Extended_Motor_Param == true)
-        Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
-    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
-
+    //    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     if (HomingRequestCallback[DispenserId])
     {
         HomingRequestCallback[DispenserId](DispenserId,0);
         HomingRequestCallback[DispenserId] = NULL;
     }
 //    HomingActive[DispenserId]= false;
-    JobStartStopBackLash[DispenserId] = false;
-    Report("End homing no backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
-    /*if (JobStartStopBackLash[DispenserId] == true)
-    {
-            JobStartStopBackLash[DispenserId] = false;
-            Report("End homing for job start",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
-    }
-    else
+      Report("End homing for job start",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
+  /*  else
     {
         Report("homing aborted,start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
         DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
@@ -393,7 +366,7 @@ uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t DispenserId)
         MotorSetSpeed(motorId, 1000);
         CurrentDispenserSpeed[DispenserId] = 1000;
     }*/
-    IDS_Dispenser_RefillEnded ( DispenserId, MotorsCfg[motorId].microstep);
+    //IDS_Dispenser_RefillEnded ( DispenserId, MotorsCfg[motorId].microstep);
 
     return OK;
 }
@@ -427,7 +400,7 @@ uint32_t IDS_EmptyDispenserCallback(uint32_t motorId, uint32_t ReadValue)
     CurrentDispenserSpeed[DispenserId] = 0;
     if (Extended_Motor_Param == true)
         Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
-    MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
+    //MotorSetMicroStep(motorId, KeepMicrostep[DispenserId]);
     PrimingActive[DispenserId]= false;
     Control_TCA9534ByPass(DispenserId,DISABLE);// use ENABLE or DISABLE
     if (DispenserId == LUBRICANT_DISPENSER)
@@ -451,10 +424,10 @@ uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fpt
     //if (DispensersAlarmState[DispenserId] == true)
     //    return ERROR;
     if ((HomingActive[DispenserId] == true)||(PrimingActive[DispenserId] == true))
+    {
+        Report("IDS_HomeDispenser - Homing/priming already active",__FILE__,HomingActive[DispenserId],(int)DispenserId,RpWarning,PrimingActive[DispenserId],0);
         return ERROR;
-    else
-        PrimingActive[DispenserId] = true;
-    HomingRequestCallback[DispenserId] = callback;
+    }
     if (Check_Disp_Safety_Stop_Indication(DispenserId) == true)
     {
         if ((Get_Notification_Disp_Down(DispenserId) == false)||(Get_Notification_Over_Press(DispenserId) == false))
@@ -466,13 +439,15 @@ uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fpt
     TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
     if ( Dispenser_Id_to_LS_Empty_Id[DispenserId] != MAX_GPI)
     {
+        PrimingActive[DispenserId] = true;
+        HomingRequestCallback[DispenserId] = callback;
         //open dispenser valve dispenser to midtank direction
         Control3WayValvesWithCallback ((Valves_t)DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
         if (Extended_Motor_Param == true)
             Power_Step_01_Dispenser_Mode(DispenserId,Current);
         //Valve_Set((Valves_t) request->index, Dispenser_Mixer);
         KeepMicrostep[DispenserId] = MotorsCfg[MotorId].microstep;
-        MotorSetMicroStep(MotorId, 1);
+        //MotorSetMicroStep(MotorId, 1);
         Task_sleep(100);
         //open dry air valve in the dispenser
         //Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_ON);
@@ -486,3 +461,40 @@ uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fpt
     }
     return ERROR;
 }
+uint32_t IDS_Dispenser_Alarm_On (uint8_t DispenserId)
+{
+    uint32_t status = OK;
+    Report("IDS_Dispenser_Alarm_On",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
+    assert(DispenserId < MAX_SYSTEM_DISPENSERS);
+    DispensersAlarmState[DispenserId] = true;
+    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
+    status |= MotorAbortMovetoLimitSwitch(MotorId);
+    Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
+    Disable_MidTank_Pressure_Reading(DispenserId);
+    if (Extended_Motor_Param == true)
+        Power_Step_01_Dispenser_Mode(DispenserId,Voltage);
+    //status |= MotorSetMicroStep(MotorId, KeepMicrostep[DispenserId]);
+    status |= MotorStop(DispenserId, Hard_Hiz);
+    IDS_Dispenser_Init(DispenserId);
+    JobEndReason = JOB_OUT_OF_DYE;
+    return status;
+}
+uint32_t IDS_Dispenser_Alarm_Off (uint8_t DispenserId)
+{
+    uint32_t status = OK;
+    assert(DispenserId < MAX_SYSTEM_DISPENSERS);
+    DispensersAlarmState[DispenserId] = false;
+    Report("IDS_Dispenser_Alarm_Off",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
+    return status;
+}
+
+void IDS_Dispenser_Init(uint8_t DispenserId)
+{
+    assert(DispenserId < MAX_SYSTEM_DISPENSERS);
+    Report("IDS_Dispenser_Init",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
+    CurrentDispenserSpeed[DispenserId] = 0;
+    HomingActive[DispenserId]= false;
+    PrimingActive[DispenserId]= false;
+    Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
+    Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 1bab2c65d..ca9a15008 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -55,10 +55,10 @@ uint32_t IDS_Valve_DistanceToSpoolReady(uint32_t deviceID, uint32_t ReadValue);
 uint32_t IDS_Valve_PresegmentReady(uint32_t deviceID, uint32_t ReadValue);
 uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue);
 //bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int SegmentId);
-bool JobStartStopBackLash[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 /******************** GLOBAL PARAMETERS  ********************************************/
 DispenserControlConfig_t DispenserControlConfig[MAX_SYSTEM_DISPENSERS];
 uint32_t    ControlIdtoDispenserId [MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
+uint32_t    ControlIdtoInactiveDispenserId [MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
 int OriginalDispenserSpd_2PPS[MAX_SYSTEM_DISPENSERS] = {0,0,0,0,0,0,0,0};
 bool         DispenserPreSegmentReady[MAX_SYSTEM_DISPENSERS] = {true,true,true,true,true,true,true,true};
 bool         DispenserSegmentReady[MAX_SYSTEM_DISPENSERS] = {true,true,true,true,true,true,true,true};
@@ -375,6 +375,22 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
  int NumOfActiveDispensers = 0;
  int DispenserBuildTimeCounter = 0;
 #define PRESSURE_READ_TIME_GAP 100
+uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
+{
+    if (AutoHoming_Config >= AutoHoming_JobEnd_PowerOn_off)
+    {
+        if ((HomingActive[DispenserId] == false)&&(PrimingActive == false))
+        {
+            Report("Homing Inactive dispenser",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
+            IDS_HomeDispenser (DispenserId, 1000 , NULL);
+        }
+        else
+        {
+            Report("Inactive dispenser already homing",__FILE__,DispenserId,HomingActive[DispenserId],RpWarning,PrimingActive[DispenserId],0);
+        }
+    }
+    return OK;
+}
  void DispenserPrepareReady(void)
  {
      int i;
@@ -387,6 +403,17 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      }
      REPORT_MSG(Module_IDS,"All Dispensers Prepare Ready");
      PrepareReady(Module_IDS,ModuleDone);
+     for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)//close valve and home inactive dispensers
+     {
+         if (DispenserUsedInJob[i] == false)
+         {
+             if ((HomingActive[i] == false)&&(PrimingActive == false))
+             {
+                 Report("Inactive dispenser close valve",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+                 Control3WayValvesWithCallback (i, MidTank_Dispenser, InactiveDispenserHome); //direction: MidTank_Dispenser or Dispenser_Mixer
+             }
+         }
+     }
  }
  //********************************************************************************************************************
   uint32_t IDS_PrepareReady(uint32_t deviceID, uint32_t ReadValue)
@@ -437,7 +464,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
              else
              {
                  tempSpeed = CurrentDispenserSpeed[i];
-                 updatedSpeed = (tempSpeed*1.02<1000)?tempSpeed*1.02:1000;
+                 updatedSpeed = (tempSpeed*1.02<InitialDispenserSpeed)?tempSpeed*1.02:InitialDispenserSpeed;
                  MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                  CurrentDispenserSpeed[i] = updatedSpeed;
                  //Report("IDS accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
@@ -520,7 +547,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
     }
     return OK;
 }
- uint32_t IDSPrepareStartDispenserAfterHoming(uint32_t DispenserId, uint32_t Result)
+ /*uint32_t IDSPrepareStartDispenserAfterHoming(uint32_t DispenserId, uint32_t Result)
  {
      double dispenserspeed = 0;
      Report("IDSPrepare Start Dispenser After Homing",__FILE__,__LINE__,DispenserId,RpWarning,(int)Result,0);
@@ -532,7 +559,28 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      }
      return OK;
 
+ }*/
+
+ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
+ {
+     TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
+     if (DispenserUsedInJob[DispenserId] == true)
+     {
+         LOG_ERROR(DispenserId,"IDS_Check_Pressure_Callback active in a job");
+     }
+     if (JobIsActive())
+     {
+         SafeRemoveControlCallback(ControlIdtoInactiveDispenserId[DispenserId], IDS_Check_Pressure_Callback );
+         ControlIdtoInactiveDispenserId[DispenserId] = 0xFF;
+     }
+     if (GetDispenserPressure(DispenserId)>3.0)
+     {
+         Report("Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
+         MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,200);
+     }
+     return OK;
  }
+
  void IDSPrepareStart(void)
  {
      int i;
@@ -545,20 +593,24 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      }
 
      NumOfActiveDispensers = 0;
+     IDS_StopHomeDispenser(CLEANER_DISPENSER);
      for (i = 0; i < MAX_DYE_DISPENSERS; i++)
      {
          if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
          {
-             IDS_StopHomeDispenser(i);
-             JobStartStopBackLash[i] = true;
              NumOfActiveDispensers++;
+             if (HomingActive[i] == true)
+             {
+                 Report("Stop active dispenser homing ",__FILE__,i,HomingActive[i],RpWarning,CurrentDispenserSpeed[i],0);
+                 IDS_StopHomeDispenser(i);
+             }
          }
          else
          {
-             if (AutoHoming_Config >= AutoHoming_JobEnd_PowerOn_off)
+             if ((HomingActive[i] == false)&&(PrimingActive == false))
              {
-                 REPORT_MSG((int)i, "Homing inactive dispenser");
-                 IDS_HomeDispenser (i, 1000 , NULL);
+                 Report("Inactive dispenser open valve",__FILE__,i,HomingActive[i],RpWarning,PrimingActive[i],0);
+                 Control3WayValvesWithCallback (i, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
              }
          }
      }
@@ -572,17 +624,17 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
 
              if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
              {
-                 if (HomingActive[i] == false)
+                 //if (HomingActive[i] == false)
                  {
-                     Report("Prepare Speed",__FILE__,__LINE__,i,RpWarning,(int)dispenserspeed,0);
+                     Report("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
                      IDS_Dispenser_Start_Motor_and_Open_Valve(i,dispenserspeed, NULL);
                  }
-                 else
+                 /*else
                  {
                      Report("IDSPrepare Stop Dispenser Homing",__FILE__,__LINE__,i,RpWarning,(int)HomingActive[i],0);
                      IDS_HomeDispenserWaitForHomingEnd(i,  DispenserPrepareTimeout/2 , IDSPrepareStartDispenserAfterHoming);
-                 }
+                 }*/
              }
          }
      }
@@ -890,11 +942,12 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                          CurrentDispenserSpeed[Dispenser_i] = segmentfirst_speed;
 
                          usnprintf(IdMessage, 80,
-                                   "WFCF Dispenser %d nl/sec %d nl/pulse %d speed %d",
+                                   "WFCF Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d",
                                    DispenserId,
                                    (int) Dispensers[Dispenser_i]->nanolitterpersecond,
                                    (int) Dispensers[Dispenser_i]->nanoliterperpulse,
-                                   (int) segmentfirst_speed);
+                                   (int) Dispensers[Dispenser_i]->pulsepersecond*1000,
+                                   (int) segmentfirst_speed*1000);
                          //REPORT_MSG(segmentfirst_speed,IdsMessage);
                          Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
                          //SendJobProgress(0.0, 0, false, IdsMessage);
@@ -1159,10 +1212,11 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                 MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
                 CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
                 usnprintf(IdsMessage, 80,
-                          "Dispenser %d nl/sec %d nl/pulse %d speed %d steps %d/%d",
+                          "Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d steps %d/%d",
                           DispenserId,
                           (int) Dispensers[Dispenser_i]->nanolitterpersecond,
                           (int) Dispensers[Dispenser_i]->nanoliterperpulse,
+                          (int) Dispensers[Dispenser_i]->pulsepersecond*1000,
                           (int) (segmentfirst_speed*1000),Dispensers[Dispenser_i]->dispenserstepdivision,MotorsCfg[HW_Motor_Id].microstep);
                 //REPORT_MSG(segmentfirst_speed,IdsMessage);
                 Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
@@ -1231,6 +1285,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
 
      Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
 
+     IDS_Cleaning_Stop_Cleaning_Solution(NULL);
      SegmentNumOfBrushStops = Segment->n_brushstops;
      BrushStopTime = Segment->length/SegmentNumOfBrushStops;  //brushstop in meters
      BrushStopTime = ((BrushStopTime*100)/dyeingspeed);//brushstop in seconds
@@ -1400,6 +1455,8 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          }
          else
          {
+             RemoveControlCallback(ControlIdtoInactiveDispenserId[Dispenser_i], IDS_Check_Pressure_Callback );
+             ControlIdtoInactiveDispenserId[Dispenser_i] = 0xFF;
              IDS_Valve_EndValveReady(Dispenser_i,false);
          }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
index fc50173fc..545495646 100644
--- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.c
@@ -18,6 +18,7 @@
 #include "include.h"
 
 #include "Modules/Waste/Waste.h"
+#include "Modules/IDS/ids_ex.h"
 #include "Modules/IFS/ifs.h"
 #include "Modules/AlarmHandling/AlarmHandling.h"
 #include "CartridgeValidationRequest.pb-c.h"
@@ -25,6 +26,7 @@
 #include  <PMR/Diagnostics/EventType.pb-c.h>
 #include "drivers/Valves/Valve.h"
 #include "Modules/Waste/Waste.h"
+#include "../control/control.h"
 
 bool IFS_TimeOutAlarm(bool status);
 bool ColorMatch();
@@ -49,8 +51,37 @@ void IFS_Init(void)
 
 }*/
 
+/**
+ *
+ * @brief detect cartridge INK Empty
+ *  this function detect changes in IFS INK cartridge
+ *  when MidTank average is bigger the 98% of midtank pressure
+ *  the INK cartridge is empty
+ * @return bool ret OK = 0 , CartridgeFinished = 1
+ */
+bool DetectIfCartridgeFinished(int int_MidTank_Pressure_1000)
+{
 
+#define CartridgeFinished 1
 
+    bool ret = OK;
+    static int measure_midtank[5] ;
+    static int count_measure_midtank = 0;
+    int i=0;
+    int sum = 0;
+    int average = 0;
+
+    if ( count_measure_midtank == 5) count_measure_midtank = 0;
+    measure_midtank[count_measure_midtank] = int_MidTank_Pressure_1000;
+    count_measure_midtank += 1;
+    for (i=0;i<5;i++)
+        sum += measure_midtank[i];
+    average = sum/5;
+    if (abs(average - int_MidTank_Pressure_1000)<10)  ret = CartridgeFinished;
+    //if (average > (int_MidTank_Pressure_1000 * 0.98) )  ret = CartridgeFinished;
+
+    return ret;
+}
 
 
 
@@ -99,14 +130,18 @@ WHS_sensor CartridgeInkTimeOutCallBackFunction()
 {
     WHS_sensor ret = WHS_no_event;
     double MidTank_Pressure = 0;
+    int int_MidTank_Pressure_1000 = 0;
+
 
+    //Enable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
     MidTank_Pressure = Read_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);// Get_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);
-    ReportWithPackageFilter(WasteFilter,"------------ IFS_info.Ink.time_out and Pressure  -----------------", __FILE__,__LINE__,(IFS_info.Ink.time_out * SECONDS_5), RpMessage, (int)(MidTank_Pressure*1000), 0);
+    //Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
+    int_MidTank_Pressure_1000 =  ((int)(MidTank_Pressure*1000));
+    ReportWithPackageFilter(WasteFilter,"------------ IFS_info.Ink.time_out and Pressure  -----------------", __FILE__,__LINE__,(IFS_info.Ink.time_out * SECONDS_5), RpMessage, (int_MidTank_Pressure_1000), 0);
 
     if (IFS_info.Ink.time_out) IFS_info.Ink.time_out += 1; /*** counter  ***/
 
 
-//#ifdef timeout_capacity
     /*** detect the MidTank capacity is full  ***/
     //Read_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);
     if (MidTank_Pressure >= IFS_info.MidTank_capacity  + CARTRIDGE_CAPATICY)
@@ -115,7 +150,18 @@ WHS_sensor CartridgeInkTimeOutCallBackFunction()
         WHS_info.event = IFS_MidTankFull;
         return IFS_MidTankFull;
     }
-//#endif
+
+    /**** detect if the MidTank_Pressure is the same, 5 times   ****/
+    if (DetectIfCartridgeFinished(int_MidTank_Pressure_1000))
+    {
+        ReportWithPackageFilter(WasteFilter,"------------ INK Cartrigde is empty (by average)  -----------------", __FILE__,__LINE__,(IFS_info.Ink.time_out * SECONDS_5), RpMessage, (int_MidTank_Pressure_1000), 0);
+        IFS_info.Ink.time_out = 0;
+        WHS_info.event = IFS_MidTankFull;
+        return IFS_MidTankFull;
+    }
+
+
+
     /*** first TimeOut  ***/
     if (IFS_info.Ink.time_out == CARTRIDGE_INK_TIMEOUT)
     {
@@ -156,36 +202,9 @@ WHS_sensor CartridgeInkTimeOutCallBackFunction()
 bool IFS_TimeOutAlarm(bool status)
 {
     bool ret =  OK;
-        switch (IFS_info.Ink.cart_color) //todo enter the correct color from RFID
-        {
-            case 1 :
-                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT,  status);
-                break;
-            case 2 :
-                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_2_FILL_TIMEOUT,  status);
-               break;
-            case 3 :
-                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_3_FILL_TIMEOUT,  status);
-                break;
-            case 4 :
-                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_4_FILL_TIMEOUT,  status);
-               break;
-            case 5 :
-                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_5_FILL_TIMEOUT,  status);
-               break;
-            case 6 :
-                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_6_FILL_TIMEOUT,  status);
-               break;
-            case 7 :
-                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_7_FILL_TIMEOUT,  status);
-                break;
-            case 8 :
-                AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_8_FILL_TIMEOUT,  status);
-               break;
-            default: //wrong color
-                ret = notOK;
-                break;
-        }
+
+        AlarmHandlingSetAlarm( EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT+IFS_info.Ink.cart_color,  status);
+
 
         return ret;
 }
@@ -211,6 +230,7 @@ bool MidTankValvesAction(bool action) //Cartridge_MidTank_ON of Cartridge_MidTan
     {
         Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
     }
+#warning check that the dispenser is not in homing before CLOSING the air valve
     Valve_Set(IDS_Id_to_AirValve[IFS_info.Ink.cart_color], action );   //Atm_MidTank_OFF/ON
     Valve_Set(IDS_Id_to_CartrideValve[IFS_info.Ink.cart_color], action );   //Atm_MidTank_OFF/ON
 
@@ -330,6 +350,56 @@ void ResponseDemo(int MidtankId)
     IFS_info.Ink.cart_color = MidtankId;
     WasteTankCBFunction();//call cart is ok
 }
+uint32_t MidTankReadControlId = 0xFF;
+int MidTankCounter = 0;
+uint32_t MidTankCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
+{
+    int MidTankOpenAir = 8;
+    int MidTankReadPressure = 16;
+    int MidTankCloseAir = 40;
+    int MidTankEnd = 48;
+    int portId;
+
+    if (MidTankCounter >= MidTankEnd)
+    {
+        SafeRemoveControlCallback(MidTankReadControlId, MidTankCallBackFunction);
+    }
+    else if (MidTankCounter >= MidTankCloseAir)
+    {
+        //close air valve for midtank (MidTankCounter-MidTankCloseAir)
+        portId = (MidTankCounter - MidTankCloseAir) ; //0-7
+        if (IDS_IsHomingActive(portId) == false)
+        {
+            Disable_MidTank_Pressure_Reading(portId);
+            Valve_Set(IDS_Id_to_AirValve[portId], Atm_MidTank_OFF );   //Atm_MidTank_OFF/ON
+        }
+    }
+    else if (MidTankCounter >= MidTankReadPressure)
+    {
+        //read pressure for midtank (MidTankCounter-MidTankCloseAir)
+        for (portId = 0;portId < MAX_SYSTEM_DISPENSERS;portId++)
+        {
+            Read_MidTank_Pressure_Sensor(portId);
+        }
+    }
+    else if (MidTankCounter >= MidTankOpenAir)
+    {
+        //open air valve for midtank (MidTankCounter-MidTankOpenAir)
+        portId = (MidTankCounter - MidTankOpenAir) ; //0-7
+        Enable_MidTank_Pressure_Reading(portId);
+        Valve_Set(IDS_Id_to_AirValve[portId], Atm_MidTank_ON );   //Atm_MidTank_OFF/ON
+    }
+    MidTankCounter++;
+    return OK;
+}
+
+uint32_t MidTankReading(void)
+{
+    MidTankCounter = 0;
+    MidTankReadControlId = AddControlCallback( MidTankCallBackFunction, 300/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
+
+    return OK;
+}
 
 bool  INKCartridgeAuthentication(cartridge_name cart_name)
 {
diff --git a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
index a7e80a31e..11ae5b008 100644
--- a/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
+++ b/Software/Embedded_SW/Embedded/Modules/IFS/ifs.h
@@ -55,5 +55,6 @@ void ResponseDemo(int MidtankId);
 
 bool CartridgeValidationResponseFunc(MessageContainer* requestContainer);
 
+uint32_t MidTankReading(void);
 
 #endif /* MODULES_IFS_IFS_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 3504c3134..5850ff7cf 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -15,12 +15,14 @@
 #include "drivers/Heater/TemperatureSensor.h"
 #include "drivers/ADC_Sampling/adc.h"
 
-#include "Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h"
+#include "Drivers/I2C_Communication/Head_Card/PT100/PT100_ADC.h"
 #include "Drivers/I2C_Communication/Head_Card/Fan/fan_click.h"
 #include "Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h"
 #include "drivers/Motors/Motor.h"
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "Modules/IFS/ifs.h"
+#include "Modules/IDS/ids_ex.h"
+#include "Modules/Control/MillisecTask.h"
 
 //#include "graphics_adapter.h"
 extern uint8_t Input_Voltage;
@@ -45,20 +47,14 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
-        if((request->amount == 0xAD) && (request->delay == 0xAD01)) //undef AUTO_HOME_DISPENSERS
-        {
-            #undef AUTO_HOME_DISPENSERS
-            response.progress = 01;
-            response.has_progress = true;
-        }
-        else
-        if((request->amount == 0xAD) && (request->delay == 0xAD00)) //define AUTO_HOME_DISPENSERS
-        {
-            #define AUTO_HOME_DISPENSERS
-            response.progress = 01;
-            response.has_progress = true;
-        }
-        else
+    if(request->amount == 0xAD) //undef AUTO_HOME_DISPENSERS
+    {
+        if ((request->delay >=AutoHoming_off )&&(request->delay<=AutoHoming_JobEnd_PowerOn_off ))
+            IDS_Dispenser_SetAutoHoming_Config(request->delay);
+        response.progress = 01;
+        response.has_progress = true;
+    }
+    else
     if((request->amount == 0x01) && ((request->delay &0x010000) == 0x010000)) //change mode powerset01
     {
         response.progress = Power_Step_01_Mode(((request->delay &0x00FF00)>>8), request->delay &0x0000FF);
@@ -168,6 +164,14 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
 
     }
+    else
+    if(request->amount == 0xE0)  //fast refresh for pressure
+    {
+        setRapidPressureRead(request->delay);
+        response.progress = (double)OK;
+        response.has_progress = true;
+
+    }
     else     if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
     {
         PowerOffInit();
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index c5cdb00d6..5a2307384 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -18,6 +18,7 @@
 #include "Modules/control/pidalgo.h"
 
 #include "Modules/heaters/heaters_ex.h"
+#include "Modules/General/buttons.h"
 #include "StateMachines/Initialization/InitSequence.h"
 
 #include "PMR/Hardware/HardwareMotor.pb-c.h"
@@ -151,7 +152,7 @@
         ProcessParametersClear.headzone6temp  = 0;
         ProcessParametersClear.dyeingspeed = 40;
         ProcessParametersClear.dryerbufferlength = ProcessParametersKeep.dryerbufferlength;
-        if (HandleProcessParameters(&ProcessParametersClear)!= OK)
+        if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
         {
             LOG_ERROR (LoadStages, "Thread_Load_Init failed");
         }
@@ -223,7 +224,7 @@
         ThreadLoadStateMachine(LoadStages);
         return OK;
     }
-    uint32_t Thread_Load_Set_Load_Arm_To_Start_Position(void)
+    /*uint32_t Thread_Load_Set_Load_Arm_To_Start_Position(void)
     {
         uint32_t numberOfSteps = 0;
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
@@ -238,14 +239,14 @@
         }
         else //number of circles is not known - compare to position of the motor to verify location at the stopper
         {
-            Report("Thread_Load_Set_Load_Arm_To_Start_Position unknown cycles",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+            Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
             status |= MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
-                                            MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/2, Thread_Load_Set_Load_Arm_To_Stopper_Callback,LoadArmInfo.LoadArmBackLash,1000);
+                                            MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep, Thread_Load_Set_Load_Arm_To_Stopper_Callback,LoadArmInfo.LoadArmBackLash,1000);
 
         }
         //Use Notation How Many Rotations In The Drier, Or Check Against Stopper. Move Slowly
         return OK;
-    }
+    }*/
     uint32_t Thread_Load_Jog_Feeder_To_Middle_Point_Callback(uint32_t deviceID, uint32_t BusyFlag)
     {
         CallbackCounter--;
@@ -265,6 +266,12 @@
         {
             if((MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)||(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING))
             {
+                if(LoadStages == THREAD_LOAD_CLOSE_ROCKERS)
+                {
+                    MotorMove(MotorId,MotorsCfg[MotorId].directionthreadwize,400);
+			        Report("Move rockers further down",__FILE__,__LINE__,MotorId,RpMessage,400,0);
+                    Task_sleep(200);
+                }
                 MotorSetMicroStep(MotorId, keepmicrostep);
                 MotorSetKvalRun(MotorId, keepkvalrun);
             }
@@ -273,6 +280,7 @@
         if (CallbackCounter)
         {
             CallbackCounter--;
+            load.color = BLINK;
             if (ReadValue != LIMIT)
             {
                 //returned with a timeout
@@ -284,10 +292,12 @@
                 {
                     LOG_ERROR(LoadStages,"Load sequence timeout");
                     TimeoutsCounter = 0;
+                    load.color = fastBILNK;
                 }
                 else
                 {
                     LoadStages++;
+                    load.color = colorON;
                     if (LoadStages == THREAD_LOAD_CLOSE_DANCERS)
                     {
                         MotorSetKvalHold(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, keepkvalhold);
@@ -296,6 +306,10 @@
                     {
                         ThreadLoadStateMachine(LoadStages);
                     }
+                    else
+                    {
+                        load.color = fastBILNK;
+                    }
                 }
             }
         }
@@ -334,7 +348,7 @@
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 15,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,15000);
         CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 600,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
+        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 500,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
 
         return OK;
     }
@@ -403,7 +417,7 @@
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 15,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
-        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 600,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
+        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LDANCER1,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1].directionthreadwize, 500,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_LDANCER1], Thread_Load_HomingCallback,25000);
 
         return OK;
     }
@@ -426,7 +440,7 @@
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
         ActivateHeadMagnet();
 
-        if (HandleProcessParameters(&ProcessParametersRecover)!= OK)
+        if (HandleProcessParameters(&ProcessParametersRecover,false)!= OK)
         {
             LOG_ERROR (LoadStages, "Thread_Load_Resume_Heating failed");
         }
@@ -494,8 +508,8 @@
 
         if (dryerbufferlength)
             LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
-        //if (LoadArmInfo.LoadArmRounds <= 2)
-        //    LoadArmInfo.LoadArmRounds = 20;
+        if (LoadArmInfo.LoadArmRounds <= 2)
+            LoadArmInfo.LoadArmRounds = 30;
         float numberOfSteps = 0;
         //Start Feeder Pid, Rotate Loading Arm Counter Thread Direction X Circles According To Rml. Feeder Speed Is 40
         SetOriginMotorSpeed(19);
@@ -591,6 +605,7 @@
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_DH_LID);
         MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,Hard_Stop);
         LoadStages = THREAD_LOAD_INIT;
+        load.color = colorOFF;
         return OK;
     }
     uint32_t Thread_Load_Dryer_UnLoading(void)
@@ -664,7 +679,8 @@
         //Keep Notation How Many Rotations In The Dryer
         LoadArmInfo.LoadArmBackLash = 5;
         LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
-        //FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
+        FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
+        load.color = BLINK;
         return OK;
     }
 
@@ -825,6 +841,35 @@ uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         CurrentControlledSpeed[index] = calculated_speed;
         MotorSetSpeed(ThreadMotorIdToMotorId[index], calculated_speed);
     }
+    if (index == POOLER_MOTOR)
+    {
+        if ((TranslatedReadValue)<(-1200))
+        {
+            if(PullerControlId != 0xFF)
+            {
+                Report("Puller stoped",__FILE__,__LINE__,ReadValue,RpWarning,(int)DancersCfg[DancerId].zeropoint,0);
+                MotorStop(ThreadMotorIdToMotorId[POOLER_MOTOR],Hard_Hiz);
+                RemoveControlCallback(PullerControlId, ThreadLoadControlCBFunction );
+                PullerControlId = 0xFF;
+            }
+        }
+
+    }
+    if (index == WINDER_MOTOR)
+    {
+        if ((TranslatedReadValue)<(-1200))
+        {
+            if(WinderControlId != 0xFF)
+            {
+                Report("Winder stoped",__FILE__,__LINE__,ReadValue,RpWarning,(int)DancersCfg[DancerId].zeropoint,0);
+                MotorStop(ThreadMotorIdToMotorId[WINDER_MOTOR],Hard_Hiz);
+                RemoveControlCallback(WinderControlId, ThreadLoadControlCBFunction );
+                WinderControlId = 0xFF;
+            }
+
+        }
+
+    }
 /*    LoadCounter++;
     if ((LoadCounter % 5001) == 0)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index a93387e0a..741fed7af 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -66,6 +66,7 @@ InternalWinderConfigStruc InternalWinderCfg = {0};
 #ifdef READ_SCREW_ENCODER
 uint32_t ScrewLocationLimitSwitch = 0,ScrewLocationStart = 0;
 uint32_t ScrewLocationRun[3];
+uint32_t ScrewLocationPrev[3];
 float WinderRunAverage = 0.0,WinderRunSum = 0.0;
 int WinderRunSamples = 0;
 #endif
@@ -305,7 +306,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 //            WinderMotorSpeedCounter=0;
         }
 //    }
-    if (flipflop == 0)
+    /*if (flipflop == 0)
     {
         MotorGetSpeedFromFPGA1(HARDWARE_MOTOR_TYPE__MOTO_SCREW);
     }
@@ -314,11 +315,11 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         speedf = MotorGetSpeedFromFPGA_Res(HARDWARE_MOTOR_TYPE__MOTO_SCREW);
     }
     flipflop ++;
-
+    */
     if (ScrewDirectionChangeCounter == CalculationDirectionChangeCounter)
         return OK;
     //deley TODO
-    flipflop = 0;
+    //flipflop = 0;
 
     ScrewCurrentDirection = 1-ScrewCurrentDirection;
     CalculationDirectionChangeCounter++;
@@ -342,6 +343,16 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
              Report(ScrewStr,__FILE__,__LINE__,CalculationDirectionChangeCounter,RpWarning,ScrewLocationStart, 0);
          }
      }
+     if (abs(ScrewLocationPrev[1]-ScrewLocationRun[1])>21)
+     {
+         Report("Winder difference",__FILE__,CalculationDirectionChangeCounter,ScrewLocationPrev[1],RpWarning,ScrewLocationRun[1], 0);
+     }
+     ScrewLocationPrev[1] = ScrewLocationRun[1];
+     if (abs(ScrewLocationPrev[0]-ScrewLocationRun[0])>21)
+     {
+         Report("Winder difference",__FILE__,CalculationDirectionChangeCounter,ScrewLocationPrev[0],RpWarning,ScrewLocationRun[0], 0);
+     }
+     ScrewLocationPrev[0] = ScrewLocationRun[0];
      //else
      //    Report("winder run error value" ,__FILE__,WinderRun,ScrewLocationRun[0],RpWarning,ScrewLocationRun[1], 0);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index 416b53494..226bb2559 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -23,6 +23,7 @@
 #include "drivers/Flash_ram/FlashProgram.h"
 
 #include "drivers/Flash_ram/MCU_E2Prom.h"
+#include "modules/ids/ids_ex.h"
 
 #include "thread.h"
 MotorDriverConfigStruc  MotorsCfg[NUM_OF_MOTORS]={0};
@@ -105,6 +106,10 @@ uint32_t MotorsConfigMessage(HardwareConfiguration * HWrequest)
         MotorsCfg[Motor_i].toffmin  = request->toffmin ;
 
             status = MotorConfig( Motor_i,  &MotorsCfg[Motor_i]);
+            if ((Motor_i >= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)&&(Motor_i <= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8))
+            {
+                IDS_Dispenser_Init(Motor_i-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
+            }
 //        if (Motor_i == MOTOR_RDRIVING)
 //            ThreadInitialTestStub(request);
     }
@@ -173,7 +178,7 @@ uint32_t StoreDancerConfigMessage()
     status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_0,DancersCfg[0].zeropoint);
     status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_1,DancersCfg[1].zeropoint);
     status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_2,DancersCfg[2].zeropoint);
-    Report("Store eeprom 0",__FILE__,DancersCfg[0].zeropoint,(int)DancersCfg[1].zeropoint,RpWarning,(int)DancersCfg[2].zeropoint,0);
+    Report("~~~~~~Store eeprom 0",__FILE__,DancersCfg[0].zeropoint,(int)DancersCfg[1].zeropoint,RpWarning,(int)DancersCfg[2].zeropoint,0);
 /*
     response_buffer = my_malloc(hardware_configuration__get_packed_size(&DancerConfig));
     if (response_buffer)
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 41d98e892..9d408a4a6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -883,9 +883,10 @@ void ThreadPreSegmentEnded(void)
 }
 #define DRYER_RAMPUP 1
 #ifdef DRYER_RAMPUP
+int DrierDivider = 10;
 uint32_t ThreadDryerRampUp(uint32_t IfIndex, uint32_t BusyFlag)
 {
-    InitialDryerSpeed += (OriginalMotorSpd_2PPS[DRYER_MOTOR]/10);
+    InitialDryerSpeed += (OriginalMotorSpd_2PPS[DRYER_MOTOR]/DrierDivider);
     if (InitialDryerSpeed >= OriginalMotorSpd_2PPS[DRYER_MOTOR])
     {
         InitialDryerSpeed = OriginalMotorSpd_2PPS[DRYER_MOTOR];
@@ -924,7 +925,9 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
 #ifndef DRYER_RAMPUP
         MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING, OriginalMotorSpd_2PPS[DRYER_MOTOR]);
 #else
-        InitialDryerSpeed = OriginalMotorSpd_2PPS[DRYER_MOTOR]/10;
+        DrierDivider = dyeingspeed/5;  //ramp up drier in 5 cm/sec steps
+        Report("Drier ramp up",__FILE__,__LINE__,(int)dyeingspeed,RpWarning,(int)DrierDivider,0);
+        InitialDryerSpeed = OriginalMotorSpd_2PPS[DRYER_MOTOR]/DrierDivider;
         MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,InitialDryerSpeed );
         ControlIdtoMotorId[DRYER_MOTOR] = AddControlCallback("DryerRampUp",ThreadDryerRampUp, 200,TemplateDataReadCBFunction,0,0,0);
 #endif
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index f3812cc2c..9c4628f4f 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -830,6 +830,7 @@ bool WasteTankCBFunction()
                         {
                             //WHS_info.cartridge_1.autheticate = PASSED; //='0'
                             //???WHS_info.WHS_valve = waste_cartridge1; // or we should do it only before pumping????
+                            AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  false);
                         }
                         else
                         {
@@ -858,6 +859,7 @@ bool WasteTankCBFunction()
                            //WHS_info.cartridge_2.autheticate = PASSED; //='0'
                            //???WHS_info.WHS_valve = waste_cartridge2; // or we should do it only before pumping????
                            //???SetValveDirection();    // or we should do it only before pumping????
+                           AlarmHandlingSetAlarm( EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL,  false);
                        }
                        else
                        {
@@ -917,12 +919,12 @@ bool WasteTankCBFunction()
             REPORT_MSG(WHS_full," ------------ call customer support ----------------- ");
             Pannel_Leds(CART_1, MODE_ON);
             cart1.color = fastBILNK;
-            IFS_TimeOutAlarm(true);
+            //IFS_TimeOutAlarm();
             break;
 
         case IFS_MidTankFull:
 //            Disable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
-            WHS_info.Cartridge_Ink_TimeOut_device_Id = RemoveControlCallback(WHS_info.Cartridge_Ink_TimeOut_device_Id, WasteTankCBFunction );
+            IFS_info.Cartridge_Ink_TimeOut_device_Id = RemoveControlCallback(IFS_info.Cartridge_Ink_TimeOut_device_Id, WasteTankCBFunction );
             REPORT_MSG(WHS_full," ------------ Change cartridge status to Waste Empty ----------------- ");
             Pannel_Leds(CART_1, MODE_OFF);
             cart1.color = colorOFF;
@@ -1157,11 +1159,11 @@ bool InitCartStatus()
     if (WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN)
     {
         REPORT_MSG(parameter," ------------ WHS_CartridgeCoverOPEN  : add callback for cart1 and cart 2   ----------------- ");
-        IFS_info.Cartridge_Ink_device_Id    = AddControlCallback("Ink Cartridge CB"   , WasteTankCBFunction, eOneSecond, CartridgeInkCallBackFunction   , 0,0,0 );
-        WHS_info.Cartridge_Waste1_device_Id = AddControlCallback("Waste1 Cartridge CB", WasteTankCBFunction, eOneSecond, CartridgeWaste1CallBackFunction, 0,0,0 );
-        WHS_info.Cartridge_Waste2_device_Id = AddControlCallback("Waste2 Cartridge CB", WasteTankCBFunction, eOneSecond, CartridgeWaste2CallBackFunction, 0,0,0 );
+        IFS_info.Cartridge_Ink_device_Id = AddControlCallback(NULL, WasteTankCBFunction, eOneSecond, CartridgeInkCallBackFunction, 0,0,0 );
+        WHS_info.Cartridge_Waste1_device_Id = AddControlCallback(NULL, WasteTankCBFunction, eOneSecond, CartridgeWaste1CallBackFunction, 0,0,0 );
+        WHS_info.Cartridge_Waste2_device_Id = AddControlCallback(NULL, WasteTankCBFunction, eOneSecond, CartridgeWaste2CallBackFunction, 0,0,0 );
     }
-    WHS_info.Cartridge_Cover_device_Id = AddControlCallback("Cartridge Cover Door", WasteTankCBFunction, eOneSecond, CartridgeCoverCallBackFunction, 0,0,0 );
+    WHS_info.Cartridge_Cover_device_Id = AddControlCallback(NULL, WasteTankCBFunction, eOneSecond, CartridgeCoverCallBackFunction, 0,0,0 );
 
     return OK;
 }