Version 1.3.0.2 Reset Cause in log, remove some logs, improve memory on alarm handling. stop heaters and dispensers on alarm without job. split microsecond and control tasks to high and low priorities. Heaters PID with multiplications - use with new CFG.

20 files changed, 562 insertions, 301 deletions

diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
index 2da8581c0..9749b7e71 100644
--- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
+++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c
@@ -20,7 +20,7 @@ typedef struct
 } TangoVersion_t;
 
 
-TangoVersion_t _gTangoVersion = {001,002,002,000};
+TangoVersion_t _gTangoVersion = {001,003,000,002};
 #define BUILD_DATE __DATE__
 char Dat[50] = BUILD_DATE;
  char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d
diff --git a/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c
index 686bf9157..4dd705dc6 100644
--- a/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c
+++ b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c
@@ -16,7 +16,7 @@ static const float speedCoef = 5.3051647697298445256294587790838f;//(200 micro s
 
 //*****************************************************************************
 
-#define MAX_MEM_LOG 300
+#define MAX_MEM_LOG 100
 int freeIndex=0,malloc_index=0;
 uint32_t malloc_size[MAX_MEM_LOG+1];
 uint32_t malloc_time[MAX_MEM_LOG+1];
diff --git a/Software/Embedded_SW/Embedded/Common/report/reportInit.c b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
index 825c23082..850228ec9 100644
--- a/Software/Embedded_SW/Embedded/Common/report/reportInit.c
+++ b/Software/Embedded_SW/Embedded/Common/report/reportInit.c
@@ -168,7 +168,19 @@ uint32_t ReportInitMessage(MessageContainer* requestContainer)
     if (ReportHandle == NULL) status |= 0x8;
     status |= ReportFunc(ReportResponseFunc , REPORT_ADD, ReportHandle);
     start_debug_log_request__free_unpacked(request,NULL);
-    LOG_ERROR(127,"test");
+    /*
+        #define SYSCTL_CAUSE_HSRVREQ    0x00001000  // Hardware System Service Request
+        #define SYSCTL_CAUSE_HIB        0x00000040  // Hibernate reset
+        #define SYSCTL_CAUSE_WDOG1      0x00000020  // Watchdog 1 reset
+        #define SYSCTL_CAUSE_SW         0x00000010  // Software reset
+        #define SYSCTL_CAUSE_WDOG0      0x00000008  // Watchdog 0 reset
+        #define SYSCTL_CAUSE_BOR        0x00000004  // Brown-out reset
+        #define SYSCTL_CAUSE_POR        0x00000002  // Power on reset
+        #define SYSCTL_CAUSE_EXT        0x00000001  // External reset
+     */
+    uint32_t RESC = SysCtlResetCauseGet ();
+    LOG_ERROR(RESC,"Reset Reason Register");
+    SysCtlResetCauseClear(RESC);
     return status;
 }
 uint32_t StopReportInitMessage(MessageContainer* requestContainer)
diff --git a/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c b/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c
index 9711cebb3..7175bc602 100644
--- a/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c
+++ b/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c
@@ -219,20 +219,21 @@ void communicationTxTask(UArg arg0, UArg arg1)
     {
         Mailbox_pend(CommunicationTxMsgQ , &Message, BIOS_WAIT_FOREVER);
         UnSentMessages--;
-        /*switch (Message.messageId)
+        if ( Message.msgSize > COMM_MAX_BUFFER_SIZE)
+        {
+            LOG_ERROR(Message.msgSize , "message too long");
+        }
+        else
         {
-            case 1:*/
                 if (CommType == isUSB)
                     USBCDCD_sendData(Message.Buff, Message.msgSize,10);
                 else if (CommType == isUART)
                     Uart_Tx(Message.Buff, Message.msgSize);
-                if (diagnosticscontainer_buffer == Message.Buff)
-                    diagnosticscontainer_buffer = 0;
-                my_free(Message.Buff);
-                /*break;
-            default:
-                break;
-        }*/
+        }
+        if (diagnosticscontainer_buffer == Message.Buff)
+            diagnosticscontainer_buffer = 0;
+        my_free(Message.Buff);
+        SysCtlDelay(40000); //wait one millisecond between messages
     }
 
 }
diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c
index 4329f2eeb..8543f0493 100644
--- a/Software/Embedded_SW/Embedded/Communication/Container.c
+++ b/Software/Embedded_SW/Embedded/Communication/Container.c
@@ -45,17 +45,18 @@
 #include "Common/report/report.h"
 #include "Connection.h"
 
-#define  MAX_CONT_LOG 500
+#define  MAX_CONT_LOG 100
 
 uint16_t TxmsgId[MAX_CONT_LOG+1] = {0};
 uint16_t TxLength[MAX_CONT_LOG+1] = {0};
 uint32_t TxAddr[MAX_CONT_LOG+1] = {0};
 uint16_t Txindex = 0;
