merge

17 files changed, 343 insertions, 105 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 7a9f8fd37..cf8684ddb 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -79,7 +79,7 @@ typedef struct AlarmHandlingMessage{
   //  uint32_t Data;
 }AlarmHandlingMessageStruc;
 
-#define MAX_SYSTEM_ALARMS EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED+1
+#define MAX_SYSTEM_ALARMS 300+1
 typedef enum
 {
     TemperatureAlarm,
@@ -215,8 +215,53 @@ const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
  {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,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 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT                          ," MotorLoadindARMOverCurrent  "                },                                           /* 3009 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_MOTOR_OVERCURRENT /*EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT*/                       ," MotorWinderDancerOverCurrent    "            },   /* 3036 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_MOTOR_OVERCURRENT /*EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT*/                       ," MotorPullerDancerOverCurrent    "            },   /* 3037 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT /*EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT*/                       ," MotorFeederDancerOverCurrent    "            },   /* 3038 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  /*EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT*/                           ," MotorDryerLidOverCurrent    "                },   /* 4017 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT                    ," MotorDyeingHeadCoverOverCurrent "            },                                       /* 5031 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT       ," MotorDyeingHeadCleaningMechanismOverCurrent "},                                       /* 5035 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT            ," MotorDyeingHeadCleaningHeadOverCurrent  "    },                                       /* 5039 */
+
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE                     ," MotorRightLoaderOverTemperature "            },                                           /* 3011 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE                      ," MotorLeftLoaderOverTemperature  "            },                                           /* 3013 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE                      ," MotorLoadArmOverTemperature "                },                                           /* 3016 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE                    ," MotorWinderDancerOverTemperature    "        },                                           /* 3039 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE                    ," MotorPullerDancerOverTemperature    "        },                                           /* 3040 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE                    ," MotorFeederDancerOverTemperature    "        },                                           /* 3041 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE                        ," MotorDryerLidOverTemperature    "            },                                           /* 4018 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE                ," MotorDyeingHeadCoverOverTemperature "        },                                           /* 5032 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE   ," MotorDyeingHeadCleaningOverTemperature  "    },                                           /* 5036 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE        ," MotorDyeingHeadCleaningHeadOverTemperature  "},                                           /* 5040 */
+
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                                ," MotorLoadingARMStall     "                   },                                           /* 3018 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              ," MotorWinderDancesStall  "                    },                                           /* 3020 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                                ," MotorLoadingARMStall     "                   },                                           /* 3023 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              ," MotorWinderDancesStall  "                    },                                           /* 3042 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_STALL                              ," MotorPullerDancerStall  "                    },                                           /* 3043 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL                              ," MotorFeederDancerStall  "                    },                                           /* 3044 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID        ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_STALL                                  ," MotorDryerLidStall  "                        },                                           /* 4019 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID           ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL                          ," MotorDyeingHeadCoverStall   "                },                                           /* 5033 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL             ," MotorDyeingHeadCleaningMechanismStall   "    },                                           /* 5037 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL                  ," MotorDryeingHeadCleaningStall   "            },                                           /* 5041 */
+
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE                        ," MotorRightLoaderUnderVoltage "               },                                           /* 3025 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE                         ," MotorLeftLoaderUnderVoltage "                },                                           /* 3027 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE                         ," MotorLoaderARMUnderVoltage  "                },                                           /* 3030 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE                       ," MotorWinderDancerUnderVoltage   "            },                                           /* 3045 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE                       ," MotorPullerDancerUnderVoltage   "            },                                           /* 3046 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE                       ," MotorFeederDancerUnderVoltage   "            },                                           /* 3047 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE                           ," MotorDryerLidUnderVoltage   "                },                                           /* 4020 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE                   ," MotorDyeingHeadCoverUnderVoltage    "        },                                           /* 5034 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE                ," MotorDyeingHeadCleaningUnderVoltage "        },                                           /* 5038 */
+ { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE           ," MotorDyeingHeadCleaningHeadUnderVoltage "    },                                           /* 5042 */
  {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK,"Thread Break"},
- {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE,"Thread Tension Control Failure"},
+ {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER,"Thread Feeder Tension Control Failure"},
+ {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,"Thread Puller Tension Control Failure"},
+ {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,"Thread Winder Tension Control Failure"},
  {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,"No cone in winder"}
 };
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 10286853e..4f78d2134 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -83,6 +83,8 @@ bool watchdogCriticalAlarm = false;
 
 uint32_t msec_millisecondCounter = 0;
 
+extern bool Machine_Idle_Mode;
+
 MillisecMotorDataStruc ScrewSetMaxSpeedPending = {0};
 MillisecMotorDataStruc ScrewMovePending = {0};
 MillisecMotorDataStruc MotorData[NUM_OF_MOTORS] = {0};
