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

27 files changed, 838 insertions, 309 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 13f0515f9..368c52436 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -175,6 +175,14 @@ const AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
  {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE,"Dispenser 7 Over Pressure"},
  {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE,"Dispenser 8 Over Pressure"},
 
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY,"MidTank 1 Empty alarm"},
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY,"MidTank 2 Empty alarm"},
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY,"MidTank 3 Empty alarm"},
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY,"MidTank 4 Empty alarm"},
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY,"MidTank 5 Empty alarm"},
+ {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY,"MidTank 8 Empty alarm"},
+
+
  {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT,"Motor Drier Over Current"},
  {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT,"Motor Feeder Over Current"},
  {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT,"Motor Screw Over Current"},
@@ -243,14 +251,14 @@ const AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
  {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor      ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN,"Rear door Open"},
  {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor,1,false,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN,"Cartridges door Open"},
 
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"},
- {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"},
+ {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"},
  {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"},
  {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,"DyeingHead 1 PT100 Heating Failure"},
  {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,"DyeingHead 2 PT100 Heating Failure"},
@@ -566,6 +574,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     }
     for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++)
     {
+
         if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__CoversAlarm)
         {
             if (AlarmState[Alarm_i].Status == true)
@@ -575,6 +584,15 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                 break;
             }
         }
+        /*if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__FluidLevelAlarm)
+        {
+            if (AlarmState[Alarm_i].Status == true)
+            {
+                status = ERROR;
+                AlarmId = Alarm_i;
+                break;
+            }
+        }*/
         if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__MotorAlarm)
         {
             if (AlarmState[Alarm_i].Status == true)
@@ -674,21 +692,25 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value)
                     AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
                     if (AlarmState[Alarm_i].EventPtr)
                     {
+                        //ROM_IntMasterDisable();
                         event__init(AlarmState[Alarm_i].EventPtr);
                         AlarmState[Alarm_i].EventPtr->has_type = true;
                         AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
                         AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName;
-                        AlarmState[Alarm_i].Status = value;
-                        Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
+	                    AlarmState[Alarm_i].Status = value;
                     }
+                    //ROM_IntMasterEnable();
+                    Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
                 }
                 else
                 {
                     Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
                     if (AlarmState[Alarm_i].EventPtr)
                     {
+                        //ROM_IntMasterDisable();
                         my_free(AlarmState[Alarm_i].EventPtr);
                         AlarmState[Alarm_i].EventPtr = NULL;
+                        //ROM_IntMasterEnable();
                     }
                     AlarmState[Alarm_i].Status = value;
                 }
@@ -861,14 +883,14 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                 value = Get_MidTank_Int100_Sensor(AlarmItem[Alarm_i].DeviceId);
                 if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE)
                 {
-                    if (value*100 > AlarmItem[Alarm_i].AlarmValue)
+                    if (value > AlarmItem[Alarm_i].AlarmValue)
                     {
                         Status = true;
                     }
                 }
                 else
                 {
-                    if (value*100 < AlarmItem[Alarm_i].AlarmValue)
+                    if (value < AlarmItem[Alarm_i].AlarmValue)
                     {
                         Status = true;
                     }
@@ -923,8 +945,6 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
             {
                 if (Status == true) // alarm on
                 {
-                    AlarmState[Alarm_i].Status = true;
-                    AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity);
                     // report the alarm!
                     AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
                     if (AlarmState[Alarm_i].EventPtr)
@@ -934,15 +954,21 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                         AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
                         AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName;
                     }
+                    AlarmState[Alarm_i].Status = true;
+                    AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity);
                     Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
                 }
                 else // alarm off
                 {
-                    AlarmState[Alarm_i].Status = false;
-                    AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info);
-                    // report the alarm!
                     if (AlarmState[Alarm_i].EventPtr)
+                    {
+                        //ROM_IntMasterDisable();
                         my_free(AlarmState[Alarm_i].EventPtr);
+                        AlarmState[Alarm_i].EventPtr = NULL;
+                        //ROM_IntMasterEnable();
+                    }
+                    AlarmState[Alarm_i].Status = false;
+                    AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info);
                     Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i);
                 }
             }
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 193769265..916d33772 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -48,6 +48,7 @@
 #include "Common/SWUpdate/FileSystem.h"
 
 #include "Communication/Connection.h"
+#include "Modules/General/buttons.h"
 
 Task_Handle Millisecond_Task_Handle;
 /******************** Definitions  ********************************************/
