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

13 files changed, 124 insertions, 64 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 518100ae0..c046aa4ea 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -48,7 +48,7 @@
 #include "drivers/FPGA/Moters_Driver/L6470.h"
 #include "drivers/Motors/Motor.h"
 #include "drivers/Heater/TemperatureSensor.h"
-
+#include "drivers/Flash_ram/FlashProgram.h"
 
 Task_Handle AlarmHandling_Task_Handle;
 Mailbox_Handle          AlarmHandlingMsgQ = NULL;
@@ -114,7 +114,13 @@ typedef struct
 }AlarmStatusItem;
 AlarmStatusItem  AlarmState[MAX_SYSTEM_ALARMS];
 
-const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
+#define FLASH_MAP _Pragma("location = MOTOR_MAP_IN_FLASH")
+/*
+* Use this pragma directive to specify the location—the absolute address—of the global
+* or static variable whose declaration follows the pragma directive (only if using it without #define for example: #pragma location = MOTOR_MAP_IN_FLASH)
+* The variables must be declared either __no_init or const!
+*/
+FLASH_MAP const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
  {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY,"Dispenser 1 Empty"},
  {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY,"Dispenser 2 Empty"},
  {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY,"Dispenser 3 Empty"},
@@ -183,13 +189,13 @@ const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
  {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_STALL,"MotorDispenser6Stall"},
  {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_STALL,"MotorDispenser7Stall"},
  {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_STALL,"MotorDispenser8Stall"},
- {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE,"Mixer Over Temperature"},
+ {eHundredMillisecond,TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE,"Mixer Over Temperature"},
  {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,"DyeingHead1 Over Temperature"},
  {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,"DyeingHead2 Over Temperature"},
  {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,"DyeingHead3 Over Temperature"},
  {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,"DyeingHead4 Over Temperature"},
  {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,"DyeingHead5 Over Temperature"},
- {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,"DyeingHead6 Over Temperature"},
+ {eHundredMillisecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,"DyeingHead6 Over Temperature"},
  {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,"Dryer Over Temperature"},
 
  /*{eHundredMillisecond,CoversAlarm,FrontDoor1    ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN,"Front door #1 Open"},
@@ -199,21 +205,21 @@ const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
  {eHundredMillisecond,CoversAlarm,RearDoor      ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN,"Rear door Open"},
  {eHundredMillisecond,CoversAlarm,CartridgesDoor,1,false,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN,"Cartridges door Open"},*/
 