-/*uint32_t msgId[50] = {0};
-uint32_t Length[50] = {0};
-uint32_t DataLength[50] = {0};
+uint32_t msgId[MAX_CONT_LOG+1] = {0};
+uint32_t Length[MAX_CONT_LOG+1] = {0};
+uint32_t DataLength[MAX_CONT_LOG+1] = {0};
 byte index = 0;
-*/
+
+
 MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*))
 {
     MessageContainer container = MESSAGE_CONTAINER__INIT;
@@ -75,13 +76,7 @@ MessageContainer createContainer(MessageType type, char* token, protobuf_c_boole
         container.data.data = response_buffer;
         container.data.len = response_size;
 
-    /*TxmsgId[Txindex] = type;
-    TxLength[Txindex] = response_size;
-    TxAddr[Txindex] = response_buffer;
-    if (Txindex++>=MAX_CONT_LOG)
-        Txindex = 0;*/
-
-    if (SuspendLargeMessages == true)
+   // if (SuspendLargeMessages == true)
     {
 //        Report("EndJobMessage",__FILE__,__LINE__,(int)type,RpWarning,(int)response_size,0);
         TxmsgId[Txindex] = type;
@@ -103,11 +98,11 @@ void receive_callback(char* buffer, size_t length)
          return;
    //  HeatingTestSendResonse(0, false,true,true, /*OriginalMotorSpd_2PPS[index]*/length,requestContainer->type,0,0, "Container");
 
-/*     msgId[index] = requestContainer->type;
+     msgId[index] = requestContainer->type;
      Length[index] = length;
      DataLength[index] = requestContainer->data.len;
-     if (index++>=50)
-         index = 0;*/
+     if (index++>=MAX_CONT_LOG)
+         index = 0;
      REPORT_MSG(requestContainer->type,"Message received");
      switch(requestContainer->type)
      {
@@ -379,8 +374,12 @@ void receive_callback(char* buffer, size_t length)
      message_container__free_unpacked(requestContainer, NULL);
 
 }
+bool SendResult,KeepSendResult = true;
 bool SendChars(char* buffer,size_t length)
 {
-    return CommunicationTaskSendMessage(buffer, length);
+    SendResult = CommunicationTaskSendMessage(buffer, length);
+    if (SendResult == false)
+        KeepSendResult = false;
+    return SendResult;
 }
 
diff --git a/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c b/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
index 39d010375..77cf0f80b 100644
--- a/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
+++ b/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c
@@ -342,7 +342,7 @@ uint32_t Valve3WayCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag)
            //stop this control loop
            if (RemoveControlCallback(Valve3WayControlId[ValveId], Valve3WayCallBackFunction )==OK)
            {
-               Report("Remove control callback",__FILE__,__LINE__,(int)ValveId,RpWarning,(int)Valve3WayControlId[ValveId],0);
+               //Report("Remove control callback",__FILE__,__LINE__,(int)ValveId,RpWarning,(int)Valve3WayControlId[ValveId],0);
                Valve3WayControlId[ValveId] = 0xFF;
            }
            else
@@ -369,7 +369,7 @@ uint32_t Control3WayValvesWithCallback (Valves_t _ValveId, bool direction, callb
     if (Valve3WayControlId[_ValveId] == 0xFF)
         Report("Add control callback failed",__FILE__,__LINE__,(int)_ValveId,RpWarning,(int)Valve3WayControlId[_ValveId],0);
     else
-        Report("Add control callback",__FILE__,__LINE__,(int)_ValveId,RpWarning,(int)Valve3WayControlId[_ValveId],0);
+        //Report("Add control callback",__FILE__,__LINE__,(int)_ValveId,RpWarning,(int)Valve3WayControlId[_ValveId],0);
 
     EnableDisableDispenserValve(_ValveId, ENABLE);
 
diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg
index 6ba47d133..4f2dfa09c 100644
--- a/Software/Embedded_SW/Embedded/Embedded.cfg
+++ b/Software/Embedded_SW/Embedded/Embedded.cfg
@@ -17,7 +17,7 @@ var Task = xdc.useModule('ti.sysbios.knl.Task');
 
 BIOS.heapSize = 30767;   // bios heapmem
 //Memory.defaultHeapSize = 48767;
-Program.heap = 50000;  //sysmem
+Program.heap = 40000;  //sysmem
 
 Clock.timerId = 7;
 
@@ -109,74 +109,76 @@ Program.global.ReconnectSem = Semaphore.create(null, semaphore7Params);
    // deleteFxn: '&myDeleteFxn',
     switchFxn: '&mySwitchFxn'
 });*/
-var task8Params = new Task.Params();
-task8Params.instance.name = "MilliSecond";
-task8Params.stackSize = 2048;
-task8Params.priority = 12;
-Program.global.millisec = Task.create("&MillisecTask", task8Params);
 
-var task7Params = new Task.Params();
-task7Params.instance.name = "control";
-task7Params.stackSize = 2048;
-task7Params.priority = 11;
-Program.global.control = Task.create("&controlTask", task7Params);
+var MillisecTaskParams = new Task.Params();
+MillisecTaskParams.instance.name = "MilliSecond";
+MillisecTaskParams.stackSize = 2048;
+MillisecTaskParams.priority = 12;
+Program.global.millisec = Task.create("&MillisecTask", MillisecTaskParams);
 
-var task2Params = new Task.Params();
-task2Params.instance.name = "communication";
-task2Params.priority = 10;
-task2Params.stackSize = 8192;
-Program.global.communication = Task.create("&communicationTask", task2Params);
+var ControlTaskParams = new Task.Params();
+ControlTaskParams.instance.name = "control";
+ControlTaskParams.stackSize = 2048;
+ControlTaskParams.priority = 11;
+Program.global.control = Task.create("&controlTask", ControlTaskParams);
 
-var task9Params = new Task.Params();
-task9Params.instance.name = "HeatersControl";
-task9Params.priority = 9;
-Program.global.HeatersControl = Task.create("&HeatersControlTask", task9Params);
+var CommRxTaskParams = new Task.Params();
+CommRxTaskParams.instance.name = "communication";
+CommRxTaskParams.priority = 10;
+CommRxTaskParams.stackSize = 8192;
+Program.global.communication = Task.create("&communicationTask", CommRxTaskParams);
 
-var task5Params = new Task.Params();
-task5Params.instance.name = "process";
-task5Params.stackSize = 2048;
-task5Params.priority = 8;
-Program.global.process = Task.create("&jobTask", task5Params);
-/*
-var task8Params = new Task.Params();
-task8Params.instance.name = "MilliSecondLow";
-task8Params.stackSize = 2048;
-task8Params.priority = 7;
-Program.global.millisec = Task.create("&MillisecTask", task8Params);
+var HeaterControlTaskParams = new Task.Params();
+HeaterControlTaskParams.instance.name = "HeatersControl";
+HeaterControlTaskParams.priority = 9;
+Program.global.HeatersControl = Task.create("&HeatersControlTask", HeaterControlTaskParams);
 
-var task7Params = new Task.Params();
-task7Params.instance.name = "controlLow";
-task7Params.stackSize = 2048;
-task7Params.priority = 7;
-Program.global.control = Task.create("&controlTask", task7Params);
-*/
-var task10Params = new Task.Params();
-task10Params.instance.name = "communicationTx";
-task10Params.priority = 7;
-Program.global.communicationTx = Task.create("&communicationTxTask", task10Params);
+var ProcessTaskParams = new Task.Params();
+ProcessTaskParams.instance.name = "process";
+ProcessTaskParams.stackSize = 2048;
+ProcessTaskParams.priority = 8;
+Program.global.process = Task.create("&jobTask", ProcessTaskParams);
+
+var CommTxTaskParams = new Task.Params();
+CommTxTaskParams.instance.name = "communicationTx";
+CommTxTaskParams.priority = 7;
+CommTxTaskParams.stackSize = 4096;
+Program.global.communicationTx = Task.create("&communicationTxTask", CommTxTaskParams);
+
+var AlarmHandlingTaskParams = new Task.Params();
+AlarmHandlingTaskParams.instance.name = "AlarmHandling";
+AlarmHandlingTaskParams.stackSize = 1024;
+AlarmHandlingTaskParams.priority = 6;
+Program.global.AlarmHandling = Task.create("&AlarmHandlingTask", AlarmHandlingTaskParams);
+
+var MillisecLowTaskParams = new Task.Params();
+MillisecLowTaskParams.instance.name = "MilliSecondLow";
+MillisecLowTaskParams.stackSize = 2048;
+MillisecLowTaskParams.priority = 5;
+Program.global.millisecLow = Task.create("&MillisecLowTask", MillisecLowTaskParams);
 
-var task12Params = new Task.Params();
-task12Params.instance.name = "AlarmHandling";
-task12Params.stackSize = 1024;
-task12Params.priority = 6;
-Program.global.AlarmHandling = Task.create("&AlarmHandlingTask", task12Params);
+var ControlLowTaskParams = new Task.Params();
+ControlLowTaskParams.instance.name = "controlLow";
+ControlLowTaskParams.stackSize = 2048;
+ControlLowTaskParams.priority = 5;
+Program.global.controlLow = Task.create("&controlLowTask", ControlLowTaskParams);
 
-var task0Params = new Task.Params();
-task0Params.instance.name = "adcProcess";
-task0Params.stackSize = 512;
-task0Params.priority = 6;
-Program.global.adcProcess = Task.create("&ADCProcessTask", task0Params);
+var DiagnosticsTaskParams = new Task.Params();
+DiagnosticsTaskParams.instance.name = "Diagnostics";
+DiagnosticsTaskParams.priority = 4;
+DiagnosticsTaskParams.stackSize = 8192;
+Program.global.Diagnostics = Task.create("&DiagnosticsTask", DiagnosticsTaskParams);
 
-var task11Params = new Task.Params();
-task11Params.instance.name = "Diagnostics";
-task11Params.priority = 3;
-task11Params.stackSize = 8192;
-Program.global.Diagnostics = Task.create("&DiagnosticsTask", task11Params);
+var ADCProcessTaskParams = new Task.Params();
+ADCProcessTaskParams.instance.name = "adcProcess";
+ADCProcessTaskParams.stackSize = 512;
+ADCProcessTaskParams.priority = 3;
+Program.global.adcProcess = Task.create("&ADCProcessTask", ADCProcessTaskParams);
 
-var task6Params = new Task.Params();
-task6Params.instance.name = "report";
-task6Params.priority = 3;
-Program.global.report = Task.create("&reportService", task6Params);
+var ReportTaskParams = new Task.Params();
+ReportTaskParams.instance.name = "report";
+ReportTaskParams.priority = 3;
+Program.global.report = Task.create("&reportService", ReportTaskParams);
 
 var updateTaskParams = new Task.Params();
 updateTaskParams.instance.name = "update";
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index b5c586b92..0e9ed5e8e 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -89,141 +89,113 @@ typedef struct
     uint16_t Frequency;  //1/10/100/1000
     AlarmSource AlarmSource;
     uint16_t DeviceId;
-    uint32_t AlarmValue;
+    uint8_t ModuleDeviceId;
+    uint16_t AlarmValue;
     bool AlarmDirection;
     DebugLogCategory Severity;
     uint16_t Predecessor;
     uint8_t DebounceValue;
-    int8_t DebounceCounter;
-    bool Status;
     EventType EventType;
-    Event *EventPtr;
     char *EventName;
 }AlarmHandlingItem;