@@ -446,7 +448,8 @@ uint32_t MillisecLowLoop(uint32_t tick)
         //Speed_Data = Calculate_Speed_Sensor_Velocity();
         //MillisecReadFromTempSensor(Sensor_Read, NULL);
         //if (Sensor_Read++ >= MAX_TEMPERATURE_SENSOR_ID) Sensor_Read = 0;
-        //Control_LED1_PWM();
+        if(Machine_Idle_Mode == true)
+            Machine_Idle_Breathing_Led();
     }
     if (Hundred_msTick)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c b/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c
index f9aee7929..a443b4785 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c
@@ -71,3 +71,51 @@ float AdvancedPIDAlgorithmCalculation(float _setPoint,float _mesuredParam , PID_
     return output;
 }
 
+float TestPIDAlgorithmCalculation(float _setPoint,float _mesuredParam , PID_Config_Params *params, float *_pre_error, float *_integral)
+{
+    float error;
+    float derivative;
+    float output;
+
+    //double error = *mySetpoint - input;
+    error = _setPoint - _mesuredParam;
+    //ITerm+= (ki * error);
+    *_integral = *_integral + (error*params->Ki);
+    /*  if(ITerm > outMax)
+      {
+          ITerm= outMax;
+      }
+      else if(ITerm < outMin)
+      {
+          ITerm= outMin;
+      } */
+    if(*_integral > params->MAX)
+    {
+        *_integral = params->MAX;
+    }
+    else if(*_integral < params->MIN)
+    {
+        *_integral = params->MIN;
+    }
+    //  double dInput = (input - lastInput);
+    derivative = error - *_pre_error;
+
+      /*Compute PID Output*/
+    //  double output = kp * error + ITerm- kd * dInput;
+    output = params->Kp*error/params->ProportionalErrorMultiplier + *_integral/params->IntegralErrorMultiplier + params->Kd*derivative;
+
+    //Saturation Filter
+    if(output > params->MAX)
+    {
+        output = params->MAX;
+    }
+    else if(output < params->MIN)
+    {
+        output = params->MIN;
+    }
+
+    //Update error
+    *_pre_error = error;
+
+    return output;
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index 538e251ef..69820e306 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -51,6 +51,7 @@
 #include <inc/hw_ints.h>
 
 #include "drivers/adc_sampling/adc.h"
+#include "Modules/General/buttons.h"
 
 #include "control.h"
 #include "MillisecTask.h"
@@ -98,7 +99,7 @@ uint32_t                ControlDatalog[MAX_TANGO_CONTROL_DEVICES];
 uint16_t ControlBacklog[MAX_BACKLOG_SIZE]={0};
 uint16_t backlogindex = 0;
 uint32_t        Control_timerBase = TIMER0_BASE;        //Timer handle
-uint32_t MaxHighDevices = 0xFF;
+uint32_t MaxHighDevices = 0;
 /******************** Functions  ********************************************/
 void OneMilliSecondFunction(UArg arg0);
 
@@ -124,7 +125,7 @@ void ControlInit(void)
     ControlRestart = false;
 
     memset(ControlDatalog,0,sizeof(uint32_t)*MAX_TANGO_CONTROL_DEVICES);
-    MaxHighDevices = 0xFF;
+    MaxHighDevices = 0;
     for (Device_i = 0; Device_i < MAX_TANGO_CONTROL_DEVICES; Device_i++)
     {
         ControlArray[Device_i].ControlActive = false;
@@ -157,10 +158,20 @@ void ControlStop(void)
 uint32_t ControlActivityLed( uint32_t Parameter1)
 {
     static bool flag = false;
+    static uint8_t counter;
+    const uint8_t Blink_Freq = 15;//odd number
+
     if (flag==true)
     {
         COMM_RED_LED_ON;
         ACTIVITY_RED_LED_OFF; // Heaters indication - all the Heaters OFF
+        if(power.color == fastBILNK)
+            Pannel_Leds(POWER_ON_OFF,MODE_OFF);
+
+        if((power.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(POWER_ON_OFF,MODE_OFF);
+        }
         flag = false;
     }
     else
@@ -168,8 +179,22 @@ uint32_t ControlActivityLed( uint32_t Parameter1)
         COMM_RED_LED_OFF;
         if (HeaterActive > 0)// Blink the led on heating
             ACTIVITY_RED_LED_ON;// Heaters indication - at least one of  the Heaters is ON
+
+        if(power.color == fastBILNK)
+            Pannel_Leds(POWER_ON_OFF,MODE_ON);
+
+        if((power.color == BLINK) && (counter % Blink_Freq == 0) )
+        {
+            Pannel_Leds(POWER_ON_OFF,MODE_ON);
+        }
+
         flag = true;
     }
+
+    if (counter < 0xFF)
+        counter++;
+    else
+        counter = Blink_Freq + 1;
 return OK;
 }
 uint32_t ControlEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue)
@@ -218,13 +243,8 @@ uint32_t  AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlF
                 break;
             }
         }