- {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"},
+ {eOneSecond,TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"},
- {eOneSecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"},
+ {eOneSecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"},
- {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"},
+ {eOneSecond,TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,"DyeingHead 1 PT100 Heating Failure"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,"DyeingHead 2 PT100 Heating Failure"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,"DyeingHead 3 PT100 Heating Failure"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,"DyeingHead 4 PT100 Heating Failure"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,"DyeingHead 5 PT100 Heating Failure"},
- {eOneSecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,"DyeingHead 6 PT100 Heating Failure"},
+ {eOneSecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,"DyeingHead 6 PT100 Heating Failure"},
  {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,"Dryer PT100 Heating Failure"},
  { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT                         ," MotorRightLoaderOverCurrent "                },                                           /* 3004 */
  { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT                          ," MotorLeftLoaderOverCurrent  "                },                                           /* 3006 */
@@ -487,32 +493,47 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                 break;
             }
         }
+        if (AlarmItem[Alarm_i].AlarmSource == MotorAlarm)
+        {
+            if (AlarmState[Alarm_i].Status == true)
+            {
+                if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
+				{
+	                status = ERROR;
+    	            AlarmId = Alarm_i;
+        	        break;
+				}
+            }
+        }
     }
     if (Configured[Module_Heaters])
     {
-        for (Heater_i = 0;Heater_i<MAX_HEATERS_NUM;Heater_i++)
+        if (HeaterCheckReady()==false)
         {
-            LoadHeaterState((HeaterType)Heater_i,&HeaterState);
-            if (HeaterState.setpoint)//temperature is set - heater active
+            for (Heater_i = 0;Heater_i<MAX_HEATERS_NUM;Heater_i++)
             {
-                for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++)
+                LoadHeaterState((HeaterType)Heater_i,&HeaterState);
+                if (HeaterState.setpoint)//temperature is set - heater active
                 {
-                    if (AlarmItem[Alarm_i].EventType == HeaterEventType[Heater_i])
+                    for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++)
                     {
-                        if (AlarmState[Alarm_i].Status == true)
+                        if (AlarmItem[Alarm_i].EventType == HeaterEventType[Heater_i])
                         {
-                            status = ERROR;
-                            AlarmId = Alarm_i;
-                            break;
+                            if (AlarmState[Alarm_i].Status == true)
+                            {
+                                status = ERROR;
+                                AlarmId = Alarm_i;
+                                break;
+                            }
                         }
-                    }
-                    if (AlarmItem[Alarm_i].EventType == HeaterEventTypeUnder[Heater_i])
-                    {
-                        if (AlarmState[Alarm_i].Status == true)
+                        if (AlarmItem[Alarm_i].EventType == HeaterEventTypeUnder[Heater_i])
                         {
-                            status = ERROR;
-                            AlarmId = Alarm_i;
-                            break;
+                            if (AlarmState[Alarm_i].Status == true)
+                            {
+                                status = ERROR;
+                                AlarmId = Alarm_i;
+                                break;
+                            }
                         }
                     }
                 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.h b/Software/Embedded_SW/Embedded/Modules/Control/control.h
index d50868064..0bcaecb03 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h
@@ -40,8 +40,8 @@ void        ControlStart(void);
 uint32_t    AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 );
 int         RemoveControlCallback(uint32_t deviceId, ControlCBFunction Callback );
 uint32_t    TemplateDataReadCBFunction (uint32_t deviceId, uint32_t Parameter1);
-uint32_t GetControlDevice_i(void);
-uint32_t GetControlLowDevice_i(void);
+uint32_t    GetControlDevice_i(void);
+uint32_t    GetControlLowDevice_i(void);
 
 extern Task_Handle Control_Task_Handle;
 extern uint32_t millisecondCounter;
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
index 42bf19b96..160119d26 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c
@@ -23,6 +23,7 @@
 
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/I2C_Communication/DAC/blower.h"
+#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "drivers/Valves/Valve.h"
 #include "drivers/Heater/Heater.h"
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index e3cec605d..603de30d4 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -327,13 +327,13 @@ void Diagnostic100msecCollection(void)
         DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
         DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
     }
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, TemperatureSensorRead( TEMP_SENSE_ANALOG_MIXCHIP_TEMP));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, TemperatureSensorRead( MIXER_PT100));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, TemperatureSensorRead(TEMP_SENSE_AN_ENCLOSURETEMP3));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, TemperatureSensorRead(HEAD6_PT100));
 
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP1));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP2));
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 3592122cc..bfc469093 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -71,21 +71,39 @@ uint32_t MotorHomingRequestFunc(MessageContainer* requestContainer)
         {
             if (request->direction == MOTOR_DIRECTION__Backward) //opening the loading system
             {
-                if ( Motor_Id_to_LS_IdUp[MotorId] != MAX_GPI)
+                if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID)
                 {
-                    MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback,10000);
+                    MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, DRIER_LID_OPEN, GPI_LS_DRYER_LID_OPEN, MotorHomingRequestCallback,4000);
                     ustrncpy (HomingToken[MotorId], requestContainer->token,36);
                     return OK;
                 }
+                else
+                {
+                    if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI)
+                    {
+                        MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback,10000);
+                        ustrncpy (HomingToken[MotorId], requestContainer->token,36);
+                        return OK;
+                    }
+                }
             }
             else // closing the system into normal work
             {
-                if ( Motor_Id_to_LS_IdDown[MotorId] != MAX_GPI)
+                if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID)
                 {
-                    MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdUp[MotorId], MotorHomingRequestCallback,10000);
+                    MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, DRIER_LID_CLOSE, GPI_LS_DRYER_LID_CLOSED, MotorHomingRequestCallback,4000);
                     ustrncpy (HomingToken[MotorId], requestContainer->token,36);
                     return OK;
                 }