-AlarmHandlingItem  AlarmItem[MAX_SYSTEM_ALARMS]={
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser1Empty,NULL,"Dispenser1Empty"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser2Empty,NULL,"Dispenser2Empty"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser3Empty,NULL,"Dispenser3Empty"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser4Empty,NULL,"Dispenser4Empty"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser5Empty,NULL,"Dispenser5Empty"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser6Empty,NULL,"Dispenser6Empty"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser7Empty,NULL,"Dispenser7Empty"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser8Empty,NULL,"Dispenser8Empty"},
-/*{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_1,false,true,DEBUG_LOG_CATEGORY__Warning,0,0,0,false,EVENT_TYPE__Dispenser1LowLevel,NULL,"Dispenser1LowLevel"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_2,false,true,DEBUG_LOG_CATEGORY__Warning,1,0,0,false,EVENT_TYPE__Dispenser2LowLevel,NULL,"Dispenser2LowLevel"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_3,false,true,DEBUG_LOG_CATEGORY__Warning,2,0,0,false,EVENT_TYPE__Dispenser3LowLevel,NULL,"Dispenser3LowLevel"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_4,false,true,DEBUG_LOG_CATEGORY__Warning,3,0,0,false,EVENT_TYPE__Dispenser4LowLevel,NULL,"Dispenser4LowLevel"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_5,false,true,DEBUG_LOG_CATEGORY__Warning,4,0,0,false,EVENT_TYPE__Dispenser5LowLevel,NULL,"Dispenser5LowLevel"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_6,false,true,DEBUG_LOG_CATEGORY__Warning,5,0,0,false,EVENT_TYPE__Dispenser6LowLevel,NULL,"Dispenser6LowLevel"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_7,false,true,DEBUG_LOG_CATEGORY__Warning,6,0,0,false,EVENT_TYPE__Dispenser7LowLevel,NULL,"Dispenser7LowLevel"},
-{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_8,false,true,DEBUG_LOG_CATEGORY__Warning,7,0,0,false,EVENT_TYPE__Dispenser8LowLevel,NULL,"Dispenser8LowLevel"},*/
-{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"Mixer Over Temperature"},
-//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"GeneralInternal Over Temperature"},
-//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,80,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"GeneralInternal Over Temperature"},
-{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead1OverTemperature,NULL,"DyeingHead1 Over Temperature"},
-{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead2OverTemperature,NULL,"DyeingHead2 Over Temperature"},
-{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead3OverTemperature,NULL,"DyeingHead3 Over Temperature"},
-{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead4OverTemperature,NULL,"DyeingHead4 Over Temperature"},
-{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead5OverTemperature,NULL,"DyeingHead5 Over Temperature"},
-{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead6OverTemperature,NULL,"DyeingHead6 Over Temperature"},
-{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer Over Temperature"},
-//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer Over Temperature"},
-//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer Over Temperature"},
-//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"Mixer PT100 Not Working"},
-//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalPT100 Not Working,NULL,"GeneralInternalPT100 Not Working"},
-//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,80,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalPT100 Not Working,NULL,"GeneralInternalPT100 Not Working"},
-/*{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead1OverTemperature,NULL,"DyeingHead 1 PT100 Not Working"},
-{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead2OverTemperature,NULL,"DyeingHead 2 PT100 Not Working"},
-{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead3OverTemperature,NULL,"DyeingHead 3 PT100 Not Working"},
-{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead4OverTemperature,NULL,"DyeingHead 4 PT100 Not Working"},
-{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead5OverTemperature,NULL,"DyeingHead 5 PT100 Not Working"},
-{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead6OverTemperature,NULL,"DyeingHead 6 PT100 Not Working"},
-{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer PT100 Not Working"},
-{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer PT100 Not Working"},
-{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer PT100 Not Working"},*/
-{eOneSecond,PressureAlarm,0,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser1Pressure,NULL,"Dispenser1Pressure"},
-{eOneSecond,PressureAlarm,1,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser2Pressure,NULL,"Dispenser2Pressure"},
-{eOneSecond,PressureAlarm,2,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser3Pressure,NULL,"Dispenser3Pressure"},
-{eOneSecond,PressureAlarm,3,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser4Pressure,NULL,"Dispenser4Pressure"},
-{eOneSecond,PressureAlarm,4,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser5Pressure,NULL,"Dispenser5Pressure"},
-{eOneSecond,PressureAlarm,5,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser6Pressure,NULL,"Dispenser6Pressure"},
-{eOneSecond,PressureAlarm,6,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser7Pressure,NULL,"Dispenser7Pressure"},
-{eOneSecond,PressureAlarm,7,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser8Pressure,NULL,"Dispenser8Pressure"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerOverCurrent,NULL,"MotorDryerOverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederOverCurrent,NULL,"MotorFeederOverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewOverCurrent,NULL,"MotorScrewOverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderOverCurrent,NULL,"MotorWinderOverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerOverCurrent,NULL,"MotorPoolerOverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1OverCurrent,NULL,"MotorDispenser1OverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2OverCurrent,NULL,"MotorDispenser2OverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3OverCurrent,NULL,"MotorDispenser3OverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4OverCurrent,NULL,"MotorDispenser4OverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5OverCurrent,NULL,"MotorDispenser5OverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6OverCurrent,NULL,"MotorDispenser6OverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7OverCurrent,NULL,"MotorDispenser7OverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8OverCurrent,NULL,"MotorDispenser8OverCurrent"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerOverTemperature,NULL,"MotorDryerOverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederOverTemperature,NULL,"MotorFeederOverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewOverTemperature,NULL,"MotorScrewOverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderOverTemperature,NULL,"MotorWinderOverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerOverTemperature,NULL,"MotorPoolerOverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1OverTemperature,NULL,"MotorDispenser1OverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2OverTemperature,NULL,"MotorDispenser2OverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3OverTemperature,NULL,"MotorDispenser3OverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4OverTemperature,NULL,"MotorDispenser4OverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5OverTemperature,NULL,"MotorDispenser5OverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6OverTemperature,NULL,"MotorDispenser6OverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7OverTemperature,NULL,"MotorDispenser7OverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8OverTemperature,NULL,"MotorDispenser8OverTemperature"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerUnderVoltage,NULL,"MotorDryerUnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederUnderVoltage,NULL,"MotorFeederUnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewUnderVoltage,NULL,"MotorScrewUnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderUnderVoltage,NULL,"MotorWinderUnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerUnderVoltage,NULL,"MotorPoolerUnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1UnderVoltage,NULL,"MotorDispenser1UnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2UnderVoltage,NULL,"MotorDispenser2UnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3UnderVoltage,NULL,"MotorDispenser3UnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4UnderVoltage,NULL,"MotorDispenser4UnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5UnderVoltage,NULL,"MotorDispenser5UnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6UnderVoltage,NULL,"MotorDispenser6UnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7UnderVoltage,NULL,"MotorDispenser7UnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8UnderVoltage,NULL,"MotorDispenser8UnderVoltage"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerStall,NULL,"MotorDryerStall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederStall,NULL,"MotorFeederStall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewStall,NULL,"MotorScrewStall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderStall,NULL,"MotorWinderStall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerStall,NULL,"MotorPoolerStall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1Stall,NULL,"MotorDispenser1Stall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2Stall,NULL,"MotorDispenser2Stall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3Stall,NULL,"MotorDispenser3Stall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4Stall,NULL,"MotorDispenser4Stall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5Stall,NULL,"MotorDispenser5Stall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6Stall,NULL,"MotorDispenser6Stall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7Stall,NULL,"MotorDispenser7Stall"},
-{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8Stall,NULL,"MotorDispenser8Stall"},
-{eOneSecond,DoNotPollAlarm,0,0,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,0,false,EVENT_TYPE__ThreadBreak,NULL,"Thread Break"},
-{eOneSecond,DoNotPollAlarm,0,0,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,0,false,EVENT_TYPE__ThreadTensionControlFailure,NULL,"Thread Tension Control Failure"},
-};
-char TestMessage[5]="Test";
-bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
-/*
- typedef struct
+typedef struct
 {
-    uint16_t Frequency;  //1/10/100/1000
-    AlarmSource AlarmSource;
-    uint16_t DeviceId;
-    uint32_t AlarmValue;
-    bool AlarmDirection;
-    DebugLogCategory Severity;
-    uint16_t Predecessor;
-    uint8_t DebounceValue;
     int8_t DebounceCounter;
     bool Status;
-    EventType EventType;
     Event *EventPtr;
-    char *EventName;
-}AlarmHandlingItem;
- */
+}AlarmStatusItem;
+AlarmStatusItem  AlarmState[MAX_SYSTEM_ALARMS];
+
+const AlarmHandlingItem  AlarmItem[MAX_SYSTEM_ALARMS]={
+ {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser1Empty,"Dispenser1Empty"},
+ {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser2Empty,"Dispenser2Empty"},
+ {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser3Empty,"Dispenser3Empty"},
+ {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser4Empty,"Dispenser4Empty"},
+ {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser5Empty,"Dispenser5Empty"},
+ {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser6Empty,"Dispenser6Empty"},
+ {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser7Empty,"Dispenser7Empty"},
+ {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser8Empty,"Dispenser8Empty"},
+ {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__GeneralInternalOverTemperature,"Mixer Over Temperature"},
+ {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead1OverTemperature,"DyeingHead1 Over Temperature"},
+ {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead2OverTemperature,"DyeingHead2 Over Temperature"},
+ {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead3OverTemperature,"DyeingHead3 Over Temperature"},
+ {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead4OverTemperature,"DyeingHead4 Over Temperature"},
+ {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead5OverTemperature,"DyeingHead5 Over Temperature"},
+ {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead6OverTemperature,"DyeingHead6 Over Temperature"},
+ {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DryerOverTemperature,"Dryer Over Temperature"},
+ {eOneSecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__GeneralInternalOverTemperature,"Mixer PT100 Not Working"},
+ {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead1OverTemperature,"DyeingHead 1 PT100 Not Working"},
+ {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead2OverTemperature,"DyeingHead 2 PT100 Not Working"},
+ {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead3OverTemperature,"DyeingHead 3 PT100 Not Working"},
+ {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead4OverTemperature,"DyeingHead 4 PT100 Not Working"},
+ {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead5OverTemperature,"DyeingHead 5 PT100 Not Working"},
+ {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead6OverTemperature,"DyeingHead 6 PT100 Not Working"},
+ {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DryerOverTemperature,"Dryer PT100 Not Working"},
+ {eOneSecond,PressureAlarm,0,0,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser1Pressure,"Dispenser1Pressure"},
+ {eOneSecond,PressureAlarm,1,1,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser2Pressure,"Dispenser2Pressure"},
+ {eOneSecond,PressureAlarm,2,2,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser3Pressure,"Dispenser3Pressure"},
+ {eOneSecond,PressureAlarm,3,3,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser4Pressure,"Dispenser4Pressure"},
+ {eOneSecond,PressureAlarm,4,4,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser5Pressure,"Dispenser5Pressure"},
+ {eOneSecond,PressureAlarm,5,5,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser6Pressure,"Dispenser6Pressure"},
+ {eOneSecond,PressureAlarm,6,6,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser7Pressure,"Dispenser7Pressure"},
+ {eOneSecond,PressureAlarm,7,7,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser8Pressure,"Dispenser8Pressure"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerOverCurrent,"MotorDryerOverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederOverCurrent,"MotorFeederOverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewOverCurrent,"MotorScrewOverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderOverCurrent,"MotorWinderOverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerOverCurrent,"MotorPoolerOverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1OverCurrent,"MotorDispenser1OverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2OverCurrent,"MotorDispenser2OverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3OverCurrent,"MotorDispenser3OverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4OverCurrent,"MotorDispenser4OverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5OverCurrent,"MotorDispenser5OverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6OverCurrent,"MotorDispenser6OverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7OverCurrent,"MotorDispenser7OverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8OverCurrent,"MotorDispenser8OverCurrent"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerOverTemperature,"MotorDryerOverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederOverTemperature,"MotorFeederOverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewOverTemperature,"MotorScrewOverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderOverTemperature,"MotorWinderOverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerOverTemperature,"MotorPoolerOverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1OverTemperature,"MotorDispenser1OverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2OverTemperature,"MotorDispenser2OverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3OverTemperature,"MotorDispenser3OverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4OverTemperature,"MotorDispenser4OverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5OverTemperature,"MotorDispenser5OverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6OverTemperature,"MotorDispenser6OverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7OverTemperature,"MotorDispenser7OverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8OverTemperature,"MotorDispenser8OverTemperature"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerUnderVoltage,"MotorDryerUnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederUnderVoltage,"MotorFeederUnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewUnderVoltage,"MotorScrewUnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderUnderVoltage,"MotorWinderUnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerUnderVoltage,"MotorPoolerUnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1UnderVoltage,"MotorDispenser1UnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2UnderVoltage,"MotorDispenser2UnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3UnderVoltage,"MotorDispenser3UnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4UnderVoltage,"MotorDispenser4UnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5UnderVoltage,"MotorDispenser5UnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6UnderVoltage,"MotorDispenser6UnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7UnderVoltage,"MotorDispenser7UnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8UnderVoltage,"MotorDispenser8UnderVoltage"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerStall,"MotorDryerStall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederStall,"MotorFeederStall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewStall,"MotorScrewStall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderStall,"MotorWinderStall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerStall,"MotorPoolerStall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1Stall,"MotorDispenser1Stall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2Stall,"MotorDispenser2Stall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3Stall,"MotorDispenser3Stall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4Stall,"MotorDispenser4Stall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5Stall,"MotorDispenser5Stall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6Stall,"MotorDispenser6Stall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7Stall,"MotorDispenser7Stall"},
+ {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8Stall,"MotorDispenser8Stall"},
+ {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__ThreadBreak,"Thread Break"},
+ {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__ThreadTensionControlFailure,"Thread Tension Control Failure"}
+};
+char TestMessage[5]="Test";
+bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 bool EventsNotificationRequestAccepted = false;
 //read dispensers limit switches. 25 - send warning. up - stop job and send alarm
 //Cone missing
@@ -243,6 +215,13 @@ void AlarmHandlingInit(void)
 
     AlarmHandlingMsgQ = Mailbox_create(sizeof(AlarmHandlingMessageStruc), 20, NULL,&eb);
 
+    int Alarm_i;
+    for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
+    {
+        AlarmState[Alarm_i].Status = false;
+        AlarmState[Alarm_i].DebounceCounter = 0;
+        AlarmState[Alarm_i].EventPtr = NULL;
+    }
     return;
 }
 JobEndReasonEnum getEndReason(uint32_t AlarmId)
