updating : special dispensers handling (for Moti), new process parameters, bugs and features. merged with Shai

13 files changed, 396 insertions, 46 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 6b8f0716d..c432edba0 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -823,7 +823,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                     {
                         if (AlarmState[Alarm_i].Status == true)
                         {
-                            status = JOB_OK;
+                            status = JOB_LS_ALARM;
                             AlarmId = Alarm_i;
                             break;
                         }
@@ -922,8 +922,9 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
         //AbortJob(AlarmReasonStr);
         //PrepareReady(Module_Alarms,ModuleFail);
         ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,AlarmId, RpMessage, DEBUG_LOG_CATEGORY__Error, 0);
+		return (JobEndReason);
     }
-    return JobEndReason;
+    return JOB_OK;
 }
 
 uint32_t AlarmHandling_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 392f36643..d3376c400 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -737,9 +737,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
         static int Counter = 0;
         MachineUpdateResponseFunc();
         KeepAliveOneSecondCall();
+#ifdef Use_Head_Card
         TemperatureListString(Lenstr);
         ReportWithPackageFilter(ThreadFilter,Lenstr,__FILE__,__LINE__,(int)Counter++,RpWarning,(int) msec_millisecondCounter,0);
-#ifdef Use_Head_Card
+//#ifdef Use_Head_Card
         for (Sensor_i = TEMP_SENSE_ANALOG_DRYER_TEMP1;Sensor_i < MAX_HEAD_CARD_TEMP_SENS_ID;Sensor_i++)
 #else
         for (Sensor_i = 0;Sensor_i < MAX_MAIN_CARD_TEMP_SENS_ID;Sensor_i++)
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index e01cd5508..2fbc60f09 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -20,10 +20,14 @@
 #include  <PMR/Diagnostics/SetValveStateResponse.pb-c.h>
 #include  <PMR/Diagnostics/ValveType.pb-c.h>
 #include  <PMR/Diagnostics/ValveStateCode.pb-c.h>
+#include  <PMR/Diagnostics/SetBlowerStateRequest.pb-c.h>
+#include  <PMR/Diagnostics/SetBlowerStateResponse.pb-c.h>
+#include  <PMR/Hardware/HardwareBlowerType.pb-c.h>
 
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/I2C_Communication/DAC/blower.h"
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
+#include "Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h"
 #include "drivers/Valves/Valve.h"
 #include "drivers/Heater/Heater.h"
 #include "modules/waste/waste.h"
@@ -330,6 +334,83 @@ uint32_t SetValveStateRequestFunc(MessageContainer* requestContainer)
 
     return status;
 }
+/********************************************************************************
+ *Blower Setting
+ ********************************************************************************/
+uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer)
+{
+    MessageContainer responseContainer;
+    uint8_t* container_buffer;
+    uint32_t status = OK;
+    uint32_t blower;
+    SetBlowerStateRequest* request = set_blower_state_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+
+    SetBlowerStateResponse response = SET_BLOWER_STATE_RESPONSE__INIT;
+
+    responseContainer = createContainer(MESSAGE_TYPE__SetBlowerStateResponse, requestContainer->token, true, &response, &set_blower_state_response__pack, &set_blower_state_response__get_packed_size);
+    container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+
+    if (request->has_blowertype)
+    {
+        switch (request->blowertype)
+        {
+        case HARDWARE_BLOWER_TYPE__DefaultBlower:
+            if ((request->has_voltage)&&(request->isactive == true))
+            {
+                Turn_the_Blower_On();//Turn on with the Default_Voltage
+                Control_Voltage_To_Blower(request->voltage);
+            }
+            else
+                Turn_the_Blower_Off();
+            break;
+        case HARDWARE_BLOWER_TYPE__HeadBlower1:
+#ifdef Use_Head_Card
+            if ((request->has_voltage)&&(request->isactive == true))
+                status = Head_Fan_PWM_Control(0,request->voltage);
+            else if (request->isactive == false)
+                status = Head_Fan_PWM_Control(0,0);
+#else
+            status = NOT_SUPPORTED;
+#endif
+            break;
+        case HARDWARE_BLOWER_TYPE__HeadBlower2:
+#ifdef Use_Head_Card
+            if ((request->has_voltage)&&(request->isactive == true))
+                status = Head_Fan_PWM_Control(1,request->voltage);
+            else if (request->isactive == false)
+                status = Head_Fan_PWM_Control(1,0);
+#else
+            status = NOT_SUPPORTED;
+#endif
+            break;
+        case HARDWARE_BLOWER_TYPE__WHSBlower2:
+#ifdef Use_WHS_Card
+#else
+            status = NOT_SUPPORTED;
+#endif
+            break;
+        default:
+            status = NOT_SUPPORTED;
+            break;
+
+        }
+    }
+    else
+        status = NOT_SUPPORTED;
+    if (status != OK)
+    {
+        status = ERROR;
+        responseContainer.has_error = true;
+        responseContainer.error = ERROR_CODE__GENERAL_ERROR;
+    }
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    my_free(responseContainer.data.data);
+    SendChars(container_buffer, container_size);
+    set_blower_state_request__free_unpacked(request,NULL);
+
+    return status;
+}
+
 
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 98ab6f9a3..9fc851319 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -109,6 +109,8 @@ double dispenserspressure[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
 double dispenserinklevel[MAX_SYSTEM_DISPENSERS][1];
 double midtankinklevel[MAX_SYSTEM_DISPENSERS][1];
 double MidTankpressure[MAX_SYSTEM_DISPENSERS][1];
+double HeadFlowMeter;
+double DrierFlowMeter;
 double HeatersCurrent[NUM_OF_CURRENT_HEATERS][1];
 double VOC_Sensor;
 double OverallTemperature;
@@ -504,6 +506,19 @@ void DiagnosticOneMinuteCollection(void)
     DiagnosticsMonitor.n_filterdeltapressure = 1;
     DiagnosticsMonitor.filterdeltapressure = &VOC_Sensor;
 
+    DiagnosticsMonitor.n_blowervoltage = 1;
+    diagvoltage = getBlowerState();
+    DiagnosticsMonitor.blowervoltage = &diagvoltage;
+
+    DrierFlowMeter = GetWHSAirFlow(0);
+    DiagnosticsMonitor.n_dryerairflow = 1;
+    DiagnosticsMonitor.dryerairflow = &DrierFlowMeter;
+    HeadFlowMeter = GetWHSAirFlow(2);
+    DiagnosticsMonitor.n_headairflow = 1;
+    DiagnosticsMonitor.headairflow = &HeadFlowMeter;
+
+
+
 }
 void DiagnosticOneSecCollection(void)
 {
@@ -726,9 +741,6 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.n_dryerzone1temperature = HeaterCounterIndex[HEATER_TYPE__DryerAirHeater];
     DiagnosticsMonitor.n_dryerzone2temperature = HeaterCounterIndex[HEATER_TYPE__DryerMainHeater];
     DiagnosticsMonitor.n_dryerzone3temperature = HeaterCounterIndex[HEATER_TYPE__DryerSecondaryHeater];
-    DiagnosticsMonitor.n_blowervoltage = 1;
-    diagvoltage = getBlowerState();
-    DiagnosticsMonitor.blowervoltage = &diagvoltage;
 
     int i;
     DiagnosticsMonitor.n_dispensersmotorsfrequency = 0;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 92ed70b1e..500f03c25 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -103,7 +103,7 @@ uint32_t HWConfigurationInit(void)
             Report("HWConfigurationInit from flash", __FILE__,__LINE__,Bytes, RpMessage, UploadRequest->hardwareconfiguration->n_dancers, 0);
         }
     }