@@ -514,6 +515,7 @@ uint32_t MillisecLowLoop(uint32_t tick)
     {
         Speed_Data = Calculate_Speed_Sensor_Velocity();
         Read_Buttons_Reg();
+        Ink_Cart_Led();
         for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++)
         {
             MillisecUpdateTemperatures (Sensor_i,TemperatureSensorRead(Sensor_i));
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index 608d17a7b..f1e19d851 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -158,7 +158,7 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
 {
     static bool flag = false;
     static uint8_t counter;
-    const uint8_t Blink_Freq = 15;//odd number
+    const uint8_t Blink_Freq = 3;//odd number
 
     if (flag==true)
     {
@@ -166,11 +166,51 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
         ACTIVITY_RED_LED_OFF; // Heaters indication - all the Heaters OFF
         if(power.color == fastBILNK)
             Pannel_Leds(POWER_ON_OFF,MODE_OFF);
-
+        else
         if((power.color == BLINK) && (counter % Blink_Freq == 0) )
         {
             Pannel_Leds(POWER_ON_OFF,MODE_OFF);
         }
+        ///////////////////////////////////////////////////////////
+        if(jog.color == fastBILNK)
+            Pannel_Leds(THREAD_JOGGING,MODE_OFF);
+        else
+        if((jog.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(THREAD_JOGGING,MODE_OFF);
+        }
+        ///////////////////////////////////////////////////////////
+        if(load.color == fastBILNK)
+            Pannel_Leds(THREAD_LOAD,MODE_OFF);
+        else
+        if((load.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(THREAD_LOAD,MODE_OFF);
+        }
+        ///////////////////////////////////////////////////////////
+        if(cart1.color == fastBILNK)
+            Pannel_Leds(CART_1,MODE_OFF);
+        else
+        if((cart1.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(CART_1,MODE_OFF);
+        }
+        ///////////////////////////////////////////////////////////
+        if(cart2.color == fastBILNK)
+            Pannel_Leds(CART_2,MODE_OFF);
+        else
+        if((cart2.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(CART_2,MODE_OFF);
+        }
+        ///////////////////////////////////////////////////////////
+        if(cart3.color == fastBILNK)
+            Pannel_Leds(CART_3,MODE_OFF);
+        else
+        if((cart3.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(CART_3,MODE_OFF);
+        }
         flag = false;
     }
     else
@@ -181,11 +221,53 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
 
         if(power.color == fastBILNK)
             Pannel_Leds(POWER_ON_OFF,MODE_ON);
-
+        else
         if((power.color == BLINK) && (counter % Blink_Freq == 0) )
         {
             Pannel_Leds(POWER_ON_OFF,MODE_ON);
         }
+        ///////////////////////////////////////////////////////////
+        if(jog.color == fastBILNK)
+            Pannel_Leds(THREAD_JOGGING,MODE_ON);
+        else
+        if((jog.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(THREAD_JOGGING,MODE_ON);
+        }
+        ///////////////////////////////////////////////////////////
+        if(load.color == fastBILNK)
+            Pannel_Leds(THREAD_LOAD,MODE_ON);
+        else
+        if((load.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(THREAD_LOAD,MODE_ON);
+        }
+        ///////////////////////////////////////////////////////////
+        if(cart1.color == fastBILNK)
+            Pannel_Leds(CART_1,MODE_ON);
+        else
+        if((cart1.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(CART_1,MODE_ON);
+        }
+        ///////////////////////////////////////////////////////////
+        if(cart2.color == fastBILNK)
+            Pannel_Leds(CART_2,MODE_ON);
+        else
+        if((cart2.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(CART_2,MODE_ON);
+        }
+        ///////////////////////////////////////////////////////////
+        if(cart3.color == fastBILNK)
+            Pannel_Leds(CART_3,MODE_ON);
+        else
+        if((cart3.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(CART_3,MODE_ON);
+        }
+
+
 
         flag = true;
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index c9bbe2df6..2b24f9832 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -26,6 +26,7 @@
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "drivers/Valves/Valve.h"
 #include "drivers/Heater/Heater.h"
+#include "modules/waste/waste.h"
 
 #include "modules/ids/ids_ex.h"
 
@@ -255,6 +256,12 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
             else
                 Control_Dryer_Fan(STOP,0);//use START or STOP,  0 - 100%();
             break;
+        case INTERFACE_IOS__GPO_WASTECH_PUMP2://valve
+                Valve_Set(VALVE_WASTE_TANK, request->value);
+            break;
+        case INTERFACE_IOS__GPO_WHS_WTANKPUMP2:
+            SetWastePump( request->value);
+            break;
         default:
             responseContainer.has_error = true;
             responseContainer.error = ERROR_CODE__GENERAL_ERROR;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index d39c97621..785d9fc3c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -29,6 +29,7 @@
 #include "Modules/AlarmHandling/AlarmHandling.h"
 #include "Modules/heaters/heaters_ex.h"
 #include "modules/thread/thread_ex.h"
+#include "modules/waste/waste.h"
 
 #include "PMR/Hardware/HardwareDancerType.pb-c.h"
 #include  <PMR/Diagnostics/StartDiagnosticsRequest.pb-c.h>
@@ -60,6 +61,7 @@ uint32_t Diagnostics_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t DispensersCollection(uint32_t IfIndex, uint32_t ReadValue);
 
+#define REDUCED_DIAGNOSTICS
 
 DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT;
 #define DIAGNOSTICS_LIMIT 3
@@ -68,7 +70,11 @@ int DiagnosticsIndex = 0;
 int DiagnosticCollectionLimit = 2;  //number of data samples to collect before sending to the host
 //int DiagnosticLimit = eHundredMillisecond; //frequency of data collection
 //int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
+#ifdef REDUCED_DIAGNOSTICS
+int DiagnosticLimit =eOneSecond; //frequency of data collection
+#else
 int DiagnosticLimit =eHundredMillisecond; //frequency of data collection
+#endif
 int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
 
 //DigitalPin DigitalPinArray[1][DIAGNOSTICS_LIMIT+1];
@@ -104,7 +110,7 @@ DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS];
 HeaterState **heatersstates;
 HeaterState  HeaterInfo[HEATER_TYPE__MixerHeater+1];
 DigitalInterfaceState **digitalinterfacestates;
-DigitalInterfaceState DigitalOutputState[MAX_HEATERS_NUM+2];
+DigitalInterfaceState DigitalOutputState[MAX_HEATERS_NUM+8];
 /*double dispenser1motorfrequency[DIAGNOSTICS_LIMIT+1];
 double dispenser2motorfrequency[DIAGNOSTICS_LIMIT+1];
 double dispenser3motorfrequency[DIAGNOSTICS_LIMIT+1];
@@ -151,7 +157,7 @@ void DiagnosticsInit(void)
 
     Error_init(&eb);
 
-    DiagnosticsMsgQ = Mailbox_create(sizeof(DiagnosticsMessageStruc), 20, NULL,&eb);
+    DiagnosticsMsgQ = Mailbox_create(sizeof(DiagnosticsMessageStruc), 40, NULL,&eb);
 
     DiagnosticsMonitor.dispensersmotorsfrequency = (DoubleArray**)my_malloc(sizeof(DoubleArray *)*8);
     DiagnosticsMonitor.dispenserspressure = (DoubleArray**)my_malloc(sizeof(DoubleArray)*8);
@@ -168,8 +174,8 @@ void DiagnosticsInit(void)
         heater_state__init(&HeaterInfo[i]);
         heatersstates[i] = &HeaterInfo[i];
     }
-    digitalinterfacestates = (DigitalInterfaceState**)my_malloc(sizeof(DigitalInterfaceState *)*MAX_HEATERS_NUM);
-    for (i = 0;i<MAX_HEATERS_NUM;i++ )
+    digitalinterfacestates = (DigitalInterfaceState**)my_malloc(sizeof(DigitalInterfaceState *)*(MAX_HEATERS_NUM+8));
+    for (i = 0;i<(MAX_HEATERS_NUM+8);i++ )
     {
         digital_interface_state__init(&DigitalOutputState[i]);
         DigitalOutputState[i].has_interfaceio = true;
@@ -251,6 +257,18 @@ void DiagnosticsLoadDigitalValues(void)
     DigitalOutputState[11].interfaceio = INTERFACE_IOS__GPO_LED4;
     DigitalOutputState[11].value = DataUpdated;
 
+    DigitalOutputState[12].interfaceio = INTERFACE_IOS__GPI_WCONTAINER_FULL;
+    DigitalOutputState[12].value = WHS_IsContainerOverflow();
+
+    DigitalOutputState[13].interfaceio = INTERFACE_IOS__GPI_WCONTAINER_WARN;
+    DigitalOutputState[13].value = WHS_IsContainerFull();
+
+    DigitalOutputState[14].interfaceio = INTERFACE_IOS__GPO_SPARE1_1; /*waste lower cartridge presence*/
+    DigitalOutputState[14].value = WHS_WasteCartridgeLowerPresent();
+
+    DigitalOutputState[15].interfaceio = INTERFACE_IOS__GPO_SPARE1_2; /*waste middle cartridge presence*/
+    DigitalOutputState[15].value = WHS_WasteCartridgeMiddlePresent();
+
 }
 void DiagnosticLoadTemperature(int HeaterId, int temperature)
 {
@@ -309,6 +327,7 @@ void DiagnosticTenMsecCollection(void)
 {
     if (DiagnosticsActive == false)
         return;
+#ifdef TEN_MSEC_COLLECTION
     /*if (JobIsActive()== false)
         return;*/
     DiagnosticLoadDancer(WINDER_DANCER,Control_Read_Dancer_Position(WINDER_DANCER, 0,0));
@@ -320,7 +339,7 @@ void DiagnosticTenMsecCollection(void)
     DiagnosticLoadDancerError(FEEDER_DANCER,ThreadGetMotorCalculatedError(FEEDER_DANCER));
 
     //DiagnosticLoadSpeedSensor(getSensorSpeedData());
-
+#endif
 }
 void Diagnostic100msecCollection(void)
 {
@@ -329,7 +348,10 @@ void Diagnostic100msecCollection(void)
         return;
 
     DiagnosticLoadSpeedSensor(getSensorSpeedData());
-
+#ifndef REDUCED_DIAGNOSTICS
+#ifndef TEN_MSEC_COLLECTION
+    DiagnosticTenMsecCollection(); //call the 10msec function every 100 msec to reduce transport
+#endif
     //if (JobIsActive())
     {
         DiagnosticLoadMotor(FEEDER_MOTOR, ThreadGetMotorSpeed (FEEDER_MOTOR));
@@ -338,6 +360,7 @@ void Diagnostic100msecCollection(void)
         DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
         DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
     }
+#endif
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
@@ -355,11 +378,13 @@ void Diagnostic100msecCollection(void)
         dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
         MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
     }
+#ifndef REDUCED_DIAGNOSTICS
     for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
     {
         HeatersCurrent[i][0] = Get_Heaters_Current(i);
     }
-/*     dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
+#endif
+    /*     dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
      dispenser2motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2);
      dispenser3motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3);
      dispenser4motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4);
@@ -436,6 +461,7 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.dancer2angle = dancer2angle;
     DiagnosticsMonitor.dancer3angle = dancer3angle;
 */
+#ifndef REDUCED_DIAGNOSTICS
     //if (JobIsActive())
     {
         DiagnosticsMonitor.n_dancer1angle =  DancerCounterIndex[0];
@@ -465,7 +491,7 @@ void SendDiagnostics(void)
         DiagnosticsMonitor.n_windermotor =  MotorCounterIndex[WINDER_MOTOR];
         DiagnosticsMonitor.n_screwmotor = MotorCounterIndex[SCREW_MOTOR];
     }
-
+#endif
     DiagnosticsMonitor.mixertemperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__MixerHeater];
     DiagnosticsMonitor.headzone1temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1];
     DiagnosticsMonitor.headzone2temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2];
@@ -586,7 +612,7 @@ void SendDiagnostics(void)
     response.n_componentsstates = 0;
 
     DiagnosticsLoadDigitalValues();
-    response.n_digitalinterfacestates = MAX_HEATERS_NUM;
+    response.n_digitalinterfacestates = MAX_HEATERS_NUM+6;
     response.digitalinterfacestates = digitalinterfacestates;
 
     for (i=HEATER_TYPE__DryerAirHeater;i<=HEATER_TYPE__MixerHeater;i++)
@@ -647,11 +673,11 @@ void SendDiagnostics(void)
 }
 void DispensersCollectionCall(void)
 {
-    int i;
+    /*int i;
     for (i = 0; i<MAX_SYSTEM_DISPENSERS;i++)
     {
         IDS_Dispenser_Content_Calculation(i);
-    }
+    }*/
 }
 uint32_t DiagnosticsControlId = 0xff;
 uint32_t Diagnostics10MSControlId = 0xff;
@@ -669,11 +695,12 @@ uint32_t DiagnosticsStart(void)
                 DiagnosticsControlId = AddControlCallback(Diagnostics_ControlTrigger,DiagnosticLimit,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
+#ifdef TEN_MSEC_COLLECTION
             if (Diagnostics10MSControlId == 0xFF)
                 Diagnostics10MSControlId = AddControlCallback(Diagnostics_TenMiliControlTrigger,DiagnosticFastLimit,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
-
+#endif
             if (DispensersControlId == 0xFF)
                 DispensersControlId = AddControlCallback(DispensersCollection,eOneSecond,TemplateDataReadCBFunction,0,0,0);
             else
@@ -746,8 +773,8 @@ uint32_t DispensersCollection(uint32_t IfIndex, uint32_t ReadValue)
     //send message to the Millisec task
     Message.messageId = DispensersCollectionTrigger;
     Message.msglen = sizeof(DiagnosticsMessageStruc);
-    if (DiagnosticsMsgQ != NULL)
-        Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);
+    //if (DiagnosticsMsgQ != NULL)
+    //    Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);
 
 
     return OK;
@@ -806,7 +833,7 @@ void DiagnosticsTask(UArg arg0, UArg arg1)
                 DiagnosticTenMsecCollection();
                 break;
             case DispensersCollectionTrigger:
-                DispensersCollectionCall();
+                //DispensersCollectionCall();  //suspended for ITMA
                 break;
             default:
                 break;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index f5aec59f6..b12064915 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -40,6 +40,8 @@
 
 #include "StateMachines/Printing/PrintingSTM.h"
 #include "StateMachines/Initialization/InitSequence.h"
+#include "StateMachines/Initialization/PowerIdle.h"
+#include "StateMachines/Initialization/PowerOffSequence.h"
 
 uint32_t EmbeddedParametersInit(void);
 uint32_t EmbeddedParametersWrite(void * buffer, uint16_t size);
@@ -128,7 +130,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters.has_initialdispenserpressure = true;
             EmbeddedParameters.initialdispenserpressure = 0.08;
             EmbeddedParameters.has_initialdispensertimeout = true;
-            EmbeddedParameters.initialdispensertimeout = 10000;
+            EmbeddedParameters.initialdispensertimeout = 60000;
             EmbeddedParameters.has_initialdispensertimelag = true;
             EmbeddedParameters.initialdispensertimelag = 100;
             EmbeddedParameters.has_dispenserbuildpressurespeed = true;
@@ -136,11 +138,11 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters.has_dispenserbuildpressurelimit = true;
             EmbeddedParameters.dispenserbuildpressurelimit=1.5 ;
             EmbeddedParameters.has_dispenserbuildpressuretimeout = true;
-            EmbeddedParameters.dispenserbuildpressuretimeout=20000;
+            EmbeddedParameters.dispenserbuildpressuretimeout=50000;
             EmbeddedParameters.has_dispenserbuildpressurelag = true;
             EmbeddedParameters.dispenserbuildpressurelag=50;
             EmbeddedParameters.has_acheatersloweroperationlimit = true;
-            EmbeddedParameters.acheatersloweroperationlimit = 995;
+            EmbeddedParameters.acheatersloweroperationlimit = 980;
             EmbeddedParameters.has_acheatersupperoperationlimit = true;
             EmbeddedParameters.acheatersupperoperationlimit = 1005;
             EmbeddedParameters.has_dcheatersloweroperationlimit = true;
@@ -148,7 +150,43 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters.has_dcheatersupperoperationlimit = true;
             EmbeddedParameters.dcheatersupperoperationlimit = 1002;
             EmbeddedParameters.has_midtankpressurecorrection = true;
-            EmbeddedParameters.midtankpressurecorrection = 0.5;
+            EmbeddedParameters.midtankpressurecorrection = 0.0;
+            EmbeddedParameters.has_dispenserpresegmentwfcf = true;
+            EmbeddedParameters.dispenserpresegmentwfcf = 80;
+            EmbeddedParameters.has_startheatingoninitsequence = true;
+            EmbeddedParameters.startheatingoninitsequence = false;
+//size_t n_generalparameters;
+//            EmbeddedParameters.*generalparameters;
+            EmbeddedParameters.has_currentalarmlowlimit = true;
+            EmbeddedParameters.currentalarmlowlimit = 0.80;
+            EmbeddedParameters.has_currentalarmhighlimit = true;
+            EmbeddedParameters.currentalarmhighlimit= 1.07;
+            EmbeddedParameters.has_ids_segmentrefilltimeout = true;
+            EmbeddedParameters.ids_segmentrefilltimeout = 5000;
+            EmbeddedParameters.has_ids_presegmentbuilduptime = true;
+            EmbeddedParameters.ids_presegmentbuilduptime = 5000;
+            EmbeddedParameters.has_ids_cleaningspeed = true;
+            EmbeddedParameters.ids_cleaningspeed = 50;
+            EmbeddedParameters.has_ids_cleaningstopbeforesegmenttime = true;
+            EmbeddedParameters.ids_cleaningstopbeforesegmenttime = 3000;
+            EmbeddedParameters.has_ids_cleaningstartspraypresegmenttime = true;
+            EmbeddedParameters.ids_cleaningstartspraypresegmenttime = 1000;
+            EmbeddedParameters.has_ids_leftcleaningmotorspeed = true;
+            EmbeddedParameters.ids_leftcleaningmotorspeed = 30;
+            EmbeddedParameters.has_ids_rightcleaningmotorspeed = true;
+            EmbeddedParameters.ids_rightcleaningmotorspeed = 23;
+            EmbeddedParameters.has_switchtoidletimeinseconds = true;
+            EmbeddedParameters.switchtoidletimeinseconds = 3600;
+            EmbeddedParameters.has_idledriertemperature = true;
+            EmbeddedParameters.idledriertemperature = 80;
+            EmbeddedParameters.has_idleheadtemperature = true;
+            EmbeddedParameters.idleheadtemperature = 80;
+            EmbeddedParameters.has_idlemixertemperature = true;
+            EmbeddedParameters.idlemixertemperature = 0;
+            EmbeddedParameters.has_powerofftemperaturelimit = true;
+            EmbeddedParameters.powerofftemperaturelimit = 50;
+            EmbeddedParameters.has_ids_presegment_wfcf_timebeforesegment = true;
+            EmbeddedParameters.ids_presegment_wfcf_timebeforesegment = 1500;
             uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(&EmbeddedParameters));
             size_t response_size = 0;
             if (response_buffer)
@@ -169,32 +207,40 @@ uint32_t EmbeddedParametersInit(void)
     ConfigurationParameters *Params;
 
     Fresult = FileRead(EmbeddedParametersPath, &Bytes, &buffer);
-    if (Fresult == FR_OK)
+    /*if (Fresult == FR_OK)
     {
-        Params = configuration_parameters__unpack(NULL, Bytes, buffer)/*(ConfigurationParameters *)buffer*/;
+        Params = configuration_parameters__unpack(NULL, Bytes, buffer);
         LoadConfigurationParameters(Params);
         DataUpdated=true;
         free (buffer);
         configuration_parameters__free_unpacked(Params,NULL);
     }
-    else
+    else*/
     {
         LoadConfigurationParameters(0);
     }
     IDS_Dispenser_SetTimeOutValues(EmbeddedParameters.closevalvetimeout, EmbeddedParameters.openvalvetimeout);
     IDS_Dispenser_SetBackLashValues(EmbeddedParameters.initialdispenserpressure, EmbeddedParameters.initialdispensertimeout, EmbeddedParameters.initialdispensertimelag);
     IDS_Dispenser_SetPrepareValues(EmbeddedParameters.dispenserbuildpressurespeed,   EmbeddedParameters.dispenserbuildpressurelimit, EmbeddedParameters.dispenserbuildpressuretimeout, EmbeddedParameters.dispenserbuildpressurelag);
+    IDS_Dispenser_SetPreSegmentWFCFValues(EmbeddedParameters.dispenserpresegmentwfcf,  EmbeddedParameters.ids_presegment_wfcf_timebeforesegment);
+    IDS_Dispenser_SetPreSegmentCleaningValues(EmbeddedParameters.ids_cleaningspeed,EmbeddedParameters.ids_cleaningstartspraypresegmenttime ,EmbeddedParameters.ids_cleaningstopbeforesegmenttime,EmbeddedParameters.ids_leftcleaningmotorspeed,EmbeddedParameters.ids_rightcleaningmotorspeed);
+
     Heaters_SetOverHeatTimeOutValues( EmbeddedParameters.overheatcountlimit,  EmbeddedParameters.underheatcountlimit);
     Heaters_SetOperationLimits(EmbeddedParameters.acheatersloweroperationlimit,EmbeddedParameters.acheatersupperoperationlimit,EmbeddedParameters.dcheatersloweroperationlimit,EmbeddedParameters.dcheatersupperoperationlimit);
     MidTankPressureCorrection(EmbeddedParameters.midtankpressurecorrection);
     SetDiagnosticCollectionLimit(EmbeddedParameters.diagnosticcollectionlimit);
     ThreadSetBreakSensorLimit(EmbeddedParameters.breaksensorlimit);
+    PowerOffSetTemperatureThreshold(EmbeddedParameters.powerofftemperaturelimit);
+
+    InitSequenceSetStartHeating (EmbeddedParameters.startheatingoninitsequence);
     bool a1,a2,a3;
     a1 = (EmbeddedParameters.generalparameters[0] < 0.5)?false:true;
     a2 = (EmbeddedParameters.generalparameters[1] < 0.5)?false:true;
     a3 = (EmbeddedParameters.generalparameters[2] < 0.5)?false:true;
     AlarmHandlingSetFlags(a1,a2,a3);
 
+    PowerIdleSetParameters(EmbeddedParameters.switchtoidletimeinseconds,EmbeddedParameters.idledriertemperature,EmbeddedParameters.idleheadtemperature,EmbeddedParameters.idlemixertemperature);
+
     return Fresult;
 }
 uint32_t GenHWControlId;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/Safety.c b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
index 840898db7..f54a4be19 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/Safety.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
@@ -25,7 +25,10 @@
 uint32_t SafetyControlId;
 bool DispenserOverPressure[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag);
-
+bool DrierDoorAlarmState = false;
+bool AirFlowAlarmState = false;
+bool AirFilterAlarmState = false;
+bool WasteOverflowAlarmState = false;
 void Safety_Init(void)
 {
     SafetyControlId = AddControlCallback( Safety_Main_State, eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
@@ -36,6 +39,10 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
    int Disp_i;
    bool AllDispensersInSafety = true;
    bool AnyDispensersInSafety = false;
+   /*bool mDrierDoorAlarmState = false;
+   bool mAirFlowAlarmState = false;
+   bool mAirFilterAlarmState = false;
+   bool mWasteOverflowAlarmState = false;*/
    for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
    {
        if (isMotorConfigured(Disp_i + HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)==true)
@@ -51,6 +58,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
        {
            //report and handle dryer door open
            AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, true);
+          // mDrierDoorAlarmState = true;
+          // DrierDoorAlarmState = true;
        }
        else
        {
@@ -59,6 +68,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
                //report and handle air flow failure
                //if blower if off handling is different
                AlarmHandlingSetAlarm(EVENT_TYPE__NO_AIR_PRESSURE, true);
+            //   mAirFlowAlarmState = true;
+            //   AirFlowAlarmState = true;
            }
            else
            {
@@ -66,6 +77,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
                {
                    //report and handle filter missing
                    AlarmHandlingSetAlarm(EVENT_TYPE__AIR_FILTER_NOT_INSTALLED, true);
+              //     mAirFilterAlarmState = true;
+              //     AirFilterAlarmState = true;
                }
                else
                {
@@ -73,6 +86,8 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
                    {
                        //report and handle waste overflow
                        AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, true);
+                //       mWasteOverflowAlarmState = true;
+                 //      WasteOverflowAlarmState = true;
                    }
                }
            }
@@ -108,7 +123,31 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
            }
        }
    }
-
+/*   if  ((mDrierDoorAlarmState != DrierDoorAlarmState)|| (mDrierDoorAlarmState == false))
+   {
+      //alarm went off
+       AlarmHandlingSetAlarm(EVENT_TYPE__DRYER_DOOR_OPEN, false);
+       DrierDoorAlarmState = mDrierDoorAlarmState;
+   }
+   if  ((mAirFlowAlarmState != AirFlowAlarmState)|| (mAirFlowAlarmState == false))
+   {
+      //alarm went off
+       AlarmHandlingSetAlarm(EVENT_TYPE__NO_AIR_PRESSURE, false);
+       AirFlowAlarmState = mAirFlowAlarmState;
+   }
+   if  ((mAirFilterAlarmState != AirFilterAlarmState)|| (mAirFilterAlarmState == false))
+   {
+      //alarm went off
+       AlarmHandlingSetAlarm(EVENT_TYPE__AIR_FILTER_NOT_INSTALLED, false);
+       AirFilterAlarmState = mAirFilterAlarmState;
+   }
+   if  ((mWasteOverflowAlarmState != WasteOverflowAlarmState)|| (mWasteOverflowAlarmState == false))
+   {
+      //alarm went off
+       AlarmHandlingSetAlarm(EVENT_TYPE__WASTE_CONTAINER_OVERFLOW, false);
+       WasteOverflowAlarmState = mWasteOverflowAlarmState;
+   }
+*/
     return OK;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
index 21d425221..cfd44a6fa 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
@@ -13,7 +13,6 @@
 #include "Modules/General/buttons.h"
 #include "StateMachines/Printing/PrintingSTM.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
-//#include "StateMachines/Initialization/PowerOffSequence.h"
 
 #include <stdlib.h>
 #include <stdint.h>
@@ -24,33 +23,13 @@
 
 #include "Modules/General/buttons.h"
 #include "StateMachines/Initialization/PowerOffSequence.h"
+#include "StateMachines/Initialization/PowerIdle.h"
 
-//int MachineOnOff();
 int PowerDown();
 int PowerUp();
 int thredJog();
 
 
-/*
-typedef enum
-{
-    OFFPB = 0,
-    COUNTPB ,
-    SHORTPB ,
-    LONGPB  ,
-    REPLONGPB //repeat long PB
-}PBstat;
-*/
-typedef enum
-{
-    MSEC = 0,
-    lESS200 ,
-    LESS500 ,
-    LESS5000 ,
-    MORE5000
-}timems;
-
-
 
 //enum PBstat OnOffPBstate = OFFPB;
 //enum PBstat ret
@@ -58,7 +37,7 @@ typedef enum
 
 
 
-button power , jog, load;
+button power, jog, load, cart1, cart2, cart3;
 uint32_t ButtonPowerCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t ShortLongOffPB(uint8_t OnOffPB,  button *pBtn);
@@ -68,7 +47,7 @@ uint32_t StateMachine( button *pBtn);
 uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint8_t  thraedJogging(uint8_t off);
-uint32_t setJoggingEnableCondition( button *pBtn);
+//uint32_t setJoggingEnableCondition( button *pBtn);
 uint32_t joggingMachine(  button *pBtn);    //uint8_t OnOffPB,
 
 
@@ -87,8 +66,8 @@ bool Read_PWR_Button();//TODO move to GPIO folder
 
 int PowerDown()
 {
-    bool ret = OK;
-    PowerOffInit();
+    bool ret = !OK;
+    ret = PowerOffInit();
 
     return ret;
 }
@@ -100,42 +79,25 @@ int PowerUp()
     return ret;
 }
 
-
 bool SetPowerMachineState(PBmachineState state)
 {
     bool ret = OK;
     switch ( state )
     {
         case sttOFF:
-            power.state = state;
-            break;
         case sttON:
+        case sttIDLE:
             power.state = state;
-            break;
+           break;
         case sttDISABLE:
-            jog.state = state;
-            break;
         case sttENABLE:
-            jog.state = state;
-            break;
-        case sttIDLE:
-            power.state = state;
-            break;
         case sttJOGGING:
             jog.state = state;
             break;
         case sttRDY:
-            load.state = state;
-            break;
         case sttPRELOAD:
-            load.state = state;
-            break;
         case sttLOADING:
-            load.state = state;
-            break;
         case sttLOADSUCSESS:
-            load.state = state;
-            break;
         case sttLOADFAIL:
             load.state = state;
             break;
@@ -190,9 +152,7 @@ uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue)
 
 uint32_t Buttons_Init(void)
 {
-
-//    power.bttn_status = 0 ;
-//    power.bttn_name = "power";  //option
+    strcpy(power.bttn_name, "power");
     power.bttn_status = release;    // 0=release 1=press
     power.Action = OFFPB ;   //off,short,long,count,replong
     power.color = BLUE;   //off, blue, blink, bithing
@@ -201,8 +161,7 @@ uint32_t Buttons_Init(void)
 
     AddControlCallback( ButtonPowerCBFunction, BUTTOMS_SAMPLE_TIME, ButtonPowerCallBackFunction, 0,0,0 ); // eFiftyMillisecond
 
-//    jog.bttn_status = 0 ;
-//    jog.bttn_name = "jog";  //option
+    strcpy(jog.bttn_name, "jog");
     jog.bttn_status = release;    // 0=release 1=press
     jog.Action = OFFPB ;   //OFFPB,short,long,count,replong
     jog.color = colorOFF;   //colorOFF, BLUE, BLINK,
@@ -210,12 +169,11 @@ uint32_t Buttons_Init(void)
     jog.count = 0;
    AddControlCallback( ButtonJogCBFunction, BUTTOMS_SAMPLE_TIME, ButtonJogCallBackFunction, 0,0,0 ); //
 
-//   load.bttn_status = 0 ;
-//    load.bttn_name = "load";  //option
+   strcpy(load.bttn_name, "load");
    load.bttn_status = release;    // 0=release 1=press
    load.Action = OFFPB ;   //OFFPB,short,long,count,replong
    load.color = colorOFF;   //colorOFF, BLUE, BLINK,
-   load.state = sttOFF; // sttDISABLE, sttENABLE, sttJOGGING
+   load.state = sttRDY; //
    load.count = 0;
 
    AddControlCallback( ButtonLoadCBFunction, BUTTOMS_SAMPLE_TIME, ButtonLoadCallBackFunction, 0,0,0 ); //
@@ -232,15 +190,12 @@ uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 
 uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
-
     jog.bttn_status = ReadValue;
     //if (ReadValue == press)
     {
-        setJoggingEnableCondition(&jog);
+        //setJoggingEnableCondition(&jog);
         joggingMachine(&jog);
     }
-
-
     return 0;
 }
 
@@ -452,36 +407,36 @@ return 0;
 
 
 
-uint32_t    setJoggingEnableCondition( button *pBtn)
-{
-    uint8_t parameter = 3;
-
-    if (0
-//         to do : what are the conditions for enable / disable
-//            1.
-//            2.
-//            3.
-//            ...
-            )
-        {
-            pBtn->state = sttDISABLE;
-            REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition  sttDISABLE  ----------------- ");
-            pBtn->color = colorOFF;
-            Pannel_Leds(THREAD_JOGGING, MODE_OFF); //AVI+
-        //    ThreadAbortJoggingFunc();
-        }
-
-    else
-    {
-        pBtn->state = sttENABLE;
-//        REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition  sttENABLE  ----------------- ");
-        pBtn->color = BLUE;
-        Pannel_Leds(THREAD_JOGGING, MODE_ON); //AVI+
-        //ThreadJoggingFunc(40);
-    }
-
-return 0;
-}
+//uint32_t    setJoggingEnableCondition( button *pBtn)
+//{
+//    uint8_t parameter = 3;
+//
+//    if (0
+////         to do : what are the conditions for enable / disable
+////            1.
+////            2.
+////            3.
+////            ...
+//            )
+//        {
+//            pBtn->state = sttDISABLE;
+//            REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition  sttDISABLE  ----------------- ");
+//            pBtn->color = colorOFF;
+//            Pannel_Leds(THREAD_JOGGING, MODE_OFF); //AVI+
+//        //    ThreadAbortJoggingFunc();
+//        }
+//
+//    else
+//    {
+//        pBtn->state = sttENABLE;
+////        REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition  sttENABLE  ----------------- ");
+//        pBtn->color = BLUE;
+//        Pannel_Leds(THREAD_JOGGING, MODE_ON); //AVI+
+//        //ThreadJoggingFunc(40);
+//    }
+//
+//return 0;
+//}
 
 
 
@@ -575,13 +530,14 @@ return 0;
 
 uint32_t LoadStatMachine( button *pBtn)
 {
-    //uint8_t parameter = 5;
+    uint8_t parameter = 5;
 
     //REPORT_MSG(parameter," ------------ start loading    ----------------- ");
     Report(" ------------ start loading    ----------------- ",__FILE__,__LINE__,pBtn->state,RpWarning,pBtn->color,0);
     switch (pBtn->state)
     {
         case sttRDY :
+            REPORT_MSG(parameter," ------------ load.state = sttRDY    ----------------- ");
             switch (pBtn->Action)
             {
                 case (SHORTPB):
@@ -589,7 +545,6 @@ uint32_t LoadStatMachine( button *pBtn)
                 case (REPLONGPB):
                     pBtn->state = sttPRELOAD;
                     pBtn->color =  BLINK;
-                    Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                     if (ThreadLoadStateMachine( THREAD_LOAD_INIT))
                     {
                         pBtn->state = sttPRELOAD ;    // to do
@@ -607,6 +562,7 @@ uint32_t LoadStatMachine( button *pBtn)
             }
             break;
         case sttPRELOAD:
+            REPORT_MSG(parameter," ------------ load.state = sttPRELOAD    ----------------- ");
             switch (pBtn->Action)
             {
                 case (SHORTPB):
@@ -624,7 +580,6 @@ uint32_t LoadStatMachine( button *pBtn)
                     {
                         pBtn->state = sttLOADFAIL ;
                         pBtn->color = fastBILNK ;    // to do
-                        Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+
                     }
                     break;
                 default :
@@ -632,6 +587,7 @@ uint32_t LoadStatMachine( button *pBtn)
             }
             break;
         case sttLOADING:
+            REPORT_MSG(parameter," ------------ load.state = sttLOADING    ----------------- ");
             break;
 //        case sttLOADSUCSESS ?????
 //            break;
@@ -639,6 +595,7 @@ uint32_t LoadStatMachine( button *pBtn)
 //            break;
 
         default: //sttDISABLE
+            REPORT_MSG(parameter," ------------ load.state = default    ----------------- ");
             pBtn->color =  colorOFF;
             Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+
             break;
@@ -646,6 +603,17 @@ uint32_t LoadStatMachine( button *pBtn)
     return OK;
 }
 
+void Ink_Cart_Led()//temporary for ITMA
+{
+    if(Is_Cartridge_Present(CART_1) == true)
+    {
+        Pannel_Leds( CART_1,  MODE_ON);
+    }
+    else
+    {
+        Pannel_Leds( CART_1,  MODE_OFF);
+    }
+}
 
 void test_avi()
 {
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
index 8b064bbcc..4d0df69e1 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
@@ -29,10 +29,12 @@ typedef enum
 {
     sttOFF = 0,
     sttON,
+    sttIDLE,
+
     sttDISABLE,
     sttENABLE,
-    sttIDLE,
     sttJOGGING,
+
     sttRDY,
     sttPRELOAD,
     sttLOADING,
@@ -50,12 +52,13 @@ typedef struct Button
     uint32_t count;
 }button;
 
-extern button power , jog, load;
+extern button power, jog, load, cart1, cart2, cart3;
 
 uint32_t Buttons_Init(void);
 uint32_t Button_load_Init(void);
 uint32_t Button_JOG_Init(void);
 bool SetPowerMachineState(PBmachineState state);
+void Ink_Cart_Led();
 
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
index 3c9c59f3e..b25c3e5c7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
@@ -5,7 +5,7 @@
 #include "PMR/Hardware/HardwarePidControlType.pb-c.h"
 #include "heaters_ex.h"
 /******************** DEFINITIONS  ********************************************/
-#define MAX_AC_HEATERS HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1
+#define MAX_AC_HEATERS (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1)
 #define MAX_TIMESLICES 200
 
 extern uint32_t OutputProportionalSingleStep;  //A/C Heaters step size from one decision point to another - in cpu clocks. 120000 = 1 millisecod
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index b373f0670..3a9ce53d8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -172,7 +172,7 @@ void Heaters_SetOverHeatTimeOutValues(uint32_t OverHeatTimeout, uint32_t UnderHe
     Overheat_Count_Limit = OverHeatTimeout;
     Underheat_Count_Limit = UnderHeatTimeout;
 }
-void  Heaters_SetOperationLimits(acheatersloweroperationlimit,acheatersupperoperationlimit,dcheatersloweroperationlimit,dcheatersupperoperationlimit)
+void  Heaters_SetOperationLimits(int acheatersloweroperationlimit, int acheatersupperoperationlimit, int dcheatersloweroperationlimit, int dcheatersupperoperationlimit)
 {
     AcHeatersLoweroperationLimit =  acheatersloweroperationlimit;
     AcHeatersUpperoperationLimit =  acheatersupperoperationlimit;
@@ -218,7 +218,7 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
     HeaterState->heatertype = HeaterType;
     HeaterState->has_setpoint = true;
     HeaterState->setpoint = HeaterCmd[HeaterId].targettemperatue/100;
-    //    HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse;
+    //HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse;
     HeaterState->has_currentvalue = true;
     HeaterState->currentvalue = temp/100;//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId])/100;
     HeaterState->has_isactive = true;
@@ -227,11 +227,16 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
     HeaterState->isrampingup = 1-HeaterReady[HeaterId];
     HeaterState->has_isinsetpoint = true;
     HeaterState->isinsetpoint = HeaterReady[HeaterId];
-    /*if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature)
+    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
     {
         HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit;
         //HeaterState->isrampingup = InitialHeating;
-    }*/
+    }
+    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
+    {
+        HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit;
+        //HeaterState->isrampingup = InitialHeating;
+    }
     return;
 }
 uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
@@ -244,13 +249,13 @@ uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
             {
                 status |= RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
                 ControlIdtoHeaterId [HeaterId]=0xFF;
-                HeaterRecalculateHeaterParams(HeaterId, 0);
             }
             if (ControlIdtoMaxHeaterId [HeaterId]!=0xFF)
             {
                 status |= RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
                 ControlIdtoMaxHeaterId [HeaterId]=0xFF;
             }
+            HeaterRecalculateHeaterParams(HeaterId, 0);
             DeActivateHeater(HeaterId);
             HeaterReady[HeaterId] = true;
         }
@@ -318,7 +323,7 @@ void HeatersStartControlTimer (void)
     Report("HeatersStartControlTimer ", __FILE__,__LINE__,0, RpMessage, 0, 0);
     return;
 }
-/***************************************************************************************************/
+/***************************************************************************************************
 int GetFilteredHeaterRead(int HeaterId)
 {
 #define MAX_FILTER 12
@@ -342,7 +347,7 @@ int GetFilteredHeaterRead(int HeaterId)
     Report("GetFilteredHeaterRead ", __FILE__,HeaterId,sum, minread, maxread, 0);
     return (sum/(MAX_FILTER-2));
 }
-/**************************************************************************************
+**************************************************************************************
  * HeaterCommandRequestMessage
  * called by: Communication from host
  * initialized all global data
@@ -457,9 +462,9 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
     HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
     if (MainDryerHeaterMaxTempControl == 0xFF)
-        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
+        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
     if (SecondDryerHeaterMaxTempControl == 0xFF)
-        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
+        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
     //InitialHeating = true;
     HeaterReady[HeaterId] = false;
     if (BlowerCfg.enabled == true)
@@ -487,7 +492,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
         DisasterControlId = AddControlCallback( HeatersDisasterControl, eOneSecond,TemplateDataReadCBFunction,0,0, 0);
 
     if (ControlIdtoHeaterId [HeaterId] == 0xFF)
-    ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+        ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
     //HeaterPIDConfig[HeaterId].m_params.dt *=10;
     //DCInitialHeating[HeaterId] = true;
     HeaterReady[HeaterId] = false;
@@ -547,7 +552,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
     HeaterPIDConfig[HeaterId].m_preError = 0;
     HeaterPIDConfig[HeaterId].m_SetParam = SetTemperatue*100;//need to update SetParams on presegment stage
 
-    int band = 6;
+    int band = 10;
     /*if (HeaterControl[HeaterId].outputproportionalband)
     {
         band = HeaterControl[HeaterId].outputproportionalband;
@@ -660,21 +665,21 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     MaxreadValue = max (MainPT100Read,SecondaryPT100Read);
     MinreadValue = min (MainPT100Read,SecondaryPT100Read);
 
-    if ((MaxreadValue) >= HeaterControl[index].sensormaxvalue)
+    if (MaxreadValue >= HeaterControl[index].sensormaxvalue)
     {
         if (HeaterMaxTempFlag[index] == false)
         {
             LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
         }
         DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-        HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = true;
+        HeaterMaxTempFlag[index] = true;
         //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
         DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-        HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true;
+        //HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true;
         //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
         return OK;
     }
-    if ((MaxreadValue) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
+    if (MaxreadValue <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
     {
         if (HeaterControl[index].sensorminvalue > 0)
         {
@@ -803,7 +808,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         //Heaters OFF until coming into the proportional band
         HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
         HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
-        //LOG_ERROR (0, "unconfigured");
+        LOG_ERROR (0, "unconfigured");
         return ERROR;
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
@@ -841,28 +846,31 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                     HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
                     return OK;
                 }
-//        if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
-        if (readValue < (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))
-                {
-                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
-                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                    return OK;
-                }
+        if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
+        //if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800))
+        {
+            //Report("AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+            if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false))
+            {
+                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,100);
+                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,100);
+            }
+            return OK;
+        }
 
-        if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
+/*        if ((readValue > (HeaterCmd[index].targettemperatue-300)/`*(HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)*`/)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
         {
 //////////////////
+            Report("AC Turn Off secondary",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
             //InitialHeating = false;
             DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
             HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
             HeatersControlStart();
 ////////////////////////
-            HeaterReady[index] = true;
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
 
             AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
-            HeaterPrepareReady();
             if (BlowerCfg.enabled == true)
             {
                 Turn_the_Blower_On();//Turn on with the Default_Voltage
@@ -871,6 +879,31 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                     Control_Voltage_To_Blower(BlowerCfg.voltage);
             }
         }
+        */
+        if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
+        {
+//////////////////
+            //InitialHeating = false;
+            Report("AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
+////////////////////////
+            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
+            HeatersControlStart();
+            AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
+            if (BlowerCfg.enabled == true)
+            {
+                Turn_the_Blower_On();//Turn on with the Default_Voltage
+                if (BlowerCfg.voltage)
+                    //Gradual_Increase_Blower(BlowerCfg.heatingvoltage,BlowerCfg.voltage);
+                    Control_Voltage_To_Blower(BlowerCfg.voltage);
+            }
+
+////////////////////////
+            HeaterReady[index] = true;
+            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
+
+            HeaterPrepareReady();
+        }
         return OK;
     }
     if(HeaterPIDConfig[index].m_isEnabled && (HeaterPIDConfig[index].m_SetParam != 0))
@@ -891,20 +924,36 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         }
         else  //PID active
         {
-            if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0)
+            if ((readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100)))
             {
-                HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
-                                                      &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+                //disable PID outside band
+                HeaterPIDConfig[index].m_calculatedError = 0;
+                HeaterPIDConfig[index].m_integral = 0;
+            }
+            else if ((readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)))
+            {
+                //disable PID outside band
+                HeaterPIDConfig[index].m_calculatedError = 10000;
+                HeaterPIDConfig[index].m_integral = 0;
             }
             else
             {
-                HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
-                                                      &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+                if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0)
+                {
+                    HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
+                                                          &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+                }
+                else
+                {
+                    HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
+                                                          &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+                }
             }
 //            len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError);
             //        Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);
             //        #warning PID is now only proportional (above)
 //             Report(ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue,  HeaterPIDConfig[index].m_calculatedError);
