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

8 files changed, 344 insertions, 20 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 0ea10bafc..7a766a552 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -16,6 +16,7 @@
 
 #include "drivers/adc_sampling/adc.h"
 #include "Control/control.h"
+#include "Control/MillisecTask.h"
 
 #include "drivers/Motors/Motor.h"
 #include "drivers/Heater/TemperatureSensor.h"
@@ -25,12 +26,15 @@
 #include "PMR/Hardware/HardwareDancerType.pb-c.h"
 
 #include "modules/thread/thread_ex.h"
+#include "modules/ids/ids_ex.h"
 #include  <PMR/Diagnostics/Event.pb-c.h>
 #include  <PMR/Diagnostics/EventType.pb-c.h>
 #include "PMR/debugging/DebugLogCategory.pb-c.h"
 
 #include "StateMachines/Printing/PrintingSTM.h"
 
+#include "drivers/FPGA/Moters_Driver/L6470.h"
+
 
 Task_Handle AlarmHandling_Task_Handle;
 Mailbox_Handle          AlarmHandlingMsgQ = NULL;
@@ -50,7 +54,105 @@ typedef struct AlarmHandlingMessage{
     uint8_t messageData[20];
 }AlarmHandlingMessageStruc;
 
-
+#define MAX_SYSTEM_ALARMS 200
+typedef enum
+{
+    TemperatureAlarm,
+    LimitSwitchAlarm,
+    PressureAlarm,
+    CurrentAlarm,
+    MotorAlarm
+}AlarmSource;
+#define OVER_VALUE true;
+#define UNDER_VALUE false;
+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;
+}AlarmHandlingItem;
+AlarmHandlingItem  AlarmItem[MAX_SYSTEM_ALARMS]={
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_1,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserEmpty},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_2,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserEmpty},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_3,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserEmpty},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_4,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserEmpty},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_5,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserEmpty},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_6,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserEmpty},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_7,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserEmpty},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_UP_8,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserEmpty},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_1,true,true,DEBUG_LOG_CATEGORY__Warning,0,0,0,false,EVENT_TYPE__DispenserLowLevel},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_2,true,true,DEBUG_LOG_CATEGORY__Warning,1,0,0,false,EVENT_TYPE__DispenserLowLevel},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_3,true,true,DEBUG_LOG_CATEGORY__Warning,2,0,0,false,EVENT_TYPE__DispenserLowLevel},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_4,true,true,DEBUG_LOG_CATEGORY__Warning,3,0,0,false,EVENT_TYPE__DispenserLowLevel},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_5,true,true,DEBUG_LOG_CATEGORY__Warning,4,0,0,false,EVENT_TYPE__DispenserLowLevel},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_6,true,true,DEBUG_LOG_CATEGORY__Warning,5,0,0,false,EVENT_TYPE__DispenserLowLevel},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_7,true,true,DEBUG_LOG_CATEGORY__Warning,6,0,0,false,EVENT_TYPE__DispenserLowLevel},
+{100,LimitSwitchAlarm,GPI_LS_DISPENSER_25_8,true,true,DEBUG_LOG_CATEGORY__Warning,7,0,0,false,EVENT_TYPE__DispenserLowLevel},
+{100,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature},
+{100,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,80,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature},
+{100,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,80,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature},
+{100,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHeadOverTemperature},
+{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHeadOverTemperature},
+{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHeadOverTemperature},
+{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHeadOverTemperature},
+{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHeadOverTemperature},
+{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DyeingHeadOverTemperature},
+{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DryerOverTemperature},
+{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DryerOverTemperature},
+{100,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DryerOverTemperature},
+{100,PressureAlarm,1,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserPressure},
+{100,PressureAlarm,2,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserPressure},
+{100,PressureAlarm,3,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserPressure},
+{100,PressureAlarm,4,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserPressure},
+{100,PressureAlarm,5,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserPressure},
+{100,PressureAlarm,6,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserPressure},
+{100,PressureAlarm,7,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserPressure},
+{100,PressureAlarm,8,7,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__DispenserPressure},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_OCD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverCurrent},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+{100,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_TH_SD,true,DEBUG_LOG_CATEGORY__Error,0xFF,4,0,false,EVENT_TYPE__MotorOverTemperature},
+};
+//read dispensers limit switches. 25 - send warning. up - stop job and send alarm
+//Cone missing
+//Dyeing head over temperature
+//mixer over temperature
+//dryer over temperature
+//heaters failure
+//dispenser pressure
+//valve OCD
+//Motor Status
+//machine cover open
 void AlarmHandlingInit(void)
 {
     Error_Block eb;
@@ -126,13 +228,20 @@ uint32_t AlarmHandlingConsequentActions(EventType EventId, DebugLogCategory Seve
         //raise flag fr next job
         break;
     case DEBUG_LOG_CATEGORY__Error:
-        JobEndReason = JOB_OTHER_ALARM;
-        EndState(NULL,event_type__descriptor.name[EventId]);
+        if (JobIsActive())
+        {
+            JobEndReason = JOB_OTHER_ALARM;
+            EndState(NULL,event_type__descriptor.name[EventId]);
+        }
 //Stop Job
         break;
     case DEBUG_LOG_CATEGORY__Critical:
-        JobEndReason = JOB_OTHER_ALARM;
-        EndState(NULL,event_type__descriptor.name[EventId]);
+        if (JobIsActive())
+        {
+            JobEndReason = JOB_OTHER_ALARM;
+            EndState(NULL,event_type__descriptor.name[EventId]);
+        }
+        watchdogCriticalAlarm = true;
         //stop job
         //turn machine off
         break;
@@ -145,11 +254,165 @@ uint32_t AlarmHandlingConsequentActions(EventType EventId, DebugLogCategory Seve
     }
     return OK;
 }
+bool AlarmHandlingActive = false;
+uint32_t AlarmHandlingControlId = 0xFF;
+uint32_t AlarmHandlingTick = 0;
+
+uint32_t AlarmHandling_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
+{
+    AlarmHandlingMessageStruc Message;
+
+    //send message to the Millisec task
+    Message.messageId = AlarmHandlingTrigger;
+    Message.msglen = sizeof(AlarmHandlingMessageStruc);
+    AlarmHandlingTick +=10;
+    Message.tick = AlarmHandlingTick;
+    if (AlarmHandlingMsgQ != NULL)
+        Mailbox_post(AlarmHandlingMsgQ , &Message, BIOS_NO_WAIT);
+
+
+    return OK;
+}
+uint32_t AlarmHandlingEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue)
+{
+    return OK;
+}
+
+uint32_t AlarmHandlingStart(void)
+{
+
+    if ( AlarmHandlingActive == false)
+    {
+            AlarmHandlingActive = true;
+            AlarmHandlingControlId = AddControlCallback(AlarmHandling_ControlTrigger,eTenMillisecond,AlarmHandlingEmptyCBFunction,0,0,0);
+    }
+    return OK;
+}
+uint32_t AlarmHandlingStop(void)
+{
+    if ( AlarmHandlingActive == true)
+    {
+        AlarmHandlingActive = false;
+        if (AlarmHandlingControlId != 0xFF)
+            RemoveControlCallback(AlarmHandlingControlId,AlarmHandling_ControlTrigger);
+
+        AlarmHandlingControlId = 0xFF;
+    }
+    return OK;
+}
 
 uint32_t AlarmHandlingLoop(uint32_t tick)
 {
+    int Alarm_i;
+    uint32_t value;
+    bool Status = false;
+    for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
+    {
+        if (AlarmItem[Alarm_i].Frequency%tick == 0)
+        {
+            if (AlarmItem[Alarm_i].Predecessor)
+                if (AlarmItem[AlarmItem[Alarm_i].Predecessor].Status == true)  //higher hierarchy alarm is on
+                    continue;
+            switch (AlarmItem[Alarm_i].AlarmSource)
+            {
+            case TemperatureAlarm:
+                value = TemperatureSensorRead(AlarmItem[Alarm_i].DeviceId);
+                if (AlarmItem[Alarm_i].AlarmDirection == true)
+                {
+                    if (value >= AlarmItem[Alarm_i].AlarmValue)
+                    {
+                        Status = true;
+                    }
+                }
+                else
+                {
+                    if (value <= AlarmItem[Alarm_i].AlarmValue)
+                    {
+                        Status = true;
+                    }
+                }
+                break;
+            case LimitSwitchAlarm:
+                value = FPGA_Read_limit_Switches(AlarmItem[Alarm_i].DeviceId);
+                if (value == AlarmItem[Alarm_i].AlarmValue)
+                {
+                    Status = true;
+                }
+                break;
+            case PressureAlarm:
+                value = GetDispenserPressure(AlarmItem[Alarm_i].DeviceId)/1000000;
+                if (AlarmItem[Alarm_i].AlarmDirection == true)
+                {
+                    if (value >= AlarmItem[Alarm_i].AlarmValue)
+                    {
+                        Status = true;
+                    }
+                }
+                else
+                {
+                    if (value <= AlarmItem[Alarm_i].AlarmValue)
+                    {
+                        Status = true;
+                    }
+                }
+                break;
+            case CurrentAlarm:
+                break;
+            case MotorAlarm:
+                value = MotorGetStatus(AlarmItem[Alarm_i].DeviceId);
+                if (value && AlarmItem[Alarm_i].AlarmValue) //
+                {
+                    Status = true;
+                }
+                break;
+            default:
+                break;
+            } //switch
+            if (AlarmItem[Alarm_i].DebounceValue > 0) //handle debouncing
+            {
+                if (Status == true) //increase counter
+                {
+                    AlarmItem[Alarm_i].DebounceCounter++;
+                    if (AlarmItem[Alarm_i].DebounceCounter < AlarmItem[Alarm_i].DebounceValue)
+                    {
+                        Status = false;
+                    }
+                    else
+                    {
+                        AlarmItem[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue;
+                    }
+                }
+                else //status  == false - decrease counter
+                {
+                    AlarmItem[Alarm_i].DebounceCounter--;
+                    if (AlarmItem[Alarm_i].DebounceCounter > 0)
+                    {
+                        Status = true;
+                    }
+                    else
+                    {
+                        AlarmItem[Alarm_i].DebounceCounter = 0;
+                    }
+                }
+            }
+            if (Status !=  AlarmItem[Alarm_i].Status) //change in alarm Status
+            {
+                if (Status == true) // alarm on
+                {
+                    AlarmItem[Alarm_i].Status = true;
+                    AlarmHandlingConsequentActions(AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity);
+                    // report the alarm!
+                }
+                else // alarm off
+                {
+                    AlarmItem[Alarm_i].Status = false;
+                    AlarmHandlingConsequentActions(AlarmItem[Alarm_i].EventType, DEBUG_LOG_CATEGORY__Info);
+                    // report the alarm!
+                }
+            }
+        }
+    }
     //read dispensers limit switches. 25 - send warning. up - stop job and send alarm
-
     //Cone missing
     //Dyeing head over temperature
     //mixer over temperature
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
index d14d2c717..5a3aa66af 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h
@@ -8,5 +8,9 @@
 #ifndef MODULES_ALARMHANDLING_ALARMHANDLING_H_
 #define MODULES_ALARMHANDLING_ALARMHANDLING_H_
 
+uint32_t AlarmHandling_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue);
+uint32_t AlarmHandlingEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue);
+uint32_t AlarmHandlingStart(void);
+uint32_t AlarmHandlingStop(void);
 
 #endif /* MODULES_ALARMHANDLING_ALARMHANDLING_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 25f826d92..75462bd7c 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -74,6 +74,8 @@ typedef struct MillisecMessage{
 uint32_t  Dancer_Data[NUM_OF_DANCERS] = {0};
 uint32_t  Speed_Data = 0;
 