-    else
+    if (UploadRequest = NULL)
     {
         buffer = HWConfigurationLoadFromFile(&Bytes); //load hardware config
         if (buffer)
@@ -274,6 +274,7 @@ uint32_t EmbeddedParametersInit(void)
 {
     FRESULT Fresult = FR_OK;
     uint32_t Bytes = 0;
+    uint8_t* buffer = NULL;
 
     ConfigurationParameters *Params;
 
@@ -281,9 +282,21 @@ uint32_t EmbeddedParametersInit(void)
 
     if ((Bytes)&&(Bytes < 1000))
     {
-        Params = configuration_parameters__unpack(NULL, Bytes, (void *)(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4));
-        LoadConfigurationParameters(Params);
-        Report("LoadConfigurationParameters from flash", __FILE__,__LINE__,Bytes, RpMessage, Fresult, 0);
+        buffer = my_malloc (Bytes);
+        if (buffer)
+        {
+            memcpy(buffer, (void *)(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4),Bytes);
+
+            Params = configuration_parameters__unpack(NULL, Bytes, buffer);
+            LoadConfigurationParameters(Params);
+            Report("LoadConfigurationParameters from flash", __FILE__,__LINE__,Bytes, RpMessage, Fresult, 0);
+            free(buffer);
+        }
+        else
+        {
+            LoadConfigurationParameters(0);
+            Report("LoadConfigurationParameters default", __FILE__,__LINE__,0, RpMessage, Fresult, 0);
+        }
     }
     else
     {
@@ -634,6 +647,10 @@ uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
         responseContainer.error = ERROR_CODE__INVALID_PARAMETER;
         responseContainer.errormessage = "JOb Active or incorrect parameters";
     }
+    else
+    {
+        AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE,OFF);
+    }
     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);
@@ -698,6 +715,7 @@ uint32_t LoadConfigurationParamsFromFile(void)
         EraseFlashSection(EMBEDDED_PARAMETERS_MAP_IN_FLASH,Bytes+4);
         ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH, 4,&Bytes);
         ReadAppAndProgram(EMBEDDED_PARAMETERS_MAP_IN_FLASH+4, Bytes, buffer);
+        EmbeddedParametersInit();
     }
     return Fresult;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index e376a99fe..cadfb3707 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -112,21 +112,25 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, true,ProcessParams->headzone1temp);
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, true,ProcessParams->headzone1temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, true,ProcessParams->headzone1temp);
     }
     else
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, false,ProcessParams->headzone1temp);
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, false,ProcessParams->headzone1temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, false,ProcessParams->headzone1temp);
     }
     if (ProcessParams->headzone2temp>1)
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, true,ProcessParams->headzone2temp);
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, true,ProcessParams->headzone2temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, true,ProcessParams->headzone2temp);
     }
     else
     {
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, false,ProcessParams->headzone2temp);
         status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, false,ProcessParams->headzone2temp);
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, false,ProcessParams->headzone2temp);
     }
     if (ProcessParams->headzone3temp>1)
     {
@@ -193,6 +197,71 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams,bool saveData)
                 HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, false,
                 ProcessParams->dryerzone3temp);
                 */
