version 1.4.6.0 - going forward

23 files changed, 449 insertions, 245 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index c7a3a5e22..daaf922cf 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -54,6 +54,8 @@
 #include "drivers/Heater/TemperatureSensor.h"
 #include "drivers/Flash_ram/FlashProgram.h"
 
+#include "drivers/Valves/Valve.h"
+
 Task_Handle AlarmHandling_Task_Handle;
 Mailbox_Handle          AlarmHandlingMsgQ = NULL;
 
@@ -213,22 +215,31 @@ AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
      {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE},
      {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE},
 
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_1_LOW_LEVEL},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_2_LOW_LEVEL},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_3_LOW_LEVEL},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_4_LOW_LEVEL},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_5_LOW_LEVEL},
-     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_6_LOW_LEVEL},
-     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_7_LOW_LEVEL},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,50/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_8_LOW_LEVEL},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY},
-     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_EMPTY},
-     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_EMPTY},
-     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,20/*500cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_1_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_2_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_3_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_4_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_5_LOW_LEVEL},
+     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_6_LOW_LEVEL},
+     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_7_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,500/*500cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_8_LOW_LEVEL},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY},
+     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_EMPTY},
+     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_EMPTY},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,200/*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY},
+
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_OVERFLOW},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_OVERFLOW},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_OVERFLOW},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_OVERFLOW},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_OVERFLOW},
+     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_OVERFLOW},
+     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_OVERFLOW},
+     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,1800/*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_OVERFLOW},
 
 
      {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  },
@@ -519,6 +530,7 @@ void     AlarmHandlingSetCurrentLimits(double currentalarmhighlimit,double curre
 {
     CurrentAlarmHighLimit = currentalarmhighlimit;
     CurrentAlarmLowLimit = currentalarmlowlimit;
+    ReportWithPackageFilter(AlarmFilter,"Alarm Current Limits", __FILE__,__LINE__,(int)(currentalarmhighlimit*100), RpMessage, (int)(currentalarmlowlimit*100), 0);
 }
 
 void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms, bool checkTamperAlarms, bool checkMotorAlarms)
@@ -605,6 +617,18 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever
                 }
             }
             break;
+        case ALARM_SOURCE_TYPE__FluidLevelAlarm:
+            if (Severity == DEBUG_LOG_CATEGORY__Error)
+            {
+                ReportWithPackageFilter(AlarmFilter,"fluid level alarm", __FILE__,AlarmItem[AlarmId].ModuleDeviceId,AlarmId, RpMessage, AlarmItem[AlarmId].AlarmSource, 0);
+                if (AlarmItem[AlarmId].EventType >= EVENT_TYPE__MID_TANK_1_OVERFLOW)
+                {
+                    Valve_Set(IDS_Id_to_AirValve[AlarmItem[AlarmId].DeviceId], AlarmItem[AlarmId].DeviceId );   //AlarmItem[AlarmId].DeviceId/ON
+                    Valve_Set(IDS_Id_to_CartrideValve[AlarmItem[AlarmId].DeviceId], AlarmItem[AlarmId].DeviceId );   //Atm_MidTank_OFF/ON
+                }
+            }
+
+            break;
         default:
             break;
     }
@@ -634,8 +658,8 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever
         {
             JobEndReason = getEndReason(AlarmId);
             AbortJob(AlarmReasonStr);
-            //Report(AlarmReasonStr, __FILE__,__LINE__,AlarmId, RpMessage, DEBUG_LOG_CATEGORY__Error, 0);
-            ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,AlarmId, RpMessage, DEBUG_LOG_CATEGORY__Error, 0);
+            //Report(AlarmReasonStr, __FILE__,__LINE__,AlarmId, RpMessage, Severity, 0);
+            ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,AlarmId, RpMessage, Severity, 0);
         }
         /*switch (AlarmItem[AlarmId].AlarmSource)
         {
@@ -752,19 +776,27 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
             if (AlarmState[Alarm_i].Status == true)
             {
                 status = JOB_TAMPER_ALARM;
+                ReportWithPackageFilter(AlarmFilter,"tamper alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                 AlarmId = Alarm_i;
                 break;
             }
         }
-        /*if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__FluidLevelAlarm)
+        if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__FluidLevelAlarm)
         {
             if (AlarmState[Alarm_i].Status == true)
             {
-                status = ERROR;
-                AlarmId = Alarm_i;
-                break;
+                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error)
+                {
+                    if (DispenserUsedInJob[AlarmItem[Alarm_i].DeviceId] == true)
+                    {
+                        status = ERROR;
+                        ReportWithPackageFilter(AlarmFilter,"fluid level alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+                        AlarmId = Alarm_i;
+                        break;
+                    }
+                }
             }
-        }*/
+        }
         if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__MotorAlarm)
         {
             if (AlarmState[Alarm_i].Status == true)
@@ -772,6 +804,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                 if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
 				{
 	                status = JOB_MOTOR_ALARM;
+                    ReportWithPackageFilter(AlarmFilter,"motor alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
     	            AlarmId = Alarm_i;
         	        break;
 				}
@@ -795,6 +828,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                             {
                                 status = JOB_TEMPERATURE_ALARM;
                                 AlarmId = Alarm_i;
+                                ReportWithPackageFilter(AlarmFilter,"temperature alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                                 break;
                             }
                         }
@@ -804,6 +838,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                             {
                                 status = JOB_TEMPERATURE_ALARM;
                                 AlarmId = Alarm_i;
+                                ReportWithPackageFilter(AlarmFilter,"temperature alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                                 break;
                             }
                         }
@@ -874,6 +909,13 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value)
 	                    AlarmState[Alarm_i].Status = value;
                     }
                     ReportWithPackageFilter(AlarmFilter,"Alarm ON ", __FILE__,AlarmState[Alarm_i].EventPtr,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
+                    if ((AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical)&&(JobIsActive()))
+                    {
+                        JobEndReason = getEndReason(Alarm_i);
+                        SendJobProgress(0.0,0, false, "Critical alarm!!!!");
+                        AbortJob("Critical alarm");
+                        ReportWithPackageFilter(AlarmFilter, AlarmReasonStr,__FILE__,__LINE__,Alarm_i,RpError, 0,0);
+                    }
                 }
                 else
                 {
@@ -900,7 +942,7 @@ uint32_t AlarmHandlingStart(void)
     if ( AlarmHandlingActive == false)
     {
             AlarmHandlingActive = true;
-            AlarmHandlingControlId = AddControlCallback(AlarmHandling_ControlTrigger,eTenMillisecond,TemplateDataReadCBFunction,0,0,0);
+            AlarmHandlingControlId = AddControlCallback("Alarm Handling",AlarmHandling_ControlTrigger,eTenMillisecond,TemplateDataReadCBFunction,0,0,0);
     }
     return OK;
 }
@@ -930,6 +972,8 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
     uint32_t drawer_small2;
     uint32_t drawer_small3;
 
+    double doubleValue = 0.0;
+
 
 
 
