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

19 files changed, 543 insertions, 287 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index b62b33cc5..eea72d6b5 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -72,7 +72,6 @@ uint8_t alarm_response_buffer[500];
 /******************** Functions  ********************************************/
 void SendEventNotifications(void);
 
-//uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Read);
 //**********************************************************************
 typedef enum
 {
@@ -91,7 +90,7 @@ typedef struct AlarmHandlingMessage{
   //  uint32_t Data;
 }AlarmHandlingMessageStruc;
 
-#define MAX_SYSTEM_ALARMS 300+1
+#define MAX_SYSTEM_ALARMS 400+1
 /*typedef enum
 {
     TemperatureAlarm,
@@ -586,7 +585,7 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
             }
             else
             {
-                usnprintf(AlarmReasonStr, 100, "Alarm %d caused a job stop",AlarmId);
+                usnprintf(AlarmReasonStr, 100, "Alarm %d type %d caused a job stop",AlarmId,AlarmItem[AlarmId].EventType);
                 return JOB_OTHER_ALARM;
             }
         default:
@@ -988,6 +987,9 @@ uint32_t AlarmHandlingStop(void)
     }
     return OK;
 }
+uint32_t Save_Alarm_i;
+void *Save_Alarm_ptr;
+EventType Save_Alarm_Type;
 
 uint32_t AlarmHandlingLoop(uint32_t tick)
 {
@@ -1101,14 +1103,18 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
             case ALARM_SOURCE_TYPE__CurrentAlarm:
                 if (CheckCurrentAlarms)
                  {
-                     if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
+#ifndef Use_Head_Card
+                    if (AlarmItem[Alarm_i].DeviceId >= NUM_OF_CURRENT_HEATERS)
+                        break;
+#endif
+                    if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
                      {
                          if (AlarmItem[Alarm_i].AlarmDirection == true)
                          {
-                             if ((doubleValue >= (AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                             if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(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);
+                                 ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,AlarmItem[Alarm_i].EventType, RpMessage, (int)(doubleValue*100), 0);
                              }
                          }
                          else
@@ -1116,7 +1122,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                              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);
+                                 ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,AlarmItem[Alarm_i].EventType, RpMessage, (int)(doubleValue*100), 0);
                              }
                          }
 
@@ -1189,7 +1195,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
 
             case ALARM_SOURCE_TYPE__TachoAlarm: // add by shai
                 Status = false;
-                if (CheckTamperAlarms)
+                if (CheckCurrentAlarms)
                 {
 
 //                ReportWithPackageFilter(AlarmFilter,"------------FANS_RPM[Alarm_i]----------------", __FILE__,__LINE__,Alarm_i, RpMessage, value, 0);
@@ -1365,16 +1371,19 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                 }
                 else // alarm off
                 {
+                    ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i);
                     if (AlarmState[Alarm_i].EventPtr)
                     {
                         //ROM_IntMasterDisable();
+                        Save_Alarm_i = Alarm_i;
+                        Save_Alarm_ptr = AlarmState[Alarm_i].EventPtr;
+                        Save_Alarm_Type = AlarmItem[Alarm_i].EventType;
                         my_free(AlarmState[Alarm_i].EventPtr);
                         AlarmState[Alarm_i].EventPtr = NULL;
                         //ROM_IntMasterEnable();
                     }
                     AlarmState[Alarm_i].Status = false;
                     AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info);
-                    ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i);
                 }
             }
         }
@@ -1579,143 +1588,7 @@ uint32_t StopEventsNotificationRequestFunc(MessageContainer* requestContainer)
     my_free(responseContainer.data.data);
     SendChars(container_buffer, container_size);
 
-return OK;
-
-
-/* function :
- * -------------
- * DrawerFansStatus     // uint32_t getDrawerFansStatus(void) 5 fans OK or NotOK
- * SystemFansStatus     // uint32_t getSystemFansStatus(void) 2 fans OK or NotOK
- * Fans_Speed_RPM[MAX_FANS] //
- *
- * Read_Dryer_Fan_Tacho // uint32_t Read_Dryer_Fan_Tacho()
- * Control_Dryer_Fan(bool StartStop, uint8_t PWM_Command_Precent)  //uint32_t Control_Dryer_Fan(bool StartStop, uint8_t PWM_Command_Precent);
- *
- * excell alarm ver9 from Nadav
- * ----------------------------
- * 2009 MACHINE_FANS_RPM_TOO_LOW             Warning
- * 2010 MACHINE_FANS_STOPPED                 Critical
- * 2011 ELECTRICAL_CABINET_FANS_RPM_TOO_LOW  Warning
- * 2012 ELECTRICAL_CABINET_FANS_STOPPED      Critical
- * 4015 DRYER_FAN_RPM_TOO_LOW                Warning
- * 4016 DRYER_FAN_STOPPED                    Critical
- *
- *
- *
- *
-
-
-
-
-    #define MACHINE_FANS_MIN_RPM 1000
-    #define MACHINE_FANS_STOP 0
-    #define ELECTRICAL_CABINET_FANS_MIN_RPM 1000
-    #define ELECTRICAL_CABINET_FANS_STOP 0
-    #define DRYER_FAN_MIN_RPM 1000
-    #define DRYER_FAN_STOP 0
-
-    typedef enum
-    {
-        MACHINE_FANS,
-        ELECTRICAL_CABINET_FANS,
-//        ELECTRICAL_CABINET_FAN_BIG,
-//        ELECTRICAL_CABINET_FAN_SMALL1,
-//        ELECTRICAL_CABINET_FAN_SMALL2,
-//        ELECTRICAL_CABINET_FAN_SMALL3,
-//        ELECTRICAL_CABINET_FAN_SMALL4,
-        DRYER_FAN,
-        NUM_OF_FANS,
-    } Fans_t;
-
-
-    ----- 2009 : -------
-    {eOneSecond,                                             // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    MACHINE_FANS  ,                                         // uint16_t DeviceId;
-    MACHINE_FANS  ,                                         // uint8_t ModuleDeviceId;
-    MACHINE_FANS_MIN_RPM ,                                  // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Warning ,                           // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW                    // EventType EventType;
-    },
-
-    ----- 2010 : -------
-    {eOneSecond,                                             // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    MACHINE_FANS  ,                                         // uint16_t DeviceId;
-    MACHINE_FANS  ,                                         // uint8_t ModuleDeviceId;
-    MACHINE_FANS_STOP ,                                     // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Critical ,                          // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__MACHINE_FANS_STOPPED                        // EventType EventType;
-    },
-
-    ----- 2011 : -------
-    {eOneSecond,                                             // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    ELECTRICAL_CABINET_FANS  ,                              // uint16_t DeviceId;
-    ELECTRICAL_CABINET_FANS  ,                              // uint8_t ModuleDeviceId;
-    ELECTRICAL_CABINET_FANS_MIN_RPM ,                       // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Warning ,                           // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW         // EventType EventType;
-    },
-
-    ----- 2012 : -------
-    {eOneSecond,                                            // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    ELECTRICAL_CABINET_FANS  ,                              // uint16_t DeviceId;
-    ELECTRICAL_CABINET_FANS  ,                              // uint8_t ModuleDeviceId;
-    ELECTRICAL_CABINET_FANS_STOP ,                          // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Critical ,                          // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED             // EventType EventType;
-    },
-
-
-    ----- 2015 : -------
-    {eOneSecond,                                             // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    DRYER_FAN  ,                                            // uint16_t DeviceId;
-    DRYER_FAN  ,                                            // uint8_t ModuleDeviceId;
-    DRYER_FAN_MIN_RPM ,                                     // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Warning ,                           // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW                       // EventType EventType;
-    },
-
-    ----- 2016 : -------
-    {eOneSecond,                                             // uint16_t Frequency;
-    ALARM_SOURCE_TYPE__TachoAlarm,                          // AlarmSourceType AlarmSource;
-    DRYER_FAN  ,                                            // uint16_t DeviceId;
-    DRYER_FAN  ,                                            // uint8_t ModuleDeviceId;
-    DRYER_FAN_STOP ,                                        // uint16_t AlarmValue;
-    FALSE ,                                                 // bool AlarmDirection;
-    DEBUG_LOG_CATEGORY__Critical ,                          // DebugLogCategory Severity;
-    0xFF ,                                                  // uint16_t Predecessor;
-    5 ,                                                     // uint8_t DebounceValue;
-    EVENT_TYPE__DRYER_FAN_STOPPED                           // EventType EventType;
-      },
-
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm,MACHINE_FANS            , MACHINE_FANS           , MACHINE_FANS_MIN_RPM           , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW            },
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm,MACHINE_FANS            , MACHINE_FANS           , MACHINE_FANS_STOP              , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__MACHINE_FANS_STOPPED                },
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_MIN_RPM, FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW },
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_STOP   , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED     },
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_MIN_RPM              , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW               },
- {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_STOP                 , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__DRYER_FAN_STOPPED                   },
-
-
-* */
+    return OK;
 
 }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
index 0f73ed4af..be7687f28 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
@@ -8,6 +8,7 @@
 #ifndef MODULES_ALARMHANDLING_ALARMHANDLING_H_
 #define MODULES_ALARMHANDLING_ALARMHANDLING_H_
 #include "StateMachines/Printing/PrintingSTM.h"