+  /*  if (ProcessParams->headzone7temp>1)
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, true,ProcessParams->headzone7temp);
+    }
+    else
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, false,ProcessParams->headzone7temp);
+    }
+    if (ProcessParams->headzone8temp>1)
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, true,ProcessParams->headzone8temp);
+    }
+    else
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, false,ProcessParams->headzone8temp);
+    }
+    if (ProcessParams->headzone9temp>1)
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, true,ProcessParams->headzone9temp);
+    }
+    else
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9, false,ProcessParams->headzone9temp);
+    }
+    if (ProcessParams->headzone10temp>1)
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, true,ProcessParams->headzone10temp);
+    }
+    else
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, false,ProcessParams->headzone10temp);
+    }
+    if (ProcessParams->headzone11temp>1)
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, true,ProcessParams->headzone11temp);
+    }
+    else
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, false,ProcessParams->headzone11temp);
+    }
+    if (ProcessParams->headzone12temp>1)
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, true,ProcessParams->headzone12temp);
+    }
+    else
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12, false,ProcessParams->headzone12temp);
+    }
+    if (ProcessParams->stspzone1temp>1)
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, true,ProcessParams->stspzone1temp);
+    }
+    else
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1, false,ProcessParams->stspzone1temp);
+    }
+    if (ProcessParams->stspzone2temp>1)
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, true,ProcessParams->stspzone2temp);
+    }
+    else
+    {
+        status |= HeaterCommandRequestMessage(HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2, false,ProcessParams->stspzone2temp);
+    }
+*/
     HeatersStopControlOnHeatersOff(ProcessParams);
     dyeingspeed = ProcessParams->dyeingspeed;
     dryerbufferlength = ProcessParams->dryerbufferlength;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 9415d9737..3baa81193 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -96,10 +96,10 @@ uint32_t    DisasterControlId = 0xFF;
 #ifdef Use_Head_Card
 uint32_t HeaterId2PT100Id[HEATER_TYPE_MAX_HEATERS] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,HEAD_PT100_ZONE_1_0X80_0, HEAD_PT100_ZONE_2_0X80_1, HEAD_PT100_ZONE_3_0X82_0,
                                                       HEAD_PT100_ZONE_4_0X82_1, HEAD_PT100_ZONE_5_0X84_0, HEAD_PT100_ZONE_6_0X84_1,HEAD_PT100_MIXER_0X8E_0, HEAD_PT100_ZONE_7_0X86_0, HEAD_PT100_ZONE_8_0X86_1,
-                                                      HEAD_PT100_ZONE_9_0X88_0, HEAD_PT100_ZONE_10_0X88_1, HEAD_PT100_ZONE_11_0X8A_0, HEAD_PT100_ZONE_12_0X8A_1 };
+                                                      HEAD_PT100_ZONE_9_0X88_0, HEAD_PT100_ZONE_10_0X88_1, HEAD_PT100_ZONE_11_0X8A_0, HEAD_PT100_ZONE_12_0X8A_1,HEAD_PT100_AIR_HEATER_1_0X8C_0,HEAD_PT100_AIR_HEATER_2_0X8C_1 };
 HEATERS_CURRENT HeaterId2CurrentId[HEATER_TYPE_MAX_HEATERS] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEAD_CURRENT_ZONE_1, HEAD_CURRENT_ZONE_2,
                                                                HEAD_CURRENT_ZONE_3, HEAD_CURRENT_ZONE_4, HEAD_CURRENT_ZONE_5, HEAD_CURRENT_ZONE_6, HEAD_CURRENT_MIXER, HEAD_CURRENT_ZONE_7,
-                                                               HEAD_CURRENT_ZONE_8, HEAD_CURRENT_ZONE_9, HEAD_CURRENT_ZONE_10, HEAD_CURRENT_ZONE_11, HEAD_CURRENT_ZONE_12};
+                                                               HEAD_CURRENT_ZONE_8, HEAD_CURRENT_ZONE_9, HEAD_CURRENT_ZONE_10, HEAD_CURRENT_ZONE_11, HEAD_CURRENT_ZONE_12,HEAD_CURRENT_HTIN_1,HEAD_CURRENT_HTOT_1};
 #else
 uint32_t HeaterId2PT100Id[HEATER_TYPE_MAX_HEATERS] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HEAD6_PT100,MIXER_PT100,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
 HEATERS_CURRENT HeaterId2CurrentId[HEATER_TYPE_MAX_HEATERS] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEATER_HEAD_CURRENT_ZONE_1,HEATER_HEAD_CURRENT_ZONE_2,HEATER_HEAD_CURRENT_ZONE_3,HEATER_HEAD_CURRENT_ZONE_4,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_MIXCHIP_CURRENT};
@@ -340,7 +340,7 @@ uint32_t HeatersSingleHeaterEnd(int HeaterId)
     int status = OK;
     assert(HeaterId < HEATER_TYPE_MAX_HEATERS);
     //HEATER_TYPE_ENUM HeaterId = HeaterPidtoHeaterId(HeaterPID_Id);
