merge

14 files changed, 421 insertions, 100 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index f4da887c7..94c7614d1 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -124,8 +124,8 @@ AlarmStatusItem  AlarmState[MAX_SYSTEM_ALARMS];
 * or static variable whose declaration follows the pragma directive (only if using it without #define for example: #pragma location = MOTOR_MAP_IN_FLASH)
 * The variables must be declared either __no_init or const!
 */
-//AlarmHandlingItemStruc  *AlarmItem;
-const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
+AlarmHandlingItemStruc  *AlarmItem;
+const AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
  {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY,"Dispenser 1 Empty"},
  {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY,"Dispenser 2 Empty"},
  {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY,"Dispenser 3 Empty"},
@@ -270,15 +270,15 @@ const AlarmHandlingItemStruc  AlarmItem[MAX_SYSTEM_ALARMS]={
  { 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, CurrentAlarm, HEAD_ZONE_1_6  , HEAD_ZONE_1_6  , 312         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE           ," Head Zone 1 Heater Current Out Of Range "    },                                           /* 5018 */
- { eOneSecond, CurrentAlarm, HEAD_ZONE_2    , HEAD_ZONE_2    , 187         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE           ," Head Zone 2 Heater Current Out Of Range "    },                                           /* 5019 */
- { eOneSecond, CurrentAlarm, HEAD_ZONE_3    , HEAD_ZONE_3    , 187         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE           ," Head Zone 3 Heater Current Out Of Range "    },                                           /* 5020 */
- { eOneSecond, CurrentAlarm, HEAD_ZONE_4    , HEAD_ZONE_4    , 312         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE           ," Head Zone 4 Heater Current Out Of Range "    },                                           /* 5021 */
- { eOneSecond, CurrentAlarm, HEAD_ZONE_5    , HEAD_ZONE_5    , 312         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE         ," Head Zone 5-6 Heater Current Out Of Range "    },                                           /* 5022 */
- { eOneSecond, CurrentAlarm, MIXCHIP        , MIXCHIP        , 187         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE                        ," Mixer Heater Current Out Of Range "    },                                           /* 6004 */
- { eOneSecond, CurrentAlarm, DRYER_CURRENT_1, DRYER_CURRENT_1, 1         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE         ," Drier Heater 1 Current Out Of Range "    },                                           /* 6004 */
- { eOneSecond, CurrentAlarm, DRYER_CURRENT_2, DRYER_CURRENT_2, 1         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE         ," Drier Heater 2 Current Out Of Range "    },                                           /* 6004 */
- {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF,"Dyeing head Thermal Cut-Off"},
+// { eOneSecond, CurrentAlarm, HEAD_ZONE_1  , HEAD_ZONE_1  , 312         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE           ," Head Zone 1 Heater Current Out Of Range "    },                                           /* 5018 */
+// { eOneSecond, CurrentAlarm, HEAD_ZONE_2    , HEAD_ZONE_2    , 187         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE           ," Head Zone 2 Heater Current Out Of Range "    },                                           /* 5019 */
+// { eOneSecond, CurrentAlarm, HEAD_ZONE_3    , HEAD_ZONE_3    , 187         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE           ," Head Zone 3 Heater Current Out Of Range "    },                                           /* 5020 */
+// { eOneSecond, CurrentAlarm, HEAD_ZONE_4    , HEAD_ZONE_4    , 312         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE           ," Head Zone 4 Heater Current Out Of Range "    },                                           /* 5021 */
+// { eOneSecond, CurrentAlarm, HEAD_ZONE_5_6    , HEAD_ZONE_5_6    , 312         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE         ," Head Zone 5-6 Heater Current Out Of Range "    },                                           /* 5022 */
+// { eOneSecond, CurrentAlarm, MIXCHIP        , MIXCHIP        , 187         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE                        ," Mixer Heater Current Out Of Range "    },                                           /* 6004 */
+// { eOneSecond, CurrentAlarm, DRYER_CURRENT_1, DRYER_CURRENT_1, 1         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE         ," Drier Heater 1 Current Out Of Range "    },                                           /* 6004 */
+// { eOneSecond, CurrentAlarm, DRYER_CURRENT_2, DRYER_CURRENT_2, 1         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE         ," Drier Heater 2 Current Out Of Range "    },                                           /* 6004 */
+// {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF,"Dyeing head Thermal Cut-Off"},
 
  {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_FEEDER_DANCER,"Thread Feeder Tension Control Failure"},
@@ -330,9 +330,10 @@ void AlarmHandlingInit(void)
         AlarmState[Alarm_i].EventPtr = NULL;
     }
 
-    //AlarmItem = (AlarmHandlingItemStruc *)MOTOR_MAP_IN_FLASH;
-    //ReadAppAndProgram(AlarmItem, sizeof(AlarmHandlingItemStruc)*MAX_SYSTEM_ALARMS, HardCodedAlarmItem);
-    //LOG_ERROR(AlarmItem[2].EventName,"Flash Test");
+    AlarmItem = (AlarmHandlingItemStruc *)ALARM_MAP_IN_FLASH;
+    EraseFlashSection(ALARM_MAP_IN_FLASH,sizeof(AlarmHandlingItemStruc)*MAX_SYSTEM_ALARMS);
+    ReadAppAndProgram(AlarmItem, sizeof(AlarmHandlingItemStruc)*MAX_SYSTEM_ALARMS, HardCodedAlarmItem);
+    LOG_ERROR(AlarmItem[2].EventName,"Flash Test");
 
     return;
 }
