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

14 files changed, 422 insertions, 163 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 81c4a230b..13f0515f9 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -685,9 +685,12 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value)
                 else
                 {
                     Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
-                    AlarmState[Alarm_i].Status = value;
                     if (AlarmState[Alarm_i].EventPtr)
+                    {
                         my_free(AlarmState[Alarm_i].EventPtr);
+                        AlarmState[Alarm_i].EventPtr = NULL;
+                    }
+                    AlarmState[Alarm_i].Status = value;
                 }
             }
             break;
@@ -735,7 +738,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
             switch (AlarmItem[Alarm_i].AlarmSource)
             {
             /*case ALARM_SOURCE_TYPE__TemperatureAlarm:
-                ivalue = TemperatureSensorRead((TEMPERATURE_SENSOR_ID_ENUM)AlarmItem[Alarm_i].DeviceId);
+                ivalue = MillisecGetTemperatures((TEMPERATURE_SENSOR_ID_ENUM)AlarmItem[Alarm_i].DeviceId);
                 if (AlarmItem[Alarm_i].AlarmDirection == true)
                 {
                     if (ivalue/100 >= AlarmItem[Alarm_i].AlarmValue)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index d34ac9ff9..193769265 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -445,6 +445,37 @@ uint32_t MillisecLoop(uint32_t tick)
 #endif
     return OK;
 }
+int TemperatureSum[MAX_TEMPERATURE_SENSOR_ID];
+int TemperatureMin[MAX_TEMPERATURE_SENSOR_ID];
+int TemperatureMax[MAX_TEMPERATURE_SENSOR_ID];
+int TemperatureCount[MAX_TEMPERATURE_SENSOR_ID];
+int TemperatureCalc[MAX_TEMPERATURE_SENSOR_ID];
+void MillisecUpdateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId,int temperature)
+{
+   //if(TemperatureCount[SensorId]++>=10)
+   //    TemperatureCount[SensorId] = 0;
+    TemperatureCount[SensorId]++;
+    if (TemperatureMax[SensorId]<temperature) TemperatureMax[SensorId]=temperature;
+    if (TemperatureMin[SensorId]>temperature) TemperatureMin[SensorId]=temperature;
+    TemperatureSum[SensorId]+=temperature;
+}
+int MillisecCalculateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId)
+{
+    int calc = 0;
+    TemperatureSum[SensorId]-=TemperatureMax[SensorId];
+    TemperatureSum[SensorId]-=TemperatureMin[SensorId];
+    calc = TemperatureSum[SensorId] / (TemperatureCount[SensorId]-2);
+
+    TemperatureSum[SensorId] = 0;
+    TemperatureCount[SensorId] = 0;
+    TemperatureMin[SensorId] = 30000;
+    TemperatureMax[SensorId] = -30000;
+    return calc;
+}
+int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId)
+{
+    return TemperatureCalc[SensorId];
+}
 uint32_t MillisecLowLoop(uint32_t tick)
 {
     uint8_t Motor_i,Disp_i,Heater_i,temp;
@@ -454,9 +485,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
     //call all modules Millisec functions
     //test dancers and speed encoders
     //check all callback units (state machine waiting for completion of a change)
-    bool Ten_msTick, Hundred_msTick, Onesecond_Tick,O900Millisecond_Tick,OneMinute_Tick;
+    bool Ten_msTick, Hundred_msTick , m90msecTick, Onesecond_Tick,O900Millisecond_Tick,OneMinute_Tick;
     Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
     Hundred_msTick  =   (tick%eHundredMillisecond == 0)  ?true:false;
+    m90msecTick  =   (tick%eHundredMillisecond == 90)  ?true:false;
     O900Millisecond_Tick  =   (tick%eOneSecond == 900)           ?true:false;
     Onesecond_Tick  =   (tick%eOneSecond == 0)           ?true:false;
     OneMinute_Tick  =   (tick%eOneMinute == 0)           ?true:false;
@@ -471,13 +503,20 @@ uint32_t MillisecLowLoop(uint32_t tick)
         if(Machine_Idle_Mode == true)
             Machine_Idle_Breathing_Led();
     }
+    if (m90msecTick)
+    {
+        for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++)
+        {
+            MillisecReadFromTempSensor(Sensor_i, NULL);
+        }
+    }
     if (Hundred_msTick)
     {
         Speed_Data = Calculate_Speed_Sensor_Velocity();
         Read_Buttons_Reg();
         for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++)
         {
-            MillisecReadFromTempSensor(Sensor_i, NULL);
+            MillisecUpdateTemperatures (Sensor_i,TemperatureSensorRead(Sensor_i));
         }
         if (GeneralHwReady == true)
         {
@@ -517,6 +556,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
             Read_Heaters_Current(Heater_i);
         }
         Gas_PPM = Calculate_Gas_Power_Consumption();
+        for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++)
+        {
+            TemperatureCalc[Sensor_i] =  MillisecCalculateTemperatures ( Sensor_i);
+        }
     }
     if (OneMinute_Tick)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
index 064302685..be82d9e98 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
@@ -33,6 +33,8 @@ float getSensorSpeedData(void);
 uint32_t getDrawerFansStatus(void);
 uint32_t getSystemFansStatus(void);
 uint8_t getGasReading(void);
+int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId);
+
 
 void MillisecInit(void);
 void MillisecStop(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index 52b52d93b..608d17a7b 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -69,7 +69,7 @@ typedef struct
   uint32_t StartTick;
   DataReadCBFunction ControlDataReadPtr;
   ControlCBFunction ControlCallbackPtr;
-  uint16_t ControlTiming;
+  uint32_t ControlTiming;
 }ControlDeviceStruc;
 
 typedef enum
@@ -224,7 +224,7 @@ void ControlStart(void)
  * both these callbacks can be removed. if a new call is arriving, it invalidates the previous one (no dual control or data)
  *
  ***************************************************************************************************************************************************/
-uint32_t  AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 )
+uint32_t  AddControlCallback( ControlCBFunction Callback, uint32_t CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 )
 {
     assert(Callback);
     assert(DriverfPtr);
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.h b/Software/Embedded_SW/Embedded/Modules/Control/control.h
index 8d7e219ac..380040e34 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h
@@ -19,7 +19,8 @@ typedef enum {
     eTenMillisecond = 10,
     eHundredMillisecond = 100,
     eOneSecond = 1000,
-    eOneMinute = 60000
+    eOneMinute = 60000,
+    eOneHour = 3600000
 }CTRL_TIMING_ENUM;
 typedef enum
 {
@@ -37,7 +38,7 @@ typedef enum
 void        ControlInit(void);
 void        ControlStop(void);
 void        ControlStart(void);
-uint32_t    AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 );
+uint32_t    AddControlCallback( ControlCBFunction Callback, uint32_t CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 );
 int         RemoveControlCallback(uint32_t deviceId, ControlCBFunction Callback );
 //The safe remove command can be used ONLY when called from the control callback itself
 int         SafeRemoveControlCallback(uint32_t deviceId , ControlCBFunction Callback);
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index 425894857..c9bbe2df6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -120,16 +120,11 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
             Valve_Set(IDS_Id_to_CartrideValve[portId], request->value );   //Atm_MidTank_OFF/ON
             break;
         case INTERFACE_IOS__GPO_DRYER_SSR3_CTRL:
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[0] = false;
-#endif
+            //CLEANER_PUMP_SSR3_CTRL
             if (request->value == true)
-                ActivateHeater(0);
+                ActivateCleanerPump();
             else
-                DeActivateHeater(0);
-#ifdef DEMO_TEMPERATURE
-            HeaterTestActive[0] = true;
-#endif
+                DeActivateCleanerPump();
             break;
         case INTERFACE_IOS__GPO_DRYER_SSR1_CTRL:
 #ifdef DEMO_TEMPERATURE
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index c936d842c..d39c97621 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -45,6 +45,10 @@
 
 #include "StateMachines/Printing/PrintingSTM.h"
 
+#include <drivers/FPGA/FPGA_Comm.h>
+
+extern F2_CTRL_REG F2_CTRL_Reg;
+
 char DiagnosticsToken[36+1] = {0};
 bool DiagnosticsActive = false;
 
@@ -209,7 +213,10 @@ void DiagnosticLoadMotor(int MotorId, int frequency)
 void DiagnosticsLoadDigitalValues(void)
 {
     DigitalOutputState[0].interfaceio = INTERFACE_IOS__GPO_DRYER_SSR3_CTRL;
-    DigitalOutputState[0].value = GetHeaterState(0);
+    if(F2_CTRL_Reg.ushort & CLEANER_PUMP_SSR3_CTRL)
+        DigitalOutputState[0].value = true;
+    else
+        DigitalOutputState[0].value = false;
 
     DigitalOutputState[1].interfaceio = INTERFACE_IOS__GPO_DRYER_SSR1_CTRL;
     DigitalOutputState[1].value = GetHeaterState(1);
@@ -331,17 +338,17 @@ void Diagnostic100msecCollection(void)
         DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
         DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
     }
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, TemperatureSensorRead( MIXER_PT100));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, TemperatureSensorRead(HEAD6_PT100));
+    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));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
 
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP1));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP2));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP3));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP3));
     for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
     {
         dispensermotorfrequency[i][DiagnosticsIndex] = IdsGetMotorSpeed(i);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index f5aec59f6..1483f2889 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);