-    ReportWithPackageFilter(HeatersFilter,"HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, 0, 0);
+    ReportWithPackageFilter(HeatersFilter,"HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, HeaterPIDConfig[HeaterId].m_SetParam, 0);
         if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
         {
             if (ControlIdtoHeaterId [HeaterId]!=0xFF)
@@ -356,6 +356,7 @@ uint32_t HeatersSingleHeaterEnd(int HeaterId)
             HeaterRecalculateHeaterParams(HeaterId, 0);
             DeActivateHeater(HeaterId);
             HeaterPIDConfig[HeaterId].m_SetParam = 0;
+            HeaterCmd[HeaterId].targettemperatue = 0;
             HeaterReady[HeaterId] = true;
             HeaterAtTemp[HeaterId] = true;
             Disable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
@@ -389,6 +390,7 @@ uint32_t HeatersSingleHeaterEnd(int HeaterId)
             Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
             Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
             HeaterPIDConfig[HeaterId].m_SetParam = 0;
+            HeaterCmd[HeaterId].targettemperatue = 0;
             HeaterReady[HeaterId] = true;
             HeaterAtTemp[HeaterId] = true;
         }
@@ -458,7 +460,7 @@ int GetFilteredHeaterRead(int HeaterId)
  * called by: Communication from host
  * initialized all global data
  *************************************************************************************/
-bool HeaterRestarted[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false};
+bool HeaterRestarted[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false};
 uint32_t  HeaterCommandRequestMessage(int HeaterNum, bool OnOff, int Temperature)
 {
     //uint32_t status = NOT_SUPPORTED;
@@ -729,12 +731,13 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
     }
     if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
     {
-        ReportWithPackageFilter(HeatersFilter,"call PrepareDCHeater",__FILE__,HeaterId,Frequency,RpWarning,HeaterPIDConfig[HeaterId].m_params.dt, 0);
+        ReportWithPackageFilter(HeatersFilter,"call PrepareDCHeater",__FILE__,HeaterId,SetTemperatue,RpWarning,HeaterPreviousRead[HeaterId], 0);
         if (PrepareDCHeater(HeaterId,Frequency,SetTemperatue)!=OK)
             return ERROR;
     }
     else if (HeaterId == HEATER_TYPE__DryerAirHeater) //AC Heaters
     {
+        ReportWithPackageFilter(HeatersFilter,"call PrepareACHeater",__FILE__,HeaterId,SetTemperatue,RpWarning,HeaterPreviousRead[HeaterId], 0);
         PrepareACHeater(HeaterId,Frequency,SetTemperatue);
     }
     return OK;
@@ -779,11 +782,17 @@ bool HeaterGetOverTemperatureState(uint8_t HeaterId)
     return HeaterMaxTempFlag[HeaterId];
 }
 uint32_t MainPT100Read = 0,SecondaryPT100Read = 0;
+int MinuteCallerMaxAc = 0,MinuteCallerMaxDc = 0,MinuteCallerAc = 0,MinuteCallerDc = 0;
 uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=HEATER_TYPE_MAX_HEATERS;
     int32_t MaxreadValue;
 
+    if (MinuteCallerMaxAc++ >= 60)
+    {
+        MinuteCallerMaxAc = 0;
+        ReportWithPackageFilter(HeatersFilter, "MinuteCallerMaxAc",__FILE__,__LINE__,IfIndex,RpError, readValue,0);
+    }
     if (IfIndex>>8 != IfTypeHeaters)
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
@@ -857,6 +866,11 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=HEATER_TYPE_MAX_HEATERS;
+    if (MinuteCallerMaxDc++ >= 60*10)
+    {
+        MinuteCallerMaxDc = 0;
+        ReportWithPackageFilter(HeatersFilter, "MinuteCallerMaxDc",__FILE__,__LINE__,IfIndex,RpError, readValue,0);
+    }
     if (IfIndex>>8 != IfTypeHeaters)
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
@@ -951,6 +965,11 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=HEATER_TYPE_MAX_HEATERS;
     //uint8_t len = 0;
+    if (MinuteCallerAc++ >= 60)
+    {
+        MinuteCallerAc = 0;
+        ReportWithPackageFilter(HeatersFilter, "MinuteCallerAc",__FILE__,__LINE__,IfIndex,RpError, readValue,0);
+    }
     if (IfIndex>>8 != IfTypeHeaters)
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
@@ -1150,6 +1169,11 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     int index=HEATER_TYPE_MAX_HEATERS;
     //int len;
    //uint8_t len = 0;
+    if (MinuteCallerDc++ >= 60*10)
+    {
+        MinuteCallerDc = 0;
+        ReportWithPackageFilter(HeatersFilter, "MinuteCallerDc",__FILE__,__LINE__,IfIndex,RpError, readValue,0);
+    }
     if (IfIndex>>8 != IfTypeHeaters)
     {
         ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index a183ec996..1984420f3 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -25,8 +25,8 @@
 #define CloseValve MidTank_Dispenser
 #define OpenValve Dispenser_Mixer
 
-uint32_t CloseValveTimeout = 250;
-uint32_t OpenValveTimeout = 250;
+uint32_t CloseValveTimeout = 10;
+uint32_t OpenValveTimeout = 10;
 #define DISPENSER_BUILD_PRESSURE_SPEED 900
 #define DISPENSER_BUILD_PRESSURE_LIMIT 1.5
 #define DISPENSER_BUILD_PRESSURE_TIMEOUT 60000
@@ -54,8 +54,10 @@ void IDS_Dispenser_SetPrepareValues(    uint32_t DispenserBuildPressureSpeed,
 }
 void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout)
 {
+#ifndef SPECIAL_DISPENSERS
      CloseValveTimeout = CloseTimeout;
      OpenValveTimeout = OpenTimeout;
+#endif
      Report("IDS_Dispenser_SetTimeOutValues ",__FILE__,__LINE__,OpenValveTimeout,RpWarning,(int)CloseValveTimeout,0);
 }
 
@@ -249,10 +251,16 @@ void IDS_Dispenser_Content_Init (void)
     memcpy(&Bytes,(void *)DISPENSERS_MAP_IN_FLASH,sizeof(Bytes));
     bool havedata = false;
     DispenserData* StoredDispenserData;
-    if ((Bytes)&&(Bytes < 4000))
+    if ((Bytes)&&(Bytes < 500))
     {
-        StoredDispenserData = dispenser_data__unpack(NULL,Bytes,(DISPENSERS_MAP_IN_FLASH+4));
-        havedata = true;
+        buffer = my_malloc (Bytes);
+        if (buffer)
+        {
+            memcpy(buffer, (void *)(DISPENSERS_MAP_IN_FLASH+4),Bytes);
+            StoredDispenserData = dispenser_data__unpack(NULL,Bytes,buffer);
+            havedata = true;
+            free(buffer);
+        }
     }
     /*else
     {
@@ -267,18 +275,25 @@ void IDS_Dispenser_Content_Init (void)
     {
         for(i=0;i<MAX_SYSTEM_DISPENSERS;i++)
         {
-            memcpy (&IDS_Dispenser_Data[i],&StoredDispenserData->dispenserinfo[i],sizeof(DispenserRunningData));
+            //memcpy (&IDS_Dispenser_Data[i],&StoredDispenserData->dispenserinfo[i],sizeof(DispenserRunningData));
             IDS_Dispenser_Data[i].has_consumedinnanolitter = true;
             IDS_Dispenser_Data[i].has_totalconsumedinnanolitter = true;
             IDS_Dispenser_Data[i].has_direction = true;
             IDS_Dispenser_Data[i].has_microsteps = true;
             IDS_Dispenser_Data[i].has_numberofrefills = true;
             IDS_Dispenser_Data[i].has_nanolitterperpulse = true;
+            IDS_Dispenser_Data[i].consumedinnanolitter = StoredDispenserData->dispenserinfo[i]->consumedinnanolitter;
+            IDS_Dispenser_Data[i].totalconsumedinnanolitter = StoredDispenserData->dispenserinfo[i]->totalconsumedinnanolitter;
+            IDS_Dispenser_Data[i].direction = StoredDispenserData->dispenserinfo[i]->direction;
+            IDS_Dispenser_Data[i].microsteps = StoredDispenserData->dispenserinfo[i]->microsteps;
+            IDS_Dispenser_Data[i].numberofrefills = StoredDispenserData->dispenserinfo[i]->numberofrefills;
+            IDS_Dispenser_Data[i].nanolitterperpulse = StoredDispenserData->dispenserinfo[i]->nanolitterperpulse;
+            Report("IDS_Dispenser load data ",__FILE__,i,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].consumedinnanolitter,0);
         }
         dispenser_data__free_unpacked(StoredDispenserData,NULL);
         free (buffer);
     }
-    Report("IDS_Dispenser load data ",__FILE__,__LINE__,(int)Bytes,RpWarning,(int)IDS_Dispenser_Data[0].nanolitterperpulse*100,0);
+    //Report("IDS_Dispenser load data ",__FILE__,__LINE__,(int)Bytes,RpWarning,(int)IDS_Dispenser_Data[0].nanolitterperpulse*100,0);
     return;
 
     //==================================
@@ -299,6 +314,7 @@ uint32_t IDS_Dispenser_Store_Data (void)
     for(i=0;i<MAX_SYSTEM_DISPENSERS;i++)
     {
         StoreDispenserData.dispenserinfo[i] = &IDS_Dispenser_Data[i];
+        Report("IDS_Dispenser store data ",__FILE__,i,(int)IDS_Dispenser_Data[i].totalconsumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[i].consumedinnanolitter,0);
     }
 
 //    Report("IDS_Dispenser_Store_Data 0",__FILE__,(int)IDS_Dispenser_Data[0].totalconsumedinnanolitter,(int)IDS_Dispenser_Data[0].consumedinnanolitter,RpWarning,(int)IDS_Dispenser_Data[0].microsteps,0);
@@ -310,7 +326,7 @@ uint32_t IDS_Dispenser_Store_Data (void)
         EraseFlashSection(DISPENSERS_MAP_IN_FLASH,response_size+4);
         ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH, 4,&response_size);
         ReadAppAndProgram(DISPENSERS_MAP_IN_FLASH+4, response_size, dispensers_container_buffer);
-        Report("IDS_Dispenser_Store ",__FILE__,__LINE__,(int)response_size,RpWarning,(int)StoreDispenserData.dispenserinfo[4]->nanolitterperpulse *100,0);
+        //Report("IDS_Dispenser_Store ",__FILE__,__LINE__,(int)response_size,RpWarning,(int)StoreDispenserData.dispenserinfo[4]->nanolitterperpulse *100,0);
 
         /*Status = FileWrite(IDS_Dispenser_Data,response_size,DispenserStorePath,BIOS_NO_WAIT);
         if (Status == FR_OK)
@@ -350,7 +366,7 @@ void IDS_Dispenser_Content_Calculation (char DispenserId)
     }
     if (DispenserId == 0)
     {
-        if ((seconds_counter++>=90000)&&(DispenserDataUpdated == true))//90000)// - one hour)
+        if ((seconds_counter++>=900)&&(DispenserDataUpdated == true))//9000)// - one hour)
         {
             seconds_counter = 0;
             if (IDS_Dispenser_Data[DispenserId].consumedinnanolitter)
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 41452cbad..1ea37a07e 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -489,6 +489,12 @@ uint32_t IDS_Dispenser_Alarm_Off (uint8_t DispenserId)
     Report("IDS_Dispenser_Alarm_Off",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,0,0);
     return status;
 }
+uint32_t IDS_ReCheck_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
+{
+    Report("Pulling dispenser down result",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
+    SafeRemoveControlCallback(GetControlLowDevice_i(), IDS_ReCheck_Pressure_Callback );
+
+}
 uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
 {
     TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
@@ -510,6 +516,7 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
     {
         Report("Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
         MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,200*MotorsCfg[HW_Motor_Id].microstep);
+        AddControlCallback("IDS_ReCheck_Pressure", IDS_ReCheck_Pressure_Callback, eOneSecond*4,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
     }
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 05676dd9e..ad9d75941 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -497,11 +497,13 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
      if (pressureReady == false)
      {
+#ifndef SPECIAL_DISPENSERS
          if (DispenserBuildTimeCounter<(2*eOneSecond))
          {
              //REPORT_MSG(DispenserBuildTimeCounter,"waiting 2 seconds for pressure changes");
              return OK;
          }
+#endif
          for (i = 0; i < MAX_DYE_DISPENSERS; i++)
          {
              //IDS_StopHomeDispenser(i);
@@ -511,19 +513,33 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  if (GetDispenserPressure(i) > DispenserPreparePressure)
                  {
                      NumofReadyDispensers++;
+                     CurrentDispenserSpeed[i] = 0;
+#ifdef SPECIAL_DISPENSERS
+                     MotorStop(HW_Motor_Id, Hard_Hiz);
+                     //Report("IDS stopped ready",__FILE__,i,(int)(DispenserPreparePressure*100),RpWarning,(int)NumofReadyDispensers,0);
+#else
                      tempSpeed = CurrentDispenserSpeed[i];
                      updatedSpeed = (tempSpeed*0.985>100)?tempSpeed*0.985:100;
                      MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                      CurrentDispenserSpeed[i] = updatedSpeed;
                      //Report("IDS reduce speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+#endif
                  }
                  else
                  {
+#ifdef SPECIAL_DISPENSERS
+                     tempSpeed = (DispenserPreparePressure-GetDispenserPressure(i))*InitialDispenserSpeed;
+                     if (tempSpeed<300)
+                         tempSpeed = 300;
+#else
                      tempSpeed = CurrentDispenserSpeed[i];
+#endif
                      updatedSpeed = (tempSpeed*1.02<InitialDispenserSpeed)?tempSpeed*1.02:InitialDispenserSpeed;
                      MotorSetSpeed(HW_Motor_Id, updatedSpeed);
                      CurrentDispenserSpeed[i] = updatedSpeed;
+#ifdef SPECIAL_DISPENSERS
                      //Report("IDS accelerate speed",__FILE__,i,(int)tempSpeed,RpWarning,(int)updatedSpeed,0);
+#endif
                  }
              }
          }
@@ -544,6 +560,7 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              Report("pressureReady = true  or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
          }
      }
+#ifndef SPECIAL_DISPENSERS
      else if (endOfPrepareWCF == false)
      {
          if ((DispenserBuildTimeCounter == PRESSURE_READ_TIME_GAP)&&(FirstBrushStop))
@@ -631,8 +648,13 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
 
          }
      }
-         //start new stage
+#endif
+#ifdef SPECIAL_DISPENSERS
+     if (pressureReady == true)
+#else
+     //start new stage
      if (endOfPrepareWCF == true)
+#endif
      {
          SafeRemoveControlCallback(DispenserPrepareControlId, IDS_Prepare_Callback );
          DispenserPrepareControlId = 0xFF;
@@ -762,7 +784,11 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  {
                      Report("Prepare Speed",__FILE__,HomingActive[i],i,RpWarning,(int)dispenserspeed,0);
                      MotorSetDirection((TimerMotors_t)HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize); //set the dispenser to the
+#ifdef SPECIAL_DISPENSERS
+                     MotorSetSpeed((TimerMotors_t)HW_Motor_Id,dispenserspeed); //set the dispenser to the
+#else
                      IDS_Dispenser_Start_Motor_and_Open_Valve(i,dispenserspeed, NULL);
+#endif
                  }
                  /*else
                  {
@@ -899,7 +925,11 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                  {
                      if (DispenserUsedInJob[DispenserId] == true)
                      {
+#ifdef SPECIAL_DISPENSERS
+                         IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
+#else
                          MotorStop(HW_Motor_Id, Hard_Hiz);
+#endif
                          CurrentDispenserSpeed[Dispenser_i] = 0;
                          usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
                          Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
@@ -1019,7 +1049,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          //cleaning
          return OK;
      }
-
+#ifndef SPECIAL_DISPENSERS
      if ((InterSegmentStartWFCFDispensers > 12000)&&(InterSegmentStartWFCFDispensers == (InterSegmentStepsCount+12000)))
      {
 	 	//start prepare 4 seconds before wcf
@@ -1100,6 +1130,7 @@ uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback);
          //close waste valve one second before segment - trial
          Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
      }
+#endif
      return OK;
  }
 uint32_t IDSCheckSegmentData(void *SegmentDetails, int SegmentId)
@@ -1177,7 +1208,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
                 Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
                 return ERROR;
             }
-            Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)IntersegmentLength,0);
+            Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)lInterSegmentLength,0);
             /*if (EnableCleaning == true)
             {
                 InterSegmentStartSprayCleaner = 500;
@@ -1285,7 +1316,11 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             {
                 if (DispenserUsedInJob[DispenserId] == true)
                 {
+#ifdef SPECIAL_DISPENSERS
+                    IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
+#else
                     MotorStop(HW_Motor_Id,Soft_Hiz); //26/03/19 test  without valves
+#endif
                     CurrentDispenserSpeed[DispenserId] = 0;
                     //MotorSetSpeed(HW_Motor_Id, 5);
                     //CurrentDispenserSpeed[Dispenser_i] = 5;
@@ -1351,7 +1386,11 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                                                          segmentfirst_speed,
                                                          NULL);*/
                 //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+#ifdef SPECIAL_DISPENSERS
+                IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed, NULL);
+#else
                 MotorSetSpeed(HW_Motor_Id, segmentfirst_speed);