+#include  <PMR/Diagnostics/EventType.pb-c.h>
 
 uint32_t AlarmHandlingFlashLoad(void);
 uint32_t AlarmHandlingLoadFile(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 48a28ffe4..862a0f8cf 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -113,7 +113,6 @@ static GateMutex_Handle gateMillisecDB;
 
 uint32_t        Millisec_timerBase = TIMER1_BASE;        //Timer handle
 /******************** Functions  ********************************************/
-uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Read);
 void CalculateVOCAlarms(void);
 //**********************************************************************
 /******************** CODE  ********************************************/
@@ -226,13 +225,18 @@ void OneMilliSecondMillisecInterrupt(UArg arg0)
     return ;
 }
 uint32_t PT100Activity = 0;
+int32_t MillisecReadFromI2CTempSensor(uint32_t TempSensorId,  MSecFptr Callback)
+{
+#warning call I2C temeratures
+    return OK;
+}
+
 int32_t MillisecReadFromTempSensor(uint32_t TempSensorId,  MSecFptr Callback)
 {
     if (TempSensorId >= MAX_MAIN_CARD_TEMP_SENS_ID) return -1;
     PT100Activity++; //read request
     PT100Data[TempSensorId].Callback = Callback;
     PT100Data[TempSensorId].Active = true;
-
     return OK;
 }
 //typedef  uint32_t (* MSecFptr)(uint32_t deviceID, uint32_t ReadValue);
@@ -562,6 +566,8 @@ float MillisecGetPressures (int SensorId)
 void setRapidPressureRead(bool value)
 {
     RapidPressureRead = value;
+    if (GetDiagnosticMode() == Diagnostic_Extreme_Mode)
+        RapidPressureRead = true;
 }
 
 uint16_t PumpCounter = 0;
@@ -574,11 +580,14 @@ uint32_t MillisecLowLoop(uint32_t tick)
     //call all modules Millisec functions
     //test dancers and speed encoders
     //check all callback units (state machine waiting for completion of a change)
-    bool Ten_msTick, Hundred_msTick , m90msecTick, Onesecond_Tick,OneMinute_Tick,OneHourTick;
+    bool Ten_msTick, Fifty_msTick, Hundred_msTick , m20msecTick,m70msecTick,m90msecTick, Onesecond_Tick,OneMinute_Tick,OneHourTick;
     bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick;
     //bool O100Millisecond_Tick,O200Millisecond_Tick,O400Millisecond_Tick,O500Millisecond_Tick,O600Millisecond_Tick,O800Millisecond_Tick,O900Millisecond_Tick;
     Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
+    Fifty_msTick      =   (tick%eHundredMillisecond == 0)      ?true:false; //eFiftyMillisecond
     Hundred_msTick  =   (tick%eHundredMillisecond == 0)  ?true:false;
+    m20msecTick  =   (tick%eHundredMillisecond == 20)  ?true:false;
+    m70msecTick  =   (tick%eHundredMillisecond == 70)  ?true:false;
     m90msecTick  =   (tick%eHundredMillisecond == 90)  ?true:false;
     O100Millisecond_Tick  =   (tick%eOneSecond == 100)           ?true:false;
     O200Millisecond_Tick  =   (tick%eOneSecond == 200)           ?true:false;
@@ -603,6 +612,29 @@ uint32_t MillisecLowLoop(uint32_t tick)
         if(Machine_Idle_Mode == true)
             Machine_Idle_Breathing_Led();
     }
+#ifdef Use_Head_Card
+    if(Fifty_msTick)
+    {
+            Set_HeadCard_PT100();//call every 50mSec (minimum delay 30mSec)
+    }
+#endif
+#ifdef Use_Head_Card
+    if (m20msecTick) //read odd PT1000
+    {
+        for (Sensor_i = HEAD_PT100_ZONE_1_0X80_0;Sensor_i < HEAD_PT100_ZONE_2_0X80_1;Sensor_i++)
+        {
+            MillisecReadFromI2CTempSensor(Sensor_i, NULL);
+        }
+#warning call chip select replace in I2C
+    }
+    if (m70msecTick) //read odd PT1000
+    {
+        for (Sensor_i = HEAD_PT100_ZONE_2_0X80_1;Sensor_i < HEAD_PT100_RESERVE_0X8E_1;Sensor_i++)
+        {
+            MillisecReadFromI2CTempSensor(Sensor_i, NULL);
+        }
+    }
+#endif
     if (m90msecTick)
     {
 #ifdef Use_Head_Card
@@ -645,6 +677,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
         }
         DispensersCollectionCall();
 
+#ifdef Use_Head_Card
+    Head_Read_IO_Reg(0x46, HIGH);//READ HEAD CARD LS
+#endif
+
     }
     if (O100Millisecond_Tick)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index d59aae8f4..b75e44001 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -45,17 +45,27 @@
 //by recieved esign flow of the user from the UI
 ///////////////////////////////////////////////////////////////////////////////////////////
 #include "include.h"
-#include "Modules/General/GeneralHardware.h"
 
 #include <driverlib/timer.h>
 #include <inc/hw_ints.h>
 
+#include  <PMR/Diagnostics/EventType.pb-c.h>
+
 #include "drivers/adc_sampling/adc.h"
+#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
+#include "drivers/FPGA/FPGA_SPI_Comm.h"
+
 #include "Modules/General/buttons.h"
+#include "Modules/General/GeneralHardware.h"
+#include "Modules/AlarmHandling/AlarmHandling.h"
+
+#include "StateMachines/Printing/PrintingSTM.h"
 
 #include "control.h"
 #include "MillisecTask.h"
-#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
+
+
+
 /******************** Definitions  ********************************************/
 #define MAX_TANGO_CONTROL_DEVICES 120
 /******************** STRUCTURES AND ENUMs  ********************************************/