+                else
+                {
+                    if ( Motor_Id_to_LS_IdUp[MotorId] != MAX_GPI)
+                    {
+                        MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed,  Motor_Id_to_LS_IdDown[MotorId], MotorHomingRequestCallback,10000);
+                        ustrncpy (HomingToken[MotorId], requestContainer->token,36);
+                        return OK;
+                    }
+                }
             }
         }
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
index 48f2e1e20..d180fb96e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
@@ -58,14 +58,22 @@ uint32_t MotorJoggingRequestFunc(MessageContainer* requestContainer)
                 switch (request->direction)
                 {
                     case MOTOR_DIRECTION__Forward:
-                        direction = 1-MotorsCfg[MotorId].directionthreadwize;
+                        direction = MotorsCfg[MotorId].directionthreadwize;
                         break;
                     case MOTOR_DIRECTION__Backward:
-                        direction = MotorsCfg[MotorId].directionthreadwize;
+                        direction = 1-MotorsCfg[MotorId].directionthreadwize;
                         break;
                 }
-                MotorSetDirection(MotorId,direction);
-                MotorSetSpeed(MotorId, speed);
+                if(MotorId == HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID)
+                {
+                    int Pos_Value = (direction == 1)?0:2;
+                    MotorGoTo(MotorId, Pos_Value );
+                }
+                else
+                {
+                    MotorSetDirection(MotorId,direction);
+                    MotorSetSpeed(MotorId, speed);
+                }
             }
         }
         else
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 789ac459e..7ac9340f2 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -10,6 +10,7 @@
 #include "thread/thread.h"
 #include "ids/ids.h"
 #include "control/control.h"
+#include "Control/MillisecTask.h"
 #include "AlarmHandling/AlarmHandling.h"
 #include "heaters/heaters_ex.h"
 #include "StateMachines/Printing/PrintingSTM.h"
@@ -84,6 +85,7 @@ uint32_t HWConfigurationInit(void)
     }
     EmbeddedParametersInit();
     IDS_Dispenser_Content_Init();
+    //ProcessParamsInit();
     return Fresult;
 }
 
@@ -167,7 +169,7 @@ uint32_t GenHWControlId;
 uint32_t GenHWInitCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
 {
     int   Dispenser_i;
-    RemoveControlCallback(GenHWControlId, GenHWInitCallBackFunction );
+    /*Safe*/RemoveControlCallback(GenHWControlId, GenHWInitCallBackFunction );
     for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
     {
         Read_MidTank_Pressure_Sensor(Dispenser_i);
@@ -220,7 +222,7 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
         return ERROR;
     }
-   // LoadDancerConfigMessage();
+    LoadDancerConfigMessage();
     //StoreDancerConfigMessage();
     if (request->n_pidcontrols <= HARDWARE_PID_CONTROL_TYPE__Dispenser8)
     {
@@ -267,14 +269,14 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
     {
         BlowerCfg.enabled = false;
     }
-
+/*
     for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
     {
         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/*eHundredMillisecond*/, TemplateDataReadCBFunction,0,0, 0 );
-
+    GenHWControlId = AddControlCallback( GenHWInitCallBackFunction, 2* eOneSecond, TemplateDataReadCBFunction,0,0, 0 );
+*/
     ControlStart();
     AlarmHandlingStart();
     //ThreadInitialTestStub(request);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 50b4658c1..53d5095c8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -84,7 +84,7 @@ uint32_t    SecondDryerHeaterMaxTempControl = 0xFF;
 #define DRYER_SECONDARY_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP3
 
 //old uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,TEMP_SENSE_AN_ENCLOSURETEMP3};
-uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_AN_ENCLOSURETEMP3,TEMP_SENSE_ANALOG_MIXCHIP_TEMP};
+uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HEAD6_PT100,MIXER_PT100};
 uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
 bool HeatersRestart = false;
 
@@ -437,6 +437,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
         //DCInitialHeating[HeaterId] = true;
         HeaterReady[HeaterId] = false;
         HeaterPreviousRead[HeaterId] = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
+        Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0);
         if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
             ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
@@ -447,6 +448,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
 		{
 	        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
             HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id);
+            Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0);
             HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
             HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
 		}