+#endif
                 CurrentDispenserSpeed[DispenserId] = segmentfirst_speed;
                 usnprintf(IdsMessage, 80,
                           "Dispenser %d nl/sec %d nl/pulse %d Pulse/sec %d speed %d steps %d/%d",
@@ -1370,7 +1409,11 @@ void IDS_StartBrushStop(int n_dispensers,  JobDispenser** Dispensers)
                 //IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);*/
                 if (DispenserUsedInJob[DispenserId] == true)
                 {
+#ifdef SPECIAL_DISPENSERS
+                    IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);
+#else
                     MotorStop(HW_Motor_Id, Hard_Hiz);
+#endif
                     CurrentDispenserSpeed[DispenserId] = 0;
                 }
                 //Report("inActive dispenser stopped", __FILE__, __LINE__, DispenserId, RpWarning,   segmentfirst_speed, 0);
@@ -1481,6 +1524,14 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
              LOG_ERROR(FileBrushStop,"BrushStopReadError");
          }
      }
+//handle ending of presegment
+    if (DispenserPreSegmentControlId != 0xFF)
+    {
+        Report("IDS presegment not yet ended!!",__FILE__,__LINE__,(int)InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
+        IDS_Cleaning_Stop_Cleaning_Solution (NULL);
+        RemoveControlCallback(DispenserPreSegmentControlId, IDSPreSegmentStateCallbackRunner );
+        DispenserPreSegmentControlId = 0xFF;
+    }
 
     IDS_StartBrushStop(n_dispensers, Dispensers);
     JobBrushStopId++;
@@ -1544,7 +1595,11 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
              if (DispenserUsedInJob[Dispenser_i]==false)//unconfigured dispenser
                  continue;
              DispenserDistanceToSpoolReady[Dispenser_i] = false;
+#ifdef SPECIAL_DISPENSERS
+             IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
+#else
              MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
+#endif
              Control3WayValvesWithCallback ((Valves_t)Dispenser_i, MidTank_Dispenser, IDS_Valve_DistanceToSpoolValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
              CurrentDispenserSpeed[Dispenser_i] = 0;
              //IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,IDS_Valve_DistanceToSpoolValveReady);
@@ -1618,11 +1673,17 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          DispenserPreSegmentControlId = 0xFF;
      }
 
+     IDS_Dispenser_Store_Data ();
+
      for ( Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
      {
          if (DispenserUsedInJob[Dispenser_i] == true)
          {
+#ifdef SPECIAL_DISPENSERS
+            IDS_Dispenser_Close_Valve_And_Stop_Motor(Dispenser_i,NULL);
+#else
             MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
+#endif
             Control3WayValvesWithCallback (Dispenser_i, MidTank_Dispenser, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
             CurrentDispenserSpeed[Dispenser_i] = 0;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 98a67f561..cef7e5af0 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -413,12 +413,21 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
     if(request->amount == 0xB3)  //fast refresh for pressure
     {
         LOG_ERROR(request->amount,"keep alive test");
-
-        keepalivetest = true;
+        //keepalivetest = true;
         response.progress = keepalivetest;
         response.has_progress = true;
 
     }
+    else
+        if(request->amount == 0xB4)  //fast refresh for pressure
+        {
+            LOG_ERROR(request->amount,"IDS_Dispenser_Content_Init");
+            IDS_Dispenser_Content_Init();
+            //keepalivetest = true;
+            response.progress = keepalivetest;
+            response.has_progress = true;
+
+        }
     else     
 	if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 049e64a64..b9bbf3aab 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -401,6 +401,8 @@
         CallbackCounter++;
         //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
         MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 0, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
+        HeadCard_Actuators_Control(ACTOT, LOW,true);
+
         return OK;
     }
     uint32_t Thread_Load_Lift_Dancers(void)
@@ -508,6 +510,7 @@
         CallbackCounter++;
 //        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
         MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 2, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
+        HeadCard_Actuators_Control(ACTOT, LOW,false);
 
         return OK;
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 1c3326336..2484b9444 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -446,6 +446,7 @@ char TMessage[150];
 //char time[150];
 uint16_t BreakSensorCounter = 0;
 uint16_t BreakSensorLatchCounter = 0;
+bool FirstCalcInJob = true;
 uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
 //#define MAX_CONTROL_SAMPLES 6
@@ -453,7 +454,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 //extern int MotorSamplePointer[MAX_THREAD_MOTORS_NUM];
 
     //read value is the dancer angle
-    int i,index=MAX_THREAD_MOTORS_NUM;
+    int i,index=MAX_THREAD_MOTORS_NUM,len;
     int DancerId;
     int32_t TranslatedReadValue, avreageSampleValue = 0;//,avreageMotorSampleValue = 0;
     //double tempcalcspeed = 0;
@@ -604,14 +605,15 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             return OK;
         }
         NormalizedError = avreageSampleValue*NormalizedErrorCoEfficient[index];
+        if ((index != FEEDER_MOTOR)||(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].speedmaster == false)) //feeder unit handles errors opposite to left unit
+        {
+            NormalizedError = (-1*NormalizedError);
+        }
+
         MotorControlConfig[index].m_mesuredParam = NormalizedError;
         DancerError[DancerId] = NormalizedError;
         MotorControlConfig[index].m_calculatedError = PIDAlgorithmCalculation((float)MotorControlConfig[index].m_SetParam , (float)MotorControlConfig[index].m_mesuredParam,
                                                                               &MotorControlConfig[index].m_params,   &MotorControlConfig[index].m_preError, &MotorControlConfig[index].m_integral);
-        if ((index != FEEDER_MOTOR)||(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].speedmaster == false)) //feeder unit handles errors opposite to left unit
-        {
-            MotorControlConfig[index].m_calculatedError = (-1*MotorControlConfig[index].m_calculatedError);
-        }
         /*else
         {
             //KeepNormalizedError = NormalizedError;
@@ -637,14 +639,37 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
         }*/
         calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*OriginalMotorSpd_2PPS[index];
         //calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*CurrentControlledSpeed[index];
+        if (FirstCalcInJob == true)
+        {
+            if (index == FEEDER_MOTOR)
+            {
+                FirstCalcInJob = false;
+                len = usnprintf(TMessage, 150, "read %d avg %d error(6) %d integral(9) %d,delta(9) %d, calc(3) %d speed %d",
+                                ReadValue,avreageSampleValue,(int)(MotorControlConfig[index].m_mesuredParam*1000000),
+                                (int)(MotorControlConfig[index].m_integral*1000000000),(int)((MotorControlConfig[index].m_mesuredParam*MotorControlConfig[index].m_params.dt)*1000000000),
+                                (int)(MotorControlConfig[index].m_calculatedError*1000),(int)calculated_speed);
+                ReportWithPackageFilter(ThreadFilter,TMessage,__FILE__,__LINE__,DancerId,RpError,ReadValue,0);
+
+            }
+        }
+
 #ifndef TEST_PID_THREAD
         if (fabs(calculated_speed-CurrentControlledSpeed[index])> MotorControlConfig[index].m_ingnoreValue)
 #else
         if (index == FEEDER_MOTOR) //feeder unit handles errors opposite to left unit
 #endif
         {
-            CurrentControlledSpeed[index] = calculated_speed;
-            MotorSetSpeed(ThreadMotorIdToMotorId[index], calculated_speed);
+            if (calculated_speed>5.0)
+            {
+                CurrentControlledSpeed[index] = calculated_speed;
+                MotorSetSpeed(ThreadMotorIdToMotorId[index], calculated_speed);
+            }
+            else
+            {
+                if (calculated_speed<0)
+                ReportWithPackageFilter(ThreadFilter,"Negative speed",__FILE__,index,(int)OriginalMotorSpd_2PPS[index],RpWarning,(int)CurrentControlledSpeed[index],0);
+            }
+
             /*if (((JobCounter % 2000) == index*100)&&(index == WINDER_MOTOR)) //feeder unit handles errors opposite to left unit
             {
                 ReportWithPackageFilter(ThreadFilter,"MotorSpeedUpdated",__FILE__,index,(int)OriginalMotorSpd_2PPS[index],RpWarning,(int)CurrentControlledSpeed[index],0);
@@ -719,7 +744,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
 //********************************************************************************************************************
  uint32_t ThreadPrepareState(void *JobDetails)
 {
-    int Motor_i, HW_Motor_Id, Pid_Id;
+    int Motor_i,i, HW_Motor_Id, Pid_Id;
     JobTicket* JobTicket = JobDetails;
     CurrentSegmentId = 0;
 
@@ -742,6 +767,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
     EnableIntersegment = JobTicket->enableintersegment;
     IntersegmentLength = JobTicket->intersegmentlength;
 
+    FirstCalcInJob = true;
     if(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].speedmaster == false)
     {
         ThreadMotorIdToMotorId[FEEDER_MOTOR] = HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING;
@@ -791,7 +817,17 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
             MotorControlConfig[Motor_i].m_mesuredParam = 0;
             MotorControlConfig[Motor_i].m_preError = 0;
             MotorControlConfig[Motor_i].m_SetParam = 0;//need to update SetParams on presegment stage
-
+//////////////////////////////////////////////////
+            for (i = 0;i < (int)MotorsControl[Motor_i].pvinputfilterfactormode; i++)
+            {
+                if (Motor_i == DRYER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
+                    MotorSamples[Motor_i][i] = Control_Read_Dancer_Position(ThreadMotorIdToDancerId[Motor_i],0);  //reset the samples value for control beginning
+                else if ((Motor_i == POOLER_MOTOR)||(Motor_i == FEEDER_MOTOR))
+                    MotorSamples[Motor_i][i] = DancersCfg[ThreadMotorIdToDancerId[Motor_i]].zeropoint;
+                //MotorSpeedSamples[Motor_i][i] = 0;
+            }
+            MotorSamplePointer[Motor_i] = 0;
+/////////////////////////////////////////////////////
             MotorSetDirection((TimerMotors_t)HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize);
 
             if (Motor_i == FEEDER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
@@ -888,10 +924,11 @@ void SetOriginMotorSpeed(float process_speed)
         OriginalMotorSpd_2PPS[Motor_i] = (int) motor_speed;
         InitialDryerSpeed = 0.0;
         CurrentControlledSpeed[Motor_i] = (int) motor_speed;
-        //ReportWithPackageFilter(ThreadFilter,"Original Speed",__FILE__,Motor_i,motor_speed,RpWarning,process_speed,0);
+        if (process_speed > 1)
+            ReportWithPackageFilter(ThreadFilter,"Original Speed",__FILE__,Motor_i,(int)motor_speed,RpWarning,process_speed,0);
 
-        for (i = 0; i <= MAX_CONTROL_SAMPLES; i++)
-            MotorSpeedSamples[Motor_i][i] = motor_speed;
+       // for (i = 0; i <= MAX_CONTROL_SAMPLES; i++)
+       //     MotorSpeedSamples[Motor_i][i] = motor_speed;
     }
 }
 void ThreadPreSegmentEnded(void)
@@ -900,7 +937,7 @@ void ThreadPreSegmentEnded(void)
     REPORT_MSG (0,"First ThreadPreSegmentEnded");
     PreSegmentReady(Module_Thread,ModuleDone);
 }
-int DrierDivider = 10;
+int DrierDivider = 20;
 uint32_t ThreadDryerRampUp(uint32_t IfIndex, uint32_t BusyFlag)
 {
     InitialDryerSpeed += (OriginalMotorSpd_2PPS[DRYER_MOTOR]/DrierDivider);
@@ -943,7 +980,14 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
         PrepareState = false;
 #ifndef TEST_PID_THREAD
         // set the new speed in the dryer motor to the speed of the new segment
-        DrierDivider = dyeingspeed/5;  //ramp up drier in 5 cm/sec steps
+        if(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].speedmaster == false)
+        {
+            DrierDivider = dyeingspeed/3;  //ramp up drier in 5 cm/sec steps
+        }
+        else
+        {
+            DrierDivider = dyeingspeed/5;  //ramp up drier in 5 cm/sec steps
+        }
         ReportWithPackageFilter(ThreadFilter,"Drier ramp up",__FILE__,__LINE__,(int)dyeingspeed,RpWarning,(int)DrierDivider,0);
         InitialDryerSpeed = OriginalMotorSpd_2PPS[DRYER_MOTOR]/DrierDivider;
         MotorSetSpeed(ThreadMotorIdToMotorId[DRYER_MOTOR],InitialDryerSpeed );
@@ -1065,7 +1109,7 @@ char Endstr[150];
 {
      int Motor_i;
      ThreadControlActive = false;
-
+     uint32_t status = OK,tempCtl;
      usnprintf(Endstr, 100, "Total _processed length: Feeder: %d Pooler %d",(int)TotalProcessedLength,(int)PoolerTotalProcessedLength);
      SendJobProgress(0.0,0,false, Endstr);
      ReportWithPackageFilter(ThreadFilter,Endstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0);
@@ -1091,15 +1135,19 @@ char Endstr[150];
 
      for ( Motor_i = 0;Motor_i <= WINDER_MOTOR;Motor_i++)
      {
+         tempCtl = ControlIdtoMotorId[Motor_i];
          if (ControlIdtoMotorId[Motor_i] != 0xFF)
          {
-             if(RemoveControlCallback(ControlIdtoMotorId[Motor_i],ThreadControlCBFunction) == OK)
+             status = RemoveControlCallback(ControlIdtoMotorId[Motor_i],ThreadControlCBFunction);
+             if(status == OK)
                  ControlIdtoMotorId[Motor_i] = 0xFF;
              else
                  ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)ControlIdtoMotorId[Motor_i],0);
          }
+         //ReportWithPackageFilter(ThreadFilter,"Remove Control",__FILE__,Motor_i,(int)status,RpError,(int)tempCtl,0);
+
      }
-	 Task_sleep(10);
+	 Task_sleep(100);
      for ( Motor_i = 0;Motor_i <= WINDER_MOTOR;Motor_i++)
      {
         MotorStop(ThreadMotorIdToMotorId[Motor_i],Hard_Hiz);