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

28 files changed, 617 insertions, 75 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c
index 12f336749..067466f74 100644
--- a/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c
+++ b/Software/Embedded_SW/Embedded/Common/SWUpdate/FirmwareUpgrade.c
@@ -168,8 +168,8 @@ uint32_t    ActivateVersionRequestFunc(MessageContainer* requestContainer)
                 break;
             case     VERSION_FILE_DESTINATION__AlarmParams:
                     usnprintf(FullPath, 50,  "%s%s%s", request->path,"/", VersionPackage->filedescriptors[File_i]->filename);
-                    Fresult = f_unlink("//SYSINFO//ALARMPRM.CFG");
-                    Fresult |= f_rename (FullPath, "//SYSINFO//ALARMPRM.CFG");
+                    Fresult = f_unlink("//SYSINFO//ALARM.CFG");
+                    Fresult |= f_rename (FullPath, "//SYSINFO//ALARM.CFG");
                     AlarmHandlingLoadFile();
                     CurrentRunningFile++;
                 break;
diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
index 379975093..99fd6392a 100644
--- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
+++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
@@ -20,7 +20,7 @@ typedef struct
 } TangoVersion_t;
 
 
-TangoVersion_t _gTangoVersion = {1,4,6,4};
+TangoVersion_t _gTangoVersion = {1,4,6,5};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE; 
  char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d