@@ -169,8 +179,16 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
         ACTIVITY_RED_LED_OFF; // Heaters indication - all the Heaters OFF
         if(FPGA_WD_Occurred == true)
         {
+            FPGA_WD_Occurred = false;
+            AlarmHandlingSetAlarm(EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED,true);
+            JobEndReason = JOB_MOTOR_ALARM;
+            SendJobProgress(0.0,0,false, "Hardware Failure Error");
+            AbortJob("FPGA Watchdog Error");
+            ReportWithPackageFilter(FPGAFilter, "FPGA Watchdog Error",__FILE__,__LINE__,0,RpError, 0,0);
+
             ACTIVITY_GREEN_LED_ON;
-            //Motor_ReconfigAllMotors();
+            FPGA_SetMotorsInit();
+            Motor_ReconfigAllMotors();
         }
 		else
             ACTIVITY_GREEN_LED_OFF;
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.h b/Software/Embedded_SW/Embedded/Modules/Control/control.h
index 4b82aab30..78e24f495 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h
@@ -17,6 +17,7 @@ typedef enum {
     eNoControl = 0,
     eOneMillisecond = 1,
     eTenMillisecond = 10,
+    eFiftyMillisecond = 50,
     eHundredMillisecond = 100,
     eOneSecond = 1000,
     eOneMinute = 60000,
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index fff75fd54..6b2cf0021 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -70,7 +70,7 @@ DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT;
 #define DIAGNOSTICS_LIMIT 3
 #define DIAGNOSTICS_DANCER_LIMIT 30
 int DiagnosticsIndex = 0;
-int DiagnosticCollectionLimit = 2;  //number of data samples to collect before sending to the host
+int DiagnosticCollectionLimit = 3;  //number of data samples to collect before sending to the host
 //int DiagnosticLimit = eHundredMillisecond; //frequency of data collection
 //int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection
 int DiagnosticLimit =eHundredMillisecond; //frequency of data collection
@@ -140,7 +140,6 @@ bool blowervolatgedisplay = false;
 bool midtankDisplay = false;
 double diagvoltage = 0;
 /******************** Functions  ********************************************/
-//uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Read);
 //**********************************************************************
 typedef enum
 {
@@ -221,6 +220,11 @@ void SetDiagnosticMode(Diagnostic_Mode Mode)
     DiagnosticMode = Mode;
     REPORT_MSG(Mode,"Diagnostic Mode set");
 }
+Diagnostic_Mode GetDiagnosticMode(void)
+{
+    return DiagnosticMode;
+}
+
 
 void  SetDiagnosticCollectionLimit(int limit)
 {
@@ -228,11 +232,12 @@ void  SetDiagnosticCollectionLimit(int limit)
         DiagnosticCollectionLimit = limit;
     DiagnosticLimit =eHundredMillisecond; //frequency of data collection
 
-    if (DiagnosticMode <= Diagnostic_Normal_Mode)
+    /*if (DiagnosticMode <= Diagnostic_Normal_Mode)
     {
         DiagnosticCollectionLimit = 1;  //overrule - send at least once every second
         DiagnosticLimit =eOneSecond; //frequency of data collection
-    }
+    }*/
+    REPORT_MSG(DiagnosticCollectionLimit,"Diagnostic limit set");
 }
 
 uint8_t HeaterCounterIndex[HEATER_TYPE_MAX_HEATERS]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
@@ -250,7 +255,7 @@ void DiagnosticLoadMotor(int MotorId, int frequency)
 {
     if (MotorId >= MAX_THREAD_MOTORS_NUM)
     {
-        LOG_ERROR(MotorId,"wrong Heater Id");
+        ReportWithPackageFilter(DiagnosticsFilter,"wrong Motor Id",__FILE__,__LINE__,(int)MotorId,RpError,(int)0,0);
         return;
     }
 
@@ -326,7 +331,7 @@ void DiagnosticLoadTemperature(int HeaterId, int temperature)
     double temp = temperature;
     if (HeaterId >= HEATER_TYPE_MAX_HEATERS)
     {
-        LOG_ERROR(HeaterId,"wrong Heater Id");
+        ReportWithPackageFilter(DiagnosticsFilter,"wrong Heater Id",__FILE__,__LINE__,(int)HeaterId,RpError,(int)0,0);
         return;
     }
     if ((temperature < 1000)||(temperature>28000)) //error read, all 0xF or all 0
@@ -351,7 +356,7 @@ void DiagnosticLoadDancer(int DancerId, uint16_t value)
 {
     if (DancerId >= NUM_OF_DANCERS)
     {
-        LOG_ERROR(DancerId,"wrong Dancer Id");
+        ReportWithPackageFilter(DiagnosticsFilter,"wrong Dancer Id",__FILE__,__LINE__,(int)DancerId,RpError,(int)0,0);
         return;
     }
     DancerValue[DancerId][DancerCounterIndex[DancerId]] = value;
@@ -364,7 +369,7 @@ void DiagnosticLoadDancerError(int DancerId, double value)
 {
     if (DancerId >= NUM_OF_DANCERS)
     {
-        LOG_ERROR(DancerId,"wrong Dancer Id");
+        ReportWithPackageFilter(DiagnosticsFilter,"wrong Dancer Id",__FILE__,__LINE__,(int)DancerId,RpError,(int)0,0);
         return;
     }
     DancerErrorValue[DancerId][DancerErrorCounterIndex[DancerId]] = value;
@@ -496,6 +501,21 @@ void DiagnosticOneMinuteCollection(void)
 void DiagnosticOneSecCollection(void)
 {
     int i;
+#ifdef Use_Head_Card
+    DiagnosticLoadTemperature(HEATER_TYPE__MixerHeater, MillisecGetTemperatures( HEAD_PT100_MIXER_0X8E_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone1, MillisecGetTemperatures(HEAD_PT100_ZONE_1_0X80_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone2, MillisecGetTemperatures(HEAD_PT100_ZONE_2_0X80_1));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone3, MillisecGetTemperatures(HEAD_PT100_ZONE_3_0X82_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone4, MillisecGetTemperatures(HEAD_PT100_ZONE_4_0X82_1));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone5, MillisecGetTemperatures(HEAD_PT100_ZONE_5_0X84_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone6, MillisecGetTemperatures(HEAD_PT100_ZONE_6_0X84_1));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone7, MillisecGetTemperatures(HEAD_PT100_ZONE_7_0X86_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone8, MillisecGetTemperatures(HEAD_PT100_ZONE_8_0X86_1));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone9, MillisecGetTemperatures(HEAD_PT100_ZONE_9_0X88_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone10, MillisecGetTemperatures(HEAD_PT100_ZONE_10_0X88_1));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone11, MillisecGetTemperatures(HEAD_PT100_ZONE_11_0X8A_0));
+    DiagnosticLoadTemperature(HEATER_TYPE__HeaterZone12, MillisecGetTemperatures(HEAD_PT100_ZONE_12_0X8A_1));
+#else
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
@@ -503,7 +523,7 @@ void DiagnosticOneSecCollection(void)
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
-
+#endif
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP3));
@@ -512,8 +532,9 @@ void DiagnosticOneSecCollection(void)
         dispensermotorfrequency[i][DiagnosticsIndex] = IdsGetMotorSpeed(i);
         //dispensermotorfrequency[i][DiagnosticsIndex] = IDS_Dispenser_Data[i].consumedinnanolitter;
 
-        dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
-
+        if (DiagnosticMode < Diagnostic_Extended_Mode)
+            dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
+        MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i);
     }
 }
 void Diagnostic100msecCollection(void)
@@ -523,7 +544,7 @@ void Diagnostic100msecCollection(void)
         return;
 
     //DiagnosticLoadSpeedSensor(getSensorSpeedData());
-    if (DiagnosticMode == Diagnostic_Extreme_Mode)
+    if (DiagnosticMode != Diagnostic_Extreme_Mode)
         DiagnosticTenMsecCollection(); //call the 10msec function every 100 msec to reduce transport
 
     if (DiagnosticMode >= Diagnostic_Extended_Mode)
@@ -536,31 +557,11 @@ void Diagnostic100msecCollection(void)
             DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
             DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
         }
+        for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
+        {
+            dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor
+        }
     }
-    /*
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
-
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP3));
-    for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
-    {
-        dispensermotorfrequency[i][DiagnosticsIndex] = IdsGetMotorSpeed(i);
-        //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);
-    }
-    */
     if (DiagnosticMode == Diagnostic_Extreme_Mode)
     {
         for (i=0;i<NUM_OF_CURRENT_HEATERS;i++)
@@ -591,10 +592,17 @@ void DiagnosticsReset(void)
     SpeedCounterIndex = 0;
     memset(HeaterCounterIndex,0,sizeof(HeaterCounterIndex));
     DiagnosticsIndex = 0;
+    DiagnosticsMonitor.n_dancer1angle =  0;
+    DiagnosticsMonitor.n_dancer2angle =  0;
+    DiagnosticsMonitor.n_dancer3angle =  0;
+    DiagnosticsMonitor.n_windertension =  0;
+    DiagnosticsMonitor.n_pullertension =  0;
+    DiagnosticsMonitor.n_feedertension =  0;
+
 }
 int j=0;
 MessageContainer diagnosticsresponseContainer;
-uint8_t diagnostics_response_buffer[3500];
+uint8_t diagnostics_response_buffer[5500];
 uint8_t *diagnostics_response_ptr = diagnostics_response_buffer;
 char * diagnosticscontainer_buffer=0;
 int LargeMessagesD = 0;
@@ -659,8 +667,8 @@ void SendDiagnostics(void)
         DiagnosticsMonitor.windertension = DancerErrorValue[0];
         DiagnosticsMonitor.pullertension = DancerErrorValue[1];
         DiagnosticsMonitor.feedertension = DancerErrorValue[2];
-        DiagnosticsMonitor.n_threadspeed = SpeedCounterIndex;
-        DiagnosticsMonitor.threadspeed = SpeedValue;
+        //DiagnosticsMonitor.n_threadspeed = SpeedCounterIndex;
+        //DiagnosticsMonitor.threadspeed = SpeedValue;
 
 
         DiagnosticsMonitor.feedermotorfrequency = MotorValue[FEEDER_MOTOR];
@@ -674,40 +682,43 @@ void SendDiagnostics(void)
         DiagnosticsMonitor.n_windermotor =  MotorCounterIndex[WINDER_MOTOR];
         DiagnosticsMonitor.n_screwmotor = MotorCounterIndex[SCREW_MOTOR];
     }
-    DiagnosticsMonitor.mixertemperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__MixerHeater];
-    DiagnosticsMonitor.headzone1temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1];
-    DiagnosticsMonitor.headzone2temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2];
-    DiagnosticsMonitor.headzone3temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3];
-    DiagnosticsMonitor.headzone4temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4];
-    DiagnosticsMonitor.headzone5temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5];
-    DiagnosticsMonitor.headzone6temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6];
-    DiagnosticsMonitor.headzone7temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7];
-    DiagnosticsMonitor.headzone8temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8];
-    DiagnosticsMonitor.headzone9temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9];
-    DiagnosticsMonitor.headzone10temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10];
-    DiagnosticsMonitor.headzone11temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11];
-    DiagnosticsMonitor.headzone12temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12];
-
-    DiagnosticsMonitor.dryerzone1temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature];
-    DiagnosticsMonitor.dryerzone2temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain];
-    DiagnosticsMonitor.dryerzone3temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary];
+    DiagnosticsMonitor.mixertemperature = HeaterTemperature[HEATER_TYPE__MixerHeater];
+    DiagnosticsMonitor.headzone1temperature = HeaterTemperature[HEATER_TYPE__HeaterZone1];
+    DiagnosticsMonitor.headzone2temperature = HeaterTemperature[HEATER_TYPE__HeaterZone2];
+    DiagnosticsMonitor.headzone3temperature = HeaterTemperature[HEATER_TYPE__HeaterZone3];
+    DiagnosticsMonitor.headzone4temperature = HeaterTemperature[HEATER_TYPE__HeaterZone4];
+    DiagnosticsMonitor.headzone5temperature = HeaterTemperature[HEATER_TYPE__HeaterZone5];
+    DiagnosticsMonitor.headzone6temperature = HeaterTemperature[HEATER_TYPE__HeaterZone6];
+#ifdef Use_Head_Card
+    DiagnosticsMonitor.headzone7temperature = HeaterTemperature[HEATER_TYPE__HeaterZone7];
+    DiagnosticsMonitor.headzone8temperature = HeaterTemperature[HEATER_TYPE__HeaterZone8];
+    DiagnosticsMonitor.headzone9temperature = HeaterTemperature[HEATER_TYPE__HeaterZone9];
+    DiagnosticsMonitor.headzone10temperature = HeaterTemperature[HEATER_TYPE__HeaterZone10];
+    DiagnosticsMonitor.headzone11temperature = HeaterTemperature[HEATER_TYPE__HeaterZone11];
+    DiagnosticsMonitor.headzone12temperature = HeaterTemperature[HEATER_TYPE__HeaterZone12];
+#endif
+    DiagnosticsMonitor.dryerzone1temperature = HeaterTemperature[HEATER_TYPE__DryerAirHeater];
+    DiagnosticsMonitor.dryerzone2temperature = HeaterTemperature[HEATER_TYPE__DryerMainHeater];
+    DiagnosticsMonitor.dryerzone3temperature = HeaterTemperature[HEATER_TYPE__DryerSecondaryHeater];
 