@@ -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.2;
+            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/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 8fe9e5c2e..c177b9b06 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -22,6 +22,7 @@
 #include "../AlarmHandling/AlarmHandling.h"
 #include "../control/control.h"
 #include "../control/pidalgo.h"
+#include "../control/MillisecTask.h"
 
 #include <ti/sysbios/knl/Task.h>
 #include <driverlib/timer.h>
@@ -81,7 +82,7 @@ uint32_t    OverHeatCounter [MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0};
 uint32_t    UnderHeatCounter [MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0};
 uint32_t    MainDryerHeaterMaxTempControl = 0xFF;
 uint32_t    SecondDryerHeaterMaxTempControl = 0xFF;
-
+uint32_t    DisasterControlId = 0xFF;
 #define DRYER_AIR_PT100  TEMP_SENSE_ANALOG_DRYER_TEMP1
 #define DRYER_MAIN_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP2
 #define DRYER_SECONDARY_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP3
@@ -122,11 +123,16 @@ EventType HeaterUnderEventType_B[MAX_HEATERS_NUM] = {EVENT_TYPE__DRYER_ZONE_1_UN
                                               EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,
                                               EVENT_TYPE__MIXER_UNDERTEMPERATURE_B};
 
+int HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {0,0,0,0,0,0,0,0,0,0};
+#define DISASTER_COUNTER_LIMIT 10
+
 /******************** FUNCTIONS  ********************************************/
 uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue);
 uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue);
 uint32_t HeaterControlCBFunction(uint32_t deviceID, uint32_t readValue);
 uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue);