diff --git a/Software/Embedded_SW/Embedded/Common/report/distributor.c b/Software/Embedded_SW/Embedded/Common/report/distributor.c
index 71d30f998..26b2f392c 100644
--- a/Software/Embedded_SW/Embedded/Common/report/distributor.c
+++ b/Software/Embedded_SW/Embedded/Common/report/distributor.c
@@ -198,6 +198,11 @@ STATUS reportDistribute(FormatType      format,
     INPUT_MESSAGE msg;
     int Distributor = GET_PRIVATE_SEVERITY(severity);
 
+    if (isReportActive() == false)
+    {
+        LogToFile(message,FileName, LineNumber,errorCode, severity, parameter1);
+    }
+
     if (Distributor > 0)
     {
         if (Dist_Table[Distributor].IsAlive == false)
diff --git a/Software/Embedded_SW/Embedded/Common/report/report.h b/Software/Embedded_SW/Embedded/Common/report/report.h
index eb0b64fab..35253ce80 100644
--- a/Software/Embedded_SW/Embedded/Common/report/report.h
+++ b/Software/Embedded_SW/Embedded/Common/report/report.h
@@ -127,6 +127,9 @@ uint32_t SetDebugLogCategoryFunc(MessageContainer* requestContainer);
 void SetupDebugDisributorsRequestFunc(MessageContainer* requestContainer);
 
 void ReportResetReason(void);
+uint32_t OpenLogFile(void);
+uint32_t CloseLogFile(void);
+bool isReportActive(void);
 
 
 /***************************************************************************
diff --git a/Software/Embedded_SW/Embedded/Common/report/reportInit.c b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
index 7417ab033..4fbae36bf 100644
--- a/Software/Embedded_SW/Embedded/Common/report/reportInit.c
+++ b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
@@ -63,8 +63,56 @@ PackageHandle LoadFilter;
 PackageHandle InitFilter;
 PackageHandle MaintFilter;
 
+char LogPath[50] = "0://ErrFile.txt";
 
 char protobufToken[36+1] = {0};
+char message[300];
+FRESULT LogFresult = FR_OK;
+FIL *LogFileHandle = 0;  //the system supports a single active file
+bool isReportActive(void)
+{
+    if (protobufToken[0] == 0)
+    {
+        return false;
+    }
+    return true;
+}
+uint32_t OpenLogFile(void)
+{
+    uint32_t Bytes = 0;
+    int len;
+    /*LogFresult = f_open(LogFileHandle,LogPath,FA_OPEN_ALWAYS | FA_WRITE | FA_READ);
+    if (LogFresult == FR_OK)
+    {
+        if (LogFileHandle->fsize < 100000)
+            f_lseek(LogFileHandle, LogFileHandle->fsize);
+        len = usnprintf(message, 80, "\r\n Log File %s %s",__DATE__, __TIME__);
+        LogFresult = f_write(LogFileHandle,message,len,&Bytes );
+    }*/
+    return LogFresult;
+}
+uint32_t CloseLogFile(void)
+{
+    /* perform default error output */
+    //f_close(LogFileHandle);
+
+}
+uint32_t LogToFile(char *message,       /* The formatted message                */
+                   char *FileName,
+                   int LineNumber,
+                       int errorCode,       /* error code that caused the report    */
+                       int Severity,      /* user parameter no. 1                 */
+                       int parameter)
+{
+    uint32_t Bytes = 0;
+    int len;
+
+        /* print user supplied error code */
+      /*  len = usnprintf(message, 300, "\r\n %s, file %s  line %d code %d sev %d,param %d",message,FileName, LineNumber,errorCode, Severity, parameter);
+        LogFresult = f_write(LogFileHandle,message,len,&Bytes );*/
+
+        return LogFresult;
+}
 int ReportResponseFunc(char *message,       /* The formatted message                */
                        char *FileName,
                        int LineNumber,
@@ -74,8 +122,9 @@ int ReportResponseFunc(char *message,       /* The formatted message
 {
     MessageContainer responseContainer;
     if (protobufToken[0] == 0)
+    {
 		return OK;
-
+    }
     StartDebugLogResponse response = START_DEBUG_LOG_RESPONSE__INIT;
     response.filename = FileName;
     response.has_linenumber = true;
@@ -221,6 +270,7 @@ uint32_t ReportInitMessage(MessageContainer* requestContainer)
     StartDebugLogRequest* request = start_debug_log_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
     ustrncpy (protobufToken, requestContainer->token,36);
     DistributorHandle ReportHandle = ReportAddDistributor("ProtoBuf");
+    CloseLogFile();
     if (ReportHandle == NULL) status |= 0x8;
     status |= ReportFunc(ReportResponseFunc , REPORT_ADD, ReportHandle);
     start_debug_log_request__free_unpacked(request,NULL);
@@ -330,6 +380,7 @@ return OK;
 void ReportStopReporting(void)
 {
     protobufToken[0] = 0;
+    OpenLogFile();
 }
 
 
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.c b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.c
index 7a4d3768d..1f2eeaf74 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.c
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.c
@@ -52,7 +52,7 @@ void   process_parameters__free_unpacked
   assert(message->base.descriptor == &process_parameters__descriptor);
   protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
 }
-static const ProtobufCFieldDescriptor process_parameters__field_descriptors[20] =
+static const ProtobufCFieldDescriptor process_parameters__field_descriptors[28] =
 {
   {
     "DyeingSpeed",
@@ -294,6 +294,102 @@ static const ProtobufCFieldDescriptor process_parameters__field_descriptors[20]
     0,             /* flags */
     0,NULL,NULL    /* reserved1,reserved2, etc */
   },
+  {
+    "HeadZone7Temp",
+    21,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(ProcessParameters, has_headzone7temp),
+    offsetof(ProcessParameters, headzone7temp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone8Temp",
+    22,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(ProcessParameters, has_headzone8temp),
+    offsetof(ProcessParameters, headzone8temp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone9Temp",
+    23,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(ProcessParameters, has_headzone9temp),
+    offsetof(ProcessParameters, headzone9temp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone10Temp",
+    24,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(ProcessParameters, has_headzone10temp),
+    offsetof(ProcessParameters, headzone10temp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone11Temp",
+    25,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(ProcessParameters, has_headzone11temp),
+    offsetof(ProcessParameters, headzone11temp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "HeadZone12Temp",
+    26,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(ProcessParameters, has_headzone12temp),
+    offsetof(ProcessParameters, headzone12temp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "StSpZone1Temp",
+    27,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(ProcessParameters, has_stspzone1temp),
+    offsetof(ProcessParameters, stspzone1temp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
+  {
+    "StSpZone2Temp",
+    28,
+    PROTOBUF_C_LABEL_OPTIONAL,
+    PROTOBUF_C_TYPE_DOUBLE,
+    offsetof(ProcessParameters, has_stspzone2temp),
+    offsetof(ProcessParameters, stspzone2temp),
+    NULL,
+    NULL,
+    0,             /* flags */
+    0,NULL,NULL    /* reserved1,reserved2, etc */
+  },
 };
 static const unsigned process_parameters__field_indices_by_name[] = {
   13,   /* field[13] = DryerAirFlow */
@@ -304,23 +400,31 @@ static const unsigned process_parameters__field_indices_by_name[] = {
   0,   /* field[0] = DyeingSpeed */
   3,   /* field[3] = FeederTension */
   18,   /* field[18] = HeadAirFlow */
+  23,   /* field[23] = HeadZone10Temp */
+  24,   /* field[24] = HeadZone11Temp */
+  25,   /* field[25] = HeadZone12Temp */
   7,   /* field[7] = HeadZone1Temp */
   8,   /* field[8] = HeadZone2Temp */
   9,   /* field[9] = HeadZone3Temp */
   10,   /* field[10] = HeadZone4Temp */
   11,   /* field[11] = HeadZone5Temp */
   12,   /* field[12] = HeadZone6Temp */
+  20,   /* field[20] = HeadZone7Temp */
+  21,   /* field[21] = HeadZone8Temp */
+  22,   /* field[22] = HeadZone9Temp */
   2,   /* field[2] = MaxInkUptake */
   1,   /* field[1] = MinInkUptake */
   6,   /* field[6] = MixerTemp */
   4,   /* field[4] = PullerTension */
+  26,   /* field[26] = StSpZone1Temp */
+  27,   /* field[27] = StSpZone2Temp */
   19,   /* field[19] = TableIndex */
   5,   /* field[5] = WinderTension */
 };
 static const ProtobufCIntRange process_parameters__number_ranges[1 + 1] =
 {
   { 1, 0 },
-  { 0, 20 }
+  { 0, 28 }
 };
 const ProtobufCMessageDescriptor process_parameters__descriptor =
 {
@@ -330,7 +434,7 @@ const ProtobufCMessageDescriptor process_parameters__descriptor =
   "ProcessParameters",
   "",
   sizeof(ProcessParameters),
-  20,
+  28,
   process_parameters__field_descriptors,
   process_parameters__field_indices_by_name,
   1,  process_parameters__number_ranges,
diff --git a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.h b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.h
index 093e64d70..97376a881 100644
--- a/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.h
+++ b/Software/Embedded_SW/Embedded/Communication/PMR/Printing/ProcessParameters.pb-c.h
@@ -66,10 +66,26 @@ struct  _ProcessParameters
   double headairflow;
   protobuf_c_boolean has_tableindex;
   int32_t tableindex;
+  protobuf_c_boolean has_headzone7temp;
+  double headzone7temp;
+  protobuf_c_boolean has_headzone8temp;
+  double headzone8temp;
+  protobuf_c_boolean has_headzone9temp;
+  double headzone9temp;
+  protobuf_c_boolean has_headzone10temp;
+  double headzone10temp;
+  protobuf_c_boolean has_headzone11temp;
+  double headzone11temp;
+  protobuf_c_boolean has_headzone12temp;
+  double headzone12temp;
+  protobuf_c_boolean has_stspzone1temp;
+  double stspzone1temp;
+  protobuf_c_boolean has_stspzone2temp;
+  double stspzone2temp;
 };
 #define PROCESS_PARAMETERS__INIT \
  { PROTOBUF_C_MESSAGE_INIT (&process_parameters__descriptor) \
-    , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+    , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 
 
 /* ProcessParameters methods */
diff --git a/Software/Embedded_SW/Embedded/DataDef.h b/Software/Embedded_SW/Embedded/DataDef.h
index 7305cf9bb..d14946d95 100644
--- a/Software/Embedded_SW/Embedded/DataDef.h
+++ b/Software/Embedded_SW/Embedded/DataDef.h
@@ -26,7 +26,7 @@
 //#define USE_POWERSTEP01
 
 //#define Use_Head_Card //for real card only
-
+//#define SPECIAL_DISPENSERS
 //#define Use_WHS_Card //for real card only
 //#define Test_headCard_With_DispCard_I2C4_Add0xE2_DispID_0
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
index 5630e8b5f..9062c79ca 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Heater/Heater.c
@@ -65,7 +65,8 @@ HardwarePidControlType HeaterIdtoHeaterpid[HEATER_TYPE_MAX_HEATERS ]=
 { HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2,
   HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6,HARDWARE_PID_CONTROL_TYPE__MixerHeater,
   HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9,
-  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12};
+  HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12,
+  HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1,HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2};
 HeaterType HeaterTypetoHeadHeater[HEATER_TYPE_MAX_HEATERS] = {HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,HEATER_TYPE_MAX_HEATERS,HEADCARD_HIT_ZN1,HEADCARD_HIT_ZN2,HEADCARD_HIT_ZN3,HEADCARD_HIT_ZN4,HEADCARD_HIT_ZN5,HEADCARD_HIT_ZN6,
     HEADCARD_HIT_MIXER,HEADCARD_HIT_ZN7,HEADCARD_HIT_ZN8,HEADCARD_HIT_ZN9,HEADCARD_HIT_ZN10,HEADCARD_HIT_ZN11,HEADCARD_HIT_ZN12,HEADCARD_UPPER_HIT_IN1,HEADCARD_UPPER_HIT_OUT1};
 HEADCARD_HEATERS_ENUM HeadHeatertoHeaterType[HEADCARD_HIT_MIXER+1] = {HEATER_TYPE__HeaterZone1,HEATER_TYPE__HeaterZone2,HEATER_TYPE__HeaterZone3,HEATER_TYPE__HeaterZone4,HEATER_TYPE__HeaterZone5,HEATER_TYPE__HeaterZone6,
@@ -94,6 +95,8 @@ bool isHeater(HardwarePidControlType HeaterId)
       case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10:
       case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11:
       case HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12:
+      case HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater1:
+      case HARDWARE_PID_CONTROL_TYPE__HeadCoverHeater2:
         return true;
     default:
         return false;
diff --git a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
index 57b64fdfa..6152d32ac 100644
--- a/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
+++ b/Software/Embedded_SW/Embedded/Drivers/I2C_Communication/I2C_Comm.c
@@ -114,9 +114,11 @@ uint32_t I2C_WriteBuff(uint32_t I2C_BASE, unsigned char addr, unsigned char* dat
         {
             Arb_Loss_Count= 0;
             Init_All_I2C();
-            Report("Reinitializing I2C master", __FILE__,__LINE__,status, RpMessage,Task_self(), 0);
+            Report("Reinitializing I2C master", __FILE__,Arb_Loss_Count,status, RpMessage,Task_self(), 0);
         }
     }
+    else
+        Arb_Loss_Count = 0;
     return status;
 }
 
@@ -188,9 +190,11 @@ uint32_t I2C_ReadBuff(uint32_t I2C_BASE, unsigned char addr, unsigned char* data
         {
             Arb_Loss_Count= 0;
             Init_All_I2C();
-            Report("Reinitializing I2C master", __FILE__,__LINE__,status, RpMessage,Task_self(), 0);
+            Report("Reinitializing I2C master", __FILE__,Arb_Loss_Count,status, RpMessage,Task_self(), 0);
         }
     }
+    else
+        Arb_Loss_Count = 0;
     return status;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c b/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c
index 81858a574..d29ccefca 100644
--- a/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c
+++ b/Software/Embedded_SW/Embedded/Drivers/USB_Communication/USBCDCD.c
@@ -655,13 +655,13 @@ void handleRx(void)
                 buffId = initArray( expected_message_size);
                 if (buffId == 0xFF)
                 {
-                    LOG_ERROR(expected_message_size,"usb message length error");
+                    //LOG_ERROR(expected_message_size,"usb message length error");
+                    Report("usb message length error", __FILE__, __LINE__, expected_message_size, RpWarning,   (int)buffId, 0);
                     keep_expected_message_size = expected_message_size;
                     expected_message_size = 0;
                     size_bar = 0;
                     FileChunkUploadError();
                 }
-                //Report("usb message length", __FILE__, __LINE__, expected_message_size, RpWarning,   (int)buffId, 0);
             }
         }
     }
diff --git a/Software/Embedded_SW/Embedded/Main.c b/Software/Embedded_SW/Embedded/Main.c
index 3616404d1..90b303ddb 100644
--- a/Software/Embedded_SW/Embedded/Main.c
+++ b/Software/Embedded_SW/Embedded/Main.c
@@ -135,6 +135,7 @@ Void errHook(Error_Block *eb)
     site = Error_getSite(eb);
     eid = Error_getId(eb);
     eCode = Error_getCode(eb);
+    CloseLogFile();
     if (UpdateFlag == true)
         return;
     FileHandle = my_malloc(sizeof(FIL));
@@ -155,7 +156,7 @@ Void errHook(Error_Block *eb)
                             site->file,site->line);
             Fresult = f_write(FileHandle,message,len,&Bytes );
 
-            LOG_ERROR (eCode, "error # ");
+            //LOG_ERROR (eCode, "error # ");
             /* check originator's mod id against known mods */
             if (site->mod == Main_Module_id()) {
                 Fresult = f_write(FileHandle,"\r\napp error: ",12,&Bytes );
@@ -236,6 +237,14 @@ int main(void)
         Init_EVB();
     #endif
 
+    FRESULT iFResult = Init_Flash_File_System(false);// true
+    if(iFResult != FR_OK)
+    {
+        LOG_ERROR (iFResult, "Error during init Flash File System");
+        assert(iFResult);
+    }
+    OpenLogFile();
+
    Init_All_I2C();
    Block_Main_MUX_TCA9548A_0xE4();//unused, same i2c as head and whs cards
    Check_Head_Type_Via_EEPROM();
@@ -294,13 +303,6 @@ int main(void)
 
     //calibration(); //test vme communication
 
-    FRESULT iFResult = Init_Flash_File_System(false);// true
-    if(iFResult != FR_OK)
-    {
-        LOG_ERROR (iFResult, "Error during init Flash File System");
-        assert(iFResult);
-    }
-
     //GetFiles(); - to start jtag
     //GetVmeByte();
 
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);
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
index 7eaabe346..03909bb56 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
@@ -418,9 +418,10 @@ uint32_t PowerOffTurnOffDryerFan(void)
     Control_Dryer_Fan(STOP,75);//use START or STOP,  0 - 100%
     PowerOffMachineState++;
 
+#ifndef SPECIAL_DISPENSERS
     for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
         Control3WayValvesWithCallback ((Valves_t)i, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
-
+#endif
 
     //TBD
     return OK;
@@ -545,11 +546,11 @@ uint32_t PowerDownUpdate(POWER_OFF_STAGES_ENUM stage)
     case POWER_OFF_HEAD_CLEAN:
         response.state = stage +1;
         response.message = "Head Cleaning running";
-        response.progresspercentage = 5.0;
-        if ((HeaterCheckReady())&&(PoolerTotalProcessedLength < 1.0))
+        response.progresspercentage = 10.0;
+        if ((HeaterCheckReady()==false)&&(PoolerTotalProcessedLength < 1.0))
         {
             response.message = "Head Cleaning heating up";
-            response.progresspercentage = 10.0;
+            response.progresspercentage = 5.0;
         }
         calculate = (double)((PoolerTotalProcessedLength/job_length)*10);
         result = (int)calculate;
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
index 108249d80..b1edd61b0 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -248,10 +248,10 @@ uint32_t PrepareReady(int ModuleId, ModuleStateEnum result)
         return ERROR;
     if (PrepareWaiting[ModuleId] != ModuleWaiting)
     {
-        LOG_ERROR (ModuleId, "Message from unrelated module!!");
+        Report("module prepare from unrelated module!!", __FILE__, PrepareWaiting[ModuleId], ModuleId, RpError,   result, 0);
         return ERROR;
     }
-    REPORT_MSG(ModuleId,"module prepare called");
+    Report("module prepare called", __FILE__, __LINE__, ModuleId, RpWarning,   result, 0);
 
     PrepareWaiting[ModuleId] = result;
     //if (result == ModuleFail) status = ERROR;
@@ -786,6 +786,9 @@ void JobRequestFunc(MessageContainer* requestContainer)
                     //REPORT_MSG(0,"Process parameters in job request are not handled. push separately for now");
                     job_length = CurrentJob->length + dryerbufferMeters;
                     Report("job length ",__FILE__,job_length,(int)CurrentJob->length,RpWarning,(int)dryerbufferCentimeters,  0);
+                    if (Ticket->name)
+                        Report(Ticket->name,__FILE__,__LINE__,(int)Ticket->length,RpWarning,(int)Ticket->numberofunits,  0);
+
                     if (Ticket->spool)
                     {
                         if (InternalWindingConfigMessage(Ticket->spool)!= OK)
@@ -1194,6 +1197,7 @@ Void jobTask(UArg arg0, UArg arg1)
                 JobActive = false;
                 setmachineActive(false);
                 //SetMachineStatus(MACHINE_STATE__Error);
+                SetMachineStatus(MACHINE_STATE__Ready);
                 resetIdleCounter();
                 CurrentJob = NULL;
                   //if (CurrentRequest!= NULL)
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
index b209208a3..962bc37ee 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c
@@ -160,7 +160,6 @@ FRESULT CloseJobFile()
         SegmentPtr = NULL;
     }
     REPORT_MSG(Fresult,"CloseJobFile");
-    IDS_Dispenser_Store_Data ();
 
     return Fresult;
 }