-    DiagnosticsMonitor.n_mixertemperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__MixerHeater];
-    DiagnosticsMonitor.n_headzone1temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1];
-    DiagnosticsMonitor.n_headzone2temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2];
-    DiagnosticsMonitor.n_headzone3temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3];
-    DiagnosticsMonitor.n_headzone4temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4];
-    DiagnosticsMonitor.n_headzone5temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5];
-    DiagnosticsMonitor.n_headzone6temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6];
-    DiagnosticsMonitor.n_headzone7temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ7];
-    DiagnosticsMonitor.n_headzone8temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ8];
-    DiagnosticsMonitor.n_headzone9temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ9];
-    DiagnosticsMonitor.n_headzone10temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ10];
-    DiagnosticsMonitor.n_headzone11temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ11];
-    DiagnosticsMonitor.n_headzone12temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ12];
-    DiagnosticsMonitor.n_dryerzone1temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature];
-    DiagnosticsMonitor.n_dryerzone2temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain];
-    DiagnosticsMonitor.n_dryerzone3temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary];
+    DiagnosticsMonitor.n_mixertemperature = HeaterCounterIndex[HEATER_TYPE__MixerHeater];
+    DiagnosticsMonitor.n_headzone1temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone1];
+    DiagnosticsMonitor.n_headzone2temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone2];
+    DiagnosticsMonitor.n_headzone3temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone3];
+    DiagnosticsMonitor.n_headzone4temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone4];
+    DiagnosticsMonitor.n_headzone5temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone5];
+    DiagnosticsMonitor.n_headzone6temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone6];
+#ifdef Use_Head_Card
+    DiagnosticsMonitor.n_headzone7temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone7];
+    DiagnosticsMonitor.n_headzone8temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone8];
+    DiagnosticsMonitor.n_headzone9temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone9];
+    DiagnosticsMonitor.n_headzone10temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone10];
+    DiagnosticsMonitor.n_headzone11temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone11];
+    DiagnosticsMonitor.n_headzone12temperature = HeaterCounterIndex[HEATER_TYPE__HeaterZone12];
+#endif
+    DiagnosticsMonitor.n_dryerzone1temperature = HeaterCounterIndex[HEATER_TYPE__DryerAirHeater];
+    DiagnosticsMonitor.n_dryerzone2temperature = HeaterCounterIndex[HEATER_TYPE__DryerMainHeater];
+    DiagnosticsMonitor.n_dryerzone3temperature = HeaterCounterIndex[HEATER_TYPE__DryerSecondaryHeater];
     DiagnosticsMonitor.n_blowervoltage = 1;
     diagvoltage = getBlowerState();
     DiagnosticsMonitor.blowervoltage = &diagvoltage;
@@ -859,20 +870,20 @@ void SendDiagnostics(void)
             }
             else
             {
-                LOG_ERROR(Task_self(),"my_malloc failed");
+                ReportWithPackageFilter(DiagnosticsFilter,"my_malloc failed, DiagnosticsStop ",__FILE__,__LINE__,(int)Task_self(),RpError,(int)0,0);
                 DiagnosticsStop();
                 //CommunicationMailboxFlush();
             }
         }
         else
         {
-            LOG_ERROR(Task_self(),"previous packet not sent");
+            ReportWithPackageFilter(DiagnosticsFilter,"previous packet not sent",__FILE__,__LINE__,(int)Task_self(),RpError,(int)0,0);
         }
         //my_free(diagnosticsresponseContainer.data.data);
     }
     else
     {
-        LOG_ERROR(Task_self(),"my_malloc failed");
+        ReportWithPackageFilter(DiagnosticsFilter,"my_malloc failed, DiagnosticsStop ",__FILE__,__LINE__,(int)Task_self(),RpError,(int)0,0);
         DiagnosticsStop();
     }
     DiagnosticsReset();
@@ -893,19 +904,19 @@ uint32_t DiagnosticsStart(void)
             if (DiagnosticsControlId == 0xFF)
                 DiagnosticsControlId = AddControlCallback(NULL,Diagnostics_ControlTrigger,DiagnosticLimit,TemplateDataReadCBFunction,0,0,0);
             else
-                LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
+                ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics restarted ",__FILE__,__LINE__,(int)DiagnosticLimit,RpWarning,(int)DiagnosticsControlId,0);
             if (Diagnostics10MSControlId == 0xFF)
                 Diagnostics10MSControlId = AddControlCallback(NULL,Diagnostics_TenMiliControlTrigger,DiagnosticFastLimit,TemplateDataReadCBFunction,0,0,0);
             else
-                LOG_ERROR(DiagnosticsControlId,"Diagnostics restarted");
+                ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics restarted ",__FILE__,__LINE__,(int)DiagnosticFastLimit,RpWarning,(int)Diagnostics10MSControlId,0);
             if (Diagnostics1SecControlId == 0xFF)
                 Diagnostics1SecControlId = AddControlCallback(NULL,Diagnostics_OneSecControlTrigger,eOneSecond,TemplateDataReadCBFunction,0,0,0);
             else
-                LOG_ERROR(Diagnostics1SecControlId,"Diagnostics restarted");
+                ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics restarted ",__FILE__,__LINE__,(int)eOneSecond,RpWarning,(int)Diagnostics1SecControlId,0);
             if (Diagnostics1MinControlId == 0xFF)
                 Diagnostics1MinControlId = AddControlCallback(NULL,Diagnostics_OneMinControlTrigger,eOneMinute,TemplateDataReadCBFunction,0,0,0);
             else
-                LOG_ERROR(Diagnostics1MinControlId,"Diagnostics restarted");
+                ReportWithPackageFilter(DiagnosticsFilter,"Diagnostics restarted ",__FILE__,__LINE__,(int)eOneMinute,RpWarning,(int)Diagnostics1MinControlId,0);
        }
 
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
index d6d515598..69482d7a0 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.h
@@ -23,6 +23,8 @@ typedef enum
 }Diagnostic_Mode;
 
 void SetDiagnosticMode(Diagnostic_Mode Mode);
+Diagnostic_Mode GetDiagnosticMode(void);
+
 uint32_t StartDiagnosticsRequestFunc(MessageContainer* requestContainer);
 uint32_t StopDiagnosticsRequestFunc(MessageContainer* requestContainer);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index b89702668..5f2046c3e 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -124,6 +124,7 @@ uint32_t HWConfigurationInit(void)
     //UploadRequest = upload_hardware_configuration_request__unpack(NULL, Bytes, buffer);
     if (UploadRequest)
     {
+        AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE,OFF);
         status = HWConfiguration(UploadRequest);
         if (status !=OK)
         {
@@ -137,6 +138,10 @@ uint32_t HWConfigurationInit(void)
         }
         upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
     }
+    else
+    {
+        AlarmHandlingSetAlarm (EVENT_TYPE__MACHINE_STATE_NO_CFG_FILE,ON);
+    }
     if (buffer)
         free (buffer);
 
@@ -166,7 +171,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             configuration_parameters__init(EmbeddedParameters);
             EmbeddedParameters->breaksensorlimit = 10;
             EmbeddedParameters->has_diagnosticcollectionlimit = true;
-            EmbeddedParameters->diagnosticcollectionlimit = 1;
+            EmbeddedParameters->diagnosticcollectionlimit = 3;
             EmbeddedParameters->has_overheatcountlimit = true;
             EmbeddedParameters->overheatcountlimit = 3;
             EmbeddedParameters->has_underheatcountlimit = true;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 51498dc04..b879a1404 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -216,6 +216,8 @@ uint32_t InternalId2PT100Id[MAX_INTERNAL_ALARMS] = {TEMP_SENSE_AN_ENCLOSURETEMP1
 int32_t    InternalOverHeatCounter [MAX_INTERNAL_ALARMS] = {0,0,0};
 bool    InternalAlarmActive[MAX_INTERNAL_ALARMS] = {false,false,false};
 uint32_t ControlIdtoInternalId[MAX_INTERNAL_ALARMS] = {0xFF,0xFF,0xFF};
+EventType InternalTempEventType[MAX_INTERNAL_ALARMS] = {EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE,EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2};
+
 uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=HEATER_TYPE_MAX_HEATERS;
@@ -250,7 +252,7 @@ uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValu
 
                     InternalAlarmActive[index] = true;
                     ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature, turned off",__FILE__,index,readValue,RpWarning,  0,0);
-                    AlarmHandlingSetAlarm(EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE, true);
+                    AlarmHandlingSetAlarm(InternalTempEventType[index], true);
             }
         }
     }
@@ -264,7 +266,7 @@ uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValu
 
                 InternalAlarmActive[index] = true;
                 ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature, turned off",__FILE__,index,readValue,RpWarning,  0,0);
-                AlarmHandlingSetAlarm(EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE, false);
+                AlarmHandlingSetAlarm(InternalTempEventType[index], false);
             }
 
         }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 0e28ec736..c49fd81f0 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -509,7 +509,8 @@ uint32_t IDS_Check_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue)
     if (GetDispenserPressure(DispenserId)>3.0)
     {
         Report("Pulling dispenser down to reduce pressure",__FILE__,DispenserId,(int)(GetDispenserPressure(DispenserId)*100),RpWarning,200,0);
-        MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,200);
+
+        MotorMove(HW_Motor_Id,1-MotorsCfg[HW_Motor_Id].directionthreadwize,200*MotorsCfg[HW_Motor_Id].microstep);
     }
     return OK;
 }