@@ -540,7 +542,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
-        Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index);
+        Report("Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
@@ -689,7 +691,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
-        Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index);
+        Report("Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
@@ -866,20 +868,8 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             }
             else
             {
-                /*if (index == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3)
-                {
-                    //temp_preError = HeaterPIDConfig[index].m_preError; temp_integral = HeaterPIDConfig[index].m_integral;
-                    temp_calculatedError =  PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
-                                                      &temp_params,   &temp_preError, &temp_integral);
-                }*/
                 HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
                                                       &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
-                /*if (index == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3)
-                {
-                    len = usnprintf(heatstr, 100, "ACD Id, Temp , Integral, Output,AdvIntegral, AdvOutput{ %d, %d ,%d, %d,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,
-                                    (int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError,(int)temp_integral,(int)temp_calculatedError);
-                    Report(heatstr,__FILE__,__LINE__,index,RpWarning,index,  readValue);
-                }*/
             }
             //        error[index][Counter[index]]    = HeaterPIDConfig[index].m_preError;
             //        integral[index][Counter[index]] = HeaterPIDConfig[index].m_integral;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index 8277c9cd9..0262db6ff 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -13,6 +13,8 @@
 #include "PMR/Hardware/HardwareDispenser.pb-c.h"
 #include "StateMachines/Printing/printingSTM.h"
 
+#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
+
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/Motors/Motor.h"
 #include "drivers/Valves/Valve.h"
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 5ee8a150d..9dd2822d6 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -319,9 +319,9 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
             DispenserPreSegmentReady[DispenserId] = false;
             REPORT_MSG(DispenserId,"IDS_Valve_Presegment start");
             IDS_Dispenser_Set_Flow_Params(DispenserId,0,0);