+            //Report("AC PID",__FILE__,__LINE__,HeaterPIDConfig[index].m_calculatedError/100,RpWarning,readValue, index);
             HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, (int)(HeaterPIDConfig[index].m_calculatedError/100));
         }
     }
@@ -944,13 +993,14 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     if (HeaterCmd[index].targettemperatue == 0)
     {
         DeActivateHeater(index);
-        //LOG_ERROR (index, "unconfigured");
+        HeaterRecalculateHeaterParams(index, 0);
+        LOG_ERROR (index, "unconfigured");
         return ERROR;
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
         Report("DC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
-        if (readValue > HeaterCmd[index].targettemperatue)
+        //if (readValue > HeaterCmd[index].targettemperatue)
         {
             DeActivateHeater(index);
             HeaterRecalculateHeaterParams(index, 0);
@@ -961,6 +1011,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     {
         Report("DC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         DeActivateHeater (index);
+        HeaterRecalculateHeaterParams(index, 0);
         return ERROR;
     }
 
@@ -987,6 +1038,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 
         if ((readValue > (HeaterCmd[index].targettemperatue * DcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * DcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
         {
+            Report("DC PID Activating",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
             //DCInitialHeating[index] = false;
             HeatersControlStart();
             HeaterReady[index] = true;
@@ -1015,15 +1067,31 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             //check only for the proportional band limits
             HeaterPIDConfig[index].m_mesuredParam = readValue;
-            if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0)
+            if ((readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100)))
             {
-                HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
-                                                      &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+                //disable PID outside band
+                HeaterPIDConfig[index].m_calculatedError = 0;
+                HeaterPIDConfig[index].m_integral = 0;
+            }
+            else if ((readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)))
+            {
+                //disable PID outside band
+                HeaterPIDConfig[index].m_calculatedError = 10000;
+                HeaterPIDConfig[index].m_integral = 0;
             }
             else
             {
-                HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
-                                                      &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+                if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0)
+                {
+                    HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
+                                                          &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+                }
+                else
+                {
+                    HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
+                                                          &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+                }
+
             }
             //        error[index][Counter[index]]    = HeaterPIDConfig[index].m_preError;
             //        integral[index][Counter[index]] = HeaterPIDConfig[index].m_integral;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index 3d2bcf9ff..b47305d8c 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -5,6 +5,9 @@
 #include "drivers/motors/motor.h"
 #include "ids_ex.h"
 
+#define LUBRICANT_DISPENSER 7
+#define CLEANER_DISPENSER 6
+
 extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
 extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 extern float DispenserPressure[MAX_SYSTEM_DISPENSERS];
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 868ddca9c..ed9a3adb7 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -13,6 +13,7 @@
 #include "drivers/valves/valve.h"
 #include "PMR/EmbeddedParameters/DispenserRunningData.pb-c.h"
 #include "PMR/EmbeddedParameters/DispenserData.pb-c.h"
+#include "PMR/EmbeddedParameters/DispenserDataResponse.pb-c.h"
 #include "Common/SWUpdate/FileSystem.h"
 #include "drivers/Flash_Memory/fatfs/ff.h"
 
@@ -65,8 +66,15 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
  {
     uint32_t status;
     DispenserPrepareTime[DispenserId]+=DispenserPrepareTimeLag;
+    double DispenserPressure = DispenserPreparePressure;
 
-     if ((GetDispenserPressure(DispenserId)>=DispenserPreparePressure)||(DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout))
+    if (DispenserId == LUBRICANT_DISPENSER)
+    {
+        DispenserPressure = DispenserPreparePressure/5;
+		//lubricant lower pressure buildup
+    }
+
+     if ((GetDispenserPressure(DispenserId)>=DispenserPressure)||(DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout))
      {
          if (DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout)
              status = ERROR;
@@ -248,6 +256,7 @@ void IDS_Dispenser_Content_Init (void)
 uint16_t seconds_counter = 0;
 uint32_t IDS_Dispenser_Store_Data (void)
 {
+    uint32_t timing =  msec_millisecondCounter;
     FRESULT Status = FR_OK;
     IDSDispenserData.n_dispenserinfo = MAX_SYSTEM_DISPENSERS;
     IDSDispenserData.dispenserinfo = dispenserdata;
@@ -262,6 +271,7 @@ uint32_t IDS_Dispenser_Store_Data (void)
     else
         return ERROR;
 
+    REPORT_MSG(msec_millisecondCounter - timing, "Updating dispensers file - time");
     return Status;
 }
 void IDS_Dispenser_Content_Calculation (char DispenserId)
@@ -323,4 +333,23 @@ void IDS_Dispenser_MovingDirection (char DispenserId, bool direction)
     }
     //Report("IDS_Dispenser_MovingDirection",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)direction,0);
 }
+void DispenserDataRequestFunc(MessageContainer* requestContainer)
+{
+    MessageContainer responseContainer;
+
+    //DisconnectRequest* request = disconnect_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    DispenserDataResponse response =   DISPENSER_DATA_RESPONSE__INIT;
+
+
+    response.n_dispenserinfo = MAX_SYSTEM_DISPENSERS;
+    response.dispenserinfo = dispenserdata;
+    responseContainer = createContainer(MESSAGE_TYPE__DispenserDataResponse, requestContainer->token, true, &response, &dispenser_data_response__pack, &dispenser_data_response__get_packed_size);
+
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    my_free(responseContainer.data.data);
+    SendChars((char*)container_buffer, container_size);
+
+}
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index 350e553b6..c691e1e90 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -64,6 +64,8 @@ uint32_t IDS_Dispenser_Build_Pressure(int DispenserId, callback_fptr callback);
 void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout);
 void IDS_Dispenser_SetBackLashValues(double   initialdispenserpressure,   uint32_t initialdispensertimeout,   uint32_t initialdispensertimelag);
 void IDS_Dispenser_SetPrepareValues(    uint32_t DispenserBuildPressureSpeed,   double DispenserBuildPressureLimit, uint32_t DispenserBuildPressureTimeout, uint32_t DispenserBuildPressureLag);
+void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, double  ids_presegment_wfcf_timebeforesegment);
+void IDS_Dispenser_SetPreSegmentCleaningValues(double ids_cleaningspeed,double ids_cleaningstartspraypresegmenttime ,double ids_cleaningstopbeforesegmenttime,double ids_leftcleaningmotorspeed,double ids_rightcleaningmotorspeed);
 
 uint32_t IDS_Dispenser_Close_Valve_And_Stop_Motor(int DispenserId, callback_fptr callback);
 uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpeed, callback_fptr callback);
@@ -76,5 +78,6 @@ uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails);
 float CalculateDispenserPressure (int DispenserId);
 float GetDispenserPressure(int DispenserId);
 int32_t IdsGetMotorSpeed(uint32_t DispenserId);
+void DispenserDataRequestFunc(MessageContainer* requestContainer);
 
 #endif /* MODULES_IDS_IDS_EX_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 215fab544..74ae94fd4 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -159,7 +159,8 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
 
         IDS_Dispenser_RefillStarted(DispenserId);
         MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
-        CurrentDispenserSpeed[DispenserId] = (-1*speed);
+        CurrentDispenserSpeed[DispenserId] = speed;
+        CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]);
         return OK;
     }
     return ERROR;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 729b2bfa0..668ab9dcd 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -40,8 +40,6 @@ typedef struct
     PID_Config_Params   m_params;
 }DispenserControlConfig_t;
 HardwarePidControl *DispensersControl;// = (HardwarePidControl *)GENHWCFG_MAP_IN_FLASH + 0x4000;
