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

2 files changed, 265 insertions, 96 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 01d372aae..53394f4c0 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -24,15 +24,20 @@
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/FPGA/FPGA.h"
+#include "drivers/FPGA/Full_Vme/FPGA_Programming_Up.h"
 #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
 #include "drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h"
+#include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
 #include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
+#include <Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h>
 #include "Common/SWUpdate/FileSystem.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
 
 #include "modules/thread/thread_ex.h"
 #include "modules/heaters/heaters_ex.h"
 #include "modules/ids/ids_ex.h"
+#include "modules/waste/waste_ex.h"
+#include "modules/General/process.h"
 #include  <PMR/Diagnostics/Event.pb-c.h>
 #include  <PMR/Diagnostics/EventType.pb-c.h>
 #include  <PMR/Diagnostics/StartEventsNotificationRequest.pb-c.h>
@@ -58,6 +63,8 @@
 
 #include "drivers/Valves/Valve.h"
 
+#include "StateMachines/Initialization/PowerIdle.h"
+
 Task_Handle AlarmHandling_Task_Handle;
 Mailbox_Handle          AlarmHandlingMsgQ = NULL;
 
@@ -66,6 +73,7 @@ bool AlarmHandlingActive = false;
 uint32_t AlarmHandlingControlId = 0xFF;
 uint32_t AlarmHandlingTick = 0;
 
+int MotorConfiguredTimeout = 100;
 double     CurrentAlarmHighLimit ,CurrentAlarmLowLimit;
 bool    CheckHardLimitAlarms = false,CheckCurrentAlarms = false,CheckTamperAlarms = false,CheckMotorAlarms = false;
 uint8_t alarm_response_buffer[500];
@@ -442,6 +450,7 @@ uint16_t FluidLevelWarning = 20,FluidLevelError = 50;
 int NumOfSystemAlarms = MAX_SYSTEM_ALARMS;
 //bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
 bool EventsNotificationRequestAccepted = false;
+char AlarmReasonStr[100];
 //read dispensers limit switches. 25 - send warning. up - stop job and send alarm
 //Cone missing
 //Dyeing head over temperature
@@ -496,7 +505,7 @@ uint32_t AlarmHandlingLoadFile(void)
 
                     if (F_count == 4)
                     {
-                        ReportWithPackageFilter(AlarmFilter,"Writing four alarms", __FILE__,AlarmPtr,F_count, RpMessage, p_size, 0);
+                        //ReportWithPackageFilter(AlarmFilter,"Writing four alarms", __FILE__,AlarmPtr,F_count, RpMessage, p_size, 0);
                         F_count = 0;
                         ReadAppAndProgram(AlarmPtr, p_size,FileAlarmItem);
                         AlarmPtr+=p_size;
@@ -538,7 +547,7 @@ void AlarmHandlingInit(void)
 
     Error_init(&eb);
 
-    AlarmHandlingMsgQ = Mailbox_create(sizeof(AlarmHandlingMessageStruc), 20, NULL,&eb);
+    AlarmHandlingMsgQ = Mailbox_create(sizeof(AlarmHandlingMessageStruc), 40, NULL,&eb);
 
     int Alarm_i;
     for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
@@ -590,7 +599,8 @@ void     AlarmHandlingLoadFlags(void)
     CheckCurrentAlarms = (AlarmhandlingFlags && 0x0002);
     CheckTamperAlarms = (AlarmhandlingFlags && 0x0004);
     CheckMotorAlarms = (AlarmhandlingFlags && 0x0008);
-    ReportWithPackageFilter(AlarmFilter,"Alarm group setting", __FILE__,__LINE__,0, RpMessage, 1*CheckHardLimitAlarms+2*CheckCurrentAlarms+3*CheckTamperAlarms+4*CheckMotorAlarms, 0);
+    usnprintf(AlarmReasonStr, 100, "Alarm group from EEPPROM Current %d Motor %d Tamper %d",CheckCurrentAlarms,CheckMotorAlarms,CheckTamperAlarms);
+    ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,0, RpMessage, 1*CheckHardLimitAlarms+2*CheckCurrentAlarms+3*CheckTamperAlarms+4*CheckMotorAlarms, 0);
 }
 
 void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms, bool checkTamperAlarms, bool checkMotorAlarms)