@@ -1027,20 +1071,22 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
             case ALARM_SOURCE_TYPE__CurrentAlarm:
                 if (CheckCurrentAlarms)
                  {
-                     if (Get_Heaters_Current_Integer(AlarmItem[Alarm_i].DeviceId, &value) == OK)
+                     if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
                      {
                          if (AlarmItem[Alarm_i].AlarmDirection == true)
                          {
-                             if ((value >= (AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (value <= (AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                             if ((doubleValue >= (AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
                              {
                                  Status = true;
+                                 //ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,AlarmItem[Alarm_i].EventType, RpMessage, (int)doubleValue, 0);
                              }
                          }
                          else
                          {
-                             if (value == 0)
+                             if (doubleValue <= 0.1)
                              {
                                  Status = true;
+                                 //ReportWithPackageFilter(AlarmFilter,"llop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,AlarmItem[Alarm_i].EventType, RpMessage, (int)doubleValue, 0);
                              }
                          }
 
@@ -1084,7 +1130,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     FluidLevelWarning = AlarmItem[Alarm_i].AlarmValue;
                 else if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error)
                     FluidLevelError = AlarmItem[Alarm_i].AlarmValue;
-                value = Get_MidTank_Int100_Sensor(AlarmItem[Alarm_i].DeviceId);
+                value = Get_MidTank_Int1000_Sensor(AlarmItem[Alarm_i].DeviceId);
                 if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE)
                 {
                     if (value > AlarmItem[Alarm_i].AlarmValue)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/DriverWithCallbackExample.c b/Software/Embedded_SW/Embedded/Modules/Control/DriverWithCallbackExample.c
index 881034e40..9dcb3affb 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/DriverWithCallbackExample.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/DriverWithCallbackExample.c
@@ -26,7 +26,7 @@ uint32_t DriverActionWithCallback (uint32_t deviceId, uint32_t parameter, callba
     ModuleCallback = callback;
     //start control:
 
-    uint32_t ControlId = AddControlCallback( callback,  eOneMillisecond, NULL, (IfTypeNone*0x100+deviceId),deviceId, parameter );
+    uint32_t ControlId = AddControlCallback(NULL, callback,  eOneMillisecond, NULL, (IfTypeNone*0x100+deviceId),deviceId, parameter );
     return ControlId;
 
 }
@@ -38,7 +38,7 @@ uint32_t ControlCallBackFunction(uint32_t deviceId, uint32_t ReadValue)
            //stop this control loop
            RemoveControlCallback(deviceId, ControlCallBackFunction );
            //possibly: start regular control (speed etc)
-           //uint32_t ControlId = AddControlCallback(ControlCBFunction Callback,  eOneMillisecond, NULL, deviceId, Parameter );
+           //uint32_t ControlId = AddControlCallback(NULL,ControlCBFunction Callback,  eOneMillisecond, NULL, deviceId, Parameter );
 
            //call the module callback
            ModuleCallback(deviceId,ReadValue);
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 53ddda9f9..7e5020336 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -38,6 +38,7 @@
 #include <drivers/FPGA/FPGA_Comm.h>
 #include "drivers/Valves/Valve.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
+#include "Drivers/I2C_Communication/I2C.h"
 
 #include "modules/thread/thread_ex.h"
 #include "modules/ids/ids_ex.h"
@@ -557,7 +558,6 @@ uint32_t MillisecLowLoop(uint32_t tick)
             for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
             {
                 CalculateDispenserPressure(Disp_i);
-                //Read_MidTank_Pressure_Sensor(Disp_i);
             }
             ADC_TriggerCollection();
         }
@@ -576,13 +576,13 @@ uint32_t MillisecLowLoop(uint32_t tick)
             for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
             {
                 CalculateDispenserPressure(Disp_i);
-                //Read_MidTank_Pressure_Sensor(Disp_i);
             }
         }
         FPGA_GetAllDispensersValveBusyOCD();
         temp = Read_Fans_Tacho();
         DrawerFansStatus = temp & 0x1F;
         SystemFansStatus = temp & 0xE0;
+        MachineUpdateResponseFunc();
         //KeepAliveOneSecondCall();
         for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++)
         {
@@ -593,24 +593,25 @@ uint32_t MillisecLowLoop(uint32_t tick)
         }
         if (!(OneMinute_Tick))
         {
-            for (Heater_i = 0;Heater_i < NUM_OF_CURRENT_HEATERS;Heater_i++)
+            Trigger_Heater_Current_Read();
+            /*for (Heater_i = 0;Heater_i < NUM_OF_CURRENT_HEATERS;Heater_i++)
             {
-                //Read_Heaters_Current(Heater_i);
-            }
+                Read_Heaters_Current(Heater_i);
+            }*/
         }
         for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++)
         {
             TemperatureCalc[Sensor_i] =  MillisecCalculateTemperatures ( Sensor_i);
         }
-        MachineUpdateResponseFunc();
     }
     if (OneMinute_Tick)
     {
-        for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
+        Trigger_MidTank_Pressure_Read();
+        /*for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
         {
             Read_MidTank_Pressure_Sensor(Disp_i);
-        }
-        //MachineUpdateResponseFunc();
+        }*/
+//        MachineUpdateResponseFunc();
         /*        for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++)
         {
             if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_SCREW)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index 80afb7ac6..b7d117efe 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -71,6 +71,7 @@ typedef struct
   DataReadCBFunction ControlDataReadPtr;
   ControlCBFunction ControlCallbackPtr;
   uint32_t ControlTiming;
+  char *Name;
 }ControlDeviceStruc;
 
 typedef enum
@@ -132,6 +133,7 @@ void ControlInit(void)
         ControlArray[Device_i].ControlCallbackPtr = NULL;
         ControlArray[Device_i].ControlDataReadPtr = NULL;
         ControlArray[Device_i].ControlTiming = eNoControl;
+        ControlArray[Device_i].Name = NULL;
     }
     gateControlDB = GateMutex_create(NULL, &eb);
     if (gateControlDB == NULL)
@@ -166,7 +168,10 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
         COMM_RED_LED_ON;
         ACTIVITY_RED_LED_OFF; // Heaters indication - all the Heaters OFF
         if(FPGA_WD_Occurred == true)
+        {
             ACTIVITY_GREEN_LED_ON;
+            HWConfigurationInit();
+        }
 
         if(power.color == fastBILNK)
             Pannel_Leds(POWER_ON_OFF,MODE_OFF);
@@ -298,7 +303,7 @@ void ControlStart(void)
         TimerEnable(Control_timerBase, TIMER_A);
 
         ADCAcquireStart(0,1);
-        AddControlCallback( ControlEmptyCBFunction,  eHundredMillisecond, ControlActivityLed,0, 0, 0 );
+        AddControlCallback("ControlActivityLed", ControlEmptyCBFunction,  eHundredMillisecond, ControlActivityLed,0, 0, 0 );
 
         SysCtlDelay(12000000);
         MillisecStart();
@@ -313,7 +318,7 @@ void ControlStart(void)
  * both these callbacks can be removed. if a new call is arriving, it invalidates the previous one (no dual control or data)
  *
  ***************************************************************************************************************************************************/
-uint32_t  AddControlCallback( ControlCBFunction Callback, uint32_t CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 )
+uint32_t  AddControlCallback(char* Name, ControlCBFunction Callback, uint32_t CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 )
 {
     assert(Callback);
     assert(DriverfPtr);
@@ -364,6 +369,7 @@ uint32_t  AddControlCallback( ControlCBFunction Callback, uint32_t CtrlFrequency
     ControlArray[deviceId].Parameter1 = Parameter1;
     ControlArray[deviceId].IfIndex = IfIndex;
     ControlArray[deviceId].StartTick = millisecondCounter;
+    ControlArray[deviceId].Name = Name;
     GateMutex_leave(gateControlDB, key);
     //LOG_ERROR(deviceId, "Add Callback");
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.h b/Software/Embedded_SW/Embedded/Modules/Control/control.h
index 450646a68..4b82aab30 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h
@@ -38,7 +38,7 @@ typedef enum
 void        ControlInit(void);
 void        ControlStop(void);
 void        ControlStart(void);
-uint32_t    AddControlCallback( ControlCBFunction Callback, uint32_t CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 );
+uint32_t    AddControlCallback(char *Name, ControlCBFunction Callback, uint32_t CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 );
 int         RemoveControlCallback(uint32_t deviceId, ControlCBFunction Callback );
 //The safe remove command can be used ONLY when called from the control callback itself
 int         SafeRemoveControlCallback(uint32_t deviceId , ControlCBFunction Callback);
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index 4597efa93..9a81854e6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -271,6 +271,12 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
         case INTERFACE_IOS__GPO_TFEED_BREAK_1:
                 Pumps_Control(WASTECH_PUMP2, request->value);
             break;
+        case INTERFACE_IOS__GPO_BUZZER:
+            if (request->value == true)
+                Buzzer(MODE_ON);//use START or STOP,  0 - 100%();
+            else
+                Buzzer(MODE_OFF);//use START or STOP,  0 - 100%();
+            break;
         default:
             responseContainer.has_error = true;
             responseContainer.error = ERROR_CODE__GENERAL_ERROR;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 6db76e842..d4e1636a5 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -63,7 +63,7 @@ uint32_t DiagnosticsStop(void);
 uint32_t Diagnostics_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t Diagnostics_OneSecControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
-uint32_t DispensersCollection(uint32_t IfIndex, uint32_t ReadValue);
+uint32_t Diagnostics_OneMinControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
 
 
 DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT;
@@ -100,12 +100,16 @@ double dryerzone3temperature[DIAGNOSTICS_LIMIT+1];
 
 double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1];
 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 HeatersCurrent[NUM_OF_CURRENT_HEATERS][1];
 double VOC_Sensor;
 
 DoubleArray DispenserFreq[MAX_SYSTEM_DISPENSERS];
 DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS];
+DoubleArray DispenserInkLevel[MAX_SYSTEM_DISPENSERS];
+DoubleArray DiagnosticsMidTankInkLevel[MAX_SYSTEM_DISPENSERS];
 
 HeaterState **heatersstates;
 HeaterState  HeaterInfo[HEATER_TYPE__MixerHeater+1];
@@ -136,6 +140,7 @@ typedef enum
     DiagnosticsTrigger,
     DiagnosticsTenMiliTrigger,
     DiagnosticsOneSecTrigger,
+    DiagnosticsOneMinuteTrigger
 }DiagnosticsMessages;
 
 typedef struct DiagnosticsMessage{
@@ -164,14 +169,16 @@ void DiagnosticsInit(void)
 
     DiagnosticsMsgQ = Mailbox_create(sizeof(DiagnosticsMessageStruc), 40, NULL,&eb);
 
-    DiagnosticsMonitor.dispensersmotorsfrequency = (DoubleArray**)my_malloc(sizeof(DoubleArray *)*8);
-    DiagnosticsMonitor.dispenserspressure = (DoubleArray**)my_malloc(sizeof(DoubleArray)*8);
-    DiagnosticsMonitor.dispenserslinearpositions = (DoubleArray**)my_malloc(sizeof(DoubleArray)*8);
-    DiagnosticsMonitor.dispensersangularencoders = (DoubleArray**)my_malloc(sizeof(DoubleArray)*8);
+    DiagnosticsMonitor.dispensersmotorsfrequency = (DoubleArray**)my_malloc(sizeof(DoubleArray *)*MAX_SYSTEM_DISPENSERS);
+    DiagnosticsMonitor.dispenserspressure = (DoubleArray**)my_malloc(sizeof(DoubleArray)*MAX_SYSTEM_DISPENSERS);
+    DiagnosticsMonitor.midtanksinklevel = (DoubleArray**)my_malloc(sizeof(DoubleArray)*MAX_SYSTEM_DISPENSERS);
+    DiagnosticsMonitor.dispensersinklevel = (DoubleArray**)my_malloc(sizeof(DoubleArray)*MAX_SYSTEM_DISPENSERS);
     for (i = 0; i<MAX_SYSTEM_DISPENSERS;i++)
     {
         double_array__init(&DispenserFreq[i]);
         double_array__init(&DiagnosticsDispenserPressure[i]);
+        double_array__init(&DiagnosticsMidTankInkLevel[i]);
+        double_array__init(&DispenserInkLevel[i]);
     }
     heatersstates = (HeaterState**)my_malloc(sizeof(HeaterState *)*(HEATER_TYPE__MixerHeater+1));
     for(i=0;i<=HEATER_TYPE__MixerHeater;i++)
@@ -366,6 +373,7 @@ void DiagnosticTenMsecCollection(void)
         return;
     /*if (JobIsActive()== false)
         return;*/
+
     DiagnosticLoadDancer(WINDER_DANCER,Control_Read_Dancer_Position(WINDER_DANCER, 0,0));
     DiagnosticLoadDancer(POOLER_DANCER,Control_Read_Dancer_Position(POOLER_DANCER, 0,0));
     DiagnosticLoadDancer(FEEDER_DANCER,Control_Read_Dancer_Position(FEEDER_DANCER, 0,0));
@@ -376,6 +384,105 @@ void DiagnosticTenMsecCollection(void)
 
     //DiagnosticLoadSpeedSensor(getSensorSpeedData());
 }
+void DiagnosticOneMinuteCollection(void)
+{
+    int i;
+
+    DiagnosticsMonitor.n_dispensersinklevel = 0;
+    DiagnosticsMonitor.n_midtanksinklevel = 0;
+    for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
+    {
+        MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
+        dispenserinklevel[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
+        midtankinklevel[i][0] = Get_MidTank_Pressure_Sensor(i);
+        if (DiagnosticsMonitor.dispensersinklevel)
+        {
+            DiagnosticsMonitor.n_dispensersinklevel = MAX_SYSTEM_DISPENSERS;
+            //DiagnosticsDispenserPressure[i] = dispenserspressure[i];
+            //double_array__init(&DiagnosticsDispenserPressure[i]);
+            DispenserInkLevel[i].data = dispenserinklevel[i];
+            DispenserInkLevel[i].n_data = 1;
+            DiagnosticsMonitor.dispensersinklevel[i] = &DispenserInkLevel[i];
+        }
+        if (DiagnosticsMonitor.midtanksinklevel)
+        {
+            DiagnosticsMonitor.n_midtanksinklevel = MAX_SYSTEM_DISPENSERS;
+            //DiagnosticsDispenserPressure[i] = dispenserspressure[i];
+            //double_array__init(&DiagnosticsDispenserPressure[i]);
+            DiagnosticsMidTankInkLevel[i].data = midtankinklevel[i];
+            DiagnosticsMidTankInkLevel[i].n_data = 1;
+            DiagnosticsMonitor.midtanksinklevel[i] = &DiagnosticsMidTankInkLevel[i];
+        }
+
+    }
+
+    DiagnosticsMonitor.n_midtank1level = 1;
+    DiagnosticsMonitor.midtank1level = MidTankpressure[0];
+    DiagnosticsMonitor.n_midtank2level = 1;
+    DiagnosticsMonitor.midtank2level = MidTankpressure[1];
+    DiagnosticsMonitor.n_midtank3level = 1;
+    DiagnosticsMonitor.midtank3level = MidTankpressure[2];
+    DiagnosticsMonitor.n_midtank4level = 1;
+    DiagnosticsMonitor.midtank4level = MidTankpressure[3];
+    DiagnosticsMonitor.n_midtank5level = 1;
+    DiagnosticsMonitor.midtank5level = MidTankpressure[4];
+    DiagnosticsMonitor.n_midtank6level = 1;
+    DiagnosticsMonitor.midtank6level = MidTankpressure[5];
+    DiagnosticsMonitor.n_midtank7level = 1;
+    DiagnosticsMonitor.midtank7level = MidTankpressure[6];
+    DiagnosticsMonitor.n_midtank8level = 1;
+    DiagnosticsMonitor.midtank8level = MidTankpressure[7];
+
+    for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
+    {
+        if (Read_Head_MixChip_Heaters_Current(i) == true)
+        {
+            HeatersCurrent[i][0] = Get_Heaters_Current(i);
+            switch(i)
+            {
+            case HEATER_DRYER_CURRENT_1:
+                DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
+                DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
+                break;
+            case HEATER_DRYER_CURRENT_2:
+                DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
+                DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];
+                break;
+            case HEATER_MIXCHIP_CURRENT:
+                DiagnosticsMonitor.n_mixer1heatercurrent = 1;
+                DiagnosticsMonitor.mixer1heatercurrent = HeatersCurrent[HEATER_MIXCHIP_CURRENT];
+                break;
+            case HEATER_HEAD_CURRENT_ZONE_1:
+                DiagnosticsMonitor.n_headzone1heatercurrent = 1;
+                DiagnosticsMonitor.headzone1heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_1];
+                break;
+            case HEATER_HEAD_CURRENT_ZONE_2:
+                DiagnosticsMonitor.n_headzone2heatercurrent = 1;
+                DiagnosticsMonitor.headzone2heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_2];
+                break;
+            case HEATER_HEAD_CURRENT_ZONE_3:
+                DiagnosticsMonitor.n_headzone3heatercurrent = 1;
+                DiagnosticsMonitor.headzone3heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_3];
+                break;
+            case HEATER_HEAD_CURRENT_ZONE_4:
+                DiagnosticsMonitor.n_headzone4heatercurrent = 1;
+                DiagnosticsMonitor.headzone4heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_4];
+                break;
+            case HEATER_HEAD_CURRENT_ZONE_5_6:
+                DiagnosticsMonitor.n_headzone5_6heatercurrent = 1;
+                DiagnosticsMonitor.headzone5_6heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6];
+                break;
+            default:
+                break;
+            }
+        }
+    }
+
+    VOC_Sensor = (double) getGasReading();
+    DiagnosticsMonitor.n_filterdeltapressure = 1;
+    DiagnosticsMonitor.filterdeltapressure = &VOC_Sensor;
+
+}
 void DiagnosticOneSecCollection(void)
 {
     int i;
@@ -396,11 +503,7 @@ void DiagnosticOneSecCollection(void)
         //dispensermotorfrequency[i][DiagnosticsIndex] = IDS_Dispenser_Data[i].consumedinnanolitter;
 
         dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
-        //if (midtankDisplay)
-            MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
-        //else
-        //    MidTankpressure[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
-        //double dispcapacity = (1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000))*130*1000*1000;
+
     }
 }
 void Diagnostic100msecCollection(void)