-#define LUBRICANT_DISPENSER 7
-#define CLEANER_DISPENSER 6
 #define MAX_DYE_DISPENSERS 6
 int32_t DispenserSamples[MAX_SYSTEM_DISPENSERS][MAX_CONTROL_SAMPLES] = {0};
 int DispenserSamplePointer[MAX_SYSTEM_DISPENSERS] = {0};
@@ -71,9 +69,36 @@ int lInterSegmentLength = 0;
  uint32_t InterSegmentStartSprayCleaner;
  uint32_t InterSegmentStartRocking;
  uint32_t InterSegmentCenterRockers;
+ uint32_t LeftRockerSpeed = 20;
+ uint32_t RighttRockerSpeed = 20;
+ uint32_t CleaningDispenserSpeed = 40;
  uint32_t InterSegmentStartWFCFDispensers;
+ uint32_t WFCF = 80;
  bool EnableCleaning = true;
 
+ void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, double  ids_presegment_wfcf_timebeforesegment)
+ {
+     if (ids_presegment_wfcf_timebeforesegment)
+         InterSegmentStartWFCFDispensers = ids_presegment_wfcf_timebeforesegment;
+     if (dispenserpresegmentwfcf)
+         WFCF = dispenserpresegmentwfcf;
+ }
+ void IDS_Dispenser_SetPreSegmentCleaningValues(double ids_cleaningspeed,double ids_cleaningstartspraypresegmenttime ,double ids_cleaningstopbeforesegmenttime,double ids_leftcleaningmotorspeed,double ids_rightcleaningmotorspeed)
+ {
+     if ( ids_cleaningspeed)
+         CleaningDispenserSpeed = ids_cleaningspeed;
+     if ( ids_cleaningstartspraypresegmenttime )
+     {
+         InterSegmentStartSprayCleaner = ids_cleaningstartspraypresegmenttime;
+         InterSegmentStartRocking = ids_cleaningstartspraypresegmenttime + 1000;
+     }
+     if ( ids_cleaningstopbeforesegmenttime)
+         InterSegmentCenterRockers = ids_cleaningstopbeforesegmenttime;
+     if ( ids_leftcleaningmotorspeed)
+         LeftRockerSpeed = ids_leftcleaningmotorspeed;
+     if ( ids_rightcleaningmotorspeed)
+         RighttRockerSpeed = ids_rightcleaningmotorspeed;
+ }
 
  uint32_t DispenserPreSegmentControlId = 0xFF;
  uint32_t BrushStopControlId = 0xFF;