@@ -600,7 +610,9 @@ void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms
     CheckCurrentAlarms = checkCurrentAlarms;
     CheckTamperAlarms = checkTamperAlarms;
     CheckMotorAlarms = checkMotorAlarms;
-    ReportWithPackageFilter(AlarmFilter,"Alarm group setting", __FILE__,__LINE__,0, RpMessage, 1*CheckHardLimitAlarms+2*CheckCurrentAlarms+3*CheckTamperAlarms+4*CheckMotorAlarms, 0);
+    usnprintf(AlarmReasonStr, 100, "Alarm group setting Current %d Motor %d Tamper %d",CheckCurrentAlarms,CheckMotorAlarms,CheckTamperAlarms);
+    ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,0, RpMessage, 1*CheckHardLimitAlarms+2*CheckCurrentAlarms+3*CheckTamperAlarms+4*CheckMotorAlarms, 0);
+
     if (CheckHardLimitAlarms) flags |= 0x1;
     if (CheckCurrentAlarms) flags |= 0x2;
     if (CheckTamperAlarms) flags |= 0x4;
@@ -611,7 +623,6 @@ void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms
         AlarmhandlingFlags = flags;
     }
 }
-char AlarmReasonStr[100];
 JobEndReasonEnum getEndReason(uint32_t AlarmId)
 {
     switch (AlarmItem[AlarmId].AlarmSource)
@@ -648,6 +659,9 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId)
                 usnprintf(AlarmReasonStr, 100, "Alarm %d type %d caused a job stop",AlarmId,AlarmItem[AlarmId].EventType);
                 return JOB_OTHER_ALARM;
             }
+        case ALARM_SOURCE_TYPE__FluidLevelAlarm:
+            usnprintf(AlarmReasonStr, 100, "Midtank %d is empty",AlarmItem[AlarmId].DeviceId);
+            return JOB_OUT_OF_DYE;
         default:
             usnprintf(AlarmReasonStr, 100, "Alarm %d type %d caused a job stop",AlarmId,AlarmItem[AlarmId].EventType);
             return JOB_OTHER_ALARM;
@@ -809,12 +823,12 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     //{
     //    DispenserInUse[Dispenser_i] = false;
     //}
-    JobEndReasonEnum status = JOB_OK;
+    JobEndReasonEnum FoundReason = JOB_OK,tempFoundReason;
     Task_Handle TaskHandle1 = Task_self();
     int pri = Task_getPri(TaskHandle1);
 
     ACTIVITY_GREEN_LED_ON;
-    Task_setPri(TaskHandle1, 2);
+    Task_setPri(TaskHandle1, 11);
     Task_sleep(10);
     Report("Task_setPri", __FILE__, pri, 3, RpWarning,   (int)TaskHandle1, 0);
     IDS_MapDispenserUsedinJob(CurrentJob);