@@ -410,7 +513,7 @@ void Diagnostic100msecCollection(void)
         return;
 
     //DiagnosticLoadSpeedSensor(getSensorSpeedData());
-    if (DiagnosticMode == Diagnostic_Extreme_Mode)
+    if (DiagnosticMode == Diagnostic_Extended_Mode)
         DiagnosticTenMsecCollection(); //call the 10msec function every 100 msec to reduce transport
 
     if (DiagnosticMode >= Diagnostic_Extended_Mode)
@@ -448,13 +551,7 @@ void Diagnostic100msecCollection(void)
             MidTankpressure[i][0] = 1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000);
     }
     */
-    if (DiagnosticMode == Diagnostic_Extreme_Mode)
-    {
-        for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
-        {
-            HeatersCurrent[i][0] = Get_Heaters_Current(i);
-        }
-    }
+
    /*dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
      dispenser2motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2);
      dispenser3motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3);
@@ -620,6 +717,7 @@ void SendDiagnostics(void)
             DiagnosticsMonitor.dispenserspressure[i] = &DiagnosticsDispenserPressure[i];
         }
     }
+
     /**/
     DiagnosticsMonitor.n_dispenserslinearpositions = 0;
     DiagnosticsMonitor.n_dispensersangularencoders = 0;
@@ -642,43 +740,6 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.dispenser8pressure = dispenserspressure[7];
 
 
-    DiagnosticsMonitor.n_midtank1level = 1;
-    DiagnosticsMonitor.midtank1level = MidTankpressure[0];
-    DiagnosticsMonitor.n_midtank2level = 1;
-    DiagnosticsMonitor.midtank2level = MidTankpressure[1];
-    DiagnosticsMonitor.n_midtank3level = 1;
-    DiagnosticsMonitor.midtank3level = MidTankpressure[2];
-    DiagnosticsMonitor.n_midtank4level = 1;
-    DiagnosticsMonitor.midtank4level = MidTankpressure[3];
-    DiagnosticsMonitor.n_midtank5level = 1;
-    DiagnosticsMonitor.midtank5level = MidTankpressure[4];
-    DiagnosticsMonitor.n_midtank6level = 1;
-    DiagnosticsMonitor.midtank6level = MidTankpressure[5];
-    DiagnosticsMonitor.n_midtank7level = 1;
-    DiagnosticsMonitor.midtank7level = MidTankpressure[6];
-    DiagnosticsMonitor.n_midtank8level = 1;
-    DiagnosticsMonitor.midtank8level = MidTankpressure[7];
-
-    DiagnosticsMonitor.n_drierzone1heatercurrent = 1;
-    DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1];
-    DiagnosticsMonitor.n_drierzone2heatercurrent = 1;
-    DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2];
-    DiagnosticsMonitor.n_mixer1heatercurrent = 1;
-    DiagnosticsMonitor.mixer1heatercurrent = HeatersCurrent[HEATER_MIXCHIP_CURRENT];
-    DiagnosticsMonitor.n_headzone1heatercurrent = 1;
-    DiagnosticsMonitor.headzone1heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_1];
-    DiagnosticsMonitor.n_headzone2heatercurrent = 1;
-    DiagnosticsMonitor.headzone2heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_2];
-    DiagnosticsMonitor.n_headzone3heatercurrent = 1;
-    DiagnosticsMonitor.headzone3heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_3];
-    DiagnosticsMonitor.n_headzone4heatercurrent = 1;
-    DiagnosticsMonitor.headzone4heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_4];
-    DiagnosticsMonitor.n_headzone5_6heatercurrent = 1;
-    DiagnosticsMonitor.headzone5_6heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6];
-
-    VOC_Sensor = (double) getGasReading();
-    DiagnosticsMonitor.n_filterdeltapressure = 1;
-    DiagnosticsMonitor.filterdeltapressure = &VOC_Sensor;
 
     response.monitors = &DiagnosticsMonitor;
     //response.digitalpins = DigitalPinArray;
@@ -742,10 +803,31 @@ void SendDiagnostics(void)
         DiagnosticsStop();
     }
     DiagnosticsReset();
+/*    DiagnosticsMonitor.n_drierzone1heatercurrent = 0;
+    DiagnosticsMonitor.n_drierzone2heatercurrent = 0;
+    DiagnosticsMonitor.n_mixer1heatercurrent = 0;
+    DiagnosticsMonitor.n_headzone1heatercurrent = 0;
+    DiagnosticsMonitor.n_headzone2heatercurrent = 0;
+    DiagnosticsMonitor.n_headzone3heatercurrent = 0;
+    DiagnosticsMonitor.n_headzone4heatercurrent = 0;
+    DiagnosticsMonitor.n_headzone5_6heatercurrent = 0;
+    DiagnosticsMonitor.n_filterdeltapressure = 0;
+    DiagnosticsMonitor.n_midtank1level = 0;
+    DiagnosticsMonitor.n_midtank2level = 0;
+    DiagnosticsMonitor.n_midtank3level = 0;
+    DiagnosticsMonitor.n_midtank4level = 0;
+    DiagnosticsMonitor.n_midtank5level = 0;
+    DiagnosticsMonitor.n_midtank6level = 0;
+    DiagnosticsMonitor.n_midtank7level = 0;
+    DiagnosticsMonitor.n_midtank8level = 0;
+    DiagnosticsMonitor.n_dispensersinklevel = 0;
+    DiagnosticsMonitor.n_midtanksinklevel = 0;
+*/
 }
 uint32_t DiagnosticsControlId = 0xff;
 uint32_t Diagnostics10MSControlId = 0xff;
 uint32_t Diagnostics1SecControlId = 0xff;