@@ -265,14 +244,46 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
 }
 uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Severity)
 {
-    switch (Severity)
+    //DebugLogCategory reprocessedSeverity = Severity;
+    //ProcessParameters ProcessParameterZero;
+    switch (AlarmItem[AlarmId].AlarmSource)
+    {
+        case TemperatureAlarm:
+            //need to discover the heater Id and shut it down
+            HeaterCommandRequestMessage(AlarmItem[AlarmId].ModuleDeviceId, HEATER_OFF, 0);
+            break;
+        case LimitSwitchAlarm:
+            IDS_StopDispenser (AlarmItem[AlarmId].ModuleDeviceId);
+            break;
+        case PressureAlarm:
+            IDS_StopDispenser (AlarmItem[AlarmId].ModuleDeviceId);
+            break;
+        case CurrentAlarm:
+            break;
+        case MotorAlarm:
+            MotorStop(AlarmItem[AlarmId].ModuleDeviceId,Hard_Hiz);
+            break;
+        default:
+            break;
+    }
+    /*switch (reprocessedSeverity)*/
+	switch (Severity)
     {
     case DEBUG_LOG_CATEGORY__Warning:
-
         //raise flag fr next job
         break;
     case DEBUG_LOG_CATEGORY__Critical:
         watchdogCriticalAlarm = true;
+/*
+        //stop all dispensers
+        for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
+        {
+            MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz);
+        }
+        //stop all heating
+        memset (ProcessParameterZero,0,sizeof(ProcessParameterZero));
+        HandleProcessParameters(ProcessParameterZero);
+        */
         //intentional fall through
     case DEBUG_LOG_CATEGORY__Error:
         if (JobIsActive())
@@ -281,7 +292,42 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever
             AbortJob(AlarmItem[AlarmId].EventName);
             Report(AlarmItem[AlarmId].EventName, __FILE__,__LINE__,AlarmId, RpMessage, DEBUG_LOG_CATEGORY__Error, 0);
         }
-//Stop Job
+        /*switch (AlarmItem[AlarmId].AlarmSource)
+        {
+            case TemperatureAlarm:
+                //need to discover the heater Id and shut it down
+  //              HeaterCommandRequestMessage(                        HARDWARE_PID_CONTROL_TYPE__MixerHeater, false,
+  //                      ProcessParams->mixertemp);
+                break;
+            case LimitSwitchAlarm:
+                if ((AlarmItem[AlarmId].EventType>=EVENT_TYPE__Dispenser1Empty)&&(AlarmItem[AlarmId].EventType<=EVENT_TYPE__Dispenser8Empty))
+                {
+                    Disp_i = AlarmItem[AlarmId].EventType- EVENT_TYPE__Dispenser1Empty;
+                    MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz);
+                    if (JobIsActive())
+                    {
+                        if (DispenserInUse[Disp_i] == false)
+                            AlarmItem[AlarmId].Severity = DEBUG_LOG_CATEGORY__Info;
+                    }
+                }
+                break;
+            case PressureAlarm:
+                Disp_i = AlarmItem[AlarmId].EventType- EVENT_TYPE__Dispenser1Pressure;
+                MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz);
+                if (JobIsActive())
+                {
+                    if (DispenserInUse[Disp_i] == false)
+                        AlarmItem[AlarmId].Severity = DEBUG_LOG_CATEGORY__Info;
+                }
+                break;
+            case CurrentAlarm:
+                break;
+            case MotorAlarm:
+                break;
+            default:
+                break;
+        }*/
+
         break;
     case DEBUG_LOG_CATEGORY__Debug:
     case DEBUG_LOG_CATEGORY__Info:
@@ -334,7 +380,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
             {
                 if (AlarmItem[Alarm_i].EventType == (EVENT_TYPE__Dispenser1Empty+Dispenser_i))
                 {
-                    if (AlarmItem[Alarm_i].Status == true)
+                    if (AlarmState[Alarm_i].Status == true)
                     {
                         status = ERROR;
                         AlarmId = Alarm_i;
@@ -353,7 +399,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
             {
                 if (AlarmItem[Alarm_i].EventType == HeaterEventType[Heater_i])
                 {
-                    if (AlarmItem[Alarm_i].Status == true)
+                    if (AlarmState[Alarm_i].Status == true)
                     {
                         status = ERROR;
                         AlarmId = Alarm_i;
@@ -412,24 +458,24 @@ void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value)
     {
         if (AlarmItem[Alarm_i].EventType == AlarmId)
         {
-            AlarmItem[Alarm_i].Status = value;
+            AlarmState[Alarm_i].Status = value;
             if (value == true)
             {
                 AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity);
                 // report the alarm!
-                AlarmItem[Alarm_i].EventPtr = my_malloc (sizeof(Event));
-                if (AlarmItem[Alarm_i].EventPtr)
+                AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
+                if (AlarmState[Alarm_i].EventPtr)
                 {
-                    event__init(AlarmItem[Alarm_i].EventPtr);
-                    AlarmItem[Alarm_i].EventPtr->has_type = true;
-                    AlarmItem[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
-                    AlarmItem[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName;
+                    event__init(AlarmState[Alarm_i].EventPtr);
+                    AlarmState[Alarm_i].EventPtr->has_type = true;
+                    AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
+                    AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName;
                 }
             }
             else
             {
-                if (AlarmItem[Alarm_i].EventPtr)
-                    my_free(AlarmItem[Alarm_i].EventPtr);
+                if (AlarmState[Alarm_i].EventPtr)
+                    my_free(AlarmState[Alarm_i].EventPtr);
             }
             break;
         }
@@ -546,7 +592,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                 }
                 break;
             case DoNotPollAlarm:
-                Status =  AlarmItem[Alarm_i].Status;
+                Status =  AlarmState[Alarm_i].Status;
                 break;
             default:
                 break;
@@ -555,64 +601,64 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
             {
                 if (Status == true) //increase counter
                 {
-                    AlarmItem[Alarm_i].DebounceCounter++;
-                    if (AlarmItem[Alarm_i].Status == false) // alarm is not set yet
+                    AlarmState[Alarm_i].DebounceCounter++;
+                    if (AlarmState[Alarm_i].Status == false) // alarm is not set yet
                     {
-                        if (AlarmItem[Alarm_i].DebounceCounter < AlarmItem[Alarm_i].DebounceValue) //had not reached the debounce value
+                        if (AlarmState[Alarm_i].DebounceCounter < AlarmItem[Alarm_i].DebounceValue) //had not reached the debounce value
                         {
                             Status = false; //do not set the alarm
                         } //else alarm will be set
                     }
                     else // alarm is already set
                     {
-                        AlarmItem[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue; // do not go over the debounce value
+                        AlarmState[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue; // do not go over the debounce value
                     }
                 }
                 else //status  == false - decrease counter
                 {
-                    AlarmItem[Alarm_i].DebounceCounter--;
-                    if (AlarmItem[Alarm_i].Status == true) // alarm is set
+                    AlarmState[Alarm_i].DebounceCounter--;
+                    if (AlarmState[Alarm_i].Status == true) // alarm is set
                     {
-                        if (AlarmItem[Alarm_i].DebounceCounter > 0) // had not reached zero yet
+                        if (AlarmState[Alarm_i].DebounceCounter > 0) // had not reached zero yet
                         {
                             Status = true; // do not reset the alarm yet
                         }   // else reset the alarm
                     }
                     else // if the alarm is off
                     {
-                        AlarmItem[Alarm_i].DebounceCounter = 0; //do not go below 0
+                        AlarmState[Alarm_i].DebounceCounter = 0; //do not go below 0
                     }
                 }
             }
             if (AlarmItem[Alarm_i].Predecessor!=0xFF)
             {
-                if (AlarmItem[AlarmItem[Alarm_i].Predecessor].Status == true)  //higher hierarchy alarm is on
+                if (AlarmState[AlarmItem[Alarm_i].Predecessor].Status == true)  //higher hierarchy alarm is on
                     Status = false;
             }
-            if (Status !=  AlarmItem[Alarm_i].Status) //change in alarm Status
+            if (Status !=  AlarmState[Alarm_i].Status) //change in alarm Status
             {
                 if (Status == true) // alarm on
                 {
-                    AlarmItem[Alarm_i].Status = true;
+                    AlarmState[Alarm_i].Status = true;
                     AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity);
                     // report the alarm!
-                    AlarmItem[Alarm_i].EventPtr = my_malloc (sizeof(Event));
-                    if (AlarmItem[Alarm_i].EventPtr)
+                    AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
+                    if (AlarmState[Alarm_i].EventPtr)
                     {
-                        event__init(AlarmItem[Alarm_i].EventPtr);
-                        AlarmItem[Alarm_i].EventPtr->has_type = true;
-                        AlarmItem[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
-                        AlarmItem[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName;
+                        event__init(AlarmState[Alarm_i].EventPtr);
+                        AlarmState[Alarm_i].EventPtr->has_type = true;
+                        AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
+                        AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName;
                     }
                     Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
                 }
                 else // alarm off
                 {
-                    AlarmItem[Alarm_i].Status = false;
+                    AlarmState[Alarm_i].Status = false;
                     AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info);
                     // report the alarm!
-                    if (AlarmItem[Alarm_i].EventPtr)
-                        my_free(AlarmItem[Alarm_i].EventPtr);
+                    if (AlarmState[Alarm_i].EventPtr)
+                        my_free(AlarmState[Alarm_i].EventPtr);
                     Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i);
                 }
             }
@@ -686,7 +732,7 @@ void SendEventNotifications(void)
 
     for (i = 0;i<MAX_SYSTEM_ALARMS;i++)
     {
-        if (AlarmItem[i].Status == true)
+        if (AlarmState[i].Status == true)
         {
             response.n_events++;
         }
@@ -696,9 +742,9 @@ void SendEventNotifications(void)
     {
         for (i = 0;i<MAX_SYSTEM_ALARMS;i++)
         {
-            if (AlarmItem[i].Status == true)
+            if (AlarmState[i].Status == true)
             {
-                response.events[e]=AlarmItem[i].EventPtr;
+                response.events[e]=AlarmState[i].EventPtr;
                 e++;
             }
         }
@@ -733,9 +779,9 @@ uint32_t ResolveEventRequestFunc(MessageContainer* requestContainer)
     {
         if (AlarmItem[Alarm_i].EventType == request->type)
         {
-            AlarmItem[Alarm_i].Status = false;
-            if (AlarmItem[Alarm_i].EventPtr)
-                my_free(AlarmItem[Alarm_i].EventPtr);
+            AlarmState[Alarm_i].Status = false;
+            if (AlarmState[Alarm_i].EventPtr)
+                my_free(AlarmState[Alarm_i].EventPtr);
             status = OK;
             break;
         }
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 68bd680a8..64b6ac4e0 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -90,6 +90,7 @@ MillisecMotorDataStruc SpeedSetPending[NUM_OF_MOTORS] = {0};
 MillisecMotorDataStruc PT100Data[MAX_TEMPERATURE_SENSOR_ID] = {0};
 /******************** GLOBAL PARAMETERS  ********************************************/
 Mailbox_Handle          MillisecMsgQ = NULL;
+Mailbox_Handle          TenMillisecMsgQ = NULL;
 Mailbox_Handle          MotorsMsgQ[NUM_OF_MOTORS] = {NULL};
 bool                    MillisecRestart;
 static GateMutex_Handle gateMillisecDB;
@@ -114,6 +115,7 @@ void MillisecInit(void)
     Error_init(&eb);
 
     MillisecMsgQ = Mailbox_create(sizeof(MillisecMessageStruc), 2, NULL,&eb);
+    TenMillisecMsgQ = Mailbox_create(sizeof(MillisecMessageStruc), 2, NULL,&eb);
     for (i=0;i<NUM_OF_MOTORS;i++)
     {
         MotorsMsgQ[i] = Mailbox_create(sizeof(MillisecMotorDataStruc), 5, NULL,&eb);
@@ -158,6 +160,7 @@ void MillisecStart(void)
 void OneMilliSecondMillisecInterrupt(UArg arg0)
 {
     MillisecMessageStruc Message;
+    uint32_t Tenmsec_millisecondCounter = 0;
     ROM_IntMasterDisable();
     ROM_TimerIntClear(Millisec_timerBase, TIMER_TIMA_TIMEOUT);  // Clear the timer interrupt
     if (MillisecRestart == true)
@@ -170,13 +173,26 @@ void OneMilliSecondMillisecInterrupt(UArg arg0)
 	    ROM_IntMasterEnable();
 		return;
 	}
+    if (msec_millisecondCounter%10 == 0)
+    {
+        Tenmsec_millisecondCounter = msec_millisecondCounter;
+    }
     //send message to the Millisec task
     Message.messageId = OneMillisec;
-    Message.tick = msec_millisecondCounter++;;
+    Message.tick = msec_millisecondCounter++;
     Message.msglen = sizeof(MillisecMessageStruc);
     if (MillisecMsgQ != NULL)
         Mailbox_post(MillisecMsgQ , &Message, BIOS_NO_WAIT);
 
+    if (Tenmsec_millisecondCounter)
+    {
+        Message.messageId = OneMillisec;
+        Message.tick = Tenmsec_millisecondCounter;
+        Message.msglen = sizeof(MillisecMessageStruc);
+        if (TenMillisecMsgQ != NULL)
+            Mailbox_post(TenMillisecMsgQ , &Message, BIOS_NO_WAIT);
+    }
+
     //
     // Enable all interrupts.
     //
@@ -341,17 +357,16 @@ int32_t MillisecReadFromMotor(TimerMotors_t MotorId, unsigned long Data, int Len
     else return false;
 }
 
-//TEMPERATURE_SENSOR_ID_ENUM Sensor_Read = 0;
 uint32_t MillisecLoop(uint32_t tick)
 {
-    uint8_t Motor_i,Disp_i;
+    uint8_t Motor_i;
     TEMPERATURE_SENSOR_ID_ENUM Sensor_i;
     unsigned int MotorInfo = 0;
     static int temp=0;
     //call all modules Millisec functions
     //test dancers and speed encoders
     //check all callback units (state machine waiting for completion of a change)
-    bool Ten_msTick, Hundred_msTick, Onesecond_Tick,O900Millisecond_Tick,Tick98,OneMinute_Tick;
+/*    bool Ten_msTick, Hundred_msTick, Onesecond_Tick,O900Millisecond_Tick,Tick98,OneMinute_Tick;
     Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
     Hundred_msTick  =   (tick%eHundredMillisecond == 0)  ?true:false;
     O900Millisecond_Tick  =   (tick%eOneSecond == 900)           ?true:false;
@@ -360,7 +375,7 @@ uint32_t MillisecLoop(uint32_t tick)
     Tick98          =   (tick%eHundredMillisecond == 99) ?true:false;
     //gather Motor data from FPGA
     //ROM_IntMasterDisable();
-
+*/
 #ifndef EVALUATION_BOARD
         FPGA_GetBusy();  //load the busy motor information to all motors
         FPGA_Read_limit_Switches_Registers();
@@ -473,6 +488,26 @@ uint32_t MillisecLoop(uint32_t tick)
     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);
+    return OK;
+}
+uint32_t MillisecLowLoop(uint32_t tick)
+{
+    uint8_t Disp_i;
+    TEMPERATURE_SENSOR_ID_ENUM Sensor_i;
+
+    static int temp=0;
+    //call all modules Millisec functions
+    //test dancers and speed encoders
+    //check all callback units (state machine waiting for completion of a change)
+    bool Ten_msTick, Hundred_msTick, Onesecond_Tick,O900Millisecond_Tick,Tick98,OneMinute_Tick;
+    Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
+    Hundred_msTick  =   (tick%eHundredMillisecond == 0)  ?true:false;
+    O900Millisecond_Tick  =   (tick%eOneSecond == 900)           ?true:false;
+    Onesecond_Tick  =   (tick%eOneSecond == 0)           ?true:false;
+    OneMinute_Tick  =   (tick%eOneMinute == 0)           ?true:false;
+    //gather Motor data from FPGA
+    //ROM_IntMasterDisable();
+
     if (Ten_msTick)
     {
         //Speed_Data = Calculate_Speed_Sensor_Velocity();
@@ -501,7 +536,7 @@ uint32_t MillisecLoop(uint32_t tick)
         for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
         {
             CalculateDispenserPressure(Disp_i);
-            Read_MidTank_Pressure_Sensor(Disp_i);
+            //Read_MidTank_Pressure_Sensor(Disp_i);
         }
         FPGA_GetAllDispensersValveBusyOCD();
         DrawerFansStatus = Read_Fans_Tacho();
@@ -509,10 +544,10 @@ uint32_t MillisecLoop(uint32_t tick)
     }
     if (OneMinute_Tick)
     {
-        for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
-        {
-            Read_MidTank_Pressure_Sensor(Disp_i);
-        }
+//        for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
+//        {
+//            Read_MidTank_Pressure_Sensor(Disp_i);
+//        }
 /*        for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++)
         {
             if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_SCREW)
@@ -553,6 +588,33 @@ void MillisecTask(UArg arg0, UArg arg1)
         }
     }
 }
+/******************************************************************************
+ *  ======== messageTsk ========
+ *  Task for this function is created statically. See the project's .cfg file.
+ *  this message task is created statically in system initialization,
+ ******************************************************************************/
+void MillisecLowTask(UArg arg0, UArg arg1)
+{
+    MillisecMessageStruc Message;
+    //char str[60];
+    //uint16_t length;
+    //Clock_setTimeout(HostKAClock, 1000);
+    //Clock_start(HostKAClock);
+    //MillisecInit();
+    //Millisecond_Task_Handle = Task_self();
+    while(1)
+    {
+        Mailbox_pend(TenMillisecMsgQ , &Message, BIOS_WAIT_FOREVER);
+        switch (Message.messageId)
+        {
+            case OneMillisec:
+                MillisecLowLoop(Message.tick);
+                break;
+            default:
+                break;
+        }
+    }
+}
 
 
 /*uint32_t getMotorStatusData(int MotorId)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c
index 2110029e4..ed1e73bef 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/control.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c
@@ -87,6 +87,7 @@ int ControlPhaseDelay = 300; //the control task enters only after data gathering
 //this parameters defines how many microseconds in the delay. it is used only on starting the control loop on the first time
 /******************** GLOBAL PARAMETERS  ********************************************/
 Mailbox_Handle          ControlMsgQ = NULL;
+Mailbox_Handle          TenControlMsgQ = NULL;
 bool                    ControlRestart;
 static GateMutex_Handle gateControlDB;
 Task_Handle Control_Task_Handle;
@@ -115,6 +116,7 @@ void ControlInit(void)
 
     //Mailbox_Params_init(&ControlMsgQ);
     ControlMsgQ = Mailbox_create(sizeof(ControlMessageStruc), 20, NULL,NULL);
+    TenControlMsgQ = Mailbox_create(sizeof(ControlMessageStruc), 20, NULL,NULL);
 
     ControlRestart = false;
 
@@ -258,6 +260,8 @@ uint32_t millisecondCounter = 0;
 void OneMilliSecondControlInterrupt(UArg arg0)
 {
     ControlMessageStruc Message;
+    uint32_t TenmillisecondCounter = 0;
+
     ROM_IntMasterDisable();
     ROM_TimerIntClear(Control_timerBase, TIMER_TIMA_TIMEOUT);  // Clear the timer interrupt
 
@@ -272,6 +276,10 @@ void OneMilliSecondControlInterrupt(UArg arg0)
         //ROM_TimerDisable(Control_timerBase, TIMER_A);
         return;
     }
+    if (millisecondCounter%10 == 0)
+    {
+        TenmillisecondCounter = millisecondCounter;
+    }
 
     //send message to the control task
     Message.messageId = OneMillisec;
@@ -279,6 +287,12 @@ void OneMilliSecondControlInterrupt(UArg arg0)
     Message.msglen = sizeof(ControlMessageStruc);
     if (ControlMsgQ != NULL)
         Mailbox_post(ControlMsgQ , &Message, BIOS_NO_WAIT);
+    //if (TenmillisecondCounter)
+    {
+        //Message.tick = TenmillisecondCounter;
+        if (TenControlMsgQ != NULL)
+            Mailbox_post(TenControlMsgQ , &Message, BIOS_NO_WAIT);
+    }
     if (millisecondCounter == 1000000000)
         millisecondCounter = 0;
     //
@@ -294,7 +308,7 @@ uint32_t ControlLoop(uint32_t tick)
     //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;
+    /*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;
@@ -302,7 +316,7 @@ uint32_t ControlLoop(uint32_t tick)
     Tick98          =   (tick%eHundredMillisecond == 98) ?true:false;
 //    Tick98          =   (tick%200 == 199) ?true:false;
     Tick998         =   (tick%eOneSecond == 996)         ?true:false;
-
+*/
     //ROM_IntMasterDisable();
     for (Device_i = 0; Device_i < MAX_TANGO_CONTROL_DEVICES;Device_i++)
     {
@@ -323,6 +337,40 @@ uint32_t ControlLoop(uint32_t tick)
                     else
                         LOG_ERROR (Device_i, "Invalid callback ptr");
                     break;
+                default:
+                    break;
+            } //switch
+        } //if control active
+    }  //for
+    //ROM_IntMasterEnable();
+
+    return OK;
+}
+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 (Device_i = 0; Device_i < MAX_TANGO_CONTROL_DEVICES;Device_i++)
+    {
+        if (ControlArray[Device_i].ControlActive)
+        {
+            ControlBacklog[backlogindex]=Device_i;
+            if ( ++backlogindex >= 999)
+                backlogindex = 0;
+            switch (ControlArray[Device_i].ControlTiming)
+            {
+                case eOneMillisecond:
+                    break;
                 case eTenMillisecond:
                     if (Ten_msTick)
                     {
@@ -374,7 +422,17 @@ uint32_t ControlLoop(uint32_t tick)
                     memset (&ControlArray[Device_i],0,sizeof(ControlDeviceStruc) );
                     break;
                 default:
-                    LOG_ERROR (ControlArray[Device_i].ControlTiming, "Invalid control timing value");
+                    if (tick%ControlArray[Device_i].ControlTiming == 0)
+                    {
+                        if(ControlArray[Device_i].ControlDataReadPtr)
+                            ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1);
+                        else
+                            LOG_ERROR (Device_i, "Invalid callback ptr");
+                        if(ControlArray[Device_i].ControlCallbackPtr)
+                            ControlArray[Device_i].ControlCallbackPtr(ControlArray[Device_i].IfIndex, ControlDatalog[Device_i]);
+                        else
+                            LOG_ERROR (Device_i, "Invalid callback ptr");
+                    }
                     break;
             } //switch
         } //if control active
@@ -410,3 +468,30 @@ void controlTask(UArg arg0, UArg arg1)
         }
     }
 }
+/******************************************************************************
+ *  ======== messageTsk ========
+ *  Task for this function is created statically. See the project's .cfg file.
+ *  this message task is created statically in system initialization,
+ ******************************************************************************/
+void controlLowTask(UArg arg0, UArg arg1)
+{
+    ControlMessageStruc Message;
+    //char str[60];
+    //uint16_t length;
+    //Clock_setTimeout(HostKAClock, 1000);
+    //Clock_start(HostKAClock);
+    Control_Task_Handle = Task_self();
+
+    while(1)
+    {
+        Mailbox_pend(TenControlMsgQ , &Message, BIOS_WAIT_FOREVER);
+        switch (Message.messageId)
+        {
+            case OneMillisec:
+                ControlLowLoop(Message.tick);
+                break;
+            default:
+                break;
+        }
+    }
+}
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 9c4ceb8d7..e2c572a6e 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -57,8 +57,8 @@ uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
 
 
 DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT;
-#define DIAGNOSTICS_LIMIT 5
-#define DIAGNOSTICS_DANCER_LIMIT 50
+#define DIAGNOSTICS_LIMIT 3
+#define DIAGNOSTICS_DANCER_LIMIT 30
 int DiagnosticsIndex = 0;
 int DiagnosticCollectionLimit = 2;  //number of data samples to collect before sending to the host
 //int DiagnosticLimit = eHundredMillisecond; //frequency of data collection
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index e5c12f7b0..482d081b0 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -20,5 +20,7 @@ bool HeaterGetOverTemperatureState(uint8_t HeaterId);
 
 void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState);
 
+uint32_t LoadHeaterSetPoint(HeaterType HeaterType);
+
 uint32_t HeatersEnd(void);
 uint32_t Heaters_Init(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index e12ede228..35b8ea9f7 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -113,6 +113,9 @@ void HeatersControlInit(void)
     {
         DCInitialHeating[i] = true;
         HeaterReady[i] = true;
+        HeaterCmd[i].targettemperatue = 0;
+        HeaterCmd[i].command = HEATER_OFF;
+        HeaterCmd[i].heaterid = i;
     }
     HeatersRestart = false;
 
@@ -138,6 +141,15 @@ void HeatersControlStart(void)
         HeatersStartControlTimer();
     }
 }
+uint32_t LoadHeaterSetPoint(HeaterType HeaterType)
+{
+    if (HeaterType >= MAX_HEATERS_NUM)
+    {
+        LOG_ERROR(HeaterType,"Wrong Heater Id");
+        return 0;
+    }
+    return HeaterCmd[HeaterType].targettemperatue;
+}
 void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
 {
     int HeaterId = HeaterType;
@@ -148,6 +160,8 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
   //  HeaterState->setpoint = HeaterCmd[HeaterId].targettemperatue/100;
   //  if (HeaterType >= HEATER_TYPE__HeaterZone1)
         HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse;
+    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature)
+        HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit;
     HeaterState->has_currentvalue = true;
     HeaterState->currentvalue = TemperatureSensorRead(HeaterId2PT100Id[HeaterId])/100;
     HeaterState->has_isactive = true;
@@ -314,6 +328,7 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
  */
 uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
 {
+    CTRL_TIMING_ENUM Frequency = eHundredMillisecond;
     if(HeaterId >= MAX_HEATERS_NUM)
     {
         LOG_ERROR (HeaterId,"HeaterId too high");
@@ -332,6 +347,8 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
     HeaterPIDConfig[HeaterId].m_params.Kd = HeaterControl[HeaterId].kd;
     HeaterPIDConfig[HeaterId].m_params.Kp = HeaterControl[HeaterId].kp;
     HeaterPIDConfig[HeaterId].m_params.Ki = HeaterControl[HeaterId].ki;
+    HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier = HeaterControl[HeaterId].setpointramprateorsoftstartramp;
+    HeaterPIDConfig[HeaterId].m_params.ProportionalErrorMultiplier = HeaterControl[HeaterId].outputonoffhysteresisvalue;
     HeaterPIDConfig[HeaterId].m_params.dt = HeaterControl[HeaterId].dt;
     HeaterPIDConfig[HeaterId].m_params.epsilon = HeaterControl[HeaterId].epsilon; //0.1 degree
     HeaterPIDConfig[HeaterId].m_calculatedError = 0;
@@ -341,10 +358,15 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
     HeaterPIDConfig[HeaterId].m_mesuredParam = 0;
     HeaterPIDConfig[HeaterId].m_preError = 0;
     HeaterPIDConfig[HeaterId].m_SetParam = SetTemperatue*100;//need to update SetParams on presegment stage
+
+    if (HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier)
+    {
+        Frequency = eOneSecond*HeaterPIDConfig[HeaterId].m_params.dt;
+    }
     if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
     {
         if (ControlIdtoHeaterId [HeaterId] == 0xFF)
-        ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+        ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
         HeaterPIDConfig[HeaterId].m_params.dt *=10;
         DCInitialHeating[HeaterId] = true;
         HeaterReady[HeaterId] = false;
@@ -353,7 +375,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
     {
         if (ControlIdtoHeaterId [HeaterId] == 0xFF)
 		{
-	        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
+	        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
       	    HeaterPIDConfig[HeaterId].m_params.dt *=10;
 		}
         if (MainDryerHeaterMaxTempControl == 0xFF)
@@ -449,7 +471,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     {
         if (HeaterMaxTempFlag[index] == false)
         {
-            LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
+     //       LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
         }
         DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
         HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = true;
@@ -468,7 +490,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
                 {
                     ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                 }
-                LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on");
+       //         LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on");
             }
             HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
             HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = false;
@@ -550,13 +572,20 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         }
         else  //PID active
         {
-            //check only for the proportional band limits
-            HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
-                                                                              &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
-            len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError);
+            if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0)
+            {
+                HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
+                                                      &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+            }
+            else
+            {
+                HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
+                                                      &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+            }
+//            len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError);
             //        Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);
             //        #warning PID is now only proportional (above)
-             Report(ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue,  HeaterPIDConfig[index].m_calculatedError);
+//             Report(ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue,  HeaterPIDConfig[index].m_calculatedError);
             HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, (int)(HeaterPIDConfig[index].m_calculatedError/100));
         }
     }
@@ -647,8 +676,16 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         {
             //check only for the proportional band limits
             HeaterPIDConfig[index].m_mesuredParam = readValue;
-            HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
+            if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0)
+            {
+                HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
                                                       &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+            }
+            else
+            {
+                HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
+                                                      &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
+            }
             //        error[index][Counter[index]]    = HeaterPIDConfig[index].m_preError;
             //        integral[index][Counter[index]] = HeaterPIDConfig[index].m_integral;
             //        output[index][Counter[index]]   = HeaterPIDConfig[index].m_calculatedError;
@@ -658,8 +695,8 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             //        #warning PID is now only proportional (above)
             if (index == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2)
             {
-                len = usnprintf(heatstr, 254, "PID id, Temp, Integral, Output { %d, %d ,%d, %d}",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError);
-                Report(heatstr,__FILE__,__LINE__,index,RpWarning,HeaterPIDConfig[index].m_calculatedError,0);
+  //              len = usnprintf(heatstr, 254, "PID id, Temp, Integral, Output { %d, %d ,%d, %d}",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError);
+  //              Report(heatstr,__FILE__,__LINE__,index,RpWarning,HeaterPIDConfig[index].m_calculatedError,0);
             }
             HeaterRecalculateHeaterParams(index, (int)(HeaterPIDConfig[index].m_calculatedError/100));
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
index 7c25fed89..1e15cc1c2 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h
@@ -43,6 +43,7 @@ uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request);
 uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback);
 uint32_t IDS_StopHomeDispenser (uint32_t deviceID);
 uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback);
+uint32_t IDS_StopDispenser (uint8_t deviceID);
 
 uint32_t IDS_CheckDispenserLimitSwitch (LimitSwitchAlarms LS_Id);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
index e4d4c7b9c..bf03b42de 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c
@@ -104,6 +104,16 @@ uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr ca
     }
     return ERROR;
 }