@@ -824,14 +838,14 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     ACTIVITY_GREEN_LED_OFF;
     if (n_segments == 0)
     {
-        ReportWithPackageFilter(AlarmFilter,"no segments in the job", __FILE__,__LINE__,0, DEBUG_LOG_CATEGORY__Warning, AlarmItem[Alarm_i].DeviceId, 0);
-        return JOB_OK;
+        ReportWithPackageFilter(AlarmFilter,"no segments in the job", __FILE__,__LINE__,0, DEBUG_LOG_CATEGORY__Warning, 222, 0);
+        return JOB_FILE_PROBLEM;
     }
     if (AlarmItem == NULL)
     {
-        ReportWithPackageFilter(AlarmFilter,"missing alarm file", __FILE__,__LINE__,0, DEBUG_LOG_CATEGORY__Warning, AlarmItem[Alarm_i].DeviceId, 0);
+        ReportWithPackageFilter(AlarmFilter,"missing alarm file", __FILE__,__LINE__,0, DEBUG_LOG_CATEGORY__Warning, 223, 0);
         usnprintf(AlarmReasonStr, 100, "No alarm file in the machine",111);
-        return JOB_UNSPECIFIED_ERROR;
+        return JOB_NO_ALARM_FILE;
     }
 
     /*for (Segment_i=0;Segment_i<JobTicket->n_segments;Segment_i++)
@@ -865,7 +879,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                     {
                         if (AlarmState[Alarm_i].Status == true)
                         {
-                            status = JOB_LS_ALARM;
+                            FoundReason = JOB_LS_ALARM;
                             AlarmId = Alarm_i;
                             break;
                         }
@@ -878,7 +892,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
     {
         if ((AlarmState[Alarm_i].Status == true)&&(AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical))
         {
-            status = JOB_SAFETY_CRITICAL_ALARM;
+            FoundReason = JOB_SAFETY_CRITICAL_ALARM;
             ReportWithPackageFilter(AlarmFilter,"critical alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
             AlarmId = Alarm_i;
             break;
@@ -886,9 +900,9 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
 
         if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__CoversAlarm)
         {
-            if (AlarmState[Alarm_i].Status == true)
+            if ((AlarmState[Alarm_i].Status == true)&&(AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error))
             {
-                status = JOB_TAMPER_ALARM;
+                FoundReason = JOB_TAMPER_ALARM;
                 ReportWithPackageFilter(AlarmFilter,"tamper alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                 AlarmId = Alarm_i;
                 break;
@@ -902,7 +916,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                 {
                     if (DispenserUsedInJob[AlarmItem[Alarm_i].DeviceId] == true)
                     {
-                        status = ERROR;
+                        FoundReason = JOB_OUT_OF_DYE;
                         ReportWithPackageFilter(AlarmFilter,"fluid level alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                         AlarmId = Alarm_i;
                         break;
@@ -916,7 +930,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
             {
                 if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
 				{
-	                status = JOB_MOTOR_ALARM;
+	                FoundReason = JOB_MOTOR_ALARM;
                     ReportWithPackageFilter(AlarmFilter,"motor alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
     	            AlarmId = Alarm_i;
         	        break;
@@ -939,7 +953,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                         {
                             if (AlarmState[Alarm_i].Status == true)
                             {
-                                status = JOB_TEMPERATURE_ALARM;
+                                FoundReason = JOB_TEMPERATURE_ALARM;
                                 AlarmId = Alarm_i;
                                 ReportWithPackageFilter(AlarmFilter,"temperature alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                                 break;
@@ -949,7 +963,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
                         {
                             if (AlarmState[Alarm_i].Status == true)
                             {
-                                status = JOB_TEMPERATURE_ALARM;
+                                FoundReason = JOB_TEMPERATURE_ALARM;
                                 AlarmId = Alarm_i;
                                 ReportWithPackageFilter(AlarmFilter,"temperature alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                                 break;
@@ -960,13 +974,55 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
             }
         }
     }
-    if (status != JOB_OK)
+    if ((IFS_Availability[1] == IFS_RECOGNIZED_INIT_PASSED)&&(IFS_Availability[2] == IFS_RECOGNIZED_INIT_PASSED)) //ifs installed -check cartridges
+    {
+
+        tempFoundReason = Waste_CheckState(&AlarmId);
+        if (tempFoundReason!=JOB_OK)
+        {
+            FoundReason = tempFoundReason;
+            ReportWithPackageFilter(AlarmFilter,"waste handling alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+        }
+    }
+    if ((AlarmState[Alarm_i].Status == true)&&(FoundReason == JOB_OK))
+    {
+        if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
+        {
+            ReportWithPackageFilter(AlarmFilter,"an alarm existing before job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+            switch (AlarmItem[Alarm_i].EventType )
+            {
+                case EVENT_TYPE__INSUFFICIENT_AIR_FLOW:
+                case EVENT_TYPE__VOC_SENSOR_ALARM_TIME:
+#warning unmark to prevent job on voc alarm//case EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE:
+                //case EVENT_TYPE__POWER_UP_BIT_FAILURE:
+                    FoundReason = JOB_WASTE_HANDLING_PROBLEM;
+                    AlarmId = Alarm_i;
+                    ReportWithPackageFilter(AlarmFilter,"an alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+                    break;
+                case EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE:
+                case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE:
+                case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2:
+                    FoundReason = JOB_TEMPERATURE_ALARM;
+                    AlarmId = Alarm_i;
+                    ReportWithPackageFilter(AlarmFilter,"machine internal over-temperature is preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    if (FoundReason != JOB_OK)
     {
         JobEndReason = getEndReason(AlarmId);
+        if (JobEndReason!=FoundReason)
+        {
+            ReportWithPackageFilter(AlarmFilter,"end reason mismatch!!!", __FILE__,AlarmId,JobEndReason, RpMessage, FoundReason, 0);
+            JobEndReason=FoundReason;
+        }
         //AbortJob(AlarmReasonStr);
         //PrepareReady(Module_Alarms,ModuleFail);
         ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,AlarmId, RpMessage, DEBUG_LOG_CATEGORY__Error, 0);
-		return (JobEndReason);
+		return (FoundReason);
     }
     return JOB_OK;
 }
@@ -989,6 +1045,7 @@ uint32_t AlarmHandling_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
     return OK;
 }
 void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value);
+StartEventsNotificationResponse PersistentEventsResponse = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
 
 void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value)
 {
@@ -1004,46 +1061,77 @@ void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value)
 }
 void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value)
 {
-    int Alarm_i;
+    int Alarm_i,Event_i;
+    Event **re_events;
     if (AlarmItem == NULL)
         return;
     for (Alarm_i = 0;Alarm_i < NumOfSystemAlarms;Alarm_i++)
     {
         if (AlarmItem[Alarm_i].EventType == AlarmId)
         {
-            if (AlarmState[Alarm_i].Status != value)
+            if (0) // PERSISTENT ALARM
             {
-                if (value == true)
+                PersistentEventsResponse.n_events++;
+                if (PersistentEventsResponse.events == NULL)
+                    PersistentEventsResponse.events = (Event **)my_malloc(sizeof(Event*)*PersistentEventsResponse.n_events);
+                else
                 {
-                    // no need to call consequent actionsAlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity);
-                    // report the alarm!
-                    AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
-                    if (AlarmState[Alarm_i].EventPtr)
-                    {
-                        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 = NULL;//AlarmItem[Alarm_i].EventName;
-	                    AlarmState[Alarm_i].Status = value;
-                    }
-                    ReportWithPackageFilter(AlarmFilter,"Alarm ON ", __FILE__,AlarmState[Alarm_i].EventPtr,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
-                    if ((AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical)&&(JobIsActive()))
+                    re_events = (Event **)my_malloc(sizeof(Event*)*PersistentEventsResponse.n_events);
+                    for (Event_i = 0;Event_i < (PersistentEventsResponse.n_events-1);Event_i++)
                     {
-                        JobEndReason = getEndReason(Alarm_i);
-                        SendJobProgress(0.0,0, false, "Critical alarm!!!!");
-                        AbortJob("Critical alarm");
-                        ReportWithPackageFilter(AlarmFilter, AlarmReasonStr,__FILE__,__LINE__,Alarm_i,RpError, 0,0);
+                        re_events[Event_i] = PersistentEventsResponse.events[Event_i];
                     }
+                    my_free(PersistentEventsResponse.events);
+                    PersistentEventsResponse.events = re_events;
                 }
-                else
+                AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
+                if (AlarmState[Alarm_i].EventPtr)
                 {
-                    ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
-                    if (AlarmState[Alarm_i].EventPtr)
+                    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 = NULL;//AlarmItem[Alarm_i].EventName;
+                }
+                AlarmState[Alarm_i].Status = true;
+                PersistentEventsResponse.events[PersistentEventsResponse.n_events] = AlarmState[Alarm_i].EventPtr;
+                ReportWithPackageFilter(AlarmFilter,"Persistent Alarm ", __FILE__,PersistentEventsResponse.n_events,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
+            }
+            else
+            {
+                if (AlarmState[Alarm_i].Status != value)
+                {
+                    if (value == true)
                     {
-                        my_free(AlarmState[Alarm_i].EventPtr);
-                        AlarmState[Alarm_i].EventPtr = NULL;
+                        // no need to call consequent actionsAlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity);
+                        // report the alarm!
+                        AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
+                        if (AlarmState[Alarm_i].EventPtr)
+                        {
+                            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 = NULL;//AlarmItem[Alarm_i].EventName;
+                            AlarmState[Alarm_i].Status = value;
+                        }
+                        ReportWithPackageFilter(AlarmFilter,"Alarm ON ", __FILE__,AlarmState[Alarm_i].EventPtr,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
+                        if ((AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical)&&(JobIsActive()))
+                        {
+                            JobEndReason = getEndReason(Alarm_i);
+                            SendJobProgress(0.0,0, false, "Critical alarm!!!!");
+                            AbortJob("Critical alarm");
+                            ReportWithPackageFilter(AlarmFilter, AlarmReasonStr,__FILE__,__LINE__,Alarm_i,RpError, 0,0);
+                        }
+                    }
+                    else
+                    {
+                        ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
+                        if (AlarmState[Alarm_i].EventPtr)
+                        {
+                            my_free(AlarmState[Alarm_i].EventPtr);
+                            AlarmState[Alarm_i].EventPtr = NULL;
+                        }
+                        AlarmState[Alarm_i].Status = value;
                     }
-                    AlarmState[Alarm_i].Status = value;
                 }
             }
             break;
@@ -1105,6 +1193,9 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
     if (AlarmItem == NULL)
         return ERROR;
     int AlarmCounter=0;
+    if (MotorConfiguredTimeout)
+        MotorConfiguredTimeout--;
+
     for (Alarm_i = 0;Alarm_i < NumOfSystemAlarms;Alarm_i++)
     {
         Status = false;
@@ -1193,7 +1284,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                 }
                 break;
             case ALARM_SOURCE_TYPE__CurrentAlarm:
-                if (CheckCurrentAlarms)
+                if ((CheckCurrentAlarms)&&(getIdleState()==false))
                  {
                     if (AlarmItem[Alarm_i].ModuleDeviceId == 0xFF)
                     {
@@ -1210,14 +1301,14 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                                     if (doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit))
                                     {
                                         Status = true;
-                                        if (AlarmState[Alarm_i].Status == false)
-                                            ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                        //if (AlarmState[Alarm_i].Status == false)
+                                        //    ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                     }
-                                    if ((doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit))&&(isHeaterReady(AlarmItem[Alarm_i].DeviceId)==false))
+                                    if ((doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit))&&(isHeaterReady(AlarmItem[Alarm_i].DeviceId)==false)&&(doubleValue>100))
                                     {
                                         Status = true;
-                                        if (AlarmState[Alarm_i].Status == false)
-                                            ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                        //if (AlarmState[Alarm_i].Status == false)
+                                        //    ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                     }
                                 }
                                 else
@@ -1225,8 +1316,8 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                                     if (doubleValue <= 0.1)
                                     {
                                         Status = true;
-                                        if (AlarmState[Alarm_i].Status == false)
-                                            ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                        //if (AlarmState[Alarm_i].Status == false)
+                                        //    ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                     }
                                 }
                             }
@@ -1234,28 +1325,43 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     }
                     else
                     {
-                        if (Get_Head_Current(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
-                         {
-                             if (AlarmItem[Alarm_i].AlarmDirection == true)
+                        if (Head_Type < HEAD_TYPE_UNKNOWN_WITH_CARD) //no current alarms for old head
+                        {
+                            Status = false;
+                        }
+                        else
+                        {
+                            if (Get_Head_Current(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
                              {
-                                 if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit)))
+                                 if (AlarmItem[Alarm_i].AlarmDirection == true)
                                  {
-                                     Status = true;
-                                     if (AlarmState[Alarm_i].Status == false)
-                                         ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                     if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit))&&(doubleValue>100))
+                                     {
+                                         Status = true;
+                                         if (AlarmState[Alarm_i].Status == false)
+                                         {
+                                             //usnprintf(AlarmReasonStr, 100, "OverCurrent Alarm %d ON dev %d debounce %d/%d value %d",AlarmItem[Alarm_i].EventType,AlarmItem[Alarm_i].DeviceId,AlarmState[Alarm_i].DebounceCounter,AlarmItem[Alarm_i].DebounceValue,(int)(doubleValue*100));
+                                             //ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                            // ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                         }
+                                     }
                                  }
-                             }
-                             else
-                             {
-                                 if (doubleValue <= 0.1)
+                                 else
                                  {
-                                     Status = true;
-                                     if (AlarmState[Alarm_i].Status == false)
-                                         ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                     if (doubleValue <= 0.1)
+                                     {
+                                         Status = true;
+                                         if (AlarmState[Alarm_i].Status == false)
+                                         {
+                                             //usnprintf(AlarmReasonStr, 100, "LOOP BREAK Alarm %d ON dev %d debounce %d/%d value %d",AlarmItem[Alarm_i].EventType,AlarmItem[Alarm_i].DeviceId,AlarmState[Alarm_i].DebounceCounter,AlarmItem[Alarm_i].DebounceValue,(int)(doubleValue*100));
+                                             //ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                            // ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
+                                         }
+                                     }
                                  }
-                             }
 
-                         }
+                             }
+                        }
                     }
                  }
                  else
@@ -1266,7 +1372,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
             case ALARM_SOURCE_TYPE__MotorAlarm:
                 if (CheckMotorAlarms)
                 {
-                    if (FPGA_WD_Occurred == true)
+                    if ((FPGA_WD_Occurred == true)||(MotorConfiguredTimeout > 0))
                     {
                         Status = false;
                     }
@@ -1274,9 +1380,38 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     {
                         Status = false;
                     }
+                    else if (AlarmItem[Alarm_i].DeviceId == HARDWARE_MOTOR_TYPE__MOTO_SCREW)
+                    {
+                        Status = false;
+                    }
                     else
                     {
-                        value = MotorGetStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                        switch (AlarmItem[Alarm_i].AlarmValue)
+                        {
+                            case 1:
+                                Status = MotorGetOverCurrentStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Overcurrent on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            case 2:
+                                Status = MotorGetUnderVoltageStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Undervoltage on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            case 3:
+                                Status = MotorGetStallStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Stall on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            case 4:
+                                Status = MotorGetOverHeatStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
+                                if (Status == true)
+                                   Report("------Overtemperature on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
+                                break;
+                            default:
+                                Status = false;
+                        }
+                        /*value = MotorGetStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
                         if (AlarmItem[Alarm_i].AlarmDirection == true)
                         {
                             if (value && AlarmItem[Alarm_i].AlarmValue)
@@ -1290,7 +1425,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                             {
                                 Status = true;
                             }
-                        }
+                        }*/
                     }
                 }
                 else