-/*        if (MaxHighDevices == 0xFF)
-            MaxHighDevices = deviceId;
-        else
-        {
-      	  	if ((deviceId!=0xFF )&&(deviceId> MaxHighDevices))
-     	       	MaxHighDevices = deviceId;
-        }
+    /*    if ((deviceId!=0xFF )&&(deviceId> MaxHighDevices))
+    //        MaxHighDevices = deviceId;
     }
     else
     {
@@ -339,23 +359,7 @@ uint32_t GetControlLowDevice_i(void)
 }
 uint32_t ControlLoop(uint32_t tick)
 {
-    //call all modules control functions
-    //test dancers and speed encoders
-    //check all callback units (state machine waiting for completion of a change)
-    //uint32_t ControlDevice_i;
-    /*bool Ten_msTick, Hundred_msTick, Onesecond_Tick,Tick98,Tick998;
-    Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
-    Hundred_msTick  =   (tick%eHundredMillisecond == 0)  ?true:false;
-//    Hundred_msTick  =   (tick%200 == 0)  ?true:false;
-    Onesecond_Tick  =   (tick%eOneSecond == 0)           ?true:false;
-    Tick98          =   (tick%eHundredMillisecond == 98) ?true:false;
-//    Tick98          =   (tick%200 == 199) ?true:false;
-    Tick998         =   (tick%eOneSecond == 996)         ?true:false;
-*/
-    //ROM_IntMasterDisable();
-    //if (MaxHighDevices == 0xFF)
-    //    return OK;
-    //for (ControlDevice_i = 0; ControlDevice_i <= MaxHighDevices;ControlDevice_i++)
+    //for (ControlDevice_i = 0; ControlDevice_i < MaxHighDevices;ControlDevice_i++)
     for (ControlDevice_i = 0; ControlDevice_i < MAX_TANGO_CONTROL_DEVICES;ControlDevice_i++)
     {
         if (ControlArray[ControlDevice_i].ControlActive)
@@ -386,18 +390,6 @@ uint32_t ControlLoop(uint32_t tick)
 }
 uint32_t ControlLowLoop(uint32_t tick)
 {
-    //call all modules control functions
-    //test dancers and speed encoders
-    //check all callback units (state machine waiting for completion of a change)
-    //uint32_t Device_i;
-    //bool Ten_msTick, Hundred_msTick, Onesecond_Tick,Tick98,Tick998;
-    //Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
-    //Hundred_msTick  =   (tick%eHundredMillisecond == 0)  ?true:false;
-    //Onesecond_Tick  =   (tick%eOneSecond == 0)           ?true:false;
-    //Tick98          =   (tick%eHundredMillisecond == 98) ?true:false;
-    //Tick998         =   (tick%eOneSecond == 996)         ?true:false;
-
-    //ROM_IntMasterDisable();
     for (ControlLowDevice_i = 0; ControlLowDevice_i < MAX_TANGO_CONTROL_DEVICES;ControlLowDevice_i++)
     {
         if (ControlArray[ControlLowDevice_i].ControlActive)
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
index 42f02556e..48f2e1e20 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsJogging.c
@@ -145,10 +145,12 @@ uint32_t DispenserJoggingRequestFunc(MessageContainer* requestContainer)
             {
                 case MOTOR_DIRECTION__Forward:
                     Control3WayValvesWithCallback ((Valves_t) request->index, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+                    SysCtlDelay(180000);
                     direction = MotorsCfg[MotorId].directionthreadwize;
                     break;
                 case MOTOR_DIRECTION__Backward:
                     Control3WayValvesWithCallback ((Valves_t) request->index, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
+                    SysCtlDelay(180000);
                     direction = 1-MotorsCfg[MotorId].directionthreadwize;
                     break;
             }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index a884c3e21..6d64bdf66 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -109,10 +109,24 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters.initialdispensertimeout = 10000;
             EmbeddedParameters.has_initialdispensertimelag = true;
             EmbeddedParameters.initialdispensertimelag = 100;
+            EmbeddedParameters.has_dispenserbuildpressurespeed = true;
             EmbeddedParameters.dispenserbuildpressurespeed=500;
+            EmbeddedParameters.has_dispenserbuildpressurelimit = true;
             EmbeddedParameters.dispenserbuildpressurelimit=1.5 ;
+            EmbeddedParameters.has_dispenserbuildpressuretimeout = true;
             EmbeddedParameters.dispenserbuildpressuretimeout=20000;
+            EmbeddedParameters.has_dispenserbuildpressurelag = true;
             EmbeddedParameters.dispenserbuildpressurelag=50;
+            EmbeddedParameters.has_acheatersloweroperationlimit = true;
+            EmbeddedParameters.acheatersloweroperationlimit = 995;
+            EmbeddedParameters.has_acheatersupperoperationlimit = true;
+            EmbeddedParameters.acheatersupperoperationlimit = 1005;
+            EmbeddedParameters.has_dcheatersloweroperationlimit = true;
+            EmbeddedParameters.dcheatersloweroperationlimit = 978;
+            EmbeddedParameters.has_dcheatersupperoperationlimit = true;
+            EmbeddedParameters.dcheatersupperoperationlimit = 1002;
+            EmbeddedParameters.has_midtankpressurecorrection = true;
+            EmbeddedParameters.midtankpressurecorrection = 0.5;
 
             FileWrite(&EmbeddedParameters,sizeof(EmbeddedParameters),EmbeddedParametersPath);
         }
@@ -138,6 +152,8 @@ uint32_t EmbeddedParametersInit(void)
     IDS_Dispenser_SetBackLashValues(EmbeddedParameters.initialdispenserpressure, EmbeddedParameters.initialdispensertimeout, EmbeddedParameters.initialdispensertimelag);
     IDS_Dispenser_SetPrepareValues(EmbeddedParameters.dispenserbuildpressurespeed,   EmbeddedParameters.dispenserbuildpressurelimit, EmbeddedParameters.dispenserbuildpressuretimeout, EmbeddedParameters.dispenserbuildpressurelag);
     Heaters_SetOverHeatTimeOutValues( EmbeddedParameters.overheatcountlimit,  EmbeddedParameters.underheatcountlimit);
+    Heaters_SetOperationLimits(EmbeddedParameters.acheatersloweroperationlimit,EmbeddedParameters.acheatersupperoperationlimit,EmbeddedParameters.dcheatersloweroperationlimit,EmbeddedParameters.dcheatersupperoperationlimit);
+    MidTankPressureCorrection(EmbeddedParameters.midtankpressurecorrection);
     SetDiagnosticCollectionLimit(EmbeddedParameters.diagnosticcollectionlimit);
     ThreadSetBreakSensorLimit(EmbeddedParameters.breaksensorlimit);
 
@@ -188,6 +204,8 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
         upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
         return ERROR;
     }
+   // LoadDancerConfigMessage();
+    //StoreDancerConfigMessage();
     if (request->n_pidcontrols <= HARDWARE_PID_CONTROL_TYPE__Dispenser8)
     {
         for (PID_i = 0; PID_i < request->n_pidcontrols ; PID_i++)
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
index 68199d19f..f80727dfc 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c
@@ -10,8 +10,9 @@
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"//#include "FPGA_GPIO.h"  //  use for FPGA IO
 #include "DataDef.h"  //  use for FPGA IO
 #include "Modules/Control/control.h" //  use for FPGA IO
-
+#include "Modules/General/buttons.h"
 #include "StateMachines/Printing/PrintingSTM.h"
+#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 
 #include <stdlib.h>
 #include <stdint.h>
@@ -26,15 +27,8 @@ int ch_to_power_down();
 int ch_to_power_up();
 int thredJog();
 
-typedef enum
-{
-    colorOFF = 0,
-    BLUE,
-    BLINK,
-    fastBILNK,
-    BREATHING
-} PBcolor;
 
+/*
 typedef enum
 {
     OFFPB = 0,
@@ -43,7 +37,7 @@ typedef enum
     LONGPB  ,
     REPLONGPB //repeat long PB
 }PBstat;
-
+*/
 typedef enum
 {
     MSEC = 0,
@@ -53,47 +47,26 @@ typedef enum
     MORE5000
 }timems;
 
-typedef enum
-{
-    sttOFF = 0,
-    sttON,
-    sttDISABLE,
-    sttENABLE,
-    sttIDLE,
-    sttJOGGING,
-    sttRDY,
-    sttPRELOAD,
-    sttLOADING,
-    sttLOADSUCSESS,
-    sttLOADFAIL
-} PBmachinState;
+
 
 //enum PBstat OnOffPBstate = OFFPB;
 //enum PBstat ret
 //enum PBstat threadPB = OFFPB;
 
-struct button
-{
-    char    bttn_name[10];  //option
-    int     bttn_status;    // 0=release 1=press
-    /* enum */ PBstat Action;   //offPB,shortPB,longPB,countPB,replongPB
-    /* enum */ PBcolor color;   //off, blue, blink, bithing
-    /* enum */ PBmachinState state; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING
-    uint32_t count;
-};
 
-struct button power , jog, load;
+
+button power , jog, load;
 uint32_t ButtonsCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t ButtonsCBFunction(uint32_t IfIndex, uint32_t ReadValue);
-uint32_t ShortLongOffPB(uint8_t OnOffPB, struct button *pBtn);
-uint32_t StateMachine(struct button *pBtn);
+uint32_t ShortLongOffPB(uint8_t OnOffPB,  button *pBtn);
+uint32_t StateMachine( button *pBtn);
 
 
 uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue);
 uint8_t  thraedJogging(uint8_t off);
-uint32_t setJoggingEnableCondition(struct button *pBtn);
-uint32_t joggingMachine(uint8_t OnOffPB, struct button *pBtn);
+uint32_t setJoggingEnableCondition( button *pBtn);
+uint32_t joggingMachine(uint8_t OnOffPB,  button *pBtn);
 
 
 uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue);
@@ -251,7 +224,7 @@ int StopTimer()
 //ShortLongOffPB( OnOffPB, &ret)
 
 
-uint32_t ShortLongOffPB(uint8_t OnOffPB, struct button *pBtn)
+uint32_t ShortLongOffPB(uint8_t OnOffPB,  button *pBtn)
 {
     uint8_t parameter = 0 ;  // why we need it!!!!
 
@@ -333,7 +306,7 @@ uint32_t ShortLongOffPB(uint8_t OnOffPB, struct button *pBtn)
 
 
 
-uint32_t StateMachine(struct button *pBtn) //short press(=0)/long press(=1)
+uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1)
 {
     uint8_t parameter = 1;
 
@@ -373,10 +346,12 @@ uint32_t StateMachine(struct button *pBtn) //short press(=0)/long press(=1)
                 {
                     case LONGPB:    //Power off from idle
                         pBtn->state = sttOFF; // todo
+                        Pannel_Leds(POWER_ON_OFF,MODE_OFF); //AVI+ - TODO option MODE_ON to stop Breathing and the led will turn off in power down
                         REPORT_MSG(parameter,"Power state is OFF ");
                         break;
                     case SHORTPB:   //Wake up from idle
                         pBtn->state = sttON;// to do ?
+                        Pannel_Leds(POWER_ON_OFF,MODE_ON); //AVI+
                         REPORT_MSG(parameter,"Power state is ON ");
                         break;
                     default:
@@ -406,7 +381,7 @@ return 0;
 
 
 
-uint32_t    setJoggingEnableCondition(struct button *pBtn)
+uint32_t    setJoggingEnableCondition( button *pBtn)
 {
     if (0
 //            1.
@@ -443,12 +418,13 @@ return 0;
  */
 
 
-uint32_t joggingMachine(uint8_t OnOffPB, struct button *pBtn)
+uint32_t joggingMachine(uint8_t OnOffPB,  button *pBtn)
 {
     if (sttDISABLE == pBtn->state)
     {
         // jogging is disable
         pBtn->color =  colorOFF;
+        Pannel_Leds(THREAD_JOGGING,MODE_OFF);//AVI+
     }
     else
     {
@@ -456,6 +432,7 @@ uint32_t joggingMachine(uint8_t OnOffPB, struct button *pBtn)
         {
             ThreadAbortJoggingFunc(); // to do!!!!
             pBtn->color =  BLUE;
+            Pannel_Leds(THREAD_JOGGING,MODE_ON);//AVI+
         }
         else
         {
@@ -534,5 +511,13 @@ ShortLongOffPB( threadPB,  ret,struct button *pBtn);
 }
 */
 
+void test_avi()
+{
+
+    power.color = BLINK;
+    //power.color = fastBILNK
 
+    //Machine_Idle_Mode = true;
+
+}
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
index 897fb6031..e7a611e9b 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h
+++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h
@@ -1,6 +1,51 @@
 #ifndef BUTTONS_H
 #define BUTTONS_H
 
+typedef enum
+{
+    colorOFF = 0,
+    BLUE,
+    BLINK,
+    fastBILNK,
+    BREATHING
+} PBcolor;
+
+typedef enum
+{
+    OFFPB = 0,
+    COUNTPB ,
+    SHORTPB ,
+    LONGPB  ,
+    REPLONGPB //repeat long PB
+}PBstat;
+
+typedef enum
+{
+    sttOFF = 0,
+    sttON,
+    sttDISABLE,
+    sttENABLE,
+    sttIDLE,
+    sttJOGGING,
+    sttRDY,
+    sttPRELOAD,
+    sttLOADING,
+    sttLOADSUCSESS,
+    sttLOADFAIL
+} PBmachinState;
+
+typedef struct
+{
+    char    bttn_name[10];  //option
+    int     bttn_status;    // 0=release 1=press
+    /* enum */ PBstat Action;   //offPB,shortPB,longPB,countPB,replongPB
+    /* enum */ PBcolor color;   //off, blue, blink, bithing
+    /* enum */ PBmachinState state; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING
+    uint32_t count;
+}button;
+
+extern button power , jog, load;
+
 uint32_t Buttons_Init(void);
 uint32_t Button_load_Init(void);
 uint32_t Button_JOG_Init(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index d8c4e287d..8a77f98a2 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -23,6 +23,7 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState);
 uint32_t LoadHeaterSetPoint(HeaterType HeaterType);
 
 void Heaters_SetOverHeatTimeOutValues(uint32_t OverHeatTimeout, uint32_t UnderHeatTimeout);
+void  Heaters_SetOperationLimits(int acheatersloweroperationlimit,int acheatersupperoperationlimit,int dcheatersloweroperationlimit,int dcheatersupperoperationlimit);
 
 
 uint32_t HeatersEnd(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index aa9e4df4a..50b4658c1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -40,6 +40,10 @@
 
  int Overheat_Count_Limit = OVERHEAT_COUNT_LIMIT;
  int Underheat_Count_Limit = UNDERHEAT_COUNT_LIMIT;
+ int  AcHeatersLoweroperationLimit = 995;
+ int  AcHeatersUpperoperationLimit = 1005;
+ int  DcHeatersLoweroperationLimit = 978;
+ int  DcHeatersUpperoperationLimit = 1002;
 
 typedef enum
 {
@@ -94,6 +98,7 @@ char     TimeSliceAllocation[MAX_TIMESLICES] = {0xFF};
 int     DCTimeSliceAllocation[MAX_HEATERS_NUM] = {0};
 
 bool TimerActivated = false;
+char ACheatstr[100];
 
 Mailbox_Handle          HeatersControlMsgQ = NULL;
 //bool InitialHeating = true;
@@ -155,6 +160,13 @@ void Heaters_SetOverHeatTimeOutValues(uint32_t OverHeatTimeout, uint32_t UnderHe
     Overheat_Count_Limit = OverHeatTimeout;
     Underheat_Count_Limit = UnderHeatTimeout;
 }
+void  Heaters_SetOperationLimits(acheatersloweroperationlimit,acheatersupperoperationlimit,dcheatersloweroperationlimit,dcheatersupperoperationlimit)
+{
+    AcHeatersLoweroperationLimit =  acheatersloweroperationlimit;
+    AcHeatersUpperoperationLimit =  acheatersupperoperationlimit;
+    DcHeatersLoweroperationLimit =  dcheatersloweroperationlimit;
+    DcHeatersUpperoperationLimit =  dcheatersupperoperationlimit;
+}
 
 void HeatersControlStop(void)
 {
@@ -190,8 +202,6 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
     double temp = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
     //double temp = HeaterPreviousRead[HeaterId];//TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
 
-
-
     HeaterState->has_heatertype = true;
     HeaterState->heatertype = HeaterType;
     HeaterState->has_setpoint = true;
@@ -215,6 +225,7 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
 uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
 {
     int status = OK;
+    Report("HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, 0, 0);
         if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
         {
             if (ControlIdtoHeaterId [HeaterId]!=0xFF)
@@ -348,7 +359,7 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
     }
     else if ((HeaterState == HEATER_ON)&& (OnOff == HEATER_ON)) //set temperature
     {
-        if (HeaterPIDConfig[HeaterId].m_SetParam < HeaterCmd[HeaterId].targettemperatue)  //#bug 221
+        //if (HeaterPIDConfig[HeaterId].m_SetParam < HeaterCmd[HeaterId].targettemperatue)  //#bug 221
         {
             PrepareHeater(HeaterId,Temperature);  //prepare the heaters control info
         }
@@ -364,13 +375,10 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
        //turn off the heater
         HeatersSingleHeaterEnd(HeaterId);
     }
-    /*else //heater off, and the heater is not ready yet
-    {
-        //turn off the heater
-         HeatersSingleHeaterEnd(HeaterId);
-         //stop the control
-         HeaterPIDConfig[HeaterId].m_SetParam  = 0;
-    }*/
+
+    //usnprintf(ACheatstr, 254, "HeaterCommandRequestMessage(Id %d,OnOff %d,Temperature %d)",HeaterId,  OnOff,  Temperature);
+    Report("HeaterCommandRequestMessage",__FILE__,Temperature,HeaterId,RpWarning,HeaterState,  0);
+    //Report("HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, 0, 0);
 
     return OK;
 }
@@ -389,6 +397,8 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
         return ERROR;
     }
 
+    Report("PrepareHeater ", __FILE__,__LINE__,HeaterId, SetTemperatue, 0, 0);
+
     //start thread control for all motors
     HeaterPIDConfig[HeaterId].m_params.MAX = HeaterControl[HeaterId].outputproportionalpowerlimit*100;
     HeaterPIDConfig[HeaterId].m_params.MIN = 0.0;
@@ -656,7 +666,6 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     return ERROR;
 }
-char ACheatstr[100];
 uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=MAX_HEATERS_NUM;
@@ -702,7 +711,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                     return OK;
                 }
 
-        if ((readValue > (HeaterCmd[index].targettemperatue * 995/1000))&&(readValue < (HeaterCmd[index].targettemperatue * 1005/1000)))//read value within 0.5 percent from target
+        if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
         {
 //////////////////
             //InitialHeating = false;
@@ -822,7 +831,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                     return OK;
                 }
 
-        if ((readValue > (HeaterCmd[index].targettemperatue * 978/1000))&&(readValue < (HeaterCmd[index].targettemperatue * 1002/1000)))//read value within 0.5 percent from target
+        if ((readValue > (HeaterCmd[index].targettemperatue * DcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * DcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
         {
             //DCInitialHeating[index] = false;
             HeatersControlStart();
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index f701d0878..f71cdc71f 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -153,6 +153,7 @@ uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr ca
         Control3WayValvesWithCallback ((Valves_t)deviceID, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
         //Valve_Set((Valves_t) request->index, MidTank_Dispenser);
         MotorSetMicroStep(deviceID, 1);
+        SysCtlDelay(180000);
         //open dry air valve in the dispenser
         Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON);
 
@@ -234,6 +235,7 @@ uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr c
         Control3WayValvesWithCallback ((Valves_t)deviceID, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer
         //Valve_Set((Valves_t) request->index, Dispenser_Mixer);
         MotorSetMicroStep(deviceID, 1);
+        SysCtlDelay(180000);
         //open dry air valve in the dispenser
         //Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON);
         IDS_Dispenser_RefillStarted(deviceID);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index 119624e3d..5ee8a150d 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -319,6 +319,15 @@ 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)
+            {
+                MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[DispenserId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
+            }
+            else
+            {
+                MotorSetMicroStep(HW_Motor_Id, MotorsCfg[HW_Motor_Id].microstep);
+            }
+
             if (JobTicket->segments[SegmentId]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond==0)
             {
                 //MotorStop(HW_Motor_Id,Hard_Hiz);
@@ -397,14 +406,14 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
                      JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse;
              if (JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto)
              {
-                 MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
+                 //MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
                  segmentfirst_speed/=JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision;  //the dye supply is calculated based on a 1/8 microstep
                  IDS_Dispenser_Set_Flow_Params ( DispenserId, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse
                                                  ,  JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision);
              }
              else
              {
-                 segmentfirst_speed/=MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
+                 //segmentfirst_speed/=MotorsCfg[HW_Motor_Id].microstep;  //the dye supply is calculated based on a 1/8 microstep
                  IDS_Dispenser_Set_Flow_Params ( DispenserId, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse
                                                  ,MotorsCfg[HW_Motor_Id].microstep);
              }
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c
index b7f6a387f..61c7afe74 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c
@@ -73,7 +73,7 @@ void Stub_DancerPositionRequest(MessageContainer* requestContainer)
         response.detailed_status = ERROR; // use the Reserved bits to send our errors
         response.has_general_status = true;
     }
-
+    StoreDancerConfigMessage();
     responseContainer = createContainer(MESSAGE_TYPE__StubDancerPositionResponse, requestContainer->token, true, &response, &stub_dancer_position_response__pack, &stub_dancer_position_response__get_packed_size);
 
     //free(request);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
index e2f97d970..3af29a043 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c
@@ -219,8 +219,8 @@
         CallbackCounter++;
         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);
-
+        //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);
+        MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 2,  Thread_Load_HomingCallback,10000);
         return OK;
     }
     uint32_t Thread_Load_Lift_Dancers(void)
@@ -283,7 +283,8 @@
         CallbackCounter++;
         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);
+//        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);
+        MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID].directionthreadwize, 0,  Thread_Load_HomingCallback,10000);
 
         return OK;
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
index 56b229ea8..a22be25dc 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h
@@ -37,6 +37,9 @@ uint32_t ThreadDistanceToSpoolState(void);
 uint32_t ThreadEndState(void *JobDetails);
 uint32_t ThreadInitialTestStub();
 
+uint32_t StoreDancerConfigMessage(void);
+uint32_t LoadDancerConfigMessage(void);
+
 //uint32_t MotorPidRequestMessage(HardwarePidControl* request);
 uint32_t Winder_Init(void);
 uint32_t Winder_Prepare(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index 04a0026bd..b414611ff 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -4,6 +4,8 @@
 #include <DataDef.h>
 #include "include.h"
 
+#include "PMR/Hardware/UploadHardWareConfigurationRequest.pb-c.h"
+#include "PMR/Hardware/HardWareConfiguration.pb-c.h"
 #include "PMR/Hardware/HardwareMotor.pb-c.h"
 #include "PMR/Hardware/HardwareDancer.pb-c.h"
 #include "PMR/Hardware/HardwareWinder.pb-c.h"
@@ -11,6 +13,10 @@
 #include "PMR/Printing/JobSpool.pb-c.h"
 #include "PMR/common/MessageContainer.pb-c.h"
 
+#include "Common/SWUpdate/FileSystem.h"
+#include "drivers/Flash_Memory/fatfs/ff.h"
+#include "drivers/SSI_Comm/Dancer/Dancer.h"
+
 #include "thread.h"
 MotorDriverConfigStruc  MotorsCfg[NUM_OF_MOTORS]={0};
 HardwarePidControl MotorsControl[MAX_THREAD_MOTORS_NUM] = {0};
@@ -100,6 +106,63 @@ uint32_t MotorPidRequestMessage(HardwarePidControl* request)
     DancerStopActivityLimit[Motor_i] = temp/(2*PI*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].armlength);
     return OK;
 }
+char DancerConfigPath[50] = "0://SWInfo//DancCfg.msg";
+
+uint32_t StoreDancerConfigMessage()
+{
+    FRESULT Fresult = FR_OK;
+    HardwareConfiguration DancerConfig;
+    HardwareDancer Dancers[MAX_SYSTEM_DANCERS];
+    uint8_t* response_buffer;
+    size_t response_size = 0;
+    int Dancer_i;
+
+    hardware_configuration__init(&DancerConfig);
+    DancerConfig.dancers = (HardwareDancer**)my_malloc(sizeof(HardwareDancer*)*MAX_SYSTEM_DANCERS);
+    for (Dancer_i = 0; Dancer_i < MAX_SYSTEM_DANCERS; Dancer_i++)
+    {
+        hardware_dancer__init(&Dancers[Dancer_i]);
+        DancerConfig.dancers[Dancer_i] = &Dancers[Dancer_i];
+        Dancers[Dancer_i].has_zeropoint = true;
+        Dancers[Dancer_i].hardwaredancertype = Dancer_i;
+        Dancers[Dancer_i].has_hardwaredancertype = true;
+        DancerConfig.dancers[Dancer_i]->zeropoint=Control_Read_Dancer_Position(Dancer_i,0,0);
+        DancerConfig.n_dancers++;
+    }
+    response_buffer = my_malloc(hardware_configuration__get_packed_size(&DancerConfig));
+    if (response_buffer)
+    {
+        response_size = hardware_configuration__pack(&DancerConfig, response_buffer);
+    }
+    Fresult = FileWrite(response_buffer,response_size,DancerConfigPath);
+    my_free(response_buffer);
+
+    return Fresult;
+}
+uint32_t LoadDancerConfigMessage()
+{
+    void* buffer = NULL;
+    uint32_t Bytes = 0;
+    FRESULT Fresult = FR_OK;
+
+    HardwareConfiguration *DancerConfig;
+    int Dancer_i;
+
+    Fresult = FileRead(DancerConfigPath, &Bytes, &buffer);
+    if (Fresult == FR_OK)
+    {
+        DancerConfig = hardware_configuration__unpack(NULL, Bytes, buffer);
+        for (Dancer_i = 0; Dancer_i < DancerConfig->n_dancers ; Dancer_i++)
+        {
+            DancersCfg[Dancer_i].zeropoint = DancerConfig->dancers[Dancer_i]->zeropoint;
+        }
+        hardware_configuration__free_unpacked(DancerConfig,NULL);
+        free (buffer);
+    }
+    return Fresult;
+
+}
+
 uint32_t DancerConfigMessage(HardwareDancer * request)
 {
     uint32_t status = PASSED;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 1cb854f87..76d4b090a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -458,7 +458,18 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             SendJobProgress(0.0,0,false, TMessage);
             //EndState(CurrentJob,TMessage );
             SegmentReady(Module_Thread,ModuleFail);
-            AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE,true);
+            switch (index)
+            {
+                case POOLER_MOTOR:
+                    AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,true);
+                    break;
+                case WINDER_MOTOR:
+                    AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER,true);
+                    break;
+                case FEEDER_MOTOR:
+                    AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,true);
+                    break;
+            }
             LOG_ERROR (DancerId, "Dancer Failure");
             return OK;
         }
@@ -551,10 +562,11 @@ uint32_t ThreadEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue)
     PoolerTotalProcessedLength = 0.0;
     PrepareState = true;
     AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,false);
-    AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE,false);
+    AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,false);
+    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);
 
-
     //start thread control for all motors
     for (Motor_i = 0;Motor_i < MAX_THREAD_MOTORS_NUM;Motor_i++)
     {