+uint32_t HeatersDisasterControl(uint32_t x,uint32_t y);
+
 uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue);
 void HeatersStartControlTimer (void);
 
@@ -205,8 +211,8 @@ uint32_t LoadHeaterSetPoint(HeaterType HeaterType)
 void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
 {
     int HeaterId = HeaterType;
-    double temp = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
-    //double temp = HeaterPreviousRead[HeaterId];//TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
+    double temp = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
+    //double temp = HeaterPreviousRead[HeaterId];//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
 
     HeaterState->has_heatertype = true;
     HeaterState->heatertype = HeaterType;
@@ -214,7 +220,7 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
     HeaterState->setpoint = HeaterCmd[HeaterId].targettemperatue/100;
     //    HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse;
     HeaterState->has_currentvalue = true;
-    HeaterState->currentvalue = temp/100;//TemperatureSensorRead(HeaterId2PT100Id[HeaterId])/100;
+    HeaterState->currentvalue = temp/100;//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId])/100;
     HeaterState->has_isactive = true;
     HeaterState->isactive = GetHeaterState(HeaterId);
     HeaterState->has_isrampingup = true;
@@ -399,7 +405,7 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
         }
         else
         {
-            HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//
+            HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId);//
             LOG_ERROR(HeaterId,"ReRead Heater Temp");
         }*/
         PrepareHeater(HeaterId,Temperature);  //prepare the heaters control info
@@ -430,12 +436,12 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
 {
     if (ControlIdtoHeaterId [HeaterId] == 0xFF)
     {
-        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
-        //HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id);
-        HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//
+        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
+        //HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(DryerInternalPT100Id);
+        HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//
         //Report("PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);//TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);// = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);//MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
+        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);// = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
     }
     //turn all alarms off
         AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false);
@@ -443,7 +449,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
         AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);
 
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
-        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
     Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
     Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
@@ -451,9 +457,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,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
+        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
     if (SecondDryerHeaterMaxTempControl == 0xFF)
-        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
+        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
     //InitialHeating = true;
     HeaterReady[HeaterId] = false;
     if (BlowerCfg.enabled == true)