@@ -1302,7 +1437,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                     break;
                 if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Warning)
                     FluidLevelWarning = AlarmItem[Alarm_i].AlarmValue;
-                else if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error)
+                else if ((AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error)&&(AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE))
                     FluidLevelError = AlarmItem[Alarm_i].AlarmValue;
                 value = Get_MidTank_Int1000_Sensor(AlarmItem[Alarm_i].DeviceId);
                 if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE)
@@ -1407,35 +1542,65 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
                             }
                             break;
                         case DRYER_FAN :
-                            value = Read_Dryer_Fan_Tacho();
-                            if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
-                                if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value == DRYER_FAN_STOP))
-                                {
-                                    Status = true;
-                                    //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
-                                }
-                            else if (AlarmItem[Alarm_i].Severity ==  DEBUG_LOG_CATEGORY__Warning)
+							if (IsDryerStopped()==STOP)
                             {
-                                if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value < DRYER_FAN_MIN_RPM))
+                                Status = false;
+                                //ReportWithPackageFilter(AlarmFilter,"----------- DRYER_FAN skip-----------", __FILE__,IsDryerStopped(),Alarm_i, RpMessage, Status, 0);
+                            }
+                            else
+                            {
+                                value = Read_Dryer_Fan_Tacho();
+                                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
+                                    if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value == DRYER_FAN_STOP))
+                                    {
+                                        Status = true;
+                                        //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
+                                    }
+                                else if (AlarmItem[Alarm_i].Severity ==  DEBUG_LOG_CATEGORY__Warning)
                                 {
-                                    Status = true;
-                                    //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
+                                    if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value < DRYER_FAN_MIN_RPM))
+                                    {
+                                        Status = true;
+                                        //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
+                                    }
                                 }