+uint32_t IDS_StopDispenser (uint8_t deviceID)
+{
+    uint32_t status = OK;
+    TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID;
+    status |= MotorAbortMovetoLimitSwitch(MotorId);
+    Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_OFF);
+    status |= MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep);
+    status |= MotorStop(deviceID, Hard_Hiz);
+    return status;
+}
 
 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 9db07f271..346ee0246 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c
@@ -189,8 +189,9 @@ bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int Segmen
  {
      TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[deviceID];
      MotorStop(HW_Motor_Id,Hard_Hiz);
-     REPORT_MSG(deviceID,"Dispenser PreSegment called");
+     //REPORT_MSG(deviceID,"Dispenser PreSegment called");
      IDS_Valve_PresegmentReady( deviceID,  ReadValue);
+     return OK;
  }
  //********************************************************************************************************************
  uint32_t IDS_Valve_PresegmentReady(uint32_t deviceID, uint32_t ReadValue)
@@ -253,7 +254,7 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
             //prepare the SW structures
             DispenserId = JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->index;
             DispenserPreSegmentReady[DispenserId] = false;
-            REPORT_MSG(DispenserId,"Dispenser PreSegment Start");
+            //REPORT_MSG(DispenserId,"Dispenser PreSegment Start");
         }
         for (Dispenser_i = 0;Dispenser_i < n_dispensers;Dispenser_i++)
         {
@@ -378,9 +379,10 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
  {
      TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[deviceID];
      MotorStop(HW_Motor_Id,Hard_Hiz);
-     REPORT_MSG(deviceID,"Dispenser DTS called");
+     //REPORT_MSG(deviceID,"Dispenser DTS called");
      IDS_Valve_DistanceToSpoolReady( deviceID,  ReadValue);
- }
+     return OK;
+}
 
  //********************************************************************************************************************
   uint32_t IDS_Valve_DistanceToSpoolReady(uint32_t deviceID, uint32_t ReadValue)
