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

9 files changed, 342 insertions, 29 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 559db0e79..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);
@@ -179,6 +181,7 @@ int32_t MillisecReadFromTempSensor(uint32_t TempSensorId,  MSecFptr Callback)
     PT100Activity++;  //get response
     PT100Activity++; //read request
     PT100Data[TempSensorId].Callback = Callback;
+    PT100Data[TempSensorId].WaitForData = true;
     PT100Data[TempSensorId].DataRequired = true;
     PT100Data[TempSensorId].Active = true;
 
@@ -343,7 +346,7 @@ uint32_t MillisecLoop(uint32_t tick)
            {
                TemperatureSendSensorDummyClk((TEMPERATURE_SENSOR_ID_ENUM)Sensor_i);
                PT100Data[Sensor_i].SyncRequired = false;
-               if (PT100Data[Sensor_i].DataRequired == true)
+               /*if (PT100Data[Sensor_i].DataRequired == true)
                {
                    PT100Data[Sensor_i].WaitForData = true; // mark the motor for data request next round
                }
@@ -351,7 +354,7 @@ uint32_t MillisecLoop(uint32_t tick)
                {
                    if (PT100Data[Sensor_i].Callback)
                        PT100Data[Sensor_i].Callback(Sensor_i,0); // call the callback to report execution
-               }
+               }*/
                PT100Activity--;
 
            }
@@ -417,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 1ca1e5f84..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,6 +229,10 @@ 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_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));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP2));
     DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP3));
@@ -252,7 +256,7 @@ void Diagnostic100msecCollection(void)
     for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
     {
         dispensermotorfrequency[i][DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+i);
-        dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i)/1000000;
+        dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i);
     }
 /*     dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
      dispenser2motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2);
@@ -292,7 +296,7 @@ void SendDiagnostics(void)
 {
     MessageContainer responseContainer;
     StartDiagnosticsResponse response = START_DIAGNOSTICS_RESPONSE__INIT;
-    int i;
+    //int i;
 
     if (DiagnosticsActive == false)
         return;
@@ -427,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)
     {
@@ -461,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)
 {
@@ -475,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;
@@ -487,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 4e573cb82..2d73379d6 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticsHoming.c
@@ -456,5 +456,6 @@ uint32_t SetComponentValueRequestRequestFunc(MessageContainer* requestContainer)
     //free(requestContainer);
     set_component_value_request__free_unpacked(request,NULL);
 
+    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 01a08125a..f1332ca98 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -46,9 +46,9 @@ uint32_t    ControlIdtoHeaterId [MAX_HEATERS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF,0x
 uint32_t    MainDryerHeaterMaxTempControl = 0xFF;
 uint32_t    SecondDryerHeaterMaxTempControl = 0xFF;
 
-#define DRYER_AIR_PT100  TEMP_SENSE_ANALOG_DRYER_TEMP3
-#define DRYER_MAIN_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP1
-#define DRYER_SECONDARY_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP2
+#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
 
 uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,TEMP_SENSE_AN_ENCLOSURETEMP3};
 uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
@@ -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
     {
@@ -348,9 +351,18 @@ bool HeaterGetOverTemperatureState(uint8_t HeaterId)
     if (HeaterId > MAX_HEATERS_NUM) return false;
     return HeaterMaxTempFlag[HeaterId];
 }
+uint32_t MainPT100Read = 0,SecondaryPT100Read = 0;
+#ifndef max
+    #define max(a,b) ((a) > (b) ? (a) : (b))
+#endif
+#ifndef min
+    #define min(a,b) ((a) < (b) ? (a) : (b))
+#endif
 uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=MAX_HEATERS_NUM;
+    uint32_t MaxreadValue = max (MainPT100Read,SecondaryPT100Read);
+    uint32_t MinreadValue = min (MainPT100Read,SecondaryPT100Read);
     /*char str[100];
     uint8_t len = 0;*/
     if (IfIndex>>8 != IfTypeHeaters)
@@ -364,26 +376,41 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
         LOG_ERROR (IfIndex, "Wrong  Interface ");
         return 0xFFFFFFFF;
     }
-    if ((readValue/100) >= HeaterControl[index].sensormaxvalue)
+    if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
+    {
+        MainPT100Read = readValue;
+    }
+    if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
+    {
+        SecondaryPT100Read = readValue;
+    }
+    if ((MaxreadValue/100) >= HeaterControl[index].sensormaxvalue)
     {
         if (HeaterMaxTempFlag[index] == false)
         {
-            LOG_ERROR (readValue, "Heater Over the max temperature, turned off");
+            LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
         }
-        DeActivateHeater(index);
-        HeaterMaxTempFlag[index] = true;
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = true;
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true;
         return OK;
     }
-    if ((readValue/100) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue))
+    if ((MinreadValue/100) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue))
     {
         if (HeaterControl[index].sensorminvalue > 0)
         {
             if (HeaterMaxTempFlag[index] == true)
             {
-                ActivateHeater(index);
-                LOG_ERROR ((readValue/100), "Heater Cooled Off max temperature, turned on");
+                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+                if (InitialHeating)
+                {
+                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                }
+                LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on");
             }
-            HeaterMaxTempFlag[index] = false;
+            HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
+            HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = false;
         }
         return OK;
     }
@@ -487,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;
     }
diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_init.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_init.c
index 1efce00e3..185d4ac66 100644
--- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_init.c
@@ -66,7 +66,7 @@ float CalculateDispenserPressure (int DispenserId)
     //-----------------------------------
     //DispenserPressure[DispenserId] /= 1000000; //Pascal
     //DispenserPressure[DispenserId] *=10;        //Bar;
-    DispenserPressure[DispenserId] *=10000000;        //uBar;
+    //DispenserPressure[DispenserId] *=10000000;        //uBar;
     //DispenserPressure[DispenserId] *=145.0377;  //PSI;
 
     return(DispenserPressure[DispenserId]);