+uint32_t Diagnostics1MinControlId = 0xFF;
 bool DiagnosticRequestAccepted = false;
 uint32_t DiagnosticsStart(void)
 {
@@ -756,17 +838,21 @@ uint32_t DiagnosticsStart(void)
         {
             DiagnosticsActive = true;
             if (DiagnosticsControlId == 0xFF)
-                DiagnosticsControlId = AddControlCallback(Diagnostics_ControlTrigger,DiagnosticLimit,TemplateDataReadCBFunction,0,0,0);
+                DiagnosticsControlId = AddControlCallback(NULL,Diagnostics_ControlTrigger,DiagnosticLimit,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
             if (Diagnostics10MSControlId == 0xFF)
-                Diagnostics10MSControlId = AddControlCallback(Diagnostics_TenMiliControlTrigger,DiagnosticFastLimit,TemplateDataReadCBFunction,0,0,0);
+                Diagnostics10MSControlId = AddControlCallback(NULL,Diagnostics_TenMiliControlTrigger,DiagnosticFastLimit,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
             if (Diagnostics1SecControlId == 0xFF)
-                Diagnostics1SecControlId = AddControlCallback(Diagnostics_OneSecControlTrigger,eOneSecond,TemplateDataReadCBFunction,0,0,0);
+                Diagnostics1SecControlId = AddControlCallback(NULL,Diagnostics_OneSecControlTrigger,eOneSecond,TemplateDataReadCBFunction,0,0,0);
             else
                 LOG_ERROR(Diagnostics1SecControlId,"Diagnostics restarted");
+            if (Diagnostics1MinControlId == 0xFF)
+                Diagnostics1MinControlId = AddControlCallback(NULL,Diagnostics_OneMinControlTrigger,eOneMinute,TemplateDataReadCBFunction,0,0,0);
+            else
+                LOG_ERROR(Diagnostics1MinControlId,"Diagnostics restarted");
        }
 
     }
@@ -783,10 +869,13 @@ uint32_t DiagnosticsStop(void)
             RemoveControlCallback(Diagnostics10MSControlId,Diagnostics_TenMiliControlTrigger);
         if (Diagnostics1SecControlId != 0xFF)
             RemoveControlCallback(Diagnostics1SecControlId,Diagnostics_OneSecControlTrigger);
+        if (Diagnostics1MinControlId != 0xFF)
+            RemoveControlCallback(Diagnostics1MinControlId,Diagnostics_OneMinControlTrigger);
 
         DiagnosticsControlId = 0xFF;
         Diagnostics10MSControlId = 0xFF;
         Diagnostics1SecControlId = 0xFF;
+        Diagnostics1MinControlId = 0xFF;
 
     }
     return OK;
@@ -848,7 +937,6 @@ uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
 
     if (DiagnosticMode == Diagnostic_Extreme_Mode)
     {
-        //send message to the Millisec task
         Message.messageId = DiagnosticsTenMiliTrigger;
         Message.msglen = sizeof(DiagnosticsMessageStruc);
         if (DiagnosticsMsgQ != NULL)
@@ -861,7 +949,6 @@ uint32_t Diagnostics_OneSecControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
 {
     DiagnosticsMessageStruc Message;
 
-    //send message to the Millisec task
     Message.messageId = DiagnosticsOneSecTrigger;
     Message.msglen = sizeof(DiagnosticsMessageStruc);
     if (DiagnosticsMsgQ != NULL)
@@ -870,6 +957,18 @@ uint32_t Diagnostics_OneSecControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
 
     return OK;
 }
+uint32_t Diagnostics_OneMinControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
+{
+    DiagnosticsMessageStruc Message;
+
+    Message.messageId = DiagnosticsOneMinuteTrigger;
+    Message.msglen = sizeof(DiagnosticsMessageStruc);
+    if (DiagnosticsMsgQ != NULL)
+        Mailbox_post(DiagnosticsMsgQ , &Message, BIOS_NO_WAIT);
+
+
+    return OK;
+}
 /******************************************************************************
  *  ======== messageTsk ========
  *  Task for this function is created statically. See the project's .cfg file.
@@ -893,11 +992,15 @@ void DiagnosticsTask(UArg arg0, UArg arg1)
                 Diagnostic100msecCollection();
                 break;
             case DiagnosticsTenMiliTrigger:
-                DiagnosticTenMsecCollection();
+                if (DiagnosticMode >= Diagnostic_Extreme_Mode)
+                    DiagnosticTenMsecCollection();
                 break;
             case DiagnosticsOneSecTrigger:
                 DiagnosticOneSecCollection();
                 break;
+            case DiagnosticsOneMinuteTrigger:
+                DiagnosticOneMinuteCollection();
+                break;
             default:
                 break;
         }
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 14c083b4d..497556878 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -27,6 +27,7 @@
 #include "drivers/Motors/Motor.h"
 #include "drivers/Valves/Valve.h"
 #include "Drivers/I2C_Communication/DAC/blower.h"
+#include "drivers/Flash_ram/MCU_E2Prom.h"
 
 #include "ids/ids_ex.h"
 #include "General/process.h"
@@ -57,7 +58,7 @@ return OK;
 uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
 {
     uint32_t numberOfSteps = 0;
-    uint32_t LoadArmRounds = (int)dryerbufferlength;
+    uint32_t LoadArmRounds = 0;
 
     MessageContainer responseContainer;
 
@@ -66,6 +67,12 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
     MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
 
     TimerMotors_t MotorId = (TimerMotors_t)request->motortype;
+
+    if (dryerbufferlength)
+        LoadArmRounds = (int)dryerbufferlength;
+    else
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmRounds);
+
     if (LoadArmRounds <= 2)
             LoadArmRounds = 20;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 58d1e1c37..dcbd6b9b0 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -214,7 +214,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
                 EmbeddedParameters->generalparameters[7] = AutoHoming_JobEnd_PowerOn_off; //
             }
             EmbeddedParameters->has_currentalarmlowlimit = true;
-            EmbeddedParameters->currentalarmlowlimit = 0.80;
+            EmbeddedParameters->currentalarmlowlimit = 0.77;
             EmbeddedParameters->has_currentalarmhighlimit = true;
             EmbeddedParameters->currentalarmhighlimit= 1.07;
             EmbeddedParameters->has_ids_segmentrefilltimeout = true;
@@ -485,7 +485,7 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         Enable_MidTank_Pressure_Reading(Dispenser_i);
         Valve_Set(IDS_Id_to_AirValve[Dispenser_i], Atm_MidTank_ON );   //Atm_MidTank_OFF/ON
     }
-    GenHWControlId = AddControlCallback( GenHWInitCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
+    GenHWControlId = AddControlCallback(NULL, GenHWInitCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
 */
     ControlStart();
     AlarmHandlingStart();
diff --git a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
index ff4909438..4958139e6 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/MachineStatus.c
@@ -68,7 +68,7 @@ int MachineUpdateResponseFunc(void)
             double dispcapacity = (1.00-(IDS_Dispenser_Data[i].consumedinnanolitter/5800000))*130*1000*1000;
             IDS_Level[i].dispenserlevel = (int32_t)dispcapacity;
             IDS_Level[i].has_midtanklevel = true;
-            IDS_Level[i].midtanklevel = Get_MidTank_Int100_Sensor(i);
+            IDS_Level[i].midtanklevel = Get_MidTank_Int1000_Sensor(i);
             MachineStatus.idspackslevels[MachineStatus.n_idspackslevels] = &IDS_Level[i];
             MachineStatus.n_idspackslevels++;
         }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/Safety.c b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
index a5a586e07..6a0b9a67b 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/Safety.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/Safety.c
@@ -33,7 +33,7 @@ bool AirFilterAlarmState = false;
 bool WasteOverflowAlarmState = false;
 void Safety_Init(void)
 {
-    SafetyControlId = AddControlCallback( Safety_Main_State, eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
+    SafetyControlId = AddControlCallback("Safety", Safety_Main_State, eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
     //return;
 }
 uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
@@ -110,6 +110,10 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
                        //report dispenser over pressure
                        AlarmHandlingSetAlarm(EVENT_TYPE__DISPENSER_1_OVERPRESSURE+Disp_i, true);
                        DispenserAlarm[Disp_i] = EVENT_TYPE__DISPENSER_1_OVERPRESSURE+Disp_i;
+                       if (DispenserAlarm[Disp_i] == false)
+                       {
+                           IDS_Dispenser_Alarm_On(Disp_i);
+                       }
                        DispenserOverPressure[Disp_i] = true;
                        Report("Dispenser Safety - over pressure", __FILE__,__LINE__,Disp_i, RpFatalError, (int)(1000*GetDispenserPressure(Disp_i)), 0);
                    }
@@ -117,6 +121,10 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
                    {
                        AlarmHandlingSetAlarm(EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT+Disp_i, true);
                        DispenserAlarm[Disp_i] = EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT+Disp_i;
+                       if (DispenserAlarm[Disp_i] == false)
+                       {
+                           IDS_Dispenser_Alarm_On(Disp_i);
+                       }
                        DispenserOverPressure[Disp_i] = true;
                        Report("Dispenser upper hard limit", __FILE__,__LINE__,Disp_i, RpFatalError, Get_Notification_Disp_UP(Disp_i), 0);
                    }
@@ -124,12 +132,16 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
                    {
                        AlarmHandlingSetAlarm(EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT+Disp_i, true);
                        DispenserAlarm[Disp_i] = EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT+Disp_i;
+                       if (DispenserAlarm[Disp_i] == false)
+                       {
+                           IDS_Dispenser_Alarm_On(Disp_i);
+                       }
                        DispenserOverPressure[Disp_i] = true;
                        Report("Dispenser lower hard limit", __FILE__,__LINE__,Disp_i, RpFatalError, Get_Notification_Disp_Down(Disp_i), 0);
                    }
                    else
                    {
-                       Report("Dispenser unknown safety alarm", __FILE__,__LINE__,Disp_i, RpFatalError, 1-DispenserBypass, 0);
+                       Report("Dispenser unknown safety alarm", __FILE__,__LINE__,Disp_i, RpFatalError,Get_Notification_Disp_Full(Disp_i), 0);
                    }
 
                }
@@ -144,8 +156,11 @@ uint32_t Safety_Main_State(uint32_t IfIndex, uint32_t BusyFlag)
            {
                if (Check_Disp_Safety_Stop_Indication(Disp_i) == false)
                {
-                   //report dispenser over pressure
                    AlarmHandlingSetAlarm(DispenserAlarm[Disp_i], false);
+                   if (DispenserAlarm[Disp_i] == true)
+                   {
+                       IDS_Dispenser_Alarm_Off(Disp_i);
+                   }
                    DispenserAlarm[Disp_i] = 0;
                    DispenserOverPressure[Disp_i] = false;
                }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
index d5ed5cef9..0a5cfc2f3 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
@@ -210,7 +210,7 @@ uint32_t Buttons_Init(void)
     power.state = sttON; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING
     power.count = 0;
 
-    AddControlCallback( ButtonPowerCBFunction, BUTTONS_SAMPLE_TIME, ButtonPowerCallBackFunction, 0,0,0 ); // eFiftyMillisecond
+    AddControlCallback("ButtonPowerCB", ButtonPowerCBFunction, BUTTONS_SAMPLE_TIME, ButtonPowerCallBackFunction, 0,0,0 ); // eFiftyMillisecond
 
     strcpy(jog.bttn_name, "jog");
     jog.bttn_status = RELEASE;    // 0=RELEASE 1=PRESS
@@ -220,7 +220,7 @@ uint32_t Buttons_Init(void)
     jog.state = sttENABLE; // sttDISABLE, sttENABLE, sttJOGGING
     jog.count = 0;
 
-    AddControlCallback( ButtonJogCBFunction, BUTTONS_SAMPLE_TIME, ButtonJogCallBackFunction, 0,0,0 ); //
+    AddControlCallback("ButtonJogCB", ButtonJogCBFunction, BUTTONS_SAMPLE_TIME, ButtonJogCallBackFunction, 0,0,0 ); //
 
     strcpy(load.bttn_name, "load");
     load.bttn_status = RELEASE;    // 0=RELEASE 1=PRESS
@@ -229,7 +229,7 @@ uint32_t Buttons_Init(void)
     load.state = sttRDY; //
     load.count = 0;
 
-    AddControlCallback( ButtonLoadCBFunction, BUTTONS_SAMPLE_TIME, ButtonLoadCallBackFunction, 0,0,0 ); //
+    AddControlCallback("ButtonLoadCB", ButtonLoadCBFunction, BUTTONS_SAMPLE_TIME, ButtonLoadCallBackFunction, 0,0,0 ); //
 return OK;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 2eab5225d..a086fe898 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -276,7 +276,7 @@ void HeatersControlStart(void)
         {
             if (ControlIdtoInternalId [i] == 0xFF)
             {
-                ControlIdtoInternalId [i] = AddControlCallback( HeatersTestInternalAlarmsCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+i),0,0);
+                ControlIdtoInternalId [i] = AddControlCallback("Internal Heaters", HeatersTestInternalAlarmsCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+i),0,0);
             }
         }
     }