@@ -170,7 +195,7 @@ JobDescriptionFileBrushStop *GetNextBrushStopFromJobFile();
 void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
 
  */
- /************************************************************************************************************************************/
+ /************************************************************************************************************************************
  uint32_t IDS_MapDispenserUsedinFileJobshort(void *JobDetails)
  {
      JobTicket* JobTicket = JobDetails;
@@ -179,6 +204,7 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
      int Dispenser_i, Brush_i,DispenserId;
      FRESULT Fresult = FR_OK;
      uint32_t status = OK;
+     bool lookForLubrication = false;
 
      for (Dispenser_i = 0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++)
      {
@@ -187,7 +213,10 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
      if (EnableCleaning == true)
          DispenserUsedInJob[CLEANER_DISPENSER] = true;
      if (JobTicket->enablelubrication == true)
+     {
          DispenserUsedInJob[LUBRICANT_DISPENSER] = true;
+         lookForLubrication = true;
+     }
 
      Fresult = OpenJobFile();
      if (Fresult == FR_OK)
@@ -211,12 +240,23 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
                                  if (BrushStop->dispensers[Dispenser_i]->nanolitterpersecond>0.0)
                                  {
                                      DispenserUsedInJob[DispenserId] = true;
-                                     /*if(DispenserId == LUBRICANT_DISPENSER)
+                                     if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER))
                                      {
-                                        lubricant_speed = JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond/
-                                                         JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanoliterperpulse;
-                                        REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100");
-                                     }*/
+                                         lookForLubrication = false;
+                                         lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse;
+                                         if (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision
+                                                 != DISPENSER_STEP_DIVISION__Auto)
+                                         {
+                                             //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
+                                             lubricant_speed /=
+                                                     BrushStop->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep
+                                         }
+                                         else
+                                         {
+                                             lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
+                                         }
+                                         REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100");
+                                     }
                                  }
                              }//for dispenser
                          }//if dispensers
@@ -243,6 +283,7 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
      return status;
 
  }
+ *************************************************************************************************************************************/
  /************************************************************************************************************************************/
  uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails)
  {
@@ -255,7 +296,8 @@ void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop);
      uint32_t status = OK;
      FRESULT Fresult = FR_OK;
      FIL *FileHandle = 0;  //the system supports a single active file
-
+     bool lookForLubrication = false;
+     int brushCounter = 0;
 /*
  Parsing the job description file.
 The job description file simply contains an array of segments and their brush stops.
@@ -277,6 +319,7 @@ b.  Read brush stop message.
 c.  Go to step 2.a x Segment.BrushStopsCount.
 3.  Go to step 1 until end of file.
  */