+bool watchdogCriticalAlarm = false;
+
 MillisecMotorDataStruc MotorData[NUM_OF_MOTORS] = {0};
 MillisecMotorDataStruc SpeedSetPending[NUM_OF_MOTORS] = {0};
 MillisecMotorDataStruc PT100Data[MAX_TEMPERATURE_SENSOR_ID] = {0};
@@ -100,7 +102,7 @@ void MillisecInit(void)
 
     Error_init(&eb);
 
-    MillisecMsgQ = Mailbox_create(sizeof(MillisecMessageStruc), 20, NULL,&eb);
+    MillisecMsgQ = Mailbox_create(sizeof(MillisecMessageStruc), 2, NULL,&eb);
     for (i=0;i<NUM_OF_MOTORS;i++)
     {
         MotorsMsgQ[i] = Mailbox_create(sizeof(MillisecMotorDataStruc), 5, NULL,&eb);
@@ -418,7 +420,8 @@ uint32_t MillisecLoop(uint32_t tick)
         for (Sensor_i = 0;Sensor_i < MAX_SYSTEM_DISPENSERS;Sensor_i++)
             CalculateDispenserPressure(Sensor_i);
         FPGA_GetAllDispensersValveBusyOCD();
-        Control_WD(ENABLE,50);  //activate heaters/dispenser watchdog, 5 seconds
+        if (watchdogCriticalAlarm == false)
+                Control_WD(ENABLE,50);  //activate heaters/dispenser watchdog, 5 seconds
     }
     //ROM_IntMasterEnable();
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
index ef9a9d21b..77c3a5ef8 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
@@ -32,5 +32,7 @@ void MillisecInit(void);
 void MillisecStop(void);
 void MillisecStart(void);
 