@@ -535,7 +535,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
 {
     if (ControlIdtoHeaterId [HeaterId] == 0xFF)
     {
-        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
+        ControlIdtoHeaterId [HeaterId] = AddControlCallback("HeatersControl", HeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
         //HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(DryerInternalPT100Id);
         HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//
         //ReportWithPackageFilter(HeatersFilter,"PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
@@ -579,7 +579,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
         AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);
 
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
-        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback("HeatersMax", DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
     Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
     Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
@@ -587,9 +587,9 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
     HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
     if (MainDryerHeaterMaxTempControl == 0xFF)
-        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
+        MainDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
     if (SecondDryerHeaterMaxTempControl == 0xFF)
-        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
+        SecondDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
     //InitialHeating = true;
     HeaterReady[HeaterId] = false;
     HeaterAtTemp[HeaterId] = false;
@@ -616,7 +616,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
 int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
 {
     if (DisasterControlId == 0xFF)
-        DisasterControlId = AddControlCallback( HeatersDisasterControl, eOneSecond,TemplateDataReadCBFunction,0,0, 0);
+        DisasterControlId = AddControlCallback("Heaters Disaster", HeatersDisasterControl, eOneSecond,TemplateDataReadCBFunction,0,0, 0);
 
     HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
     if((HeaterPreviousRead[HeaterId]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HeaterId]))
@@ -639,7 +639,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
         return ERROR;
     }
     if (ControlIdtoHeaterId [HeaterId] == 0xFF)
-        ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+        ControlIdtoHeaterId [HeaterId] = AddControlCallback("DCHeatersControl", DCHeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
     //HeaterPIDConfig[HeaterId].m_params.dt *=10;
     //DCInitialHeating[HeaterId] = true;
     HeaterReady[HeaterId] = false;
@@ -655,7 +655,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
 
     //ReportWithPackageFilter(HeatersFilter,"PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
-        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback("DcHeatersMax", DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
     return OK;
 }
@@ -697,7 +697,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
     int band = 10;
     if (HeaterControl[HeaterId].outputproportionalband)
     {
-        band = HeaterControl[HeaterId].outputproportionalband+2; //sometimes the dryer heat drops after PID starts.
+        band = HeaterControl[HeaterId].outputproportionalband+2; //sometimes after PID is started the temp is falling a little bit. we want to avoid an alarm
     }
     temp = SetTemperatue*(100+band);
     //temp = SetTemperatue*110.0;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
index a919ce4e1..3e2cf6ecb 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h
@@ -15,6 +15,7 @@ extern uint32_t DispenserPrepareTimeLag ;
 
 extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS];
 extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS];
+extern bool JobStartStopBackLash[MAX_SYSTEM_DISPENSERS];
 extern float DispenserPressure[MAX_SYSTEM_DISPENSERS];
 uint32_t DispenserConfigMessage(HardwareDispenser * request);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index b9ab97714..9c15885fc 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -111,7 +111,7 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
     {
         Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
     }
-    DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_Build_Pressure_Callback, DispenserPrepareTimeLag,TemplateDataReadCBFunction ,DispenserId, DispenserId, 0 );
+    DispenserControlId[DispenserId] = AddControlCallback(NULL, IDS_Dispenser_Build_Pressure_Callback, DispenserPrepareTimeLag,TemplateDataReadCBFunction ,DispenserId, DispenserId, 0 );
     if (DispenserControlId[DispenserId] == 0xFF)
         Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
     else
@@ -156,7 +156,7 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re
     if (DispenserControlId[DispenserId] != 0xFF)
         Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
 
-    DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_StopMotorCallback, CloseValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
+    DispenserControlId[DispenserId] = AddControlCallback(NULL, IDS_Dispenser_StopMotorCallback, CloseValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
     if (DispenserControlId[DispenserId] == 0xFF)
         Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
     else
@@ -207,7 +207,7 @@ uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpee
             Report("Cannot Add control callback",__FILE__,(int)DispenserId,GetControlCallbackFuncPtr(DispenserControlId[DispenserId]),RpWarning,(int)DispenserControlId[DispenserId],0);
         //Report("IDS_Dispenser_Start_Motor_and_Open_Valve",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
 
-        DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_OpenValveCallback, OpenValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
+        DispenserControlId[DispenserId] = AddControlCallback(NULL, IDS_Dispenser_OpenValveCallback, OpenValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
         if (DispenserControlId[DispenserId] == 0xFF)
             Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
         //else
@@ -235,6 +235,12 @@ void IDS_Dispenser_Content_Init (void)
         HW_Motor_Id = DispenserIdToMotorId[i];
         dispenser_running_data__init(&IDS_Dispenser_Data[i]);
         dispenserdata[i] = &IDS_Dispenser_Data[i];
+        IDS_Dispenser_Data[i].has_consumedinnanolitter = true;
+        IDS_Dispenser_Data[i].has_direction = true;
+        IDS_Dispenser_Data[i].has_microsteps = true;
+        IDS_Dispenser_Data[i].has_nanolitterperpulse = true;
+        IDS_Dispenser_Data[i].has_numberofrefills = true;
+        IDS_Dispenser_Data[i].has_totalconsumedinnanolitter = true;
         IDS_Dispenser_Data[i].nanolitterperpulse = DEFAULT_NANOLITER_PER_PULSE;
         IDS_Dispenser_Data[i].microsteps = MotorsCfg[HW_Motor_Id].microstep;
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 1302d262a..f3528d4c8 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -136,7 +136,7 @@ uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId,  uint32_t timeo
         DispenserBacklashControlId[DispenserId] = 0xFF;
         //return ERROR;
     }
-    DispenserBacklashControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserWaitForHomingEnd,eOneSecond , TemplateDataReadCBFunction,DispenserId,0, 0 );
+    DispenserBacklashControlId[DispenserId] = AddControlCallback(NULL, IDS_HomeDispenserWaitForHomingEnd,eOneSecond , TemplateDataReadCBFunction,DispenserId,0, 0 );
     if ( DispenserBacklashControlId[DispenserId] == 0xFF)
         return ERROR;
 
@@ -146,7 +146,7 @@ uint32_t IDS_HomeDispenserWaitForHomingEnd(uint32_t DispenserId,  uint32_t timeo
 uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue)
 {
     uint8_t DispenserId = motorId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1;
-    if ((GetDispenserPressure(DispenserId)>=InitialDispenserPressure)||(DispenserHomingTime[DispenserId]>InitialDispenserTimeout))
+    if ((GetDispenserPressure(DispenserId)>=InitialDispenserPressure)||(DispenserHomingTime[DispenserId]>InitialDispenserTimeout)||(JobStartStopBackLash[DispenserId] == true))
     {
         MotorStop(motorId,Hard_Hiz);
         CurrentDispenserSpeed[DispenserId] = 0;
@@ -161,6 +161,8 @@ uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue)
         Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
         Disable_MidTank_Pressure_Reading(DispenserId);
 
+        if (JobStartStopBackLash[DispenserId] == true)
+            JobStartStopBackLash[DispenserId] = false;
         Report("End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
         if (SafeRemoveControlCallback(DispenserHomingControlId[DispenserId], IDS_HomeDispenserBackMoveCallback )==OK)
             DispenserHomingControlId[DispenserId] = 0xFF;
@@ -191,7 +193,7 @@ uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue)
 //    HomingActive[DispenserId]= false;
     IDS_Dispenser_RefillEnded ( DispenserId, MotorsCfg[motorId].microstep);
     Report("Start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
-    DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
+    DispenserHomingControlId[DispenserId] = AddControlCallback(NULL, IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
     MotorSetDirection(motorId,MotorsCfg[motorId].directionthreadwize);
     Task_sleep(10);
     MotorSetSpeed(motorId, InitialDispenserSpeed);
@@ -213,7 +215,7 @@ uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr
     }
     if (Get_MidTank_Pressure_Sensor(DispenserId)<0.2)
     {
-        Report("IDS_HomeDispenser - Midtank is empty",__FILE__,Get_MidTank_Int100_Sensor(DispenserId),(int)DispenserId,RpWarning,LIMIT,0);
+        Report("IDS_HomeDispenser - Midtank is empty",__FILE__,Get_MidTank_Int1000_Sensor(DispenserId),(int)DispenserId,RpWarning,LIMIT,0);
         return ERROR;
     }
     //if Safety is active
@@ -363,7 +365,7 @@ uint32_t IDS_StopHomeDispenserBuildPressure (uint32_t DispenserId)
     }
 //    HomingActive[DispenserId]= false;
     Report("Start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0);
-    DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
+    DispenserHomingControlId[DispenserId] = AddControlCallback("DispenserBackLash", IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 );
     Task_sleep(10);
     MotorSetDirection(motorId,MotorsCfg[motorId].directionthreadwize);
     Task_sleep(10);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 791b3c47b..1bab2c65d 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -55,6 +55,7 @@ uint32_t IDS_Valve_DistanceToSpoolReady(uint32_t deviceID, uint32_t ReadValue);
 uint32_t IDS_Valve_PresegmentReady(uint32_t deviceID, uint32_t ReadValue);
 uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue);
 //bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int SegmentId);
+bool JobStartStopBackLash[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 /******************** GLOBAL PARAMETERS  ********************************************/
 DispenserControlConfig_t DispenserControlConfig[MAX_SYSTEM_DISPENSERS];
 uint32_t    ControlIdtoDispenserId [MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
@@ -549,6 +550,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
          if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers
          {
              IDS_StopHomeDispenser(i);
+             JobStartStopBackLash[i] = true;
              NumOfActiveDispensers++;
          }
          else
@@ -585,7 +587,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
          }
      }
      DispenserBuildTimeCounter = 0;
-     DispenserPrepareControlId = AddControlCallback( IDS_Prepare_Callback, PRESSURE_READ_TIME_GAP,TemplateDataReadCBFunction ,0, 0, 0 );
+     DispenserPrepareControlId = AddControlCallback(NULL, IDS_Prepare_Callback, PRESSURE_READ_TIME_GAP,TemplateDataReadCBFunction ,0, 0, 0 );
      setRapidPressureRead(true);
 
  }