@@ -525,6 +526,6 @@ void IDS_Dispenser_Init(uint8_t DispenserId)
     Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF);
     Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
     if (ControlIdtoInactiveDispenserId[DispenserId] == 0xFF)
-        ControlIdtoInactiveDispenserId[DispenserId] = AddControlCallback("IDS_Check_Pressure", IDS_Check_Pressure_Callback, eOneMinute,TemplateDataReadCBFunction ,0, 0, 0 );
+        ControlIdtoInactiveDispenserId[DispenserId] = AddControlCallback("IDS_Check_Pressure", IDS_Check_Pressure_Callback, eOneMinute,TemplateDataReadCBFunction ,DispenserId, 0, 0 );
 
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 3b55758e4..3af6416cb 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -48,7 +48,7 @@ int DispenserSamplePointer[MAX_SYSTEM_DISPENSERS] = {0};
 double DispenserNormalizedErrorCoEfficient[MAX_SYSTEM_DISPENSERS] = {0};
 double lubricant_speed = 0.0;
 HardwarePidControlType ThreadDispenserIdToControlId[MAX_SYSTEM_DISPENSERS] = {  HARDWARE_PID_CONTROL_TYPE__Dispenser1,HARDWARE_PID_CONTROL_TYPE__Dispenser2,HARDWARE_PID_CONTROL_TYPE__Dispenser3,HARDWARE_PID_CONTROL_TYPE__Dispenser4,HARDWARE_PID_CONTROL_TYPE__Dispenser5,HARDWARE_PID_CONTROL_TYPE__Dispenser6,HARDWARE_PID_CONTROL_TYPE__Dispenser7,HARDWARE_PID_CONTROL_TYPE__Dispenser8};
-
+JobUploadStrategy uploadstrategy = JOB_UPLOAD_STRATEGY__Default;
 bool    DispenserReady[MAX_SYSTEM_DISPENSERS] = {true};
 bool IDS_Active = false;
 /******************** STRUCTURES AND ENUMs  ********************************************/
@@ -300,7 +300,8 @@ JobDescriptionFileBrushStop *FirstBrushStop = NULL;
                          {
                              LOG_ERROR (BrushStop->index, "no dispensers in brushstop");
                          }
-                         FreeBrushStopFileData(BrushStop);
+                         if (FirstBrushStop!= BrushStop)
+                             FreeBrushStopFileData(BrushStop);
                          BrushStop = NULL;
                      }
                      else
@@ -356,6 +357,7 @@ c.  Go to step 2.a x Segment.BrushStopsCount.
      JobTicket* JobTicket = JobDetails;
      int Dispenser_i, Segment_i,Brush_i,DispenserId;
 
+     uploadstrategy = JobTicket->uploadstrategy;
      if (JobTicket->uploadstrategy == JOB_UPLOAD_STRATEGY__JobDescriptionFile)
      {
          return (IDS_MapDispenserUsedinFileJob(JobDetails));
@@ -480,7 +482,6 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
  //********************************************************************************************************************
  uint32_t IDS_Prepare_Callback(uint32_t DispenserId, uint32_t ReadValue)
  {
-     bool pressureReady = false;
      int i;
      int NumofReadyDispensers = 0;
      TimerMotors_t  HW_Motor_Id;
@@ -534,16 +535,18 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
          if (NumofReadyDispensers>=NumOfActiveDispensers)
          {
              pressureReady = true;
+             Report("pressureReady = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
          }
          if ((DispenserBuildTimeCounter >= DispenserPrepareTimeout)||(pressureReady == true))
          {
              DispenserBuildTimeCounter = 0;
              pressureReady = true;
+             Report("pressureReady = true  or timeout;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
          }
      }
      else if (endOfPrepareWCF == false)
      {
-         if ((0 == DispenserBuildTimeCounter)&&(FirstBrushStop))
+         if ((DispenserBuildTimeCounter == PRESSURE_READ_TIME_GAP)&&(FirstBrushStop))
          {
              Report("start prepare dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0);
              if (FirstBrushStop)
@@ -600,6 +603,16 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
                              Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
                              //SendJobProgress(0.0, 0, false, IdsMessage);
                          }
+                         else
+                         {
+                             if (DispenserUsedInJob[DispenserId] == true)
+                             {
+                                 MotorStop(HW_Motor_Id, Hard_Hiz);
+                                 CurrentDispenserSpeed[Dispenser_i] = 0;
+                                 usnprintf(IdsMessage, 80,"Presegment Prepare Dispenser %d stopped",DispenserId,(int) segmentfirst_speed);
+                                 Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning,   segmentfirst_speed, 0);
+                             }
+                         }
                      }//for
                  }//if n_dis
              }
@@ -609,9 +622,13 @@ uint32_t InactiveDispenserHome(uint32_t DispenserId, uint32_t ReadValue)
              //close waste valve one second before segment - trial
              Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head);
          }
-         if (InterSegmentStartWFCFDispensers >= DispenserBuildTimeCounter)
+         if (DispenserBuildTimeCounter >=  InterSegmentStartWFCFDispensers)
          {
              endOfPrepareWCF = true;
+             FreeBrushStopFileData(FirstBrushStop);
+             FirstBrushStop =NULL;
+             Report("endOfPrepareWCF = true;",__FILE__,DispenserBuildTimeCounter,NumofReadyDispensers,RpWarning,(int)NumOfActiveDispensers,0);
+
          }
      }
          //start new stage
@@ -1242,7 +1259,7 @@ uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId)
         }
         else
         {
-            LOG_ERROR(FileBrushStop,"BrushStopReadError");
+            LOG_ERROR(FileBrushStop,"End run - BrushStopReadError");
             JobEndReason = JOB_OUT_OF_DYE;
             PreSegmentReady(Module_IDS,ModuleFail);
         }
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 77edc45b5..45cc80dff 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -24,6 +24,10 @@
 #include "Modules/IDS/ids_ex.h"
 #include "Modules/Control/MillisecTask.h"
 
+#include <Drivers/I2C_Communication/I2C.h>
+#include <Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.h>
+#include <Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h>
+
 //#include "graphics_adapter.h"
 extern uint8_t Input_Voltage;
 extern uint8_t Test_Read_Buf[4];
@@ -74,6 +78,50 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
 
     }
+        else
+        if(request->amount == 0x0EAD)  //Head Card I/O
+        {
+            uint8_t Write_Buf[2] = {0,0};
+            uint8_t Script_Slave_Add = request -> delay >> 16;
+            Write_Buf[0] = request -> delay >> 8;
+            Write_Buf[1] = request -> delay & 0x0000FF;
+
+            Select_Main_Head_Mux_Channel();
+            I2C_Write(I2C_ID_HEAD_CARD, Script_Slave_Add, Write_Buf, 2);
+
+            delayms(1);
+
+            uint8_t Read_Buf[2] = {0,0};
+            I2C_Read(I2C_ID_HEAD_CARD, Script_Slave_Add + 1, Read_Buf, 2);
+            response.progress = Read_Buf[1] << 8 | Read_Buf[0];
+            response.has_progress = true;
+
+        }
+        else
+        if(request->amount == 0xFEAD)  //functions Head Card I/O
+        {
+                    Select_Main_Head_Mux_Channel();
+
+                    if((request -> delay & 0xFFF000) == 0xCAF000)//Actuator
+                    {
+                        HeadCard_Actuators_Control((ACTUATORS)((request -> delay & 0x100)>>8), (bool)((request -> delay & 0x10)>>4), (bool)((request -> delay & 0x01)));//Actuators: ID, power, Direction
+                        response.progress = HeadCard_Actuators_Status((ACTUATORS)(request -> delay & 0x100)>>8);
+                        response.has_progress = true;
+                    }
+                    else
+                    if((request -> delay & 0xFF0000) == 0xCA0000)//control all heaters
+                    {
+                        if(request -> delay & 0x01)
+                        {
+                            Disconnect_Mixer_and_12_Heaters_Latch();
+                            HeadCard_Control_Heaters((request -> delay & 0xFF00)>>8, TRUE);
+                            Connect_Mixer_and_12_Heaters_Latch();
+                        }
+                        else
+                            HeadCard_Control_Heaters((request -> delay & 0xFF00)>>8, FALSE);
+                    }
+
+    }
     else
     if((request->amount == 0xFAC0) /*&& (request->delay == 0xFAC)*/) //Head Fan control
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c
index 4bac7f7e4..f4384ab94 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c
@@ -39,6 +39,7 @@
 
 #include "Modules/thread/thread.h"
 #include "Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h"
+#include "Drivers/I2C_Communication/Head_Card/PT100/ADS122X04.h"
 
 void Stub_TempSensorRequest(MessageContainer* requestContainer)
 {
@@ -71,7 +72,7 @@ void Stub_TempSensorRequest(MessageContainer* requestContainer)
         }
         else if(request->stemp_sensor_id < MAX_HEAD_CARD_TEMP_SENS_ID)
         {
-            response.temperature_c_mult_by_100 = Test_ADS122X_Internal_Temperature_Sensor(request->stemp_sensor_id);//head / WHS
+            response.temperature_c_mult_by_100 = Test_ADS122X_Internal_Temperature_Sensor(request->stemp_sensor_id) *100;//head / WHS
         }
         response.has_temperature_c_mult_by_100 = true;
 
@@ -83,22 +84,70 @@ void Stub_TempSensorRequest(MessageContainer* requestContainer)
         first_time_flag = TRUE;
 
     }