@@ -477,8 +483,11 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
  */
 int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
 {
+    if (DisasterControlId == 0xFF)
+        DisasterControlId = AddControlCallback( HeatersDisasterControl, eOneSecond,TemplateDataReadCBFunction,0,0, 0);
+
     if (ControlIdtoHeaterId [HeaterId] == 0xFF)
-    ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(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;
@@ -491,7 +500,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
 
     Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
 
-    HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
+    HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
     if((abs(HeaterPreviousRead[HeaterId]-MINIMUM_HEATER_READ)<1)||(abs(MAXIMUM_HEATER_READ-HeaterPreviousRead[HeaterId])<10))
     {
         LOG_ERROR (HeaterId,"PT100 not working properly");
@@ -499,7 +508,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
     }
     //Report("PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
-        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
     return OK;
 }
@@ -538,13 +547,19 @@ 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
 
-    temp = SetTemperatue*(100+HeaterControl[HeaterId].outputproportionalband);
-    temp = SetTemperatue*110.0;
+    int band = 8;
+    /*if (HeaterControl[HeaterId].outputproportionalband)
+    {
+        band = HeaterControl[HeaterId].outputproportionalband;
+    }*/
+    temp = SetTemperatue*(100+band);
+    //temp = SetTemperatue*110.0;
     HeaterControl[HeaterId].sensormaxvalue = (int)temp;
 
-    temp = SetTemperatue*(100-HeaterControl[HeaterId].outputproportionalband);
-    temp = SetTemperatue*90.0;
+    temp = SetTemperatue*(100-band);
+    //temp = SetTemperatue*90.0;
     HeaterControl[HeaterId].sensorminvalue = (int)temp;
+    Report("Temperature limits",__FILE__,HeaterId,HeaterControl[HeaterId].sensormaxvalue,RpWarning,HeaterControl[HeaterId].sensorminvalue, 0);
 
     if (HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier)
     {
@@ -606,13 +621,11 @@ uint32_t MainPT100Read = 0,SecondaryPT100Read = 0;
 #ifndef min
     #define min(a,b) ((a) < (b) ? (a) : (b))
 #endif
-uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
+uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=MAX_HEATERS_NUM;
-    int32_t MaxreadValue = max (MainPT100Read,SecondaryPT100Read);
-    int32_t MinreadValue = min (MainPT100Read,SecondaryPT100Read);
-    /*char str[100];
-    uint8_t len = 0;*/
+    int32_t MaxreadValue;
+    int32_t MinreadValue;
     if (IfIndex>>8 != IfTypeHeaters)
     {
         LOG_ERROR (IfIndex, "Wrong  Interface type");
@@ -624,11 +637,15 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
         LOG_ERROR (IfIndex, "Wrong  Interface ");
         return 0xFFFFFFFF;
     }
-    int32_t readValue = TemperatureSensorRead(HeaterId2PT100Id[index]);
+    //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]);
 
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
         Report("Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
@@ -640,19 +657,24 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
     {
         SecondaryPT100Read = readValue;
     }
+    MaxreadValue = max (MainPT100Read,SecondaryPT100Read);
+    MinreadValue = min (MainPT100Read,SecondaryPT100Read);
+
     if ((MaxreadValue) >= HeaterControl[index].sensormaxvalue)
     {
         if (HeaterMaxTempFlag[index] == false)
         {
-     //       LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
+            LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
         }
         DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
         HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = true;
+        //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
         DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
         HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true;
+        //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
         return OK;
     }
-    if ((MinreadValue) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue))
+    if ((MaxreadValue) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
     {
         if (HeaterControl[index].sensorminvalue > 0)
         {
@@ -663,7 +685,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
                 {
                     ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                 }*/
-       //         LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on");
+                LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on");
             }
             HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
             HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = false;
@@ -672,7 +694,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
     }
     return ERROR;
 }
-uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
+uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=MAX_HEATERS_NUM;
     if (IfIndex>>8 != IfTypeHeaters)
@@ -681,7 +703,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
-    int32_t readValue = TemperatureSensorRead(HeaterId2PT100Id[index]);
+    //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]);
     if (HeaterControl[index].sensormaxvalue == 0)
         return OK;
     if ((HeaterPreviousRead[index]) >= HeaterControl[index].sensormaxvalue)
@@ -689,11 +711,13 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
         if(OverHeatCounter[index]++ >=Overheat_Count_Limit)
         {
             OverHeatCounter[index] = Overheat_Count_Limit;
+            //?????HeaterReady[index] = false;
             if (JobIsActive()&&(HeaterReady[index]==true))
             {
                 JobEndReason = JOB_TEMPERATURE_ALARM;
                 SendJobProgress(0.0,0,false, "Temperature Error");
-                SegmentReady(Module_Heaters,ModuleFail);
+                AbortJob("Over Temperature Error");
+                //SegmentReady(Module_Heaters,ModuleFail);
                 LOG_ERROR(index, "Temperature Error");
                 return OK;
             }
@@ -702,7 +726,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
         HeaterRecalculateHeaterParams(index, 0);
         HeaterMaxTempFlag[index] = true;
         //LOG_ERROR ((MinreadValue/100), "Heater Over the max temperature, turned off");
-        Report("Heater Over the max temperature, turned off",__FILE__,__LINE__,index,RpWarning,HeaterPreviousRead[index],  HeaterControl[index].sensormaxvalue);
+        Report("Heater Over the max temperature, turned off",__FILE__,index,HeaterPreviousRead[index],RpWarning,  HeaterControl[index].sensormaxvalue,0);
         AlarmHandlingSetAlarm(HeaterEventType[index], true);
         return OK;
     }
@@ -711,15 +735,16 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
         if(UnderHeatCounter[index]++ >=Underheat_Count_Limit)
         {
             UnderHeatCounter[index] = Underheat_Count_Limit;
+            //???HeaterReady[index] = false;
             if (JobIsActive()&&(HeaterReady[index]==true))
             {
                 JobEndReason = JOB_TEMPERATURE_ALARM;
                 SendJobProgress(0.0,0,false, "Temperature Error");
-                SegmentReady(Module_Heaters,ModuleFail);
+                AbortJob("Under Temperature Error");
                 LOG_ERROR(index, "Temperature Error");
                 return OK;
             }
-            HeaterMinTempFlag[index] = true;
+            //HeaterMinTempFlag[index] = true;
 //            Report("Heater under the min temperature",__FILE__,__LINE__,index,RpWarning,HeaterPreviousRead[index],  HeaterControl[index].sensormaxvalue);
             if (HeaterReady[index]==false)
                 AlarmHandlingSetAlarm(HeaterUnderEventType[index], true);
@@ -763,17 +788,21 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     if (IfIndex>>8 != IfTypeHeaters)
     {
         LOG_ERROR (IfIndex, "Wrong  Interface type");
-        return 0xFFFFFFFF;
+        return ERROR;
     }
     index = IfIndex&0xFF;
     if (index != HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
     {
         LOG_ERROR (IfIndex, "Wrong  Interface ");
-        return 0xFFFFFFFF;
+        return ERROR;
     }
     if (HeaterCmd[index].targettemperatue == 0)
     {
-        DeActivateHeater(index);
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        //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");
         return ERROR;
     }
@@ -782,12 +811,22 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         Report("AC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         if (readValue > HeaterCmd[index].targettemperatue)
         {
-            DeActivateHeater(index);
+            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
             HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
             HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
         }
         return ERROR;
     }
+    if (HeaterDisasterCounter[index] >= DISASTER_COUNTER_LIMIT)
+    {
+        Report("AC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
+        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+        return ERROR;
+    }
     HeaterPreviousRead[index] = readValue;
 
     // check if the read value is within the proportional band
@@ -916,9 +955,15 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             DeActivateHeater(index);
             HeaterRecalculateHeaterParams(index, 0);
         }
-        return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
+    if (HeaterDisasterCounter[index] >= DISASTER_COUNTER_LIMIT)
+    {
+        Report("DC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        DeActivateHeater (index);
+        return ERROR;
+    }
+
     // check if the read value is within the proportional band
     if (HeaterReady[index]==false)
     {
@@ -945,6 +990,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             //DCInitialHeating[index] = false;
             HeatersControlStart();
             HeaterReady[index] = true;
+            AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
             Disable_Reading_Heaters_Current(HeaterId2CurrentId[index]);
             HeaterPrepareReady();
         }
@@ -1031,55 +1077,102 @@ void EightMilliSecondHeatersInterrupt(UArg arg0)
     return ;
 }
 
+int HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {28000,28000,28000,17000,17000,17000,17000,17000,17000,11000};
+//int HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {8100,8100,8200,8100,8100,8100,8100,8100,8100,8100};
+uint32_t HeatersDisasterControl(uint32_t x,uint32_t y)
+{
+    int HeaterId,temperature;
+
+    for ( HeaterId = HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature; HeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;HeaterId++)
+    {
+        temperature = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
+        if (temperature>=HeaterDisasterTemp[HeaterId])
+        {
+            Report("Disaster Temperature ",__FILE__,HeaterId,temperature,RpWarning,HeaterDisasterTemp[HeaterId], 0);
+            if (HeaterDisasterCounter[HeaterId]++ >= DISASTER_COUNTER_LIMIT)
+                HeaterDisasterCounter[HeaterId] = DISASTER_COUNTER_LIMIT;
+        }
+        else if (temperature<0)
+        {
+            if (HeaterDisasterCounter[HeaterId]++ <= 0)
+                HeaterDisasterCounter[HeaterId] = 0;
+        }
+        else
+        {
+            if (HeaterDisasterCounter[HeaterId]-- <= 0)
+                HeaterDisasterCounter[HeaterId] = 0;
+        }
 
+    }
+    return OK;
+}
 uint32_t HeatersControlLoop(uint32_t tick)
 {
     //char str[100];
     //uint8_t len = 0;
     int DcHeaterId;
+    bool AcHeaterDisaster = false;
+
     /*len = usnprintf(str, 100, "\r\n EightMilliSecondHeatersInterrupt SliceCounter %d Owner %d H1000 %d  H2000 %d"
                     ,SliceCounter,TimeSliceAllocation[SliceCounter],HeatersRestart,NumberOFSlicesInUse);
     Report(str, __FILE__,__LINE__,0, RpMessage, SliceCounter, TimeSliceAllocation[SliceCounter]);
 */
-    static bool first = true;
-    if (first == true)
+    if (HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] >= DISASTER_COUNTER_LIMIT)
     {
-        first = false;
+        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        AcHeaterDisaster = true;
     }
-    if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature] == true)
+    if (HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] >= DISASTER_COUNTER_LIMIT)
+    {
+        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        AcHeaterDisaster = true;
+    }
+
+
+    if (AcHeaterDisaster == false)
     {
-        if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
+        if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature] == true)
         {
-            if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)
+            if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
             {
-                //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain should be active
-                //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)
+                {
+                    //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain should be active
+                    //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
+                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
+                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                }
             }