@@ -978,7 +980,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
             lInterSegmentLength = ((IntersegmentLength*100)*1000/dyeingspeed);
             lInterSegmentLength-=(lInterSegmentLength%100);   //round to a 100 multiplication
             InterSegmentStepsCount = 0;
-            DispenserPreSegmentControlId = AddControlCallback( IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
+            DispenserPreSegmentControlId = AddControlCallback(NULL,IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
             if (DispenserPreSegmentControlId == 0xFF)
             {
                 Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
@@ -1256,7 +1258,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
     JobBrushStopId++;
     if ((BrushStopTime)&&(SegmentNumOfBrushStops > 1))
     {
-        BrushStopControlId = AddControlCallback( IDSBrushStopRestartCallback, BrushStopTime,TemplateDataReadCBFunction ,SegmentDetails, 0, 0 );
+        BrushStopControlId = AddControlCallback(NULL, IDSBrushStopRestartCallback, BrushStopTime,TemplateDataReadCBFunction ,SegmentDetails, 0, 0 );
         if (BrushStopControlId == 0xFF)
         {
             Report("Add control callback failed",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)0,0);
@@ -1327,7 +1329,7 @@ uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId)
          lInterSegmentLength = (dryerbufferCentimeters*1000/dyeingspeed);
          lInterSegmentLength-=(lInterSegmentLength%100);   //round to a 100 multiplication
          InterSegmentStepsCount = 0;
-         DispenserPreSegmentControlId = AddControlCallback( IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
+         DispenserPreSegmentControlId = AddControlCallback(NULL, IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 );
          if (DispenserPreSegmentControlId == 0xFF)
          {
              Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 8f9628f20..79e4b202a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -16,8 +16,6 @@
 #include "drivers/ADC_Sampling/adc.h"
 
 #include "Drivers/I2C_Communication/Head_Card/PT100/PT100_ADC.h"
-#include "Drivers/I2C_Communication/Head_Card/Fan/fan_click.h"
-#include "Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h"
 #include "drivers/Motors/Motor.h"
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "Modules/IFS/ifs.h"
@@ -25,10 +23,6 @@
 //#include "graphics_adapter.h"
 extern uint8_t Input_Voltage;
 extern uint8_t Test_Read_Buf[4];
-
-extern uint8_t Head_Fan_PWM_1_Command;
-extern uint16_t Head_Fan_Tach[2];
-
 void Stub_ProgressRequest(MessageContainer* requestContainer)
 {
     MessageContainer responseContainer;
@@ -79,16 +73,6 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
 
     }
     else
-        if((request->amount == 0xFAC) /*&& (request->delay == 0xFAC)*/) //measured sensor voltage without flow (orifice flow meter)
-    {
-        Head_Fan_PWM_1_Command = (request->delay & 0xFF) ;
-        Test_fan_Click();
-        //response.progress = Fan_Click_Info.Product_ID;
-        response.progress = Head_Fan_Tach[0];
-        response.has_progress = true;
-
-    }
-    else
         if((request->amount == 0x0A) && ((request->delay >= 0) && (request->delay < 8))) //read the midtank calibration
         {
             response.progress = Initial_Offset_A[request->delay];
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 5a1bb9063..50fad6503 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -29,6 +29,7 @@
 #include "drivers/I2C_Communication/DAC/Blower.h"
 #include "drivers/SSI_Comm/Dancer/Dancer.h"
 #include "drivers/motors/motor.h"
+#include "drivers/Flash_ram/MCU_E2Prom.h"
 
 #include "PMR/Stubs/StubHeatingTestRequest.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestResponse.pb-c.h"
@@ -78,7 +79,7 @@
         uint32_t LoadArmBackLash;
     }LoadArmInfoStruc;
     LoadArmInfoStruc LoadArmInfo;
-    char LoadArmPath[50] = "0://SysInfo//LoadArm.cfg";
+    //char LoadArmPath[50] = "0://SysInfo//LoadArm.cfg";
 
     //RUN MOTOR TO SWITCH WITH TIMEOUT
     //RUN MOTOR TO BREAK SENSOR
@@ -96,14 +97,21 @@
     }
     uint32_t Thread_Load_Init(void)
     {
-        void* buffer = NULL;
-        uint32_t Bytes = 0;
-        FRESULT Fresult = FR_OK;
+        //void* buffer = NULL;
+        //uint32_t Bytes = 0;
+        //FRESULT Fresult = FR_OK;
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
 
         LoadArmInfo.LoadArmBackLash = 5;
-        LoadArmInfo.LoadArmRounds = 0xFF;
-        Fresult = f_mkdir(SW_INFO_DIR);
+        //LoadArmInfo.LoadArmRounds = 0xFF;
+        //EEPROM_STORAGE_DRYER_CYCLES
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmInfo.LoadArmRounds);
+        if (LoadArmInfo.LoadArmRounds <= 2)
+                LoadArmInfo.LoadArmRounds = 20;
+        MCU_E2PromRead(EEPROM_STORAGE_DRYER_CYCLES,&LoadArmInfo.LoadArmRounds);
+        Report("MotorMovetoEncoderPosition",__FILE__,__LINE__,LoadArmInfo.LoadArmRounds,RpWarning,LoadArmInfo.LoadArmBackLash,0);
+
+        /*Fresult = f_mkdir(SW_INFO_DIR);
         if ((Fresult == FR_OK)||(Fresult == FR_EXIST))
         {
 
@@ -114,9 +122,9 @@
                    memcpy (&LoadArmInfo,buffer,sizeof(LoadArmInfo));
                free (buffer);
             }
-        }
+        }*/
 
-        Report("Thread_Load_Init",__FILE__,__LINE__,LoadArmInfo.LoadArmBackLash,RpMessage,LoadArmInfo.LoadArmRounds,0);
+        Report("Thread_Load_Init",__FILE__,__LINE__,LoadArmInfo.LoadArmRounds,RpMessage,LoadArmInfo.LoadArmRounds,0);
         StopInitSequence();
         memcpy (&ProcessParametersRecover,&ProcessParametersKeep,sizeof(ProcessParameters));
         //NumberOfDrierLoaderCycles = loadLoadArmParameters();
@@ -175,6 +183,8 @@
         {
             Report("Thread_Load_Set_Load_Arm_To_Start_Position_Callback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
             //storeLoadArmParameters();
+            MotorMove(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,LoadArmInfo.LoadArmBackLash );
+
             SetMotHome(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);  //set this point as the spool home
             LoadStages++;
             ThreadLoadStateMachine(LoadStages);
@@ -228,7 +238,7 @@
         }
         else //number of circles is not known - compare to position of the motor to verify location at the stopper
         {
-            Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
+            Report("Thread_Load_Set_Load_Arm_To_Start_Position unknown cycles",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
             status |= MotorMoveToStopper(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize),
                                             MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/2, Thread_Load_Set_Load_Arm_To_Stopper_Callback,LoadArmInfo.LoadArmBackLash,1000);
 
@@ -251,6 +261,15 @@
     {
         Report("Thread_Load_HomingCallback",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
 //        REPORT_MSG(MotorId, "Thread_Load_HomingCallback Motor Id");
+        if ((LoadStages == THREAD_LOAD_CLOSE_ROCKERS)||(LoadStages == THREAD_LOAD_LIFT_ROCKERS))
+        {
+            if((MotorId == HARDWARE_MOTOR_TYPE__MOTO_RLOADING)||(MotorId == HARDWARE_MOTOR_TYPE__MOTO_LLOADING))
+            {
+                MotorSetMicroStep(MotorId, keepmicrostep);
+                MotorSetKvalRun(MotorId, keepkvalrun);
+            }
+        }
+
         if (CallbackCounter)
         {
             CallbackCounter--;
@@ -269,13 +288,6 @@
                 else
                 {
                     LoadStages++;
-                    if (LoadStages == THREAD_LOAD_CLOSE_ROCKERS)
-                    {
-                        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING,  keepmicrostep);
-                        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, keepmicrostep);
-                        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, keepkvalrun);
-                        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, keepkvalrun);
-                    }
                     if (LoadStages == THREAD_LOAD_CLOSE_DANCERS)
                     {
                         MotorSetKvalHold(HARDWARE_MOTOR_TYPE__MOTO_RDANCER, keepkvalhold);
@@ -331,6 +343,10 @@
     {
         keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
         keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+        if (keepkvalrun>=25)
+            keepkvalrun = 25;
+        Report("Thread_Load_Lift_Rockers",__FILE__,__LINE__,keepkvalrun,RpMessage,keepmicrostep,0);
+
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 8);
         MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 8);
@@ -360,6 +376,17 @@
     }
     uint32_t Thread_Load_Close_Rockers(void)
     {
+        keepmicrostep = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep;
+        keepkvalrun = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].kvalrun;
+        if (keepkvalrun>=25)
+            keepkvalrun = 25;
+        Report("Thread_Load_Close_Rockers",__FILE__,__LINE__,keepkvalrun,RpMessage,keepmicrostep,0);
+
+        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 8);
+        MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 8);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 70);
+        MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 70);
+
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 250,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,25000);
@@ -464,15 +491,19 @@
     uint32_t Thread_Load_Dryer_Loading(void)
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
-        LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
-        if (LoadArmInfo.LoadArmRounds <= 2)
-            LoadArmInfo.LoadArmRounds = 20;
+
+        if (dryerbufferlength)
+            LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
+        //if (LoadArmInfo.LoadArmRounds <= 2)
+        //    LoadArmInfo.LoadArmRounds = 20;
         float numberOfSteps = 0;
         //Start Feeder Pid, Rotate Loading Arm Counter Thread Direction X Circles According To Rml. Feeder Speed Is 40
         SetOriginMotorSpeed(19);
 //        OriginalMotorSpd_2PPS[FEEDER_MOTOR] = 1000;
 //        CurrentControlledSpeed[FEEDER_MOTOR] = 1000;
 
+        MCU_E2PromProgram(EEPROM_STORAGE_DRYER_CYCLES,LoadArmInfo.LoadArmRounds);
+
         numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*LoadArmInfo.LoadArmRounds*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
         numberOfSteps -= 100;
         //numberOfSteps = MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround*3.3*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].microstep*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius;
@@ -498,7 +529,7 @@
 
         MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulleyradius);
 