+     GeneralHwReady = false;
      for (Dispenser_i = 0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++)
      {
          DispenserUsedInJob[Dispenser_i] = false;
@@ -285,7 +328,10 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      if (EnableCleaning == true)
          DispenserUsedInJob[CLEANER_DISPENSER] = true;
      if (JobTicket->enablelubrication == true)
+     {
          DispenserUsedInJob[LUBRICANT_DISPENSER] = true;
+         lookForLubrication = true;
+     }
      if (JobTicket->uploadstrategy == JOB_UPLOAD_STRATEGY__JobDescriptionFile)
      {
          FileHandle = my_malloc(sizeof(FIL));
@@ -310,7 +356,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
                              Segment = job_description_file_segment__unpack(NULL, SegmentSize, SegmentPtr);
                              if ((Segment->has_brushstopscount)&&(Segment->brushstopscount))
                              {
-                                 REPORT_MSG (Segment->brushstopscount, "Segment->brushstopscount");
+                                 //REPORT_MSG (Segment->brushstopscount, "Segment->brushstopscount");
                                  for (Brush_i=0;Brush_i<Segment->brushstopscount;Brush_i++)
                                  {
                                      if (status == ERROR)
@@ -327,7 +373,13 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
                                              {
                                                  readBytes += ImmediateRead;
                                                  BrushStop = job_description_file_brush_stop__unpack(NULL, BrushStopSize, BrushStopPtr);
-                                                 REPORT_MSG (BrushStopSize, "BrushStop");
+                                                 //REPORT_MSG (BrushStopSize, "BrushStop");
+                                                 if ((brushCounter % 100)==0)
+                                                 {
+                                                     SendJobProgress(0.0,0,false, "Processing file");
+                                                     Control_WD(ENABLE,55);  //activate heaters/dispenser watchdog, 0.5 seconds
+                                                 }
+                                                 brushCounter++;
                                                  if (BrushStop->n_dispensers)
                                                  {
                                                      for (Dispenser_i = 0;Dispenser_i < BrushStop->n_dispensers;Dispenser_i++)
@@ -338,6 +390,26 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
                                                          {
                                                              DispenserUsedInJob[DispenserId] = true;
                                                          }
+                                                         if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER))
+                                                         {
+                                                             lookForLubrication = false;
+                                                             lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse;
+                                                             REPORT_MSG (BrushStop->dispensers[Dispenser_i]->nanolitterpersecond*100, "LUBRICANT nl / sec");
+                                                             REPORT_MSG (BrushStop->dispensers[Dispenser_i]->nanoliterperpulse*100, "LUBRICANT nl / pulse");
+                                                             REPORT_MSG (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision, "step division");
+                                                             if (BrushStop->dispensers[Dispenser_i]->dispenserstepdivision
+                                                                     != DISPENSER_STEP_DIVISION__Auto)
+                                                             {
+                                                                 //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
+                                                                 lubricant_speed /=
+                                                                         BrushStop->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep
+                                                             }
+                                                             else
+                                                             {
+                                                                 lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
+                                                             }
+                                                             REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100");
+                                                         }
                                                      }//for dispenser
                                                  }//if dispensers
                                                  else
@@ -409,6 +481,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      if (BrushStop != NULL)
          job_description_file_brush_stop__free_unpacked (BrushStop,NULL);
      Fresult = f_close(FileHandle);
+     GeneralHwReady = true;
      REPORT_MSG (n_segments, "Finished checking the file");
      return status;
 
@@ -450,6 +523,17 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
                                  {
                                     lubricant_speed = JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond/
                                                      JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanoliterperpulse;
+                                    if (JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->dispenserstepdivision
+                                            != DISPENSER_STEP_DIVISION__Auto)
+                                    {
+                                        //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
+                                        lubricant_speed /=
+                                                JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep
+                                    }
+                                    else
+                                    {
+                                        lubricant_speed/=8;//MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
+                                    }
                                     REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100");
                                  }
 
@@ -502,9 +586,9 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
     //IDS_MapDispenserUsedinJob(JobDetails);
     for (i = 0; i < MAX_SYSTEM_DISPENSERS; i++)
     {
+        //IDS_StopHomeDispenser(i);
         if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
         {
-            //IDS_StopHomeDispenser(i);
             DispenserReady[i] = false;
             IDS_Dispenser_Build_Pressure(i, IDS_PrepareReady);
             REPORT_MSG(i,"Dispenser prepare called");
@@ -634,7 +718,10 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                      if (MotorsCfg[HW_Motor_Id].hardwaremotortype
                              != DispenserIdToMotorId[DispenserId])
                          continue;
-
+                     if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER))
+                     {
+                         continue;
+                     }
                      //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius)
                      segmentfirst_speed = Dispensers[Dispenser_i]->nanolitterpersecond
                              / Dispensers[Dispenser_i]->nanoliterperpulse;
@@ -650,14 +737,13 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                      }
                      else
                      {
-                         //segmentfirst_speed/=MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
+                         segmentfirst_speed/=8;//MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
                          IDS_Dispenser_Set_Flow_Params(
                                  DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse,
                                  MotorsCfg[HW_Motor_Id].microstep);
                      }
                      if ((int) segmentfirst_speed > 0)
                      {
-#define WFCF 80
                          segmentfirst_speed *= (100+WFCF);
                          segmentfirst_speed /= 100;
                          DispenserSegmentReady[DispenserId] = false;
@@ -672,7 +758,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                                    (int) segmentfirst_speed);
                          //REPORT_MSG(segmentfirst_speed,IdsMessage);
                          Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
-                         SendJobProgress(0.0, 0, false, IdsMessage);
+                         //SendJobProgress(0.0, 0, false, IdsMessage);
                      }
                  }
              }
@@ -771,8 +857,17 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             {
                 REPORT_MSG(DispenserId,"Dispenser PreSegment not configured");
                 DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped
+                IDS_Valve_PresegmentReady(DispenserId,0); //27/03/19 to be removed when the presegment handler will be added
                 continue;
             }
+            if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER))
+            {
+                REPORT_MSG(DispenserId,"Dispenser PreSegment cleaner or lubricant");
+                DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped
+                IDS_Valve_PresegmentReady(DispenserId,0); //27/03/19 to be removed when the presegment handler will be added
+                continue;
+            }
+
             //REPORT_MSG(DispenserId,"IDS_Valve_Presegment start");
             IDS_Dispenser_Set_Flow_Params(DispenserId,0,0);
             if (Dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
@@ -787,12 +882,13 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             {
                 MotorStop(HW_Motor_Id,Hard_Hiz); //26/03/19 test  without valves
                 CurrentDispenserSpeed[DispenserId] = 0;
+                DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped
                 REPORT_MSG(DispenserId,"Dispenser stopped pre Segment");
             }
             IDS_Valve_PresegmentReady(DispenserId,0); //27/03/19 to be removed when the presegment handler will be added
         }
     }
-
+    //Task_sleep(5);
     return OK;
 }
 //********************************************************************************************************************
@@ -816,12 +912,14 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
             if (MotorsCfg[HW_Motor_Id].hardwaremotortype
                     != DispenserIdToMotorId[DispenserId])
                 continue;
-
+            if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER))
+            {
+                continue;
+            }
             //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius)
             segmentfirst_speed = Dispensers[Dispenser_i]->nanolitterpersecond
                     / Dispensers[Dispenser_i]->nanoliterperpulse;
-            if (Dispensers[Dispenser_i]->dispenserstepdivision
-                    != DISPENSER_STEP_DIVISION__Auto)
+            if (Dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
             {
                 //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision);
                 segmentfirst_speed /=
@@ -832,7 +930,8 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
             }
             else
             {
-                //segmentfirst_speed/=MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
+                segmentfirst_speed/=8;//MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
+
                 IDS_Dispenser_Set_Flow_Params(
                         DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse,
                         MotorsCfg[HW_Motor_Id].microstep);
@@ -848,14 +947,14 @@ 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",
+                          "Dispenser %d nl/sec %d nl/pulse %d speed %d steps %d/%d",
                           DispenserId,
                           (int) Dispensers[Dispenser_i]->nanolitterpersecond,
                           (int) Dispensers[Dispenser_i]->nanoliterperpulse,
-                          (int) segmentfirst_speed);
+                          (int) segmentfirst_speed,Dispensers[Dispenser_i]->dispenserstepdivision,MotorsCfg[HW_Motor_Id].microstep);
                 //REPORT_MSG(segmentfirst_speed,IdsMessage);
                 Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
-                SendJobProgress(0.0, 0, false, IdsMessage);
+                //SendJobProgress(0.0, 0, false, IdsMessage);
             }
             else
             {
@@ -1051,21 +1150,22 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          }
 
      }
-
+	IDS_StopLubrication();
     return OK;
 }
 uint32_t IDS_StartLubrication(void)
 {
     IDS_Dispenser_Start_Motor_and_Open_Valve(LUBRICANT_DISPENSER,lubricant_speed,NULL);
+    CurrentDispenserSpeed[LUBRICANT_DISPENSER] = lubricant_speed;
+    REPORT_MSG (lubricant_speed, "IDS_StartLubrication");
     Lubricant_2Way_Valve (START);
     return OK;
 }
 uint32_t IDS_StopLubrication(void)
 {
-    if(DispenserUsedInJob[LUBRICANT_DISPENSER])
-    {
-        IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady);
-        Lubricant_2Way_Valve (STOP);
-    }
+    IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady);
+    CurrentDispenserSpeed[LUBRICANT_DISPENSER] = 0;
+    REPORT_MSG (lubricant_speed, "IDS_StopLubrication");
+    Lubricant_2Way_Valve (STOP);
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index d041b648e..c6f2526db 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -9,6 +9,10 @@
 #include "Drivers/USB_Communication/USBCDCD.h"
 #include "StateMachines/Initialization/PowerOffSequence.h"
 
+#include "drivers/Flash_Memory/FATFS/ff.h"
+#include "drivers/Flash_Memory/FATFS/Control_File_System.h"
+#include "drivers/adc_sampling/adc.h"
+
 //#include "graphics_adapter.h"
 
 void Stub_ProgressRequest(MessageContainer* requestContainer)
@@ -20,27 +24,49 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     //writeLine("Progress Request...");
 
     ProgressResponse response = PROGRESS_RESPONSE__INIT;
-    response.has_progress = true;
-    PowerOffInit();
-    int i = 0;
-    for (i = 0; i < request->amount; i++)
-    {
-        response.progress = i;
-        responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size);
-        uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
-        size_t container_size = message_container__pack(&responseContainer, container_buffer);
-        free(responseContainer.data.data);
-        SendChars((char*)container_buffer, container_size);
-        //free(container_buffer);
 
-
-        int co = 0;
-        for (co = 0; co < request->delay; co++)
+    if((request->amount == 0xCF) && (request->delay == 0xCF)) //Create File System on the Drive
+    {
+        FRESULT iFResult = Init_Flash_File_System(true);
+        if(iFResult != FR_OK)
         {
-            __delay_cycles(1000000);
+            LOG_ERROR (iFResult, "Error during init Flash File System");
+            assert(iFResult);
         }
     }
+    else
+    if((request->amount == 0x0C) && (request->delay == 0x0C)) //Get Gas Sensor
+    {
+        response.progress = (double)Calculate_Gas_Power_Consumption();
+        response.has_progress = true;
+
+    }
+    else     if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
+    {
+        PowerOffInit();
+    }
+    else
+    {
+        response.has_progress = true;
+        int i = 0;
+        for (i = 0; i < request->amount; i++)
+        {
+            response.progress = i;
+            responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size);
+            uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
+            size_t container_size = message_container__pack(&responseContainer, container_buffer);
+            free(responseContainer.data.data);
+            SendChars((char*)container_buffer, container_size);
+            //free(container_buffer);
 
+
+            int co = 0;
+            for (co = 0; co < request->delay; co++)
+            {
+                __delay_cycles(1000000);
+            }
+        }
+    }
     responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, true, &response, &progress_response__pack, &progress_response__get_packed_size);
     uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c
index e2f2013c9..4867587d9 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c
@@ -22,41 +22,7 @@
 #include "driverlib/rom.h"
 
 