@@ -421,8 +423,9 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
  uint32_t IDS_Valve_EndValveReady(uint32_t deviceID, uint32_t ReadValue)
  {
      TimerMotors_t  HW_Motor_Id = DispenserIdToMotorId[deviceID];
-     REPORT_MSG(deviceID,"Dispenser End called");
+     //REPORT_MSG(deviceID,"Dispenser End called");
      MotorStop(HW_Motor_Id,Hard_Hiz);
+     return OK;
  }
 //********************************************************************************************************************
  uint32_t IDSEndState(void *JobDetails)
@@ -430,10 +433,10 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId)
      int Dispenser_i;
      IDS_Active = false;
      Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste);
+     REPORT_MSG(0,"Dispenser End Start");
      for ( Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
      {
         //MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz);
-        REPORT_MSG(Dispenser_i,"Dispenser End Start");
         Control3WayValvesWithCallback (Dispenser_i, MidTank_Dispenser, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer
      }
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
index 22fcf3e6f..d92e6a330 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c
@@ -220,7 +220,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
             winderspeed+=WinderMotorSpeed[i];
         }
         winderspeed/=MAX_WINDER_SPEED_CALCULATION;
-        //LOG_ERROR(winderspeed, "WinderSpeedUpdated");
+        //REPORT_MSG(winderspeed, "WinderSpeedUpdated");
         Report("WinderSpeedUpdated",__FILE__,__LINE__,winderspeed,RpWarning,ScrewNumberOfSteps,0);
 
         WinderReferenceSpeed = winderspeed;
@@ -238,7 +238,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag)
         //        Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);
         //        #warning PID is now only proportional (above)
         Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0);