-        LoadingControlId = AddControlCallback(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
+        LoadingControlId = AddControlCallback(NULL,ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
         Report("AddControlCallback feeder",__FILE__,__LINE__,LoadingControlId,RpMessage,IfTypeThread*0x100+FEEDER_MOTOR,0);
         CallbackCounter++;
         Report("Thread_Load_Dryer_Loading",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
@@ -507,7 +538,7 @@
 
         //Keep Notation How Many Rotations In The Dryer
         //LoadArmInfo.LoadArmBackLash = 0;
-        LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
+        //LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
         //FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
         return OK;
     }
@@ -526,7 +557,7 @@
     {
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
         ThreadJoggingFunc(20);
-        LoadingControlId = AddControlCallback(Thread_Load_Jog_ThreadStop, eOneSecond*5,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
+        LoadingControlId = AddControlCallback(NULL,Thread_Load_Jog_ThreadStop, eOneSecond*5,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
         return OK;
     }
     uint32_t Thread_Load_End(void)
@@ -592,7 +623,7 @@
         MotorControlConfig[POOLER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage
         MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LDRIVING].directionthreadwize);
 
-        PullerControlId = AddControlCallback(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+POOLER_MOTOR),POOLER_DANCER,POOLER_MOTOR);
+        PullerControlId = AddControlCallback(NULL,ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+POOLER_MOTOR),POOLER_DANCER,POOLER_MOTOR);
         Report("AddControlCallback Puller",__FILE__,__LINE__,PullerControlId,RpMessage,IfTypeThread*0x100+POOLER_MOTOR,0);
 ////////////////////////
         MotorControlConfig[WINDER_MOTOR].m_params.MAX = 1;
@@ -614,7 +645,7 @@
         MotorControlConfig[WINDER_MOTOR].m_SetParam = 0;//need to update SetParams on presegment stage
         MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_WINDER,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].directionthreadwize);
 
-        WinderControlId = AddControlCallback(ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+WINDER_MOTOR),WINDER_DANCER,WINDER_MOTOR);
+        WinderControlId = AddControlCallback(NULL,ThreadLoadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+WINDER_MOTOR),WINDER_DANCER,WINDER_MOTOR);
         Report("AddControlCallback Winder",__FILE__,__LINE__,WinderControlId,RpMessage,IfTypeThread*0x100+WINDER_MOTOR,0);
 
 ////////////////////////
@@ -631,9 +662,9 @@
                                         MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].pulseperround/4, Thread_Load_Set_Load_Arm_To_Stopper_Callback,LoadArmInfo.LoadArmBackLash,1000);
 
         //Keep Notation How Many Rotations In The Dryer
-        //LoadArmInfo.LoadArmBackLash = 0;
+        LoadArmInfo.LoadArmBackLash = 5;
         LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
-        FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
+        //FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath,BIOS_WAIT_FOREVER);
         return OK;
     }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 9d57cd29f..a93387e0a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -547,7 +547,7 @@ uint32_t Winder_Presegment(void *SegmentDetails, uint32_t SegmentId)
    }
     if (SegmentId == 0)
     {
-            ScrewControlId = AddControlCallback(Screw100msecDirectionChange, eHundredMillisecond,TemplateDataReadCBFunction,0,0,0);
+            ScrewControlId = AddControlCallback("screw control",Screw100msecDirectionChange, eHundredMillisecond,TemplateDataReadCBFunction,0,0,0);
     }
     PreSegmentReady(Module_Winder,ModuleDone);
 
@@ -583,7 +583,7 @@ uint32_t WinderDistanceToSpoolState(void )
     double DTS_Time = (dryerbufferCentimeters/dyeingspeed)*1000;//distance to spool time in milliseconds
     REPORT_MSG ((int)DTS_Time,"WinderDistanceToSpoolState");
 
-    ScrewDTSControlId = AddControlCallback(ScrewDTSCallback, DTS_Time-WinderBackToBaseTime,TemplateDataReadCBFunction,0,0,0);
+    ScrewDTSControlId = AddControlCallback("screw DTS",ScrewDTSCallback, DTS_Time-WinderBackToBaseTime,TemplateDataReadCBFunction,0,0,0);
     REPORT_MSG ((int)msec_millisecondCounter,"ScrewDTSCallback start");
 
     return OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index 8c42735cb..416b53494 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -148,12 +148,13 @@ char DancerConfigPath[50] = "0://SysInfo//DancCfg.cfg";
 
 uint32_t StoreDancerConfigMessage()
 {
-    FRESULT Fresult = FR_OK;
-    HardwareConfiguration DancerConfig;
-    HardwareDancer Dancers[MAX_SYSTEM_DANCERS];
-    uint8_t* response_buffer;
-    size_t response_size = 0;
-    int Dancer_i;
+    uint32_t status = OK;
+  /*  FRESULT Fresult = FR_OK;
+  //  HardwareConfiguration DancerConfig;
+  //  HardwareDancer Dancers[MAX_SYSTEM_DANCERS];
+  //  uint8_t* response_buffer;
+  //  size_t response_size = 0;
+  //  int Dancer_i;
 
     hardware_configuration__init(&DancerConfig);
     DancerConfig.dancers = (HardwareDancer**)my_malloc(sizeof(HardwareDancer*)*MAX_SYSTEM_DANCERS);
@@ -168,11 +169,12 @@ uint32_t StoreDancerConfigMessage()
         DancerConfig.n_dancers++;
         DancersCfg[Dancer_i].zeropoint = DancerConfig.dancers[Dancer_i]->zeropoint;
     }
-    MCU_E2PromProgram(EEPROM_STORAGE_DANCER_0,DancersCfg[0].zeropoint);
-    MCU_E2PromProgram(EEPROM_STORAGE_DANCER_1,DancersCfg[1].zeropoint);
-    MCU_E2PromProgram(EEPROM_STORAGE_DANCER_2,DancersCfg[2].zeropoint);
+    */
+    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_0,DancersCfg[0].zeropoint);
+    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_1,DancersCfg[1].zeropoint);
+    status |= MCU_E2PromProgram(EEPROM_STORAGE_DANCER_2,DancersCfg[2].zeropoint);
     Report("Store eeprom 0",__FILE__,DancersCfg[0].zeropoint,(int)DancersCfg[1].zeropoint,RpWarning,(int)DancersCfg[2].zeropoint,0);
-
+/*
     response_buffer = my_malloc(hardware_configuration__get_packed_size(&DancerConfig));
     if (response_buffer)
     {
@@ -187,43 +189,23 @@ uint32_t StoreDancerConfigMessage()
 
 
     my_free(response_buffer);
-
-    return Fresult;
+*/
+    return status;
 }
 uint32_t LoadDancerConfigMessage()
 {
-    void* buffer = NULL;
-    uint32_t Bytes = 0;
-    FRESULT Fresult = FR_OK;
-
-    HardwareConfiguration *DancerConfig;
-    int Dancer_i;
-    HardwareDancer DancersCfg1[MAX_SYSTEM_DANCERS] = {0};
-    HardwareDancer DancersCfg2[MAX_SYSTEM_DANCERS] = {0};
+    uint32_t status = OK;
 
-    memcpy(DancersCfg1,(void *)DANCERS_MAP_IN_FLASH,sizeof(DancersCfg1));
-
-    Fresult = FileRead(DancerConfigPath, &Bytes, &buffer);
-    if (Fresult == FR_OK)
-    {
-        DancerConfig = hardware_configuration__unpack(NULL, Bytes, buffer);
-        for (Dancer_i = 0; Dancer_i < DancerConfig->n_dancers ; Dancer_i++)
-        {
-            DancersCfg2[Dancer_i].zeropoint = DancerConfig->dancers[Dancer_i]->zeropoint;
-        }
-        hardware_configuration__free_unpacked(DancerConfig,NULL);
-        free (buffer);
-    }
     MCU_E2PromRead(EEPROM_STORAGE_DANCER_0,&DancersCfg[0].zeropoint);
     MCU_E2PromRead(EEPROM_STORAGE_DANCER_1,&DancersCfg[1].zeropoint);
     MCU_E2PromRead(EEPROM_STORAGE_DANCER_2,&DancersCfg[2].zeropoint);
 
 
-    Report("Dancer 0 Store data flash, internal flash, eeprom ",__FILE__,DancersCfg[0].zeropoint,(int)DancersCfg1[0].zeropoint,RpWarning,(int)DancersCfg2[0].zeropoint,0);
-    Report("Dancer 1 Store data flash, internal flash, eeprom ",__FILE__,DancersCfg[1].zeropoint,(int)DancersCfg1[1].zeropoint,RpWarning,(int)DancersCfg2[1].zeropoint,0);
-    Report("Dancer 2 Store data flash, internal flash, eeprom ",__FILE__,DancersCfg[2].zeropoint,(int)DancersCfg1[2].zeropoint,RpWarning,(int)DancersCfg2[2].zeropoint,0);
+    status |= Report("Dancer 0 Store data eeprom ",__FILE__,__LINE__,0,RpWarning,(int)DancersCfg[0].zeropoint,0);
+    status |= Report("Dancer 1 Store data eeprom ",__FILE__,__LINE__,1,RpWarning,(int)DancersCfg[1].zeropoint,0);
+    status |= Report("Dancer 2 Store data eeprom ",__FILE__,__LINE__,2,RpWarning,(int)DancersCfg[2].zeropoint,0);
 
-    return Fresult;
+    return status;
 
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 45acfabea..28ba11fcd 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -732,6 +732,18 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
 
     MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, Hard_Stop);
 
+    if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID]) != LIMIT)
+    {
+        ReportWithPackageFilter(ThreadFilter,"Dyeing head is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DH_LID,RpFatalError,LIMIT,0);
+        PrepareReady(Module_Thread,ModuleFail);
+        return ERROR;
+    }
+    if (FPGA_Read_limit_Switches(Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID]) != LIMIT)
+    {
+        ReportWithPackageFilter(ThreadFilter,"Dryer lid is open!!!",__FILE__,__LINE__,HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,RpFatalError,LIMIT,0);
+        PrepareReady(Module_Thread,ModuleFail);
+        return ERROR;
+    }
 
     //start thread control for all motors
     for (Motor_i = 0;Motor_i < MAX_THREAD_MOTORS_NUM;Motor_i++)
@@ -768,7 +780,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                 }
                 //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
                 LengthCalculationMultiplier = (MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulleyradius*2*PI)/(MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulseperround*MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].microstep);