-char Read_HW_Version(unsigned char *Brd_ID, unsigned char *Assy_ID)
-{
-    //TODO Move in GPIO Initialisation
-
-    // -----------  Set HW Version GPIO as Input -----------
-    //MAP_GPIOPinTypeGPIOInput(GPIO_PORTS_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1);
-    //MAP_GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_7);
-    //MAP_GPIOPinTypeGPIOInput(GPIO_PORTP_BASE, GPIO_PIN_3 | GPIO_PIN_5);
-
-    //Set HW Version GPIO to Pull down
-    GPIOPadConfigSet(GPIO_PORTS_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD );
-    GPIOPadConfigSet(GPIO_PORTJ_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_7, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD );
-    GPIOPadConfigSet(GPIO_PORTP_BASE, GPIO_PIN_3 | GPIO_PIN_5,              GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD );
-    // ------------------------------------------------------
 
-    if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_3) == GPIO_PIN_3)
-        *Brd_ID |= 0x08;
-    if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_2) == GPIO_PIN_2)
-        *Brd_ID |= 0x04;
-    if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_5) == GPIO_PIN_5)
-        *Brd_ID |= 0x02;
-    if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_4) == GPIO_PIN_4)
-        *Brd_ID |= 0x01;
-
-    if (ROM_GPIOPinRead(GPIO_PORTP_BASE, GPIO_PIN_3) == GPIO_PIN_3)
-        *Assy_ID |= 0x08;
-    if (ROM_GPIOPinRead(GPIO_PORTP_BASE, GPIO_PIN_5) == GPIO_PIN_5)
-        *Assy_ID |= 0x04;
-    if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_1) == GPIO_PIN_1)
-        *Assy_ID |= 0x02;
-    if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_7) == GPIO_PIN_7)
-        *Assy_ID |= 0x01;
-
-    return PASSED;
-}
 
 void Stub_HWVersionRequest(MessageContainer* requestContainer)
 {
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c
index 636889127..7995b1a42 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c
@@ -21,7 +21,7 @@
 #include "drivers/SPI/SPI_Comm.h"
 
 #include "driverlib/ssi.h"
-
+/*
     unsigned long Run_Value = 136902 ;
     unsigned long Pos_Value;
     unsigned long Mov_Value ;
@@ -43,6 +43,28 @@
     unsigned long TestUint32_4;
     unsigned long TestUint32_5;
     unsigned long TestUint32_6;
+    */
+    extern unsigned long Run_Value ;
+    extern unsigned long Mov_Value ;
+    extern unsigned long Pos_Value;
+    extern bool Direction ;
+    extern unsigned long Time_2_Change_Direction ;
+    extern bool Display_Tx_ON_LCD;
+    extern bool Display_Rx_on_LCD;
+    extern unsigned long Init_MicroStep ;
+    extern unsigned long Init_Acc;
+    extern unsigned long Init_Dec;
+    extern bool TestBool_1;
+    extern bool TestBool_2;
+    extern bool TestBool_3;
+    extern bool TestBool_4;
+    extern bool TestBool_5;
+    extern unsigned long TestUint32_1;
+    extern unsigned long TestUint32_2;
+    extern unsigned long TestUint32_3;
+    extern unsigned long TestUint32_4;
+    extern unsigned long TestUint32_5;
+    extern unsigned long TestUint32_6;
 
 void Stub_L6470DriverRequest(MessageContainer* requestContainer)
 {
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.h
deleted file mode 100644
index 0b4702861..000000000
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.h
+++ /dev/null
@@ -1,3 +0,0 @@
-void Stub_L6470DriverRequest(MessageContainer* requestContainer);
-
-void temp_init_spi2();
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
index 3e2a6aa40..97f3811c7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
@@ -41,8 +41,8 @@ typedef struct
 }MotorControlConfig_t;
 
 
-#define MAX_THREAD_FEED_MOTORS WINDER_MOTOR+1
-#define MAX_SYSTEM_DANCERS HARDWARE_DANCER_TYPE__RightDancer+1
+#define MAX_THREAD_FEED_MOTORS (WINDER_MOTOR+1)
+#define MAX_SYSTEM_DANCERS (HARDWARE_DANCER_TYPE__RightDancer+1)
 
 extern TimerMotors_t ThreadMotorIdToMotorId[MAX_THREAD_MOTORS_NUM];
 extern HardwareDancerType ThreadMotorIdToDancerId[MAX_THREAD_MOTORS_NUM];
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 1f7836ea5..df88db3f9 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -54,6 +54,9 @@ uint32_t ScrewControlId = 0xFF;
 
 InternalWinderConfigStruc InternalWinderCfg = {0};
 
+uint32_t ScrewLocationLimitSwitch = 0,ScrewLocationStart = 0;
+uint32_t ScrewLocationRun[3];
+
 uint32_t Winder_Init(void)
 {
     ScrewTimerInterruptInit();
@@ -109,6 +112,10 @@ uint32_t Winder_Prepare(void)
         AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
         return ERROR;
     }*/
+
+    ScrewLocationRun[0] = 0;
+    ScrewLocationRun[1] = 0;
+
     if (FPGA_Read_limit_Switches(GPI_LS_SCREW_RIGHT)==LIMIT)
     {
         //REPORT_MSG(LIMIT, "Winder_Prepare at limit");
@@ -136,6 +143,11 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue)
 
     //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,InternalWinderCfg.segmentoffsetpulses);
     //REPORT_MSG(numOfSteps, "Winder_PrepareStage2");
+    //Read_Screw_Encoder();
+    //ScrewLocationLimitSwitch = Screw_RotEnc.Position;
+    //REPORT_MSG(ScrewLocationLimitSwitch, "Winder_PrepareStage2 Encoder Location");
+
+
     REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2");
     if (ReadValue != LIMIT)
     {
@@ -157,7 +169,13 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag)
     //SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_SCREW);  //set this point as the spool home
     //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,temp_MaxFrequency);
 
+    //Read_Screw_Encoder();
+    //ScrewLocationStart = Screw_RotEnc.Position;
+
+    REPORT_MSG(ScrewLocationStart, "Winder_ScrewAtOffsetCallback Encoder Location");
+
     ScrewCurrentDirection = false;
+    ScrewLocationRun[ScrewCurrentDirection] = Screw_RotEnc.Position;
     ScrewSpeed = 0;
     ScrewControlId = 0xFF;
     ScrewNumberOfSteps = 0;
@@ -230,6 +248,10 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
 
     ScrewCurrentDirection = 1-ScrewCurrentDirection;
     CalculationDirectionChangeCounter++;
+    //REPORT_MSG(ScrewLocationRun[1] - ScrewLocationRun[0], "Screw Run NumberOfSteps");
+    //usnprintf(ScrewStr, 100, "Winder Encoder: 0 0x%x 1 0x%x diff %d ",ScrewLocationRun[0],ScrewLocationRun[1],abs(ScrewLocationRun[1] - ScrewLocationRun[0]));
+    //usnprintf(ScrewStr, 100, "Winder Encoder: 0 %d 1 %d diff %d ",ScrewLocationRun[0],ScrewLocationRun[1],ScrewLocationRun[1] - ScrewLocationRun[0]);
+    //Report(ScrewStr,__FILE__,__LINE__,ScrewLocationLimitSwitch,RpWarning,ScrewLocationStart, 0);
 
     if (ScrewCurrentDirection == 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize) //next time going out
     {
@@ -242,7 +264,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         if ((CalculationDirectionChangeCounter/2)%InternalWinderCfg.spoolbackingrate == 0)
         {
             ScrewNumberOfSteps--;
-            //REPORT_MSG(ScrewNumberOfSteps, "Head Backing ScrewNumberOfSteps");
+            REPORT_MSG(ScrewNumberOfSteps, "Head Backing ScrewNumberOfSteps");
 
         }
     }
@@ -251,7 +273,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         if ((CalculationDirectionChangeCounter/2)%InternalWinderCfg.SpoolBottomBackingRate == 0)
         {
             ScrewNumberOfSteps++;
-            //REPORT_MSG(ScrewNumberOfSteps, "Bottom Backing ScrewNumberOfSteps");
+            REPORT_MSG(ScrewNumberOfSteps, "Bottom Backing ScrewNumberOfSteps");
         }
     }
     if (WinderMotorSpeedRollOver)
@@ -288,7 +310,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         //Report(TempScrewStr,__FILE__,__LINE__,0,RpWarning,0, 0);
         //Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0);
         //REPORT_MSG(temp , "new winder speed");
-//        Report("new winder speed",__FILE__,ScrewNumberOfSteps,temp,RpWarning,ScrewSpeed,0);
+        //Report("new winder speed",__FILE__,ScrewNumberOfSteps,temp,RpWarning,ScrewSpeed,0);
     }
 
     /********************************************************************************/
@@ -322,7 +344,9 @@ uint32_t Winder_Presegment(void *SegmentDetails, uint32_t SegmentId)
         //     * calculate
         //     * 1. calculate speed according to JobTicket->processparameters->dyeingspeed
         //     * calculation input: traverse length in milimeters/pulses, number of rotations per traverse ==> length of traverse per rotation.
-        screw_horizontal_speed = InternalWinderCfg.segmentoffsetpulses /  InternalWinderCfg.NumberOfRotationPerPassage;
+        ScrewNumberOfSteps = InternalWinderCfg.segmentoffsetpulses;//*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep;
+        ScrewNumberOfSteps -= 100;
+        screw_horizontal_speed = ScrewNumberOfSteps /  InternalWinderCfg.NumberOfRotationPerPassage;
         // calculation input#2: number of rotations per second - (basically: speed/winder perimeter. later - according to winder actual speed - calculate according to winder position accumulation in the last second.
         //RotationsPerSecond = dyeingspeed / (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulleyradius * PI);
         RotationsPerSecond =  OriginalMotorSpd_2PPS[WINDER_MOTOR] / MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround;
@@ -343,10 +367,8 @@ uint32_t Winder_Presegment(void *SegmentDetails, uint32_t SegmentId)
     //     * 3. calculate cart travel length from winding parameters
     //     * 4. start move of travel length
     //     * 5. register motor nBusy callback. this callback will flip between move(traverse length, hardstop) and goto(0), with handline og the coneshape and adjusting maxspeed
-        ScrewNumberOfSteps = InternalWinderCfg.segmentoffsetpulses;//*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep;
-        ScrewNumberOfSteps -= 100;
         temp = SYS_CLK_FREQ;
-        temp *= InternalWinderCfg.segmentoffsetpulses;
+        temp *= ScrewNumberOfSteps;
         temp /= ScrewSpeed;
         ScrewRunningTime = temp;//(SYS_CLK_FREQ*InternalWinderCfg.segmentoffsetpulses)/ScrewSpeed;
         REPORT_MSG(ScrewNumberOfSteps,"Winder pre segment - ScrewNumberOfSteps");
@@ -440,6 +462,9 @@ void ScrewTimerInterrupt(int ARG0)
     ROM_TimerIntClear(Screw_timerBase, TIMER_TIMA_TIMEOUT);  // Clear the timer interrupt
     ROM_IntMasterDisable();
 
+    //Read_Screw_Encoder();
+    //ScrewLocationRun[ScrewCurrentDirection] = Screw_RotEnc.Position;
+
     if (SCREW_TimerActivated == true)
     {
         ROM_TimerLoadSet(Screw_timerBase, TIMER_A,(int)ScrewRunningTime);
@@ -455,13 +480,7 @@ void ScrewTimerInterrupt(int ARG0)
     }
     ROM_IntMasterEnable();
     Rotations+=0.03;
-    /*random++;
-    if (random >= 2)
-        random = -1;*/
-    //Report("ScrewTimerInterrupt dir, duration, speed", __FILE__,ScrewCurrentDirection,ScrewRunningTime, RpMessage, ScrewSpeed, 0);
-    //
-    // Enable all interrupts.
-    //
+
     return ;
 
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index d7ce917c0..91eedeb6b 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -9,7 +9,7 @@
 #define WINDER_DANCER HARDWARE_DANCER_TYPE__LeftDancer
 #define POOLER_DANCER HARDWARE_DANCER_TYPE__MiddleDancer
 #define FEEDER_DANCER HARDWARE_DANCER_TYPE__RightDancer