+                             //ReportWithPackageFilter(AlarmFilter,"----------- DRYER_FAN----------------", __FILE__,value,Alarm_i, RpMessage, Status, 0);
                             }
                             break;
-                    }
+                        default:
 
-                    //ReportWithPackageFilter(AlarmFilter,"------------FANS_RPM[Alarm_i]----------------", __FILE__,__LINE__,Alarm_i, RpMessage, value, 0);
-
-                    if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
-                    {
-                        if (AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE)
-                        {
-                            if (value < AlarmItem[Alarm_i].AlarmValue)
+		                    //ReportWithPackageFilter(AlarmFilter,"------------FANS_RPM[Alarm_i]----------------", __FILE__,__LINE__,Alarm_i, RpMessage, value, 0);
+                            if (AlarmItem[Alarm_i].DeviceId >= WHS_FAN_1 )
                             {
-                                Status = true;
+                                value = WHS_Get_fan_tach(AlarmItem[Alarm_i].DeviceId - WHS_FAN_1+1);
+                                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
+                                    if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value == DRYER_FAN_STOP))
+                                    {
+                                        Status = true;
+                                        //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
+                                    }
+                                else if (AlarmItem[Alarm_i].Severity ==  DEBUG_LOG_CATEGORY__Warning)
+                                {
+                                    if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value < DRYER_FAN_MIN_RPM))
+                                    {
+                                        Status = true;
+                                        //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
+                                    }
+                                }
+                                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
+                                {
+                                    if (AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE)
+                                    {
+                                        if (value < AlarmItem[Alarm_i].AlarmValue)
+                                        {
+                                            Status = true;
+                                        }
+                                    }
+                                }
                             }
-                        }
+                            else
+                                Status = false;
+                            break;
                     }
                 }
                 break;
@@ -1590,6 +1755,8 @@ void SendEventNotifications(void)
         LargeMessagesAH++;
         return;
     }
+    if (FPGABurningActive==true)
+        return;
 
     EventsResponse.n_events = 0;
     //UInt Key = Task_disable();
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
index 3b39370bf..0ce6d4816 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
@@ -10,6 +10,8 @@
 #include "StateMachines/Printing/PrintingSTM.h"
 #include  <PMR/Diagnostics/EventType.pb-c.h>
 
+extern int MotorConfiguredTimeout;
+
 uint32_t AlarmHandlingFlashLoad(void);
 uint32_t AlarmHandlingLoadFile(void);