@@ -394,7 +395,7 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever
     case DEBUG_LOG_CATEGORY__Critical:
     case DEBUG_LOG_CATEGORY__Safety:
 
-        watchdogCriticalAlarm = true;
+//        watchdogCriticalAlarm = true;
         LOG_ERROR(AlarmId,"Critical Alarm - Watchdog activated to reset  hardware");
 /*
         //stop all dispensers
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 968e52d7d..db6624fd4 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -40,6 +40,13 @@
 #include "modules/thread/thread_ex.h"
 #include "modules/ids/ids_ex.h"
 
+#include "drivers/Flash_Memory/Flash_Memory.h"
+#include "drivers/Flash_Memory/fatfs/ff.h"
+#include "drivers/Flash_ram/FlashProgram.h"
+
+#include "third_party/fatfs/src/ffconf.h"
+#include "Common/SWUpdate/FileSystem.h"
+
 #include "Communication/Connection.h"
 
 Task_Handle Millisecond_Task_Handle;
@@ -147,7 +154,11 @@ void MillisecStop(void)
     MillisecRestart = false;
     ADCAcquireStop();
 }
+#ifdef HUNDRED_MICROSECONDS_DANCER_READ
+#define HIGH_TASK_FREQUENCY 12000
+#else
 #define HIGH_TASK_FREQUENCY 120000
+#endif
 void MillisecStart(void)
 {
     MillisecRestart = true;
@@ -164,6 +175,8 @@ void OneMilliSecondMillisecInterrupt(UArg arg0)
 {
     MillisecMessageStruc MillisecMessage;
     uint32_t Tenmsec_millisecondCounter = 0;
+#ifndef HUNDRED_MICROSECONDS_DANCER_READ
+
     ROM_IntMasterDisable();
     ROM_TimerIntClear(Millisec_timerBase, TIMER_TIMA_TIMEOUT);  // Clear the timer interrupt
     if (MillisecRestart == true)
@@ -176,6 +189,7 @@ void OneMilliSecondMillisecInterrupt(UArg arg0)
 	    ROM_IntMasterEnable();
 		return;
 	}
+#endif
     if (msec_millisecondCounter%10 == 0)
     {
         Tenmsec_millisecondCounter = msec_millisecondCounter;
@@ -420,10 +434,13 @@ uint32_t MillisecLoop(uint32_t tick)
            }
        }
    }
+#ifdef HUNDRED_MICROSECONDS_DANCER_READ
+   SaveLogData();
+#else
     Dancer_Data[FEEDER_DANCER] = Read_Dancer_Position(FEEDER_DANCER);
     Dancer_Data[POOLER_DANCER] = Read_Dancer_Position(POOLER_DANCER);
     Dancer_Data[WINDER_DANCER] = Read_Dancer_Position(WINDER_DANCER);
-
+#endif
     return OK;
 }
 uint32_t MillisecLowLoop(uint32_t tick)
@@ -489,10 +506,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
             if (isMotorConfigured(Motor_i))
                 MotorGetStatusFromFPGA(Motor_i);
         }
-       /* for (Heater_i = 0;Heater_i < NUM_OF_HEATERS;Heater_i++)
+        for (Heater_i = 0;Heater_i < NUM_OF_HEATERS;Heater_i++)
         {
-            Read_Head_MixChip_Heaters_Current(Heater_i);
-        }*/
+            Read_Heaters_Current(Heater_i);
+        }
     }
     if (OneMinute_Tick)
     {
@@ -600,3 +617,147 @@ uint32_t getDrawerFansStatus(void)
 {
     return DrawerFansStatus;
 }
+#ifdef HUNDRED_MICROSECONDS_DANCER_READ
+uint32_t DancerData[NUM_OF_DANCERS];
+uint32_t Control_Read_Dancer_Position(HardwareDancerType DancerId, uint32_t Parameter1, uint32_t Parameter2)
+{
+    return DancerData[DancerId];
+}
+uint32_t dancer1;
+uint32_t dancer2;
+uint32_t dancer3;
+uint32_t dancer1sum;
+uint32_t dancer2sum;
+uint32_t dancer3sum;
+uint32_t dancer_count;
+/*-----------------------*/
+uint32_t StoreBuffer[2][128];
+//char * StoreBuffer[2][512];
+/*-----------------------*/
+int  StoreBufferId = 0;
+int  StoreBufferCounter=0;
+uint32_t  BufferCounter=0xEEEEEEEE;
+bool storeData=false;
+uint8_t len=0;
+void HundredMicroTimerInterrupt(int ARG0)
+{
+    ROM_IntMasterDisable();
+    ROM_TimerIntClear(Millisec_timerBase, TIMER_TIMA_TIMEOUT);  // Clear the timer interrupt
+    if (MillisecRestart == true)
+    {
+        ROM_TimerLoadSet(Millisec_timerBase, TIMER_A,HIGH_TASK_FREQUENCY);
+    }
+    else
+    {
+        ROM_TimerDisable(Millisec_timerBase,TIMER_A);
+        ROM_IntMasterEnable();
+        return;
+    }
+    dancer1 = Read_Dancer_Position(WINDER_DANCER);
+    dancer2 = Read_Dancer_Position(POOLER_DANCER);
+    dancer3 = Read_Dancer_Position(FEEDER_DANCER);
+//data store - logging
+//double buffer switch
+    /*-----------------------*/
+    if (StoreBufferCounter>125)
+    //if (StoreBufferCounter>490)
+        /*-----------------------*/
+    {
+        StoreBufferId = 1-StoreBufferId;//switch buffer
+        StoreBufferCounter=0;
+        storeData = true;
+    }
+//double buffer initialize
+    /*-----------------------*/
+    if (StoreBufferCounter==0)
+    {
+        StoreBuffer[StoreBufferId][StoreBufferCounter] = BufferCounter++;
+        StoreBufferCounter++;
+    }
+    /*-----------------------*/
+//store data
+    /*-----------------------*/
+    StoreBuffer[StoreBufferId][StoreBufferCounter++] = dancer1;
+    StoreBuffer[StoreBufferId][StoreBufferCounter++] = dancer2;
+    StoreBuffer[StoreBufferId][StoreBufferCounter++] = dancer3;
+    /*-----------------------*/
+    //len = usprintf(&StoreBuffer[StoreBufferId][StoreBufferCounter], "\r\n%d %d %d", dancer1[dancer_count],dancer2[dancer_count],dancer3[dancer_count]);
+    //StoreBufferCounter+=(len+1);
+    /*-----------------------*/
+    dancer1sum+=dancer1;
+    dancer2sum+=dancer2;
+    dancer3sum+=dancer3;
+    dancer_count++;
+
+
+    if (dancer_count == 10)
+    {
+        DancerData[WINDER_DANCER] = dancer1sum/dancer_count;
+        DancerData[POOLER_DANCER] = dancer2sum/dancer_count;
+        DancerData[FEEDER_DANCER] = dancer3sum/dancer_count;
+        dancer_count = 0;
+        dancer1sum = 0;
+        dancer2sum = 0;
+        dancer3sum = 0;
+        OneMilliSecondMillisecInterrupt(ARG0);
+    }
+    ROM_IntMasterEnable();
+    return ;
+
+}
+char MillisecPath[50] = "0://SysInfo//Millisec.txt";
+FIL *FileHandle;
+void SaveLogData(void)
+{
+    uint32_t WrittenBytes = 0;
+    int BufferID = 1- StoreBufferId;
+
+    if (storeData == true)
+    {
+        if (FileHandle)
+        {
+            f_write(FileHandle,StoreBuffer[BufferID],512,&WrittenBytes );
+            storeData = false;
+        }
+    }
+}
+void MillisecLogInit(void)
+{
+    FRESULT Fresult = FR_OK;
+    ROM_IntMasterDisable();
+    BufferCounter = 0;
+    FileHandle = my_malloc(sizeof(FIL));
+    if (FileHandle == 0)
+        Fresult = FR_DENIED;
+    else
+        Fresult = f_open(FileHandle,MillisecPath,FA_WRITE |  FA_OPEN_ALWAYS);
+    ROM_IntMasterEnable();
+    return ;
+
+}
+void MillisecLogClose(void)
+{
+    FRESULT Fresult = FR_OK;
+    if (FileHandle == 0)
+        Fresult = FR_DENIED;
+    else
+    {
+        storeData = false;
+        ROM_IntMasterDisable();
+        Fresult = f_close(FileHandle);
+        my_free(FileHandle);
+        FileHandle = 0;
+        ROM_IntMasterEnable();
+    }
+    return ;
+
+}
+#endif
+void MillisecInterrupt(UArg arg0)
+{
+#ifdef HUNDRED_MICROSECONDS_DANCER_READ
+    HundredMicroTimerInterrupt(arg0);
+#else
+    OneMilliSecondMillisecInterrupt(arg0);
+#endif
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
index 517716c08..61c7df7ee 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
@@ -36,6 +36,14 @@ void MillisecInit(void);
 void MillisecStop(void);
 void MillisecStart(void);
 
+#ifdef HUNDRED_MICROSECONDS_DANCER_READ
+void SaveLogData(void);
+void MillisecLogInit(void);
+void MillisecLogClose(void);
+
+#endif
+
+
 extern bool watchdogCriticalAlarm;
 
 extern Task_Handle Millisecond_Task_Handle;
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 580648842..97bb2e245 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -60,7 +60,9 @@ uint32_t HWConfigurationInit(void)
     uint32_t status = OK;
     UploadHardwareConfigurationRequest* UploadRequest;
 
+    GeneralHwReady = false;
     Control_WD(ENABLE,250);
+
     Fresult = f_mkdir(SW_INFO_DIR);
     if ((Fresult == FR_OK)||(Fresult == FR_EXIST))
     {
@@ -85,6 +87,7 @@ uint32_t HWConfigurationInit(void)
            if (status ==OK)
            {
                upload_hardware_configuration_request__free_unpacked(UploadRequest,NULL);
+               EraseFlashSection(GENHWCFG_MAP_IN_FLASH,Bytes);
                ReadAppAndProgram(GENHWCFG_MAP_IN_FLASH, Bytes, buffer);
            }
            else
@@ -232,9 +235,11 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
     if (request->n_winders == 1)
         status += InternalWinderConfigMessage(request->winders);
     status += MotorsInit();
-
+ 
     if (request->n_motors < NUM_OF_MOTORS)
     {
+       //EraseFlashSection(GENHWCFG_MAP_IN_FLASH + 0x2000,sizeof(HardwareMotor)*request->n_motors);
+
         for (Motor_i = 0; Motor_i < request->n_motors ; Motor_i++)
         status += MotorsConfigMessage(request->motors[Motor_i]);
     }
@@ -259,6 +264,8 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest)
     //StoreDancerConfigMessage();
     if (request->n_pidcontrols <= HARDWARE_PID_CONTROL_TYPE__Dispenser8)
     {
+        IDS_DispenserControlInit();
+
         for (PID_i = 0; PID_i < request->n_pidcontrols ; PID_i++)
         {
             if (request->pidcontrols[PID_i]->hardwarepidcontroltype <= HARDWARE_PID_CONTROL_TYPE__MixerHeater)
@@ -338,6 +345,9 @@ uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
 
     UploadHardwareConfigurationRequest* UploadRequest = upload_hardware_configuration_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
 
+    GeneralHwReady = false;
+    Control_WD(ENABLE,250);
+
     status = HWConfiguration(UploadRequest);
 
     responseContainer = createContainer(MESSAGE_TYPE__UploadHardwareConfigurationResponse, requestContainer->token, true, &response, &upload_hardware_configuration_response__pack, &upload_hardware_configuration_response__get_packed_size);
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index dd9f8deae..458bb35f2 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -38,11 +38,29 @@ int32_t tableindex = 0;
 char ProcessParamsConfigPath[50] = "0://SysInfo//ProcessP.cfg";
 
 ProcessParameters ProcessParametersKeep;
+void HeatersStopControlOnHeatersOff(ProcessParameters* ProcessParams)
+{
+    uint32_t temp_sum = 0;
+    temp_sum += ProcessParams->dryerzone1temp;
+    temp_sum += ProcessParams->dryerzone2temp;
+    temp_sum += ProcessParams->dryerzone3temp;
+    temp_sum += ProcessParams->mixertemp;
+    temp_sum += ProcessParams->headzone1temp;
+    temp_sum += ProcessParams->headzone2temp;
+    temp_sum += ProcessParams->headzone3temp;
+    temp_sum += ProcessParams->headzone4temp;
+    temp_sum += ProcessParams->headzone5temp;
+    temp_sum += ProcessParams->headzone6temp;
 
+    if (temp_sum == 0)// heating off
+    {
+        HeatersControlStop();
+        REPORT_MSG(temp_sum,"Heating control off - temperatures off");
+    }
+}
 uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
 {
     uint32_t status = 0;
-
     if (ProcessParams==NULL)
         {
             status = ERROR_CODE__INVALID_PARAMETER;
@@ -145,6 +163,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
                 HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, false,
                 ProcessParams->dryerzone3temp);
                 */
+    HeatersStopControlOnHeatersOff(ProcessParams);
     dyeingspeed = ProcessParams->dyeingspeed;
     dryerbufferlength = ProcessParams->dryerbufferlength;
     mininkuptake = ProcessParams->mininkuptake;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index 8a77f98a2..0b65d9e5e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -27,4 +27,5 @@ void  Heaters_SetOperationLimits(int acheatersloweroperationlimit,int acheatersu
 
 
 uint32_t HeatersEnd(void);
+void HeatersControlStop(void);
 uint32_t Heaters_Init(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
index 6fbfa5884..7c4bb1761 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
@@ -29,7 +29,7 @@
 
 
 /******************** STRUCTURES AND ENUMs  ********************************************/
-typedef enum {
+/*typedef enum {
     HeatersInitialState,
     HeatersInit,
     HeatersControlledOp,
@@ -43,7 +43,7 @@ typedef enum {
     HeatersOverHeat,
     HeatersOnTest
 }HEATERS_EVENTS_ENUM;
-
+*/
 /******************** GLOBAL PARAMETERS  ********************************************/
 HeaterPIDControlConfig HeaterControl[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0,0,0};
 bool AcHeaterConfigured[MAX_AC_HEATERS] = {0,0,0};
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index bbf3822f0..3f62fc3b6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -17,12 +17,13 @@
 #include "PMR/Diagnostics/HeaterType.pb-c.h"
 #include "PMR/Diagnostics/HeaterState.pb-c.h"
 #include "PMR/common/MessageContainer.pb-c.h"
-#include  "PMR/Diagnostics/EventType.pb-c.h"
+#include "PMR/Diagnostics/EventType.pb-c.h"
 
 #include "../AlarmHandling/AlarmHandling.h"
 #include "../control/control.h"
 #include "../control/pidalgo.h"
 
+#include <ti/sysbios/knl/Task.h>
 #include <driverlib/timer.h>
 #include <inc/hw_ints.h>
 #include <inc/hw_memmap.h>
@@ -89,7 +90,7 @@ uint32_t    SecondDryerHeaterMaxTempControl = 0xFF;
 
 //old uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,TEMP_SENSE_AN_ENCLOSURETEMP3};
 uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HEAD6_PT100,MIXER_PT100};
-HEATERS_CURRENT HeaterId2CurrentId[MAX_HEATERS_NUM] = {NUM_OF_HEATERS,DRYER_CURRENT_1,DRYER_CURRENT_2,HEAD_ZONE_1_6,HEAD_ZONE_2,HEAD_ZONE_3,HEAD_ZONE_4,HEAD_ZONE_5,HEAD_ZONE_1_6,MIXCHIP};
+HEATERS_CURRENT HeaterId2CurrentId[MAX_HEATERS_NUM] = {NUM_OF_HEATERS,DRYER_CURRENT_1,DRYER_CURRENT_2,HEAD_ZONE_1,HEAD_ZONE_2,HEAD_ZONE_3,HEAD_ZONE_4,HEAD_ZONE_5_6,HEAD_ZONE_5_6,MIXCHIP};
 uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
 bool HeatersRestart = false;
 
@@ -276,6 +277,9 @@ uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
             HeaterReady[HeaterId] = true;
         }
 
+    AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false);
+    AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false);
+    AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);
     return status;
 
 }
@@ -308,6 +312,30 @@ void HeatersStartControlTimer (void)
     Report("HeatersStartControlTimer ", __FILE__,__LINE__,0, RpMessage, 0, 0);
     return;
 }
+/***************************************************************************************************/
+int GetFilteredHeaterRead(int HeaterId)
+{
+#define MAX_FILTER 12
+    int i,maxread = -999999,minread = 999999,sum=0;
+    int FilteredRead[MAX_FILTER];
+    for (i = 0; i < MAX_FILTER;i++)
+    {
+        FilteredRead[i] = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
+        Task_sleep(1);
+    }
+    for (i = 0; i < MAX_FILTER;i++)
+    {
+        if (FilteredRead[i]<minread)
+            minread = FilteredRead[i];
+        if (FilteredRead[i]>maxread)
+            maxread = FilteredRead[i];
+        sum+=FilteredRead[i];
+    }
+    sum -= minread;
+    sum -= maxread;
+    Report("GetFilteredHeaterRead ", __FILE__,HeaterId,sum, minread, maxread, 0);
+    return (sum/(MAX_FILTER-2));
+}
 /**************************************************************************************
  * HeaterCommandRequestMessage
  * called by: Communication from host
@@ -364,11 +392,17 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
     }
     else if ((HeaterState == HEATER_ON)&& (OnOff == HEATER_ON)) //set temperature
     {
-        if (abs(HeaterPIDConfig[HeaterId].m_SetParam - HeaterCmd[HeaterId].targettemperatue)>0.5)  //#bug 221
+        HeaterPIDConfig[HeaterId].m_SetParam = HeaterCmd[HeaterId].targettemperatue;
+        /*/if (abs(HeaterPIDConfig[HeaterId].m_SetParam - HeaterCmd[HeaterId].targettemperatue)>0.5)  //#bug 221
         {
             PrepareHeater(HeaterId,Temperature);  //prepare the heaters control info
         }
-        HeaterPIDConfig[HeaterId].m_SetParam = HeaterCmd[HeaterId].targettemperatue;
+        else
+        {
+            HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//
+            LOG_ERROR(HeaterId,"ReRead Heater Temp");
+        }*/
+        PrepareHeater(HeaterId,Temperature);  //prepare the heaters control info
         // if the heater is not on return (?).
         //set the target operation temperature
         //set the heater operation mode to fast heating - depended on the current temperature
@@ -392,6 +426,88 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
  * called by: Communication from host
  * initialized all global data
  */
+void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
+{
+    if (ControlIdtoHeaterId [HeaterId] == 0xFF)
+    {
+        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
+        //HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id);
+        HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//
+        Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0);
+        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);//TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
+        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);// = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+    }
+    //turn all alarms off
+        AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false);
+        AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false);
+        AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);
+
+    if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
+        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+
+    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
+    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+
+    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
+    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
+    if (MainDryerHeaterMaxTempControl == 0xFF)
+        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
+    if (SecondDryerHeaterMaxTempControl == 0xFF)
+        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
+    //InitialHeating = true;
+    HeaterReady[HeaterId] = false;
+    if (BlowerCfg.enabled == true)
+    {
+        Turn_the_Blower_On();//Turn on with the Default_Voltage
+        if (BlowerCfg.heatingvoltage)
+            Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
+        else
+            Control_Voltage_To_Blower(BlowerCfg.voltage-500);
+
+    }
+    if (SetTemperatue)
+    {
+        Control_Dryer_Fan(START,75);//use START or STOP,  0 - 100%
+    }
+}
+/*
+ * PrepareHeater
+ * called by: Communication from host
+ * initialized all global data
+ */
+int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
+{
+    if (ControlIdtoHeaterId [HeaterId] == 0xFF)
+    ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+    //HeaterPIDConfig[HeaterId].m_params.dt *=10;
+    //DCInitialHeating[HeaterId] = true;
+    HeaterReady[HeaterId] = false;
+    HeaterRecalculateHeaterParams(HeaterId, 0);
+
+    //turn all alarms off
+    AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false);
+    AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false);
+    AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);
+
+    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
+
+    HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
+    if((abs(HeaterPreviousRead[HeaterId]-MINIMUM_HEATER_READ)<1)||(abs(MAXIMUM_HEATER_READ-HeaterPreviousRead[HeaterId])<10))
+    {
+        LOG_ERROR (HeaterId,"PT100 not working properly");
+        return ERROR;
+    }
+    Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0);
+    if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
+        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+
+    return OK;
+}
+/*
+ * PrepareHeater
+ * called by: Communication from host
+ * initialized all global data
+ */
 uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
 {
     double temp ;
@@ -402,7 +518,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
         return ERROR;
     }
 