-    else
+    else if(request->stemp_sensor_id & 0x8000) //Init + Read the temperature from ADC
     {
+        request->stemp_sensor_id = request->stemp_sensor_id &~0x8000;
 
         response.temp_sensor_id = request->stemp_sensor_id;
         response.has_temp_sensor_id = true;
 
+        if(first_time_flag == TRUE)
+        {
+            FPGA_SensorInitConfig();
+            HeadADCPT100_SensorInitConfig();
+            first_time_flag = FALSE;
+        }
+
+        if(request->stemp_sensor_id < MAX_MAIN_CARD_TEMP_SENS_ID)
+        {
+        }
+        else
+        if(request->stemp_sensor_id < MAX_HEAD_CARD_TEMP_SENS_ID)
+        {
+            control_HeadCard_PT100(HEAD_CONFIG_ODD_PT100_MUX);
+            delayms(50);//must use deley
+            control_HeadCard_PT100(HEAD_CONFIG_EVEN_PT100_MUX);
+            //delayms(5000);//must use deley
+            //control_HeadCard_PT100(HEAD_CONFIG_ODD_PT100_MUX);
 
+            //response.temperature_c_mult_by_100 = TempSensorResponse[request->stemp_sensor_id].PT100_ADC_Reading_Bits;
+            //response.temperature_c_mult_by_100 = TempSensorResponse[12].Temperature_C_mult_by_100;
+        }
+    }
+    else //
+    {
+
+        response.temp_sensor_id = request->stemp_sensor_id;
+        response.has_temp_sensor_id = true;
 
-        //Debug_Start_PT00(request->stemp_sensor_id);
 
         if(first_time_flag == TRUE)
         {
             FPGA_SensorInitConfig();
-            HeadADCPT100_InitConfigReg();
+            HeadADCPT100_SensorInitConfig();
             first_time_flag = FALSE;
         }
+        //Debug_Start_PT00(request->stemp_sensor_id);
+
+        if(request->stemp_sensor_id < MAX_MAIN_CARD_TEMP_SENS_ID)
+        {
+            response.temperature_c_mult_by_100 = TempSensorResponse[request->stemp_sensor_id].Temperature_C_mult_by_100;
+        }
+        else if(request->stemp_sensor_id < MAX_HEAD_CARD_TEMP_SENS_ID)
+        {
+            /*
+            //--------------------------------------------------------------------------------------
+            if(request->stemp_sensor_id < HEAD_PT100_ZONE_2_0X80_1)
+                control_HeadCard_PT100(HEAD_CONFIG_ODD_PT100_MUX);
+            else
+                control_HeadCard_PT100(HEAD_CONFIG_EVEN_PT100_MUX);
+            //---------------------------------------------------------------------------------------
+
+             */
+            //response.temperature_c_mult_by_100 = TempSensorResponse[request->stemp_sensor_id].PT100_ADC_Reading_Bits;
+            //delayms(1000);
+            response.temperature_c_mult_by_100 = TempSensorResponse[request->stemp_sensor_id].Temperature_C_mult_by_100;
+        }
 
 
 
@@ -131,7 +180,7 @@ void Stub_TempSensorRequest(MessageContainer* requestContainer)
             SysCtlDelay(400);
             TemperatureSensorReadFromFPGA_Res((TEMPERATURE_SENSOR_ID_ENUM)request->stemp_sensor_id);
             */
-            response.temperature_c_mult_by_100 = TempSensorResponse[request->stemp_sensor_id].Temperature_C_mult_by_100;
+
             response.has_temperature_c_mult_by_100 = true;
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
index 56fb79c23..d1d23598f 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h
@@ -82,6 +82,7 @@ void     SetKeepWindingCone(bool value);
 void SetWinderBackToBaseTime(uint32_t value);
 
 uint32_t DancerConfigMessage(HardwareDancer * request);
+uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Read);
 
 void SetOriginMotorSpeed(float process_speed);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index 852c19a1a..aeacde455 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -36,6 +36,10 @@
 #include "PMR/Stubs/StubHeatingTestResponse.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestPollRequest.pb-c.h"
 #include "PMR/Stubs/StubHeatingTestPollResponse.pb-c.h"
+#include "PMR/ThreadLoading/StartThreadLoadingRequest.pb-c.h"
+#include "PMR/ThreadLoading/StartThreadLoadingResponse.pb-c.h"
+#include "PMR/ThreadLoading/ContinueThreadLoadingRequest.pb-c.h"
+#include "PMR/ThreadLoading/ContinueThreadLoadingResponse.pb-c.h"
 
 //#include <stdint.h>
 //#include <stdbool.h>
@@ -62,6 +66,8 @@
     THREAD_LOAD_STAGES_ENUM LoadStages = THREAD_LOAD_INIT;
     ProcessParameters ProcessParametersClear,ProcessParametersRecover;
 
+    uint32_t LoadStatus = OK;
+    char LoadErrorMsg[100];
     int32_t keepmicrostep;
     int32_t keepkvalrun,keepkvalhold;
     uint8_t CallbackCounter = 0;
@@ -70,10 +76,16 @@
     uint32_t UnloadingStart = 0;
     uint8_t NumberOfDrierLoaderCycles = 0;
     uint32_t status = OK;
-    uint32_t LoadingControlId = 0xFF,PullerControlId = 0xFF,WinderControlId = 0xFF;
+    uint32_t LoadingControlId = 0xFF,PullerControlId = 0xFF,WinderControlId = 0xFF, SpeedTControlId = 0xFF;
+    uint32_t previousPosition = 0, currentPosition = 0,Tinitialpos = 0xFFFF;
+    uint32_t LoadCounter = 0;
+    double TotalProcessedLen = 0.0;
+    double LengthCalculationMultiplier;
     uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM LoadStages);
     uint32_t ThreadLoadControlCBFunction(uint32_t index, uint32_t ReadValue);
+    uint32_t ThreadLoadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue);
     uint32_t Thread_Load_Dryer_UnLoading(void);
+    uint32_t ThreadLoadingReport(void);
 
     typedef struct
     {
@@ -104,13 +116,17 @@
         //FRESULT Fresult = FR_OK;
         REPORT_MSG(LoadStages, "Thread Load State Machine step");
 
-        LoadArmInfo.LoadArmBackLash = 5;
+        LoadStatus = OK;
+        LoadArmInfo.LoadArmBackLash = MCU_E2PromDryerBacklashRead();
+        REPORT_MSG(LoadArmInfo.LoadArmBackLash, "Thread Load MCU_E2PromDryerBacklashRead");
+        if (LoadArmInfo.LoadArmBackLash > 10)
+            LoadArmInfo.LoadArmBackLash = 5;
         //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);
@@ -156,6 +172,8 @@
         if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
         {
             LOG_ERROR (LoadStages, "Thread_Load_Init failed");
+            strcpy(LoadErrorMsg,"Thread_Load_Init failed");
+            LoadStatus = ERROR;
         }
         else
         {
@@ -294,6 +312,9 @@
                     LOG_ERROR(LoadStages,"Load sequence timeout");
                     TimeoutsCounter = 0;
                     load.color = fastBILNK;
+                    usnprintf(LoadErrorMsg, 100, "Load sequence timeout %d motor %d",LoadStages, MotorId);
+                    LoadStatus = ERROR;
+                    ThreadLoadingReport();
                 }
                 else
                 {
@@ -310,6 +331,7 @@
                     else
                     {
                         load.color = fastBILNK;
+                        ThreadLoadingReport();
                     }
                 }
             }
@@ -472,6 +494,13 @@
             RemoveControlCallback(LoadingControlId, ThreadLoadControlCBFunction );
             LoadingControlId = 0xFF;
         }
+        if (SpeedTControlId != 0xFF)
+        {
+           RemoveControlCallback(SpeedTControlId, ThreadLoadLengthCBFunction );
+           SpeedTControlId = 0xFF;
+        }
+        Report("Total Feeder load",__FILE__,__LINE__,dryerbufferCentimeters,RpMessage,TotalProcessedLen,0);
+
         if (CallbackCounter)
         {
             CallbackCounter--;
@@ -546,6 +575,15 @@
 
         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);
+        if (SpeedTControlId != 0xFF)
+        {
+            RemoveControlCallback(SpeedTControlId,ThreadLoadLengthCBFunction);
+            SpeedTControlId = 0xFF;
+        }
+        //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
+        LengthCalculationMultiplier = (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].pulleyradius*2*PI)/(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].pulseperround*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].microstep);
+        SpeedTControlId = AddControlCallback(NULL,ThreadLoadLengthCBFunction, eHundredMillisecond,MotorGetPositionFromFPGA,(IfTypeThread*0x100+HARDWARE_MOTOR_TYPE__MOTO_RDRIVING),HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,0);
+        Tinitialpos = 0xFFFF;previousPosition = 0; currentPosition = 0;
         CallbackCounter++;
         Report("Thread_Load_Dryer_Loading",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
         MotorMoveWithCallback (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM].directionthreadwize,
@@ -596,6 +634,11 @@
             RemoveControlCallback(WinderControlId, ThreadLoadControlCBFunction );
             WinderControlId = 0xFF;
         }
+        if (SpeedTControlId != 0xFF)
+        {
+           RemoveControlCallback(SpeedTControlId, ThreadLoadLengthCBFunction );
+           SpeedTControlId = 0xFF;
+        }
 
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM);
         MotorStopAction(HARDWARE_MOTOR_TYPE__MOTO_RLOADING);