-        }
-        else if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
-        {
-            if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)
+            else if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
             {
-                //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary should be active
-                //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)
+                {
+                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
+                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+                    //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary should be active
+                    //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
+                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                }
+            }
+            else
+            {
+                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
+                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
+                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
             }
-        }
-        else
-        {
-                //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
         }
     }
     for ( DcHeaterId = HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1; DcHeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;DcHeaterId++)
     {
+        if (HeaterDisasterCounter[DcHeaterId] >= DISASTER_COUNTER_LIMIT)
+        {
+            DeActivateHeater (DcHeaterId);
+            continue;
+        }
         if (HeaterReady[DcHeaterId] == false)
             continue;
         if (DCTimeSliceAllocation[DcHeaterId] > 0) //heater active
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index 80a55d63e..3d2bcf9ff 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -5,7 +5,7 @@
 #include "drivers/motors/motor.h"
 #include "ids_ex.h"
 
-extern uint32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
+extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
 extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
 extern float DispenserPressure[MAX_SYSTEM_DISPENSERS];
 uint32_t DispenserConfigMessage(HardwareDispenser * request);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index b33b531a3..13142ad5f 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"
 
@@ -33,7 +34,8 @@ double   DispenserPreparePressure = DISPENSER_BUILD_PRESSURE_LIMIT;
 uint32_t DispenserPrepareTimeout = DISPENSER_BUILD_PRESSURE_TIMEOUT;
 uint32_t DispenserPrepareTimeLag = DISPENSER_BUILD_PRESSURE_LAG;
 uint32_t DispenserPrepareTime[MAX_SYSTEM_DISPENSERS] = {0,0,0,0,0,0,0,0};
-uint32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS] = {0, 0, 0, 0, 0, 0, 0, 0,};
+
+int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS] = {0, 0, 0, 0, 0, 0, 0, 0,};
 
 callback_fptr DispenserCallback[MAX_SYSTEM_DISPENSERS] = {0, 0, 0, 0, 0, 0, 0, 0,};
 uint32_t DispenserControlId[MAX_SYSTEM_DISPENSERS] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