-    Report("PrepareHeater ", __FILE__,__LINE__,HeaterId, SetTemperatue, 0, 0);
+    //Report("PrepareHeater ", __FILE__,__LINE__,HeaterId, SetTemperatue, 0, 0);
 
     //start thread control for all motors
     HeaterPIDConfig[HeaterId].m_params.MAX = HeaterControl[HeaterId].outputproportionalpowerlimit*100;
@@ -436,60 +552,12 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
     }
     if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
     {
-        if (ControlIdtoHeaterId [HeaterId] == 0xFF)
-        ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
-        //HeaterPIDConfig[HeaterId].m_params.dt *=10;
-        //DCInitialHeating[HeaterId] = true;
-        HeaterReady[HeaterId] = false;
-
-        Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
-
-        HeaterPreviousRead[HeaterId] = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
-        if((abs(HeaterPreviousRead[HeaterId]-MINIMUM_HEATER_READ)<1)||(abs(MAXIMUM_HEATER_READ-HeaterPreviousRead[HeaterId])<10))
-        {
-            LOG_ERROR (HeaterId,"PT100 not working properly");
+        if (PrepareDCHeater(HeaterId,Frequency,SetTemperatue)!=OK)
             return ERROR;
-        }
-        Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0);
-        if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
-            ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
-
     }
     else if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
     {
-        if (ControlIdtoHeaterId [HeaterId] == 0xFF)
-		{
-	        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
-            HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id);
-            Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0);
-            HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-            HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
-		}
-        if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
-            ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
-
-        Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-        Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
-
-        if (MainDryerHeaterMaxTempControl == 0xFF)
-            MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
-        if (SecondDryerHeaterMaxTempControl == 0xFF)
-            SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
-        //InitialHeating = true;
-        HeaterReady[HeaterId] = false;
-        if (BlowerCfg.enabled == true)
-        {
-            Turn_the_Blower_On();//Turn on with the Default_Voltage
-            if (BlowerCfg.heatingvoltage)
-                Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
-            else
-                Control_Voltage_To_Blower(BlowerCfg.voltage-500);
-
-        }
-        if (SetTemperatue)
-        {
-            Control_Dryer_Fan(START,75);//use START or STOP,  0 - 100%
-        }
+        PrepareACHeater(HeaterId,Frequency,SetTemperatue);
     }
     return OK;
 }