@@ -673,12 +716,10 @@
         //                       numberOfSteps,    Thread_Load_Dryer_Loading_Callback, 100000);
         UnloadingStart = msec_millisecondCounter;
         Report("Thread_Load_Set_Load_Arm_To_Start_Position",__FILE__,UnloadingStart,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0);
-        LoadArmInfo.LoadArmBackLash = 5;
         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);
 
         //Keep Notation How Many Rotations In The Dryer
-        //LoadArmInfo.LoadArmBackLash = 0;
         LoadArmInfo.LoadArmRounds = (int)dryerbufferlength;
         load.color = BLINK;
         return OK;
@@ -752,6 +793,7 @@
         case THREAD_LOAD_JOG_THREAD: //JOG THREAD SHORTLY TO MAKE SURE SPOOL IS RUNNING. REPORT END OF LOADING
             //LoadStages++;
             Thread_Load_Jog_Thread();
+            ThreadLoadingReport();
             break;
         case THREAD_LOAD_END:
             LoadStages = THREAD_LOAD_END;
@@ -770,6 +812,11 @@ uint32_t ThreadLoadButton(THREAD_LOAD_STAGES_ENUM ReadValue)
         Report("ThreadLoadButton called on job",__FILE__,__LINE__,LoadStages,RpMessage,ReadValue,0);
         return ERROR;
     }
+    if (CallbackCounter)
+    {
+        Report("ThreadLoadButton called when the loading is active",__FILE__,__LINE__,LoadStages,RpMessage,CallbackCounter,0);
+        return ERROR;
+    }
     Report("ThreadLoadButton",__FILE__,__LINE__,LoadStages,RpMessage,ReadValue,0);
     if (LoadStages > ReadValue)
     {
@@ -781,8 +828,60 @@ uint32_t ThreadLoadButton(THREAD_LOAD_STAGES_ENUM ReadValue)
     }
     return OK;
 }
-uint32_t LoadCounter = 0;
 
+uint32_t ThreadLoadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
+{
+    uint32_t positionDiff = 0,prevprev;
+    double length = 0.0;
+    char lenstr[150];
+
+    int index = MAX_THREAD_MOTORS_NUM;
+    if (IfIndex>>8 != IfTypeThread)
+    {
+        LOG_ERROR (IfIndex, "Wrong  Interface type");
+        return 0xFFFFFFFF;
+    }
+    index = IfIndex&0xFF;
+//    if (CurrentRequestedLength == 0.0)
+//        return OK;
+    if (index != HARDWARE_MOTOR_TYPE__MOTO_RDRIVING)
+    {
+        LOG_ERROR (IfIndex, "Wrong Motor");
+        return 0xFFFFFFFF;
+    }
+    currentPosition = MotorGetPosition(HARDWARE_MOTOR_TYPE__MOTO_RDRIVING);
+    if (currentPosition != 0)
+    {
+        if (Tinitialpos == 0xFFFF)
+        {
+            previousPosition = currentPosition;
+            Tinitialpos = 0;
+        }
+        prevprev = previousPosition;
+        positionDiff = Control_Delta_Position_Pass(currentPosition,previousPosition);
+        //positionDiff = positionDiff / MotorsCfg[ThreadMotorIdToMotorId[index]].microstep;
+        previousPosition = currentPosition;
+
+        // total length = (position diff / full cycle) * pulley perimeter
+        //(positionDiff/pulseperround)*((2*PI*motor_Radius)
+
+        //positionDiff = positionDiff / MotorsCfg[ThreadMotorIdToMotorId[index]].microstep;
+        length = (double)(positionDiff)*LengthCalculationMultiplier;
+
+        //if (length > 1000)
+        {
+            usnprintf(lenstr, 100, " length %d, diff 0x%x, pos 0x%x prev 0x%x",(int)length*100,(int)positionDiff,previousPosition,prevprev);
+            SendJobProgress(0.0,0,false, lenstr);
+            ReportWithPackageFilter(ThreadFilter,lenstr,__FILE__,__LINE__,(int)TotalProcessedLen,RpWarning,(int)TotalProcessedLen,0);
+            length = 0;
+
+        }
+
+    }
+    TotalProcessedLen += length;
+
+    return OK;
+}
 uint32_t ThreadLoadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
     //read value is the dancer angle
@@ -911,6 +1010,7 @@ void ThreadLoadRequest(MessageContainer* requestContainer)
 //    return ERROR;
 //#endif
 }
+
 void ThreadLoadPollRequest(MessageContainer* requestContainer)
 {
     uint8_t* container_buffer;
@@ -936,3 +1036,86 @@ void ThreadLoadPollRequest(MessageContainer* requestContainer)
     SendChars(container_buffer, container_size);
     stub_heating_test_poll_request__free_unpacked(request,NULL);
 }
+char ThreadLoadingToken[36+1] = {0};
+int MessageState = 0; //0 - none, 1 = start, 2 = continue
+uint32_t ThreadLoadingReport(void)
+{
+    MessageContainer responseContainer;
+    bool last = false;
+    StartThreadLoadingResponse response = START_THREAD_LOADING_RESPONSE__INIT;
+    ContinueThreadLoadingResponse Cresponse = CONTINUE_THREAD_LOADING_RESPONSE__INIT;
+
+    if (ThreadLoadingToken[0] == 0)
+        return OK;
+
+    if (MessageState == 1)
+    {
+        response.has_state = true;
+        if (LoadStatus == OK)
+        {
+            response.state = THREAD_LOADING_STATE__Preparing;
+            if (LoadStages == THREAD_LOAD_INITIAL_TENSION)
+            {
+                response.state = THREAD_LOADING_STATE__ReadyForLoading;
+                last = true;
+            }
+        }
+        else
+        {
+            response.state = THREAD_LOADING_STATE__PreparationError;
+            response.errorreason = LoadErrorMsg;
+        }
+        responseContainer = createContainer(MESSAGE_TYPE__StartThreadLoadingResponse, ThreadLoadingToken, last, &response, &start_thread_loading_response__pack, &start_thread_loading_response__get_packed_size);
+        responseContainer.continuous = true;
+    }
+    else if (MessageState == 2)
+    {
+        Cresponse.has_state = true;
+        if (LoadStatus == OK)
+        {
+            Cresponse.state = THREAD_LOADING_STATE__Finalizing;
+            if (LoadStages >= THREAD_LOAD_JOG_THREAD)
+            {
+                Cresponse.state = THREAD_LOADING_STATE__Completed;
+                last = true;
+            }
+        }
+        else
+        {
+            Cresponse.state = THREAD_LOADING_STATE__FinalizationError;
+            Cresponse.errorreason = LoadErrorMsg;
+        }
+        responseContainer = createContainer(MESSAGE_TYPE__ContinueThreadLoadingResponse, ThreadLoadingToken, last, &Cresponse, &continue_thread_loading_response__pack, &continue_thread_loading_response__get_packed_size);
+        responseContainer.continuous = true;
+    }
+    else return ERROR;
+
+    //-------------------------------------------------------------------------------------------
+    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
+    size_t container_size = message_container__pack(&responseContainer, container_buffer);
+    my_free(responseContainer.data.data);
+    SendChars((char*)container_buffer, container_size);
+
+    return OK;
+
+}
+
+uint32_t StartThreadLoadingFunc(MessageContainer* requestContainer)
+{
+    StartThreadLoadingRequest *request = start_thread_loading_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    ustrncpy (ThreadLoadingToken, requestContainer->token,36);
+    MessageState = 1;
+    ThreadLoadingReport();
+    return OK;
+
+}
+
+uint32_t ContinueThreadLoadingFunc(MessageContainer* requestContainer)
+{
+    ContinueThreadLoadingRequest *request = continue_thread_loading_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
+    ustrncpy (ThreadLoadingToken, requestContainer->token,36);
+    MessageState = 2;
+    ThreadLoadingReport();
+    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 4c4ab2bcc..4db985954 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -140,13 +140,13 @@ uint32_t Winder_Prepare(void *JobDetails)
      * report ready to the job STM
      */
 
-    /*if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
+    if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
     {
         REPORT_MSG(LIMIT, "No cone in winder");
-        PrepareReady(Module_Winder,ModuleFail);
-        AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
-        return ERROR;
-    }*/
+     //   PrepareReady(Module_Winder,ModuleFail);
+     //   AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,true);
+     //   return ERROR;
+    }
 
 #ifdef READ_SCREW_ENCODER
     ScrewLocationRun[0] = 0;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 29876549e..772025072 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -74,6 +74,9 @@ bool ThreadLoadingActive(void);
 void ThreadLoadPollRequest(MessageContainer* requestContainer);
 void ThreadLoadRequest(MessageContainer* requestContainer);
 