-            if (JobTicket->segments[DispenserId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
+            if (JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
             {
-                MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[DispenserId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
+                MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
             }
             else
             {
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
index 319f85454..65ede8fac 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
@@ -539,7 +539,7 @@ void Stub_MotorMovRequest(MessageContainer* requestContainer)
     #else
         TimerMotors_t Motor_Id  = (TimerMotors_t)request->motor_id; //to remove warning
 
-        MotorMove(Motor_Id, Direction, Pos_Value );
+
         if(GoTo_Flag)
         {
             MotorGoTo(Motor_Id, Pos_Value );
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index cc9bb099f..53bac3004 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -83,6 +83,7 @@
         void* buffer = NULL;
         uint32_t Bytes = 0;
         FRESULT Fresult = FR_OK;
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
 
         LoadArmInfo.LoadArmBackLash = 0;
         LoadArmInfo.LoadArmRounds = 0xFF;
@@ -109,6 +110,7 @@
     uint32_t Thread_Load_Reduce_Heat(void)
     {
         //Heaters Off, Dryer Blower Off, Blower Low,
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         memcpy (&ProcessParametersClear,&ProcessParametersKeep,sizeof(ProcessParameters));
         ProcessParametersClear.dryerzone1temp = 0;
         ProcessParametersClear.dryerzone2temp = 0;
@@ -140,6 +142,7 @@
     }
     uint32_t Thread_Load_Set_Load_Arm_To_Start_Position_Callback(uint32_t deviceID, uint32_t BusyFlag)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine Callback");
 
         NumberOfDrierLoaderCycles--;
         if (NumberOfDrierLoaderCycles)
@@ -157,6 +160,7 @@
     }
     uint32_t Thread_Load_Set_Load_Arm_To_Stopper_Callback(uint32_t deviceID, uint32_t BusyFlag)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine Callback");
         NumberOfDrierLoaderCycles=0;
         //storeLoadArmParameters();
         LoadStages++;
@@ -165,6 +169,7 @@
     }
     uint32_t Thread_Load_Set_Load_Arm_To_Start_Position(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         if (LoadArmInfo.LoadArmRounds != 0xFF)
         {
             NumberOfDrierLoaderCycles = LoadArmInfo.LoadArmRounds;
@@ -183,6 +188,7 @@
     uint8_t CallbackCounter = 0;
     uint32_t Thread_Load_HomingCallback(uint32_t MotorId, uint32_t ReadValue)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine Callback");
         REPORT_MSG(MotorId, "Thread_Load_HomingCallback Motor Id");
         if(ControlId != 0xFF)
         {
@@ -204,6 +210,7 @@
     }
     uint32_t Thread_Load_Center_Head_Rockers(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
@@ -212,6 +219,7 @@
     }
     uint32_t Thread_Load_Open_Covers(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         //Open Dyeing Head Cover And Dryer Lid
         //HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2,
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
@@ -220,11 +228,12 @@
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
         //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 2,  Thread_Load_HomingCallback,4000);
+        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 0, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,4000);
         return OK;
     }
     uint32_t Thread_Load_Lift_Dancers(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
@@ -235,6 +244,7 @@
     uint32_t Thread_Load_Lift_Rockers(void)
     //Machine Is Ready. Send Message, Start Timer To Close Lids, Wait For Operator Response
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 200,  Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
@@ -244,6 +254,7 @@
     }
     uint32_t Thread_Load_Initial_Tension(void) //Check Spool Presence, run Winder Until Break Sensor Is Identifieing Movement For A Second
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         if (FPGA_Read_limit_Switches(GPI_SW_SPOOL_EXISTS)==LIMIT)
         {
             REPORT_MSG(LIMIT, "No cone in winder");
@@ -257,6 +268,7 @@
     }
     uint32_t Thread_Load_Close_Rockers(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
@@ -268,6 +280,7 @@
     uint32_t Thread_Load_Close_Dancers(void)
     //Send Dancer Motors To Preset Location, Check That The Dancers Are On The Thread
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDANCER,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDANCER].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_RDANCER], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
@@ -277,6 +290,7 @@
     }
     uint32_t Thread_Load_Close_Lids(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         //Close Dyeing Head Cover And Dryer Lid
         //HARDWARE_MOTOR_TYPE__MOTO_DH_LID = 2,
         //HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID = 4,
@@ -284,12 +298,13 @@
         MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DH_LID], Thread_Load_HomingCallback,10000);
         CallbackCounter++;
 //        MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 200,  Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,10000);
-        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 0,  Thread_Load_HomingCallback,4000);
+        MotorGotoWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID, 2, Motor_Id_to_LS_IdDown[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID], Thread_Load_HomingCallback,4000);
 
         return OK;
     }
     uint32_t Thread_Load_Resume_Heating(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         ActivateHeadMagnet();
 
         if (HandleProcessParameters(&ProcessParametersRecover)!= OK)
@@ -307,12 +322,14 @@
     uint32_t Thread_Load_Jog_Feeder_To_Middle_Point(void)
     //Jog The Feeder Motor Until The Feeder Dancer Is At Middle Position
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         CallbackCounter++;
         MotorMovetoDancerPosition (HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize, 200, FEEDER_DANCER ,true, Thread_Load_HomingCallback,10000);
         return OK;
     }
     uint32_t Thread_Load_Dryer_Loading(void)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         LoadArmInfo.LoadArmRounds = 20;
         //Start Feeder Pid, Rotate Loading Arm Counter Thread Direction X Circles According To Rml. Feeder Speed Is 40
         OriginalMotorSpd_2PPS[FEEDER_MOTOR] = 1000;
@@ -328,6 +345,7 @@
     }
     uint32_t Thread_Load_Jog_ThreadStop(uint32_t index, uint32_t ReadValue)
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         RemoveControlCallback(ControlId, Thread_Load_Jog_ThreadStop );
         ControlId = 0xFF;
         ThreadAbortJoggingFunc();
@@ -338,6 +356,7 @@
     uint32_t Thread_Load_Jog_Thread(void)
     //Jog Thread Shortly To Make Sure Spool Is Running. Report End Of Loading
     {
+        REPORT_MSG(LoadStages, "Thread Load State Machine step");
         ThreadJoggingFunc(40);
         ControlId = AddControlCallback(Thread_Load_Jog_ThreadStop, eOneSecond*5,Control_Read_Dancer_Position,(IfTypeThread*0x100+FEEDER_MOTOR),FEEDER_DANCER,FEEDER_MOTOR);
         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 becdf054a..9b95ab52c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -100,14 +100,13 @@ uint32_t Winder_Prepare(void)
      * 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;
-        //Winder_PrepareStage2(0,0);
-    }
+    }*/
     if (FPGA_Read_limit_Switches(GPI_LS_SCREW_RIGHT)==LIMIT)
     {
         //REPORT_MSG(LIMIT, "Winder_Prepare at limit");