-                SpeedControlId = AddControlCallback(ThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
+                SpeedControlId = AddControlCallback(NULL,ThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
             }
             if (Motor_i == POOLER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
             {
@@ -781,7 +793,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                 }
                 //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
                 PoolerLengthCalculationMultiplier = (MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulleyradius*2*PI)/(MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].pulseperround*MotorsCfg[ThreadMotorIdToMotorId[Motor_i]].microstep);
-                PoolerSpeedControlId = AddControlCallback(PoolerThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
+                PoolerSpeedControlId = AddControlCallback(NULL,PoolerThreadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
             }
             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
             {
@@ -793,8 +805,8 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                     CurrentControlledSpeed[Motor_i] = 0;
                 }
 #ifndef TEST_PID_THREAD
-                ControlIdtoMotorId[Motor_i] = AddControlCallback(ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
-                //AddControlCallback(ThreadControlSpeedReadFunction, eHundredMillisecond,MotorGetSpeedFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
+                ControlIdtoMotorId[Motor_i] = AddControlCallback(NULL,ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
+                //AddControlCallback(NULL,ThreadControlSpeedReadFunction, eHundredMillisecond,MotorGetSpeedFromFPGA,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToMotorId[Motor_i],Motor_i);
 #endif
             }
             if (Motor_i == POOLER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will n//ot be controlled
@@ -807,7 +819,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                     ControlIdtoMotorId[Motor_i] = 0xFF;
                 }
 #ifndef TEST_PID_THREAD
-                ControlIdtoMotorId[Motor_i] = AddControlCallback(ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
+                ControlIdtoMotorId[Motor_i] = AddControlCallback(NULL,ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
 #endif
             }
             if (Motor_i == WINDER_MOTOR) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will n//ot be controlled
@@ -821,7 +833,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                     ControlIdtoMotorId[Motor_i] = 0xFF;
                 }
 #ifndef TEST_PID_THREAD
-                ControlIdtoMotorId[Motor_i] = AddControlCallback(ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
+                ControlIdtoMotorId[Motor_i] = AddControlCallback(NULL,ThreadControlCBFunction, eOneMillisecond,Control_Read_Dancer_Position,(IfTypeThread*0x100+Motor_i),ThreadMotorIdToDancerId[Motor_i],Motor_i);
 #endif
             }
 //            if (HW_Motor_Id == HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING) // dryer motor is speed controlled. later a speed sensor will be utilized, but for now it will not be controlled
@@ -912,7 +924,7 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
 #else
         InitialDryerSpeed = OriginalMotorSpd_2PPS[DRYER_MOTOR]/10;
         MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,InitialDryerSpeed );
-        ControlIdtoMotorId[DRYER_MOTOR] = AddControlCallback(ThreadDryerRampUp, 200,TemplateDataReadCBFunction,0,0,0);
+        ControlIdtoMotorId[DRYER_MOTOR] = AddControlCallback("DryerRampUp",ThreadDryerRampUp, 200,TemplateDataReadCBFunction,0,0,0);
 #endif
 #endif
 #ifdef HUNDRED_MICROSECONDS_DANCER_READ
diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
index c2451118d..90df9cfb1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c
@@ -589,7 +589,7 @@ bool initWHS_WasteTank()
     WHS_info.WHS_sensors.waste_tank_empty_sensor = RdWasteTankEmptySensor();
     WHS_info.WHS_sensors.waste_tank_full_sensor =  SENSORnotFULL;
     UpdateStateMachine();
-    AddControlCallback(WasteTankCBFunction, WasteTankCallBackTime , WasteTankCallBackFunction, 0,0,0);//eOneMinute
+    AddControlCallback("Waste tank",WasteTankCBFunction, WasteTankCallBackTime , WasteTankCallBackFunction, 0,0,0);//eOneMinute
     return OK;
 }
 
@@ -663,7 +663,7 @@ WHS_sensor WasteTankCallBackFunction()
 /*
 bool start_WHS_machin()
 {
-    AddControlCallback( WasteTankCBFunction,  eTenMillisecond, WasteTankCallBackFunction, 0,0,0 );// eOneMinute
+    AddControlCallback(NULL, WasteTankCBFunction,  eTenMillisecond, WasteTankCallBackFunction, 0,0,0 );// eOneMinute
     return OK;
 }
  */
@@ -700,7 +700,7 @@ bool WasteTankCBFunction()
                     REPORT_MSG(WHS_filling," ------------ WHS_empty ----------------- ");
                     ret = CartridgeWasteFilling(OFF);
                     WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
-                    WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackTime, CartridgeCoverCallBackFunction, 0,0,0 );//eOneSecond
+                    WHS_info.Cartridge_Cover_device_Id = AddControlCallback(NULL, WasteTankCBFunction, CartridgeCoverCallBackTime, CartridgeCoverCallBackFunction, 0,0,0 );//eOneSecond
                     WrRFIDStatus(WHS_info.active_cartridge, WasteFull);//write RFID status todo
                 }
                 else
@@ -726,7 +726,7 @@ bool WasteTankCBFunction()
                 WHS_info.sttMachine = WHS_full;
                 REPORT_MSG(WHS_emptying," ------------ WHS_full ----------------- ");
                 WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction );
-                WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackFastTime , CartridgeCoverCallBackFunction, 0,0,0 );//eTenMillisecond
+                WHS_info.Cartridge_Cover_device_Id = AddControlCallback(NULL, WasteTankCBFunction, CartridgeCoverCallBackFastTime , CartridgeCoverCallBackFunction, 0,0,0 );//eTenMillisecond
                 if (RdRFIDStatus (WHS_info.active_cartridge) == WasteEmpty)
                 {
                     ret = WrRFIDStatus(WHS_info.active_cartridge, WasteFilling);//write RFID status todo
@@ -794,9 +794,9 @@ bool WasteTankCBFunction()
 
                 if ( !PowerOffInProcessGetState() )
                 {
-                    IFS_info.Cartridge_Ink_device_Id    = AddControlCallback( WasteTankCBFunction, CartridgeInkCallBackTime   , CartridgeInkCallBackFunction   , 0,0,0 ); //eOneSecond
-                    WHS_info.Cartridge_Waste1_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeWaste1CallBackTime, CartridgeWaste1CallBackFunction, 0,0,0 ); //eOneSecond
-                    WHS_info.Cartridge_Waste2_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeWaste2CallBackTime, CartridgeWaste2CallBackFunction, 0,0,0 ); //eOneSecond
+                    IFS_info.Cartridge_Ink_device_Id    = AddControlCallback(NULL, WasteTankCBFunction, CartridgeInkCallBackTime   , CartridgeInkCallBackFunction   , 0,0,0 ); //eOneSecond
+                    WHS_info.Cartridge_Waste1_device_Id = AddControlCallback(NULL, WasteTankCBFunction, CartridgeWaste1CallBackTime, CartridgeWaste1CallBackFunction, 0,0,0 ); //eOneSecond
+                    WHS_info.Cartridge_Waste2_device_Id = AddControlCallback(NULL, WasteTankCBFunction, CartridgeWaste2CallBackTime, CartridgeWaste2CallBackFunction, 0,0,0 ); //eOneSecond
                 }
                 else
                 {
@@ -848,11 +848,11 @@ bool WasteTankCBFunction()
                     cart1.color  = BLINK;
                     //add timeout
                     IFS_info.Ink.time_out = 1;
-                    IFS_info.Cartridge_Ink_TimeOut_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeInkTimeOutCallBackTime, CartridgeInkTimeOutCallBackFunction, 0,0,0 ); //eOneSecond
+                    IFS_info.Cartridge_Ink_TimeOut_device_Id = AddControlCallback(NULL, WasteTankCBFunction, CartridgeInkTimeOutCallBackTime, CartridgeInkTimeOutCallBackFunction, 0,0,0 ); //eOneSecond
 
 
 //                    //add callback for midtank status is full
-//                    IFS_info.Cartridge_Ink_TimeOut_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeInkTimeOutCallBackTime, CartridgeInkTimeOutCallBackFunction, 0,0,0 ); //eOneSecond
+//                    IFS_info.Cartridge_Ink_TimeOut_device_Id = AddControlCallback(NULL, WasteTankCBFunction, CartridgeInkTimeOutCallBackTime, CartridgeInkTimeOutCallBackFunction, 0,0,0 ); //eOneSecond
 //                    Enable_MidTank_Pressure_Reading(IFS_info.Ink.cart_color);
 //                    Read_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color);
 //                    if ( Get_MidTank_Pressure_Sensor(IFS_info.Ink.cart_color) > MidTank_Pressure_FULL )
@@ -1257,11 +1257,11 @@ bool InitCartStatus()
     if (WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN)
     {
         REPORT_MSG(parameter," ------------ WHS_CartridgeCoverOPEN  : add callback for cart1 and cart 2   ----------------- ");
-        IFS_info.Cartridge_Ink_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeInkCallBackFunction, 0,0,0 );
-        WHS_info.Cartridge_Waste1_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste1CallBackFunction, 0,0,0 );
-        WHS_info.Cartridge_Waste2_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste2CallBackFunction, 0,0,0 );
+        IFS_info.Cartridge_Ink_device_Id = AddControlCallback(NULL, WasteTankCBFunction, eOneSecond, CartridgeInkCallBackFunction, 0,0,0 );
+        WHS_info.Cartridge_Waste1_device_Id = AddControlCallback(NULL, WasteTankCBFunction, eOneSecond, CartridgeWaste1CallBackFunction, 0,0,0 );
+        WHS_info.Cartridge_Waste2_device_Id = AddControlCallback(NULL, WasteTankCBFunction, eOneSecond, CartridgeWaste2CallBackFunction, 0,0,0 );
     }
-    WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeCoverCallBackFunction, 0,0,0 );
+    WHS_info.Cartridge_Cover_device_Id = AddControlCallback(NULL, WasteTankCBFunction, eOneSecond, CartridgeCoverCallBackFunction, 0,0,0 );
 
     return OK;
 }
@@ -1355,7 +1355,7 @@ U8 RdWastePrecenseSensor(cartridge_name name)
 /*
 U8 cartridge_handeling()
 {
-    AddControlCallback( CartridgePrecenceCBFunction, eOneMinute, CartridgePrecenceCallBackFunction, 0,0,0 ); //
+    AddControlCallback(NULL, CartridgePrecenceCBFunction, eOneMinute, CartridgePrecenceCallBackFunction, 0,0,0 ); //
     return OK;
 }
 */
@@ -1802,23 +1802,23 @@ uint32_t start_WHS_machin()
     switch( WHS_info.sttMachine )
         {
             case WHS_empty: // last OnOffPBstate was OFF
-                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); //
+                AddControlCallback(NULL, EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); //
                break;
             case WHS_filling : // last OnOffPBstate was COUNTPB
-                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
-                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); //
+                AddControlCallback(NULL, EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
+                AddControlCallback(NULL, EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); //
                 break;
             case WHS_emptying: // last OnOffPBstate was SHORTPB
-                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); //
-                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
+                AddControlCallback(NULL, EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); //
+                AddControlCallback(NULL, EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
                  break;
             case WHS_full:
-                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
-                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankOverflowCallBackFunction, 0,0,0 ); //
+                AddControlCallback(NULL, EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
+                AddControlCallback(NULL, EmptyWasteTankCBFunction, eOneMinute, WasteTankOverflowCallBackFunction, 0,0,0 ); //
                  break;
             case WHS_overflow:
-                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
-                AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankOverflowCallBackFunction, 0,0,0 ); //
+                AddControlCallback(NULL, EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); //
+                AddControlCallback(NULL, EmptyWasteTankCBFunction, eOneMinute, WasteTankOverflowCallBackFunction, 0,0,0 ); //
                  break;
           default:              // WHS_sttError
                break;