-        //LOG_ERROR(temp , "new winder speed");
+        //REPORT_MSG(temp , "new winder speed");
         //Report("new winder speed",__FILE__,__LINE__,temp,RpWarning,ScrewSpeed,0);
     }
     ScrewRunningTime = temp;//(SYS_CLK_FREQ*Steps)/ScrewSpeed;
@@ -283,7 +283,7 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId)
 
         //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed);
         usnprintf(Message, 80, "SCREW speed Rot/sec %d horizon %d pulses %d",(int)RotationsPerSecond,(int)screw_horizontal_speed,(int)ScrewSpeed);
-        //LOG_ERROR(segmentfirst_speed,Message);
+        //REPORT_MSG(segmentfirst_speed,Message);
         //Report(Message,__FILE__,__LINE__,Dispenser_i,RpWarning,segmentfirst_speed,0);
         SendJobProgress(0.0,0,false, Message);
 
@@ -299,11 +299,11 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId)
         temp *= InternalWinderCfg.segmentoffsetpulses;
         temp /= ScrewSpeed;
         ScrewRunningTime = temp;//(SYS_CLK_FREQ*InternalWinderCfg.segmentoffsetpulses)/ScrewSpeed;
-        LOG_ERROR(ScrewNumberOfSteps,"Winder pre segment - ScrewNumberOfSteps");
-        LOG_ERROR(ScrewRunningTime,"Winder pre segment - ScrewRunningTime");
+        REPORT_MSG(ScrewNumberOfSteps,"Winder pre segment - ScrewNumberOfSteps");
+        REPORT_MSG(ScrewRunningTime,"Winder pre segment - ScrewRunningTime");
 //        MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection);
         //ScrewDirection = 1-ScrewDirection;