@@ -659,7 +727,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
             return OK;
         }
     }
-    else //temperature withing limits
+    else //temperature within limits
     {
         if(UnderHeatCounter[index] )
         {
@@ -711,6 +779,10 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
         Report("Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        if (readValue > HeaterCmd[index].targettemperatue)
+        {
+            DeActivateHeater(index);
+        }
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
@@ -834,6 +906,11 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
         Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index);
+        if (readValue > HeaterCmd[index].targettemperatue)
+        {
+            DeActivateHeater(index);
+            HeaterRecalculateHeaterParams(index, 0);
+        }
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
@@ -844,6 +921,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
                 {
                     DeActivateHeater(index);
+                    HeaterRecalculateHeaterParams(index, 0);
                     //Heaters OFF until coming into the proportional band
                     //Report("DC HEATER Over temperature ", __FILE__,__LINE__,index, RpMessage, readValue, 0);
                     return OK;
@@ -851,6 +929,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
                 {
                     ActivateHeater(index);
+                    //HeaterRecalculateHeaterParams(index, 100);
                     //Heaters OFF until coming into the proportional band
                     //Report("DC HEATER Under temperature ", __FILE__,__LINE__,index, RpMessage, readValue, 0);
                     return OK;
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
index 417b4e536..1e33b99ca 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c
@@ -169,17 +169,30 @@ uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpee
     DispenserCallback[DispenserId] = callback;
 
     TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[DispenserId];
-    MotorSetSpeed(HW_Motor_Id, MotorSpeed);
-    CurrentDispenserSpeed[DispenserId] = MotorSpeed;
-    if (DispenserControlId[DispenserId] != 0xFF)
-        Report("Cannot Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
-    Report("IDS_Dispenser_Start_Motor_and_Open_Valve",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
-
-    DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_OpenValveCallback, OpenValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
-    if (DispenserControlId[DispenserId] == 0xFF)
-        Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+    if (CurrentDispenserSpeed[DispenserId]) //motor already running
+    {
+        MotorSetSpeed(HW_Motor_Id, MotorSpeed);
+        CurrentDispenserSpeed[DispenserId] = MotorSpeed;
+        if (DispenserCallback[DispenserId])
+        {
+            DispenserCallback[DispenserId](DispenserId,0);
+            DispenserCallback[DispenserId] = 0;
+        }
+    }
     else
-        Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+    {
+        MotorSetSpeed(HW_Motor_Id, MotorSpeed);
+        CurrentDispenserSpeed[DispenserId] = MotorSpeed;
+        if (DispenserControlId[DispenserId] != 0xFF)
+            Report("Cannot Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+        Report("IDS_Dispenser_Start_Motor_and_Open_Valve",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0);
+
+        DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_OpenValveCallback, OpenValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 );
+        if (DispenserControlId[DispenserId] == 0xFF)
+            Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+        else
+            Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0);
+    }
 
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index 8f58bac3e..bf73ed7fa 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -40,6 +40,7 @@ uint32_t IDSDistanceToSpoolState(void);
 uint32_t IDSEndState(void *JobDetails);
 
 uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request);
+uint32_t IDS_DispenserControlInit();
 
 uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback);
 uint32_t IDS_StopHomeDispenser (uint32_t deviceID);
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
index d77d6f082..2be233962 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -30,7 +30,7 @@ typedef struct
     bool                m_isReady;
     PID_Config_Params   m_params;
 }DispenserControlConfig_t;
-HardwarePidControl DispensersControl[MAX_SYSTEM_DISPENSERS] = {0};
+HardwarePidControl *DispensersControl;// = (HardwarePidControl *)GENHWCFG_MAP_IN_FLASH + 0x4000;
 
 int32_t DispenserSamples[MAX_SYSTEM_DISPENSERS][MAX_CONTROL_SAMPLES] = {0};
 int DispenserSamplePointer[MAX_SYSTEM_DISPENSERS] = {0};
@@ -55,6 +55,13 @@ bool         DispenserUsedInJob[MAX_SYSTEM_DISPENSERS] = {false,false,false,fals
 bool         DispensersAlarmState[ MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 int JobBrushStopId = 0;
 
+uint32_t IDS_DispenserControlInit()
+{
+    DispensersControl = (void *)(GENHWCFG_MAP_IN_FLASH + 0x4000);
+    EraseFlashSection(DispensersControl,sizeof(HardwarePidControl)*MAX_SYSTEM_DISPENSERS);
+    return OK;
+}
+
 uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request)
 {
     int Dispenser_i,i;
@@ -67,9 +74,10 @@ uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request)
             break;
         }
     }
-    memcpy (&DispensersControl[Dispenser_i],request,sizeof(HardwarePidControl));
-    if (DispensersControl[Dispenser_i].pvinputfilterfactormode > MAX_CONTROL_SAMPLES)
-        DispensersControl[Dispenser_i].pvinputfilterfactormode = MAX_CONTROL_SAMPLES;
+    if (request->pvinputfilterfactormode > MAX_CONTROL_SAMPLES)
+        request->pvinputfilterfactormode = MAX_CONTROL_SAMPLES;
+    ReadAppAndProgram(&DispensersControl[Dispenser_i], sizeof(HardwarePidControl), request);
+
     for (i = 0;i < DispensersControl[Dispenser_i].pvinputfilterfactormode; i++)
         DispenserSamples[Dispenser_i][i] = 0;  //reset the samples value for control beginning
     /*DispenserNormalizedErrorCoEfficient[Dispenser_i] = (2*PI*DancersCfg[ThreadDispenserIdToDancerId[Dispenser_i]].armlength);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.c
index 47e1bda34..7735c9955 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.c
@@ -25,7 +25,7 @@
 
 void Stub_HeaterRequest(MessageContainer* requestContainer)
 {
-    uint32_t status = NOT_SUPPORTED;
+    uint32_t status = PASSED;
     MessageContainer responseContainer;
 
     StubHeaterRequest* request = stub_heater_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
@@ -35,6 +35,11 @@ void Stub_HeaterRequest(MessageContainer* requestContainer)
 	request->heatergroupon
     */
 
+    if((request->heatergroupid == 0xff) && (request->heatergroupon == false) && (request->heatertemperaturereq == 0))
+    {
+        HeatersEnd();
+    }
+    else
     if (request->heatergroupon )
         status = ActivateHeater(request->heatergroupid);
     else
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
index 435d7aef3..a1e91f6fc 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c
@@ -17,6 +17,8 @@
 #include "drivers/Flash_Memory/fatfs/ff.h"
 #include "drivers/SSI_Comm/Dancer/Dancer.h"
 
+#include "drivers/FPGA/Moters_Driver/PowerSTEP01.h"
+
 #include "thread.h"
 MotorDriverConfigStruc  MotorsCfg[NUM_OF_MOTORS]={0};
 HardwarePidControl MotorsControl[MAX_THREAD_MOTORS_NUM] = {0};
@@ -52,6 +54,14 @@ uint32_t MotorsConfigMessage(HardwareMotor * request)
         MotorsCfg[Motor_i].pulseperround = request->pulseperround;
         MotorsCfg[Motor_i].pulleyradius = request->pulleyradius;
         MotorsCfg[Motor_i].configword = request->configword;
+        if(MotorDriverResponse[Motor_i].DriverType == VoltageCombinedMotDriver)
+        {
+            MotorsCfg[Motor_i].directionthreadwize = !(request->directionthreadwize);//PowerSTEP01
+        }
+        else
+        {
+            MotorsCfg[Motor_i].directionthreadwize = request->directionthreadwize;//L6470 + L6472
+        }
         MotorsCfg[Motor_i].directionthreadwize = request->directionthreadwize;
         MotorsCfg[Motor_i].kvalhold = request->kvalhold;
         MotorsCfg[Motor_i].kvalrun = request->kvalrun;
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index ee49d56f3..6a8474438 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -427,9 +427,9 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                             JobEndReason = JOB_THREAD_BREAK;
                             ThreadControlActive = false;
                             SendJobProgress(0.0,0,false, TMessage);
-                            //SegmentReady(Module_Thread,ModuleFail);
-                            AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true);
-                            EndState(CurrentJob,"ReadBreakSensor Error" );
+                            SegmentReady(Module_Thread,ModuleFail);
+                            //AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true);
+                            //EndState(CurrentJob,"ReadBreakSensor Error" );
                             LOG_ERROR(index, "ReadBreakSensor Error");
                             return OK;
                         } //passed limit