-#define NUM_OF_DANCERS HARDWARE_DANCER_TYPE__RightDancer+1
+#define NUM_OF_DANCERS (HARDWARE_DANCER_TYPE__RightDancer+1)
 //} DANCER_ENUM;
 typedef enum threadMotorsEnum
 {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index a4208ad25..c292f7dcd 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -842,8 +842,8 @@ char Endstr[150];
      Report(Endstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
 
      ThreadUpdateProcessLength (0.0,(void *)NULL);
-     TotalProcessedLength = 0.0;
-    SetOriginMotorSpeed(0);
+     //TotalProcessedLength = 0.0;
+     SetOriginMotorSpeed(0);
 #ifdef HUNDRED_MICROSECONDS_DANCER_READ
      MillisecLogClose();
 #endif
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
index bda01564f..74f7b40ef 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h
@@ -38,14 +38,14 @@ typedef enum
 
 typedef enum
 {
-    SENSORnotFULL = 0,
-    SENSORFULL
+    SENSORFULL = 0,
+    SENSORnotFULL
 } WHS_FullSensorStatus;
 
 typedef enum
 {
-    SENSOREMPTY = 0,
-    SENSORnotEMPTY
+    SENSORnotEMPTY = 0,
+    SENSOREMPTY
 } WHS_EmptySensorStatus;
 
 typedef enum
@@ -99,6 +99,15 @@ U8 WHS_init(void);
 U8 WHS_HW_test(void);
 bool WHS_IsEmptying();
 
+bool WHS_IsContainerFull();
+bool WHS_IsContainerOverflow();
+bool WHS_WasteCartridgeLowerPresent();
+bool WHS_WasteCartridgeMiddlePresent();
+bool WHS_IsPumpActive();
+bool WHS_IsValveOpen();
+
+bool SetWastePump( bool power);
+
 
 #endif
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h
index e69de29bb..8b1378917 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h
@@ -0,0 +1 @@
+
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index 9531b67d6..8aa358e32 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -19,7 +19,7 @@
 #define CartridgeWaste2CallBackTime     eOneSecond
 #define STARTCOUNT  1
 #define STOPCOUNT   0
-#define PumpTimeout 60 //  minutes
+#define PumpTimeout 1200 //  seconds; 20 minutes, per Moty,  15/4/19
 
 
 /*------------Waste Tank function-----------------------*/
@@ -98,6 +98,14 @@ struct WHS_information
 
 struct WHS_information WHS_info;
 
+bool WHS_IsContainerFull(){return WHS_info.WHS_sensors.waste_tank_full_sensor;}
+bool WHS_IsContainerOverflow(){return WHS_info.WHS_sensors.waste_tank_over_flow_sensor;}
+bool WHS_WasteCartridgeLowerPresent(){return WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;}
+bool WHS_WasteCartridgeMiddlePresent(){return WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;}
+bool WHS_IsPumpActive(){return WHS_info.WHS_pump.status;}
+bool WHS_IsValveOpen(){return WHS_info.WHS_valve;}
+
+
 
 bool WHS_IsEmptying()
 {
@@ -141,13 +149,17 @@ bool CartridgeAuthentication(cartridge_name cart_name)
     {
         case waste_cartridge1:
             WHS_info.cartridge_1.autheticate = PASSED;
+            //Pannel_Leds(CART_2, MODE_ON);
             break;
         case waste_cartridge2:
             WHS_info.cartridge_2.autheticate = PASSED;
+            //Pannel_Leds(CART_3, MODE_ON);
             break;
         default:
             WHS_info.cartridge_1.autheticate = FAILED;
             WHS_info.cartridge_2.autheticate = FAILED;
+            //Pannel_Leds(CART_2, MODE_OFF);
+            //Pannel_Leds(CART_3, MODE_OFF);
             break;
     }
     ret = OK;
@@ -231,7 +243,9 @@ bool SetValveDirection()
      *
      * */
     bool ret = notOK;
-    if (WHS_info.WHS_valve != no_waste_cartridge)
+    //if (WHS_info.WHS_valve != no_waste_cartridge)
+    if (WHS_info.active_cartridge == waste_cartridge1) WHS_info.WHS_valve = 1;
+    else WHS_info.WHS_valve = 2;
     {
         Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve);
         ret = OK;
@@ -258,6 +272,7 @@ U8 CartridgeWasteFilling(bool status)
         SetWastePump(OPEN);
         //WHS_info.WHS_pump.time = 0;
         REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP  ----------------- ");
+        ret=OK;
     }
     else // stop Waste cartridge filling
     {
@@ -352,7 +367,7 @@ WHS_sttMachin UpdateStateMachine()
 bool initWHS_WasteTank()
 {
     WHS_info.WHS_sensors.waste_tank_empty_sensor = RdWasteTankEmptySensor();
-    WHS_info.WHS_sensors.waste_tank_full_sensor =  SENSORnotFULL;//RdWasteTankFullSensor();
+    WHS_info.WHS_sensors.waste_tank_full_sensor =  SENSORnotFULL;//;RdWasteTankFullSensor()
     UpdateStateMachine();
     AddControlCallback(WasteTankCBFunction, WasteTankCallBackTime , WasteTankCallBackFunction, 0,0,0);//eOneMinute
     return OK;
@@ -392,7 +407,7 @@ WHS_sensor FullSensorEvent()
     {
         WHS_info.event =  WHS_full_sensor;
         ret = WHS_full_sensor;
-        WHS_info.WHS_sensors.waste_tank_full_sensor = !WHS_info.WHS_sensors.waste_tank_full_sensor;
+        WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor;
     }
     return ret;
 }
@@ -446,7 +461,10 @@ bool WasteTankCBFunction()
             if (WHS_info.WHS_sensors.waste_tank_empty_sensor == SENSORnotEMPTY)
             {
                 if (WHS_info.sttMachine == WHS_empty)
+                {
                     WHS_info.sttMachine = WHS_filling;
+                    REPORT_MSG(WHS_filling," ------------ WHS_filling ----------------- ");
+                }
                 else
                 {
                     REPORT_MSG(WHS_filling," ------------ WHS EMPTY sensor failed !!!!!!! ----------------- ");
@@ -457,9 +475,10 @@ bool WasteTankCBFunction()
                 if (WHS_info.sttMachine == WHS_emptying)
                 {
                     WHS_info.sttMachine = WHS_empty;
+                    REPORT_MSG(WHS_filling," ------------ WHS_empty ----------------- ");
                     ret = CartridgeWasteFilling(OFF);
                     WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
-                   WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackTime, CartridgeCoverCallBackFunction, 0,0,0 );//eOneSecond
+                    WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackTime, CartridgeCoverCallBackFunction, 0,0,0 );//eOneSecond
                     //SafeRemoveControlCallback(Cartridge_Cover_device_Id, CartridgeCoverCBFunction );
                 }
                 else
@@ -471,24 +490,25 @@ bool WasteTankCBFunction()
         case WHS_full_sensor:
             if (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL)
             {
-                if (WHS_info.sttMachine == WHS_filling)
-                {
-                    WHS_info.sttMachine = WHS_full;
-                    WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
-                    WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackFastTime , CartridgeCoverCallBackFunction, 0,0,0 );//eTenMillisecond
-                    ret = CartridgeWasteFilling(ON);
-                    // cant start a new Job
-                }
-                else
+                WHS_info.sttMachine = WHS_full;
+                REPORT_MSG(WHS_emptying," ------------ WHS_full ----------------- ");
+                WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
+                WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackFastTime , CartridgeCoverCallBackFunction, 0,0,0 );//eTenMillisecond
+                ret = CartridgeWasteFilling(ON);
+                if (ret != OK)
                 {
-                    REPORT_MSG(WHS_filling," ------------ WHS FULL sensor failed !!!!!!! ----------------- ");
+                    //recreate the full event until cartridge is inserted
+                    WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor;
                 }
+
+                // cant start a new Job
             }
             else
             {
                 if (WHS_info.sttMachine == WHS_full)
                 {
                     WHS_info.sttMachine = WHS_emptying;
+                    REPORT_MSG(WHS_emptying," ------------ WHS_emptying ----------------- ");
                     // can start a new JOB
                 }
                 else
@@ -548,13 +568,15 @@ bool WasteTankCBFunction()
         case WHS_waste1_presence_sensor :
                     if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == WHS_CarteidgePrecense ) // waste cartridge 1 is inserted .
                     {
-                        SetCartridgeLED(waste_cartridge1, led_on);
+                        //SetCartridgeLED(waste_cartridge1, led_on);
+                        Pannel_Leds(CART_2, MODE_ON);
                         RdWasteCartridgeParam(waste_cartridge1);
+                        SetActiveWastCartridge();
+                        SetValveDirection();
                         if ( CartridgeAuthentication(waste_cartridge1)) // to define authentication
                         {
                             //WHS_info.cartridge_1.autheticate = PASSED; //='0'
                             //???WHS_info.WHS_valve = waste_cartridge1; // or we should do it only before pumping????
-                            //???SetValveDirection();    // or we should do it only before pumping????
                         }
                         else
                         {
@@ -564,6 +586,7 @@ bool WasteTankCBFunction()
                     }
                     else    // waste cartridge 1 take out
                     {
+                        Pannel_Leds(CART_2, MODE_OFF);
                         WHS_info.cartridge_1.autheticate = FAILED;
                         //???if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping????
                         //???{
@@ -582,7 +605,7 @@ bool WasteTankCBFunction()
         case WHS_waste2_presence_sensor :
                     if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == WHS_CarteidgePrecense ) // waste cartridge  is inserted .
                     {
-                       SetCartridgeLED(waste_cartridge2, led_on);
+                       Pannel_Leds(CART_3, MODE_ON);//SetCartridgeLED(waste_cartridge2, led_on);
                        RdWasteCartridgeParam(waste_cartridge2);
                        if ( CartridgeAuthentication(waste_cartridge2)) // to define authentication
                        {
@@ -598,6 +621,7 @@ bool WasteTankCBFunction()
                     }
                     else    // waste cartridge 2 take out
                     {
+                        Pannel_Leds(CART_3, MODE_OFF);
                         WHS_info.cartridge_2.autheticate = FAILED;
                         /*
                           if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping????
@@ -616,6 +640,7 @@ bool WasteTankCBFunction()
                     //SetActiveWastCartridge();
                     break;
         case WHS_Timeout:
+            REPORT_MSG(WHS_emptying," ------------ WHS_Timeout ----------------- ");
             AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,  true);
             CartridgeWasteFilling(OFF);
             break;
@@ -633,11 +658,16 @@ bool WasteTankCBFunction()
 
 bool RdCartridgeCoverSensor()
 {
+    uint32_t parameter = 6 ;
+
+    //REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor    ----------------- ");
     bool ret = notOK;
     WHS_Read_GPI_Registers();
    // WHS_info.WHS_sensors.cartridge_cover = Get_COVER_1_State(CartridgesDoor);
    // ret = WHS_info.WHS_sensors.cartridge_cover;
     ret = Get_COVER_1_State(CartridgesDoor);
+    if ((ret == OPEN ) && (ret != WHS_info.WHS_sensors.cartridge_cover)) Report(" ------------ RD Cartridge Cover Sensor is = OPEN(1)    ----------------- ",__FILE__,__LINE__,ret,RpWarning,ret,0);
+    if ((ret == CLOSE ) && (ret != WHS_info.WHS_sensors.cartridge_cover)) REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor is = CLOSE(0)   ----------------- ");
     return ret;
 }
 
@@ -646,10 +676,14 @@ bool RdCartridgeCoverSensor()
 
 WHS_sensor CartridgeCoverCallBackFunction()
 {
+    uint32_t parameter = 6 ;
+
+
     WHS_sensor ret = WHS_no_event;
    //ret = RdCartridgeCoverSensor();
     if (WHS_info.WHS_sensors.cartridge_cover != RdCartridgeCoverSensor())
     {
+        REPORT_MSG(parameter," ------------ find  :  WHS_cartridge_cover_sensor event   ----------------- ");
         WHS_info.event = WHS_cartridge_cover_sensor;
         WHS_info.WHS_sensors.cartridge_cover = !WHS_info.WHS_sensors.cartridge_cover;
         ret = WHS_cartridge_cover_sensor;
@@ -659,10 +693,13 @@ WHS_sensor CartridgeCoverCallBackFunction()
 
 WHS_sensor CartridgeWaste1CallBackFunction()
 {
+    uint32_t parameter = 6 ;
+
     WHS_sensor ret = WHS_no_event;
     //ret = RdCartridgeCoverSensor();
     if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor != RdWasteCartridge1Sensor())
     {
+        REPORT_MSG(parameter," ------------ find  : WHS_waste1_presence_sensor event   ----------------- ");
         WHS_info.event = WHS_waste1_presence_sensor;
         WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;
         ret = WHS_waste1_presence_sensor;
@@ -672,10 +709,13 @@ WHS_sensor CartridgeWaste1CallBackFunction()
 
 WHS_sensor CartridgeWaste2CallBackFunction()
 {
+    uint32_t parameter = 6 ;
+
     WHS_sensor ret = WHS_no_event;
     //ret = RdCartridgeCoverSensor();
     if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor != RdWasteCartridge2Sensor())
     {
+        REPORT_MSG(parameter," ------------ find  : WHS_waste2_presence_sensor event   ----------------- ");
         WHS_info.event = WHS_waste2_presence_sensor;
         WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;
         ret = WHS_waste2_presence_sensor;
@@ -686,15 +726,45 @@ WHS_sensor CartridgeWaste2CallBackFunction()
 /*------------------------------- Cartridge  Waste       -----------------------------------------*/
 bool InitWasteCartStatus()
 {
+    uint32_t parameter = 6 ;
+
     WHS_info.WHS_sensors.cartridge_cover = RdCartridgeCoverSensor();
-    WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = RdWasteCartridge1Sensor();
-    WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = RdWasteCartridge2Sensor();
+
+    if (RdWasteCartridge1Sensor())
+    {
+        REPORT_MSG(parameter," ------------  WHS_waste1_presence_sensor event   ----------------- ");
+        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = WHS_CarteidgePrecense;
+        Pannel_Leds( CART_2,  MODE_ON);
+    }
+    else
+    {
+        REPORT_MSG(parameter," ------------  WHS_waste1_NOT !!!  presence_sensor   ----------------- ");
+        WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = WHS_CarteidgeNotPrecense;
+        Pannel_Leds( CART_2,  MODE_OFF);
+    }
+
+    if (RdWasteCartridge2Sensor())
+    {
+        REPORT_MSG(parameter," ------------  WHS_waste2_presence_sensor event   ----------------- ");
+        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = WHS_CarteidgePrecense;
+        Pannel_Leds( CART_3,  MODE_ON);
+    }
+    else
+    {
+        REPORT_MSG(parameter," ------------  WHS_waste1_NOT !!!  presence_sensor   ----------------- ");
+        WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = WHS_CarteidgeNotPrecense;
+        Pannel_Leds( CART_3,  MODE_OFF);
+    }
+
+
+
     if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == WHS_CarteidgePrecense) CartridgeAuthentication(waste_cartridge1);
     if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == WHS_CarteidgePrecense) CartridgeAuthentication(waste_cartridge2);
     SetActiveWastCartridge();
 
     if (WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN)
     {
+        REPORT_MSG(parameter," ------------ WHS_CartridgeCoverOPEN  : add callback for cart1 and cart 1   ----------------- ");
         WHS_info.Cartridge_Waste1_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste1CallBackFunction, 0,0,0 );
         WHS_info.Cartridge_Waste2_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste2CallBackFunction, 0,0,0 );
     }
@@ -725,12 +795,26 @@ bool RdWasteCartridge2Sensor()
 
 bool SetActiveWastCartridge()
 {
+    uint8_t parameter = 5;
+
     bool ret = notOK;
     if (( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == PRECENSE ) &&
-            (WHS_info.cartridge_1.autheticate == PASSED))    WHS_info.active_cartridge = waste_cartridge1;
+            (WHS_info.cartridge_1.autheticate == PASSED))
+        {
+            REPORT_MSG(parameter," ------------  WHS : active_cartridge = waste_cartridge  1   ----------------- ");
+            WHS_info.active_cartridge = waste_cartridge1;
+        }
     else if (( WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == PRECENSE) &&
-            (WHS_info.cartridge_2.autheticate == PASSED))    WHS_info.active_cartridge = waste_cartridge2;
-    else WHS_info.active_cartridge = no_waste_cartridge;
+            (WHS_info.cartridge_2.autheticate == PASSED))
+        {
+            REPORT_MSG(parameter," ------------  WHS : active_cartridge = waste_cartridge  2   ----------------- ");
+            WHS_info.active_cartridge = waste_cartridge2;
+        }
+    else
+        {
+            REPORT_MSG(parameter," ------------  WHS : NO active_cartridge   ----------------- ");
+            WHS_info.active_cartridge = no_waste_cartridge;
+        }
     return ret;
 
 }
@@ -911,6 +995,7 @@ U8 RdWaste2()
 U8 SetValve(bool value)
 {
     bool ret = notOK;
+    WHS_info.WHS_valve = value;
     ret = SetValveDirection( );
     return ret;
 }