+uint32_t StartThreadLoadingFunc(MessageContainer* requestContainer);
+uint32_t ContinueThreadLoadingFunc(MessageContainer* requestContainer);
+
 uint32_t Thread_Load_End(void);
 
 #endif
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index 226bb2559..0df950f34 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -154,12 +154,12 @@ char DancerConfigPath[50] = "0://SysInfo//DancCfg.cfg";
 uint32_t StoreDancerConfigMessage()
 {
     uint32_t status = OK;
-  /*  FRESULT Fresult = FR_OK;
-  //  HardwareConfiguration DancerConfig;
-  //  HardwareDancer Dancers[MAX_SYSTEM_DANCERS];
+  //  FRESULT Fresult = FR_OK;
+    HardwareConfiguration DancerConfig;
+    HardwareDancer Dancers[MAX_SYSTEM_DANCERS];
   //  uint8_t* response_buffer;
   //  size_t response_size = 0;
-  //  int Dancer_i;
+    int Dancer_i;
 
     hardware_configuration__init(&DancerConfig);
     DancerConfig.dancers = (HardwareDancer**)my_malloc(sizeof(HardwareDancer*)*MAX_SYSTEM_DANCERS);
@@ -174,7 +174,7 @@ uint32_t StoreDancerConfigMessage()
         DancerConfig.n_dancers++;
         DancersCfg[Dancer_i].zeropoint = DancerConfig.dancers[Dancer_i]->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);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index c0d571fab..f0331b4bc 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -158,7 +158,7 @@ uint32_t ThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 #endif
     if (IfIndex>>8 != IfTypeThread)
     {
-        LOG_ERROR (IfIndex, "Wrong  Interface type");
+        ReportWithPackageFilter(ThreadFilter,"Wrong  Interface type",__FILE__,__LINE__,(int)IfIndex,RpError,(int)PoolerTotalProcessedLength,0);
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
@@ -166,7 +166,7 @@ uint32_t ThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 //        return OK;
     if (index != FEEDER_MOTOR)
     {
-        LOG_ERROR (IfIndex, "Wrong Motor");
+        ReportWithPackageFilter(ThreadFilter,"Wrong  Motor",__FILE__,__LINE__,(int)IfIndex,RpError,(int)index,0);
         return 0xFFFFFFFF;
     }
     CurrentPosition = MotorGetPosition(ThreadMotorIdToMotorId[index]);
@@ -248,7 +248,7 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 #endif
     if (IfIndex>>8 != IfTypeThread)
     {
-        LOG_ERROR (IfIndex, "Wrong  Interface type");
+        ReportWithPackageFilter(ThreadFilter,"Wrong  Interface type",__FILE__,__LINE__,(int)IfIndex,RpError,(int)PoolerTotalProcessedLength,0);
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
@@ -256,7 +256,7 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 //        return OK;
     if (index != POOLER_MOTOR)
     {
-        LOG_ERROR (IfIndex, "Wrong Motor");
+        ReportWithPackageFilter(ThreadFilter,"Wrong  Motor",__FILE__,__LINE__,(int)IfIndex,RpError,(int)index,0);
         return 0xFFFFFFFF;
     }
     PoolerCurrentPosition = MotorGetPosition(ThreadMotorIdToMotorId[index]);
@@ -300,9 +300,12 @@ uint32_t PoolerThreadLengthCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     {
         if (PrepareState == true)
         {
+#ifdef Use_Head_Card
+            strcpy(Lenstr,"Heating up");
+#else
             //later - add temperatures
              TemperatureListString(Lenstr);
-
+#endif
             SendJobProgress(0.0,0,false, Lenstr);
         }
         else
@@ -340,7 +343,7 @@ uint32_t ThreadSpeedControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     float speed = getSensorSpeedData();
     if (IfIndex>>8 != IfTypeThread)
     {
-        LOG_ERROR (IfIndex, "Wrong  Interface type");
+        ReportWithPackageFilter(ThreadFilter,"Wrong  Interface type",__FILE__,__LINE__,(int)IfIndex,RpError,(int)PoolerTotalProcessedLength,0);
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
@@ -372,7 +375,7 @@ uint32_t ThreadControlSpeedReadFunction(uint32_t IfIndex, uint32_t ReadValue)
     int index;
     if (IfIndex>>8 != IfTypeThread)
     {
-        LOG_ERROR (IfIndex, "Wrong  Interface type");
+        ReportWithPackageFilter(ThreadFilter,"Wrong  Interface type",__FILE__,__LINE__,(int)IfIndex,RpError,(int)PoolerTotalProcessedLength,0);
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
@@ -465,7 +468,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 #endif
     if (IfIndex>>8 != IfTypeThread)
     {
-        LOG_ERROR (IfIndex, "Wrong  Interface type");
+        ReportWithPackageFilter(ThreadFilter,"Wrong  Interface type",__FILE__,__LINE__,(int)IfIndex,RpError,(int)PoolerTotalProcessedLength,0);
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
@@ -487,7 +490,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             if (dancerinvalid == false)
             {
                 dancerinvalid = true;
-                LOG_ERROR(index, "Dancer value invalid.");
+                ReportWithPackageFilter(ThreadFilter,"Dancer value invalid.",__FILE__,__LINE__,(int)IfIndex,RpError,(int)ReadValue,0);
             }
             return OK;
         }
@@ -725,6 +728,8 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
     AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER,false);
     AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,false);
     AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,false);
+    AlarmHandlingSetAlarm(EVENT_TYPE__FPGA_WATCHDOG_ACTIVATED,false);
+
 
     EnableLubrication = JobTicket->enablelubrication;
     EnableIntersegment = JobTicket->enableintersegment;
@@ -735,16 +740,16 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
     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);
-        JobEndReason = JOB_LIDS_OPEN;
-        PrepareReady(Module_Thread,ModuleFail);
-        return ERROR;
+        //JobEndReason = JOB_LIDS_OPEN;
+        //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);
-        JobEndReason = JOB_LIDS_OPEN;
-        PrepareReady(Module_Thread,ModuleFail);
-        return ERROR;
+        //JobEndReason = JOB_LIDS_OPEN;
+        //PrepareReady(Module_Thread,ModuleFail);
+        //return ERROR;
     }
 
     //start thread control for all motors
@@ -790,7 +795,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                 if (PoolerSpeedControlId != 0xFF)
                 {
                     if (RemoveControlCallback(PoolerSpeedControlId,PoolerThreadLengthCBFunction)!=OK)
-                        LOG_ERROR(Motor_i,"Remove Control Failed");
+                        ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)PoolerSpeedControlId,0);
                      PoolerSpeedControlId = 0xFF;
                 }
                 //SetMotHome(ThreadMotorIdToMotorId[Motor_i]);
@@ -802,7 +807,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                 if (ControlIdtoMotorId[Motor_i] != 0xFF)
                 {
                     if(RemoveControlCallback(ControlIdtoMotorId[Motor_i],ThreadControlCBFunction)!=OK)
-                        LOG_ERROR(Motor_i,"Remove Control Failed");
+                        ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)PoolerSpeedControlId,0);
                     ControlIdtoMotorId[Motor_i] = 0xFF;
                     CurrentControlledSpeed[Motor_i] = 0;
                 }
@@ -816,7 +821,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                 if (ControlIdtoMotorId[Motor_i] != 0xFF)
                 {
                     if(RemoveControlCallback(ControlIdtoMotorId[Motor_i],ThreadControlCBFunction)!=OK)
-                        LOG_ERROR(Motor_i,"Remove Control Failed");
+                        ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)PoolerSpeedControlId,0);
                     CurrentControlledSpeed[Motor_i] = 0;
                     ControlIdtoMotorId[Motor_i] = 0xFF;
                 }
@@ -830,7 +835,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request)
                 if (ControlIdtoMotorId[Motor_i] != 0xFF)
                 {
                     if(RemoveControlCallback(ControlIdtoMotorId[Motor_i],ThreadControlCBFunction)!=OK)
-                        LOG_ERROR(Motor_i,"Remove Control Failed");
+                        ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)PoolerSpeedControlId,0);
                     CurrentControlledSpeed[Motor_i] = 0;
                     ControlIdtoMotorId[Motor_i] = 0xFF;
                 }
@@ -908,10 +913,10 @@ uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId)
     float process_speed = dyeingspeed;
     if (dyeingspeed == 0)
     {
-        LOG_ERROR (dyeingspeed," job speed zero");
+        ReportWithPackageFilter(ThreadFilter,"job speed zero.",__FILE__,__LINE__,(int)dyeingspeed,RpError,(int)SegmentId,0);
         return ERROR;
     }
-    REPORT_MSG (dyeingspeed," ThreadPreSegmentState");
+    ReportWithPackageFilter(ThreadFilter,"ThreadPreSegmentState",__FILE__,__LINE__,(int)dyeingspeed,RpWarning,(int)SegmentId,0);
     if (SegmentId == 0) // do all this only in the beginning of the job. do not touch after that (assuming spool does not change mid job)
     {
         SetOriginMotorSpeed(process_speed);
@@ -1055,13 +1060,13 @@ char Endstr[150];
      if (SpeedControlId != 0xFF)
      {
          if(RemoveControlCallback(SpeedControlId,ThreadLengthCBFunction)!=OK)
-             LOG_ERROR(SpeedControlId,"RemoveControl Failed");
+             ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)SpeedControlId,0);
          SpeedControlId = 0xFF;
      }
      if (PoolerSpeedControlId != 0xFF)
      {
          if(RemoveControlCallback(PoolerSpeedControlId,PoolerThreadLengthCBFunction)!=OK)
-             LOG_ERROR(PoolerSpeedControlId,"RemoveControl Failed");
+             ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)PoolerSpeedControlId,0);
          PoolerSpeedControlId = 0xFF;
      }
 
@@ -1072,7 +1077,7 @@ char Endstr[150];
              if(RemoveControlCallback(ControlIdtoMotorId[Motor_i],ThreadControlCBFunction) == OK)
                  ControlIdtoMotorId[Motor_i] = 0xFF;
              else
-                 LOG_ERROR (ControlIdtoMotorId[Motor_i],"Remove Control failed");
+                 ReportWithPackageFilter(ThreadFilter,"Remove Control Failed.",__FILE__,__LINE__,(int)Motor_i,RpError,(int)ControlIdtoMotorId[Motor_i],0);
          }
      }
 	 Task_sleep(10);