@@ -458,7 +458,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
             SendJobProgress(0.0,0,false, TMessage);
             //EndState(CurrentJob,TMessage );
             SegmentReady(Module_Thread,ModuleFail);
-            switch (index)
+            /*switch (index)
             {
                 case POOLER_MOTOR:
                     AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,true);
@@ -469,7 +469,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue)
                 case WINDER_MOTOR:
                     AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,true);
                     break;
-            }
+            }*/
             LOG_ERROR (DancerId, "Dancer Failure");
             return OK;
         }
@@ -694,6 +694,9 @@ uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId)
         PrepareState = false;
         // set the new speed in the dryer motor to the speed of the new segment
         MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING, OriginalMotorSpd_2PPS[DRYER_MOTOR]);
+#ifdef HUNDRED_MICROSECONDS_DANCER_READ
+     MillisecLogInit();
+#endif
 
         if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].maxfrequency > 0)
         {
@@ -775,7 +778,9 @@ char Endstr[150];
 
      ThreadUpdateProcessLength (0.0,(void *)NULL);
     SetOriginMotorSpeed(0);
-
+#ifdef HUNDRED_MICROSECONDS_DANCER_READ
+     MillisecLogClose();
+#endif
      if (SpeedControlId != 0xFF)
      {
          if(RemoveControlCallback(SpeedControlId,ThreadLengthCBFunction)!=OK)