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

12 files changed, 242 insertions, 16 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/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 69820e306..b7521d796 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -99,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 = 0;
+uint32_t MaxHighDevices = 0xFF;
 /******************** Functions  ********************************************/
 void OneMilliSecondFunction(UArg arg0);
 
@@ -125,7 +125,7 @@ void ControlInit(void)
     ControlRestart = false;
 
     memset(ControlDatalog,0,sizeof(uint32_t)*MAX_TANGO_CONTROL_DEVICES);
-    MaxHighDevices = 0;
+    MaxHighDevices = 0xFF;
     for (Device_i = 0; Device_i < MAX_TANGO_CONTROL_DEVICES; Device_i++)
     {
         ControlArray[Device_i].ControlActive = false;
@@ -243,8 +243,13 @@ uint32_t  AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlF
                 break;
             }
         }
-    /*    if ((deviceId!=0xFF )&&(deviceId> MaxHighDevices))
-    //        MaxHighDevices = deviceId;
+/*        if (MaxHighDevices == 0xFF)
+            MaxHighDevices = deviceId;
+        else
+        {
+      	  	if ((deviceId!=0xFF )&&(deviceId> MaxHighDevices))
+     	       	MaxHighDevices = deviceId;
+        }
     }
     else
     {
@@ -359,7 +364,9 @@ uint32_t GetControlLowDevice_i(void)
 }
 uint32_t ControlLoop(uint32_t tick)
 {
-    //for (ControlDevice_i = 0; ControlDevice_i < MaxHighDevices;ControlDevice_i++)
+    //if (MaxHighDevices == 0xFF)
+    //    return OK;
+    //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)
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/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 8302fcab6..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
 {
@@ -156,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)
 {
@@ -700,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;
@@ -820,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/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/Stubs_Handler/Stub_Motor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
index c0f0954ed..319f85454 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c
@@ -513,6 +513,9 @@ void Stub_MotorPositionRequest(MessageContainer* requestContainer)
 
 void Stub_MotorMovRequest(MessageContainer* requestContainer)
 {
+
+    bool GoTo_Flag = false;
+
 #ifdef EVALUATION_BOARD
     uint32_t read_status;
 #endif
@@ -520,6 +523,12 @@ void Stub_MotorMovRequest(MessageContainer* requestContainer)
 
     StubMotorMovRequest* request = stub_motor_mov_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
+    if(request->position & 0x800000)
+    {
+        request->position =  request->position & ~0x800000;
+        GoTo_Flag = true;
+    }
+
     Pos_Value = request->position;
     Direction = request->direction;
 
@@ -531,6 +540,14 @@ void Stub_MotorMovRequest(MessageContainer* requestContainer)
         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 );
+        }
+        else
+        {
+            MotorMove(Motor_Id, Direction, Pos_Value );
+        }
     #endif
 
     StubMotorMovResponse response =   STUB_MOTOR_MOV_RESPONSE__INIT;
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++)
     {