@@ -55,7 +57,7 @@ void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout)
 }
 
 //********************************************************************************************************************
-uint32_t IdsGetMotorSpeed(uint32_t DispenserId)
+int32_t IdsGetMotorSpeed(uint32_t DispenserId)
 {
     return  CurrentDispenserSpeed[DispenserId];
 }
@@ -322,4 +324,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 9b2442698..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);
@@ -75,6 +77,7 @@ uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails);
 
 float CalculateDispenserPressure (int DispenserId);
 float GetDispenserPressure(int DispenserId);
-uint32_t IdsGetMotorSpeed(uint32_t 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 1bdf15b29..74ae94fd4 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -78,13 +78,14 @@ void IDS_Dispenser_SetBackLashValues(double   initialdispenserpressure,   uint32
 
     Report("IDS_Dispenser_SetBackLashValues ",__FILE__,InitialDispenserPressure,InitialDispenserTimeout,RpWarning,(int)InitialDispenserTimeLag,0);
 }
-uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t deviceID, uint32_t ReadValue)
+uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue)
 {
-    uint8_t DispenserId = deviceID-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
+    uint8_t DispenserId = motorId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
     if ((GetDispenserPressure(DispenserId)>=InitialDispenserPressure)||(DispenserHomingTime[DispenserId]>InitialDispenserTimeout))
     {
-        MotorStop(deviceID,Hard_Hiz);
-        MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
+        MotorStop(motorId,Hard_Hiz);
+        CurrentDispenserSpeed[DispenserId] = 0;
+        MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
         HomingActive[DispenserId]= false;
         Report("End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
         if (SafeRemoveControlCallback(DispenserHomingControlId[DispenserId], IDS_HomeDispenserBackMoveCallback )==OK)
@@ -99,15 +100,15 @@ uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t deviceID, uint32_t ReadValue
     }
     return OK;
 }
-uint32_t IDS_HomeDispenserCallback(uint32_t deviceID, uint32_t ReadValue)
+uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
 {
-    uint8_t DispenserId = deviceID-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
+    uint8_t DispenserId = motorId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
 
     Read_MidTank_Pressure_Sensor(DispenserId);
     //close dry air valve in the dispenser
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Disable_MidTank_Pressure_Reading(DispenserId);
-    //MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
+    //MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep);
     if (HomingRequestCallback[DispenserId])
     {
         HomingRequestCallback[DispenserId](DispenserId,0);
@@ -115,11 +116,12 @@ uint32_t IDS_HomeDispenserCallback(uint32_t deviceID, uint32_t ReadValue)
     }
 //    HomingActive[DispenserId]= false;
     Report("Start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
-    DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,deviceID, deviceID, 0 );
+    DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
 
-    MotorSetDirection(deviceID,MotorsCfg[deviceID].directionthreadwize);
+    MotorSetDirection(motorId,MotorsCfg[motorId].directionthreadwize);
 
-    MotorSetSpeed(deviceID, 1000);
+    MotorSetSpeed(motorId, 1000);
+    CurrentDispenserSpeed[DispenserId] = 1000;
     IDS_Dispenser_RefillEnded ( DispenserId);
 
 
@@ -127,74 +129,85 @@ return OK;
 
 }
 
-uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback)
+uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr callback)
 {
-    assert(deviceID < MAX_SYSTEM_DISPENSERS);
+    assert(DispenserId < MAX_SYSTEM_DISPENSERS);
 
-    //if (DispensersAlarmState[deviceID] == true)
+    //if (DispensersAlarmState[DispenserId] == true)
     //    return ERROR;
 
-    if (HomingActive[deviceID] == true)
+    if (HomingActive[DispenserId] == true)
+    {
+        LOG_ERROR (DispenserId,"Homing already active");
         return ERROR;
+    }
     else
-        HomingActive[deviceID] = true;
+        HomingActive[DispenserId] = true;
 
-    HomingRequestCallback[deviceID] = callback;
+    HomingRequestCallback[DispenserId] = callback;
 
-    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID;
-    if ( Dispenser_Id_to_LS_Id[deviceID] != MAX_GPI)
+    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
+    if ( Dispenser_Id_to_LS_Id[DispenserId] != MAX_GPI)
     {
         //open dispenser valve dispenser to midtank direction
-        Control3WayValvesWithCallback ((Valves_t)deviceID, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+        Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
         //Valve_Set((Valves_t) request->index, MidTank_Dispenser);
         MotorSetMicroStep(MotorId, 1);
         SysCtlDelay(180000);
         //open dry air valve in the dispenser
-        Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON);
+        Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_ON);
 
-        IDS_Dispenser_RefillStarted(deviceID);
-        MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Id[deviceID], IDS_HomeDispenserCallback,0);
+        IDS_Dispenser_RefillStarted(DispenserId);
+        MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0);
+        CurrentDispenserSpeed[DispenserId] = speed;
+        CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]);
         return OK;
     }
     return ERROR;
 }