+extern bool watchdogCriticalAlarm;
+
 extern Task_Handle Millisecond_Task_Handle;
 #endif /* MODULES_CONTROL_MILLISECTASK_H_ */
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index a2031a2e2..477fc0732 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -15,8 +15,8 @@
 #include <Container.h>
 
 #include "drivers/Motors/Motor.h"
-#include "drivers/SSI_Comm/SSI_Comm.h"
 #include "drivers/Heater/TemperatureSensor.h"
+#include "drivers/SSI_Comm/Dancer/Dancer.h"
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
 #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
 #include "drivers/FPGA/FPGA.h"
@@ -229,8 +229,8 @@ void Diagnostic100msecCollection(void)
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, TemperatureSensorRead(TEMP_SENSE_ANALOG_MIXCHIP_TEMP));
 #ifndef DEMO_TEMPERATURE
-//#define DRYER_AIR_PT100  TEMP_SENSE_ANALOG_DRYER_TEMP2
-//#define DRYER_MAIN_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP1
+//#define DRYER_AIR_PT100  TEMP_SENSE_ANALOG_DRYER_TEMP1
+//#define DRYER_MAIN_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP2
 //#define DRYER_SECONDARY_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP3
 
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP1));
@@ -296,7 +296,7 @@ void SendDiagnostics(void)
 {
     MessageContainer responseContainer;
     StartDiagnosticsResponse response = START_DIAGNOSTICS_RESPONSE__INIT;
-    int i;
+    //int i;
 
     if (DiagnosticsActive == false)
         return;
@@ -431,7 +431,6 @@ void SendDiagnostics(void)
     response.monitors = &DiagnosticsMonitor;
     response.n_digitalpins = 0/**MAX_GPI*/;
     //response.digitalpins = DigitalPinArray;
-    response.n_events = 0;
     response.n_componentsstates = 0;
 /*    if (blowervolatgedisplay == true)
     {
@@ -465,6 +464,7 @@ void SendDiagnostics(void)
     }
 }
 uint32_t DiagnosticsControlId = 0xff;
+uint32_t Diagnostics10MSControlId = 0xff;
 bool DiagnosticRequestAccepted = false;
 uint32_t DiagnosticsEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue)
 {
@@ -479,7 +479,7 @@ uint32_t DiagnosticsStart(void)
         {
             DiagnosticsActive = true;
             DiagnosticsControlId = AddControlCallback(Diagnostics_ControlTrigger,DiagnosticLimit,DiagnosticsEmptyCBFunction,0,0,0);
-            DiagnosticsControlId = AddControlCallback(Diagnostics_TenMiliControlTrigger,DiagnosticFastLimit,DiagnosticsEmptyCBFunction,0,0,0);
+            Diagnostics10MSControlId = AddControlCallback(Diagnostics_TenMiliControlTrigger,DiagnosticFastLimit,DiagnosticsEmptyCBFunction,0,0,0);
        }
     }
     return OK;
@@ -491,7 +491,12 @@ uint32_t DiagnosticsStop(void)
         DiagnosticsActive = false;
         if (DiagnosticsControlId != 0xFF)
             RemoveControlCallback(DiagnosticsControlId,Diagnostics_ControlTrigger);
+        if (Diagnostics10MSControlId != 0xFF)
+            RemoveControlCallback(Diagnostics10MSControlId,Diagnostics_TenMiliControlTrigger);
+
         DiagnosticsControlId = 0xFF;
+        Diagnostics10MSControlId = 0xFF;
+
     }
     return OK;
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
index 2d73379d6..871123a1d 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -77,6 +77,44 @@ FPGA_GPI_ENUM     Motor_Id_to_LS_Id[NUM_OF_MOTORS] = {
       MAX_GPI, //MOTO_SPARE2_2 = 28
 
 };
+typedef enum {
+    MotorHomingDirectionUp,
+    MotorHomingDirectionDown,
+    MotorHomingDirectionNoHoming
+}MotorHomingDirectionEnum;
+
+MotorHomingDirectionEnum     Motor_Id_to_LS_Direction[NUM_OF_MOTORS] = {
+      MotorHomingDirectionNoHoming, //MOTO_DH_CLEANHEAD = 0,
+      MotorHomingDirectionNoHoming, //MOTO_DH_CLEANMECH = 1,
+      MotorHomingDirectionNoHoming, //MOTO_DH_LID = 2,
+      MotorHomingDirectionNoHoming, //MOTO_DRYER_DRIVING = 3,
+      MotorHomingDirectionNoHoming, //MOTO_DRYER_LID = 4,
+      MotorHomingDirectionNoHoming, //MOTO_DRYER_LOADARM = 5,
+      MotorHomingDirectionDown, //MOTO_DISPENSER_1 = 6,
+      MotorHomingDirectionDown, //MOTO_DISPENSER_2 = 7,
+      MotorHomingDirectionDown, //MOTO_DISPENSER_3 = 8,
+      MotorHomingDirectionDown, //MOTO_DISPENSER_4 = 9,
+      MotorHomingDirectionDown, //MOTO_DISPENSER_5 = 10,
+      MotorHomingDirectionDown, //MOTO_DISPENSER_6 = 11,
+      MotorHomingDirectionDown, //MOTO_DISPENSER_7 = 12,
+      MotorHomingDirectionDown, //MOTO_DISPENSER_8 = 13,
+      MotorHomingDirectionUp, //MOTO_SCREW = 14,
+      MotorHomingDirectionNoHoming, //MOTO_WINDER = 15,
+      MotorHomingDirectionDown, //MOTO_LDANCER1 = 16,
+      MotorHomingDirectionDown, //MOTO_LDANCER2 = 17,
+      MotorHomingDirectionNoHoming, //MOTO_LDRIVING = 18,
+      MotorHomingDirectionUp, //MOTO_LLOADING = 19,
+      MotorHomingDirectionUp, //MOTO_LPIVOT1 = 20,
+      MotorHomingDirectionDown, //MOTO_RDANCER = 21,
+      MotorHomingDirectionNoHoming, //MOTO_RDRIVING = 22,
+      MotorHomingDirectionUp, //MOTO_RLOADARM = 23,
+      MotorHomingDirectionDown, //MOTO_RLOADING = 24,
+      MotorHomingDirectionNoHoming, //MOTO_SPARE1_1 = 25,
+      MotorHomingDirectionNoHoming, //MOTO_SPARE1_2 = 26,
+      MotorHomingDirectionNoHoming, //MOTO_SPARE2_1 = 27,
+      MotorHomingDirectionNoHoming, //MOTO_SPARE2_2 = 28
+
+};
 char HomingToken[NUM_OF_MOTORS][36+1]={0};
 
 /********************************************************************************
@@ -87,13 +125,13 @@ uint32_t MotorHomingRequestCallback(uint32_t deviceID, uint32_t ReadValue)
     MessageContainer responseContainer;
     MotorHomingResponse response = MOTOR_HOMING_RESPONSE__INIT;
 
-    responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], false, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
-    responseContainer.continuous = false;
-    HomingToken[deviceID][0] = 0;
+    responseContainer = createContainer(MESSAGE_TYPE__MotorHomingResponse, HomingToken[deviceID], true, &response, &motor_homing_response__pack, &motor_homing_response__get_packed_size);
+    responseContainer.continuous = true;
     uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
     free(responseContainer.data.data);
     SendChars(container_buffer, container_size);
+    HomingToken[deviceID][0] = 0;
 
 return OK;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 9600b9310..dc9d89766 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -10,6 +10,7 @@
 #include "thread/thread.h"
 #include "ids/ids.h"
 #include "control/control.h"
+#include "AlarmHandling/AlarmHandling.h"
 #include "heaters/heaters_ex.h"
 #include "StateMachines/Printing/PrintingSTM.h"
 
@@ -106,6 +107,7 @@ uint32_t HWConfigurationFunc(MessageContainer* requestContainer)
     }
 
     ControlStart();
+    AlarmHandlingStart();
     //ThreadInitialTestStub(request);
 
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 2450b32e2..f1332ca98 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -124,6 +124,8 @@ uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
             {
                 status |= RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
                 ControlIdtoHeaterId [HeaterId]=0xFF;
+                HeaterRecalculateHeaterParams(HeaterId, 0);
+
             }
             DeActivateHeater(HeaterId);
         }
@@ -132,6 +134,7 @@ uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
             if (ControlIdtoHeaterId [HeaterId]!=0xFF)
             {
                 status |=RemoveControlCallback(ControlIdtoHeaterId [HeaterId] ,HeaterControlCBFunction);
+                HeaterRecalculateSharedHeatersParams(HeaterId,0);
                 ControlIdtoHeaterId [HeaterId]=0xFF;
             }
             if (MainDryerHeaterMaxTempControl)
@@ -239,10 +242,10 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
     }
     else if (OnOff == HEATER_OFF)//((HeaterState == HEATER_ON)&& (OnOff == HEATER_OFF)) //stop heating
     {
-       //turn off the heater
-        HeatersSingleHeaterEnd(HeaterId);
         //stop the control
         HeaterPIDConfig[HeaterId].m_SetParam  = 0;
+       //turn off the heater
+        HeatersSingleHeaterEnd(HeaterId);
     }
     /*else //heater off, and the heater is not ready yet
     {
@@ -400,7 +403,10 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
             if (HeaterMaxTempFlag[index] == true)
             {
                 ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                if (InitialHeating)
+                {
+                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                }
                 LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on");
             }
             HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
@@ -508,6 +514,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     if (HeaterCmd[index].targettemperatue == 0)
     {
+        DeActivateHeater(index);
         LOG_ERROR (index, "unconfigured");
         return ERROR;
     }