-        LOG_ERROR(ScrewSpeed,"Winder pre segment - ScrewSpeed");
+        REPORT_MSG(ScrewSpeed,"Winder pre segment - ScrewSpeed");
         //MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed);
         ScrewsStartControlTimer ();
         ScrewControlId = AddControlCallback(Screw100msecDirectionChange, eHundredMillisecond,TemplateDataReadCBFunction,0,0,0);
diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
index 76c0fbfd8..0e0a9f987 100644
--- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c
@@ -670,7 +670,7 @@ uint32_t ThreadPreSegmentState(void *JobDetails)
         LOG_ERROR (dyeingspeed," job speed zero");
         return ERROR;
     }
-    LOG_ERROR (dyeingspeed," ThreadPreSegmentState");
+    REPORT_MSG (dyeingspeed," ThreadPreSegmentState");
 
     SetOriginMotorSpeed(process_speed);
     ThreadControlActive = true;
@@ -718,17 +718,17 @@ uint32_t ThreadPreSegmentState(void *JobDetails)
 int REPSegmentId = 0;
 void ThreadInterSegmentEnded(void)
 {
-    LOG_ERROR (REPSegmentId,"ThreadInterSegmentEnded");
+    REPORT_MSG (REPSegmentId,"ThreadInterSegmentEnded");
     PreSegmentReady(Module_Thread,ModuleDone);
 }
 void ThreadSegmentEnded(void)
 {
-    LOG_ERROR (REPSegmentId," ThreadSegmentState");
+    REPORT_MSG (REPSegmentId," ThreadSegmentState");
     SegmentReady(Module_Thread,ModuleDone);
 }
 void ThreadDistanceToSpoolEnded(void)
 {
-    LOG_ERROR (REPSegmentId," ThreadDistanceToSpoolEnded");
+    REPORT_MSG (REPSegmentId," ThreadDistanceToSpoolEnded");
     DistanceToSpoolReady(Module_Thread,ModuleDone);
 }
 double seglength = 0.0;
@@ -739,7 +739,7 @@ uint32_t ThreadSegmentState(void *JobDetails, int SegmentId)
     REPSegmentId = SegmentId;
     seglength = JobTicket->segments[SegmentId]->length;
     CurrentSegmentId = SegmentId;
-    LOG_ERROR (seglength," ThreadSegmentState");
+    REPORT_MSG (seglength," ThreadSegmentState");
     ThreadUpdateProcessLength (seglength,(void *)ThreadSegmentEnded);
     return OK;
 }
@@ -748,7 +748,7 @@ uint32_t ThreadSegmentState(void *JobDetails, int SegmentId)
 uint32_t ThreadDistanceToSpoolState(void )
 {
     seglength = dryerbufferlength;
-    LOG_ERROR (seglength,"ThreadDistanceToSpoolState");
+    REPORT_MSG (seglength,"ThreadDistanceToSpoolState");
     ThreadUpdateProcessLength (seglength,(void *)ThreadDistanceToSpoolEnded);
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
index 49a01de82..3d3cdaa3d 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -59,6 +59,7 @@
 
 #include "./printingSTM.h"
 #include "modules/thread/thread_ex.h"
+#include "modules/AlarmHandling/AlarmHandling.h"
 #include "modules/ids/ids_ex.h"
 #include "Modules/heaters/heaters_ex.h"
 #include "Modules/control/control.h"
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h
index 503fbeed9..5c90bb972 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h
@@ -172,7 +172,7 @@ uint32_t PreSegmentReady(int ModuleId, ModuleStateEnum result);
 uint32_t SegmentReady(int ModuleId, ModuleStateEnum result);
 uint32_t DistanceToSpoolReady(int ModuleId, ModuleStateEnum result);
 uint32_t PrintingHWConfiguration(void *Configuration);
-//uint32_t EndState(void *JobDetails, char *Message);
+uint32_t EndState(void *JobDetails, char *Message);
 
 bool GetHeatersPrepareWaiting(void);