-uint32_t IDS_Dispenser_Alarm_On (uint8_t deviceID)
+uint32_t IDS_Dispenser_Alarm_On (uint8_t DispenserId)
 {
     uint32_t status = OK;
-    DispensersAlarmState[deviceID] = true;
-    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID;
+    DispensersAlarmState[DispenserId] = true;
+    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
     status |= MotorAbortMovetoLimitSwitch(MotorId);
-    Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_OFF);
-    Enable_MidTank_Pressure_Reading(deviceID);
-    status |= MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
-    status |= MotorStop(deviceID, Hard_Hiz);
+    Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
+    Enable_MidTank_Pressure_Reading(DispenserId);
+    status |= MotorSetMicroStep(DispenserId, MotorsCfg[DispenserId].microstep);
+    status |= MotorStop(DispenserId, Hard_Hiz);
+    CurrentDispenserSpeed[DispenserId] = 0;
     JobEndReason = JOB_OUT_OF_DYE;
     return status;
 }
-uint32_t IDS_Dispenser_Alarm_Off (uint8_t deviceID)
+uint32_t IDS_Dispenser_Alarm_Off (uint8_t DispenserId)
 {
     uint32_t status = OK;
-    DispensersAlarmState[deviceID] = false;
+    DispensersAlarmState[DispenserId] = false;
     return status;
 }
 
-uint32_t IDS_StopHomeDispenser (uint32_t deviceID)
+uint32_t IDS_StopHomeDispenser (uint32_t DispenserId)
 {
-    assert(deviceID < MAX_SYSTEM_DISPENSERS);
+    assert(DispenserId < MAX_SYSTEM_DISPENSERS);
 
-    if (HomingActive[deviceID] != true)
+    Report("IDS_StopHomeDispenser",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0);
+    if (HomingActive[DispenserId] != true)
+    {
+        LOG_ERROR (DispenserId,"Homing not active");
         return ERROR;
+    }
     else
-        HomingActive[deviceID] = false;
+        HomingActive[DispenserId] = false;
 
-    TimerMotors_t MotorId = (deviceID)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
+    TimerMotors_t MotorId = (DispenserId)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
     MotorAbortMovetoLimitSwitch(MotorId);
     //close dry air valve in the dispenser
-    Disable_MidTank_Pressure_Reading(deviceID);
-    Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_OFF);
-    Control3WayValvesWithCallback ((Valves_t)deviceID, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+    Disable_MidTank_Pressure_Reading(DispenserId);
+    Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
+    Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
 
     MotorSetMicroStep(MotorId, MotorsCfg[MotorId].microstep);
+    CurrentDispenserSpeed[DispenserId] = 0;
     return OK;
 }
 
@@ -215,34 +228,35 @@ uint32_t IDS_CheckDispenserLimitSwitch (LimitSwitchAlarms LS_Id)
         return FPGA_Read_limit_Switches(Dispenser_Id_to_Alarm_LS_Id[LS_Id]);
 }
 
-uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback)
+uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr callback)
 {
-    assert(deviceID < MAX_SYSTEM_DISPENSERS);
+    assert(DispenserId < MAX_SYSTEM_DISPENSERS);
 
-    //if (DispensersAlarmState[deviceID] == true)
+    //if (DispensersAlarmState[DispenserId] == true)
     //    return ERROR;
 
-    if (HomingActive[deviceID] == true)
+    if (HomingActive[DispenserId] == true)
         return ERROR;
     else
-        HomingActive[deviceID] = true;
-    HomingRequestCallback[deviceID] = callback;
+        HomingActive[DispenserId] = true;
+    HomingRequestCallback[DispenserId] = callback;
 
-    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID;
-    if ( Dispenser_Id_to_LS_Empty_Id[deviceID] != MAX_GPI)
+    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId;
+    if ( Dispenser_Id_to_LS_Empty_Id[DispenserId] != MAX_GPI)
     {
         //open dispenser valve dispenser to midtank direction
-        Control3WayValvesWithCallback ((Valves_t)deviceID, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+        Control3WayValvesWithCallback ((Valves_t)DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
         //Valve_Set((Valves_t) request->index, Dispenser_Mixer);
         MotorSetMicroStep(MotorId, 1);
         SysCtlDelay(180000);
         //open dry air valve in the dispenser
-        //Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON);
-        IDS_Dispenser_RefillStarted(deviceID);
-        IDS_Dispenser_MovingDirection(deviceID,UP);
+        //Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_ON);
+        IDS_Dispenser_RefillStarted(DispenserId);
+        IDS_Dispenser_MovingDirection(DispenserId,UP);
 
 
-        MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Empty_Id[deviceID], IDS_HomeDispenserCallback,0);
+        MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Dispenser_Id_to_LS_Empty_Id[DispenserId], IDS_HomeDispenserCallback,0);
+        CurrentDispenserSpeed[DispenserId] = speed;
         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 2a8cac415..c4c9085ea 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -71,9 +71,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;
@@ -151,8 +178,10 @@ void DispenserPrepareReady(void)
  uint32_t IDS_PrepareReady(uint32_t deviceID, uint32_t ReadValue)
  {
      if (IDS_Active == false)
+     {
+        REPORT_MSG(deviceID,"IDS_Active false");
         return ERROR;
-
+     }
      DispenserReady[deviceID] = true;
      REPORT_MSG(deviceID,"Dispenser prepare ready");
      DispenserPrepareReady();
@@ -500,9 +529,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");
@@ -510,7 +539,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
         else
         {
             DispenserReady[i] = true;
-            IDS_HomeDispenser (i, 1000 , NULL);
+            //IDS_HomeDispenser (i, 1000 , NULL);
         }
 
     }
@@ -655,7 +684,6 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
                      }
                      if ((int) segmentfirst_speed > 0)
                      {
-#define WFCF 80
                          segmentfirst_speed *= (100+WFCF);
                          segmentfirst_speed /= 100;
                          DispenserSegmentReady[DispenserId] = false;
@@ -751,7 +779,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
         {
             LOG_ERROR(FileBrushStop,"BrushStopReadError");
             JobEndReason = JOB_OUT_OF_DYE;
-            SegmentReady(Module_IDS,ModuleFail);
+            PreSegmentReady(Module_IDS,ModuleFail);
         }
     }
     if (n_dispensers)
@@ -781,10 +809,13 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             {
                 MotorSetMicroStep(HW_Motor_Id, MotorsCfg[HW_Motor_Id].microstep);
             }
-            MotorStop(HW_Motor_Id,Hard_Hiz); //26/03/19 test  without valves
-            CurrentDispenserSpeed[DispenserId] = 0;
+            if ((EnableIntersegment == true)&&(IntersegmentLength>0))
+            {
+                MotorStop(HW_Motor_Id,Hard_Hiz); //26/03/19 test  without valves
+                CurrentDispenserSpeed[DispenserId] = 0;
+                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
-            //REPORT_MSG(DispenserId,"Dispenser stopped pre Segment");
         }
     }
 
@@ -1012,7 +1043,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
      //TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[deviceID];
      //REPORT_MSG(deviceID,"Dispenser End called");
      //MotorStop(HW_Motor_Id,Hard_Hiz);
-     IDS_HomeDispenser (deviceID, 1000 , NULL);
+     IDS_HomeDispenser (deviceID, 800 , NULL);
 
      return OK;
  }