aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
blob: b1d870919301d8dc6b0f19545bf1903e7c95f779 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#ifndef MODULES_HEATERS_HEATERS_H_
#define MODULES_HEATERS_HEATERS_H_
#include "PMR/Hardware/HardwarePidControl.pb-c.h"
#include "PMR/Hardware/HardwarePidControlType.pb-c.h"
#include "heaters_ex.h"
#include "Drivers/Heater/Heater.h"
/******************** DEFINITIONS  ********************************************/
#define MAX_AC_HEATERS (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1)
#define MAX_TIMESLICES 200

extern uint32_t OutputProportionalSingleStep;  //A/C Heaters step size from one decision point to another - in cpu clocks. 120000 = 1 millisecod
extern uint32_t OutputProportionalCycleTime; //A/C Heaters Cycle time in milliseconds - one for all heaters
//extern uint32_t Heater_timerBase;        //Timer handle
extern char     TimeSliceAllocation[MAX_TIMESLICES];
extern int     DCTimeSliceAllocation[HEATER_TYPE_MAX_HEATERS];
extern int      NumberOFSlicesInUse;
extern uint32_t MillisecondsPerChange;

void initializeArrays(void);

typedef struct  HeaterPIDControlConfigstruc
{
  bool configured;
  int id;  //HardwarePidControlType
  float outputproportionalpowerlimit;
  float outputproportionalband;
  //int32_t sensorcorrectionadjustment;
  //int32_t sensortypeandsetpointlimits;
  float IntegralErrorMultiplier; //setpointramprateorsoftstartramp
  //int32_t setpointcontroloutputrate;
  float ProportionalErrorMultiplier;//outputonoffhysteresisvalue;
  //int32_t processvariablesamplingrate;
  //int32_t pvinputfilterfactormode;
  int32_t sensormaxvalue;
  int32_t sensorminvalue;
  double kp;
  double ki;
  double kd;
  double epsilon;
  double dt;
  bool   pidactive;
}HeaterPIDControlConfig;

typedef struct  HeaterCommandstruc
{
  int heaterid; //HardwarePidControlType
  bool     command;
  uint32_t targettemperatue;
}HeaterCommand;


extern HeaterPIDControlConfig HeaterControl[HEATER_TYPE_MAX_HEATERS];
extern HeaterCommand          HeaterCmd[HEATER_TYPE_MAX_HEATERS];
extern uint32_t  Heater_timerBase;

uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_outputproportionalpowerlimit);
uint32_t HeaterRecalculateHeaterParams(uint32_t deviceId, uint32_t new_outputproportionalpowerlimit);

uint32_t HeatersSingleHeaterEnd(int HeaterId);

#endif
/*
 * AlarmHandling.c

 *
 *  Created on: 24 may 2018
 *      Author: shlomo
 */

#include "include.h"
#include "Modules/General/GeneralHardware.h"

#include "AlarmHandling.h"
#include <driverlib/timer.h>
#include <Drivers/FPGA/Motors_Driver/L6470.h>
#include <Drivers/SSI_Comm/SSI_Comm.h>
#include <inc/hw_ints.h>

#include "drivers/adc_sampling/adc.h"
#include "Control/control.h"
#include "Control/MillisecTask.h"

#include "drivers/Motors/Motor.h"
#include "drivers/Heater/TemperatureSensor.h"
#include "drivers/FPGA/FPGA_SPI_Comm.h"
#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
#include "drivers/FPGA/FPGA.h"
#include "PMR/Hardware/HardwareDancerType.pb-c.h"
#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
#include "drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h"

#include "modules/thread/thread_ex.h"
#include "modules/heaters/heaters_ex.h"
#include "modules/ids/ids_ex.h"
#include  <PMR/Diagnostics/Event.pb-c.h>
#include  <PMR/Diagnostics/EventType.pb-c.h>
#include  <PMR/Diagnostics/StartEventsNotificationRequest.pb-c.h>
#include  <PMR/Diagnostics/StartEventsNotificationResponse.pb-c.h>
#include  <PMR/Diagnostics/StopEventsNotificationRequest.pb-c.h>
#include  <PMR/Diagnostics/StopEventsNotificationResponse.pb-c.h>

#include  <PMR/EmbeddedParameters/AlarmHandlingItem.pb-c.h>
#include  <PMR/EmbeddedParameters/AlarmSourceType.pb-c.h>
#include  <PMR/EmbeddedParameters/AlarmParameters.pb-c.h>

#include  <PMR/Diagnostics/ResolveEventRequest.pb-c.h>
#include  <PMR/Diagnostics/ResolveEventResponse.pb-c.h>
#include "PMR/debugging/DebugLogCategory.pb-c.h"

#include "StateMachines/Printing/PrintingSTM.h"

#include "drivers/Motors/Motor.h"
#include "drivers/Heater/TemperatureSensor.h"
#include "drivers/Flash_ram/FlashProgram.h"

Task_Handle AlarmHandling_Task_Handle;
Mailbox_Handle          AlarmHandlingMsgQ = NULL;

char AlarmHandlingToken[36+1] = {0};
bool AlarmHandlingActive = false;
uint32_t AlarmHandlingControlId = 0xFF;
uint32_t AlarmHandlingTick = 0;

bool    CheckHardLimitAlarms = false,CheckCurrentAlarms = false,CheckTamperAlarms = false;
uint8_t alarm_response_buffer[500];

/******************** Functions  ********************************************/
void SendEventNotifications(void);

//uint32_t Control_Delta_Position_Pass(uint32_t Current_Read,uint32_t Previous_Read);
//**********************************************************************
typedef enum
{
    AlarmHandlingTrigger,
    AlarmHandlingAlarm
    //AlarmHandlingCalculateTemperature,
}AlarmHandlingMessages;

typedef struct AlarmHandlingMessage{
    uint16_t messageId;
    uint16_t msglen;
    uint32_t tick;
    uint32_t AlarmId;
    bool     Value;
  //  uint32_t SensorId;
  //  uint32_t Data;
}AlarmHandlingMessageStruc;

#define MAX_SYSTEM_ALARMS 300+1
/*typedef enum
{
    TemperatureAlarm,
    LimitSwitchAlarm,
    PressureAlarm,
    CurrentAlarm,
    MotorAlarm,
    CoversAlarm,
    DoNotPollAlarm,
    HardLimitAlarm,
    TachoAlarm,
    FluidLevelAlarm,
}AlarmSource;*/
#define OVER_VALUE true
#define UNDER_VALUE false
typedef struct
{
    uint16_t Frequency;  //1/10/100/1000
    AlarmSourceType AlarmSource;
    uint16_t DeviceId;
    uint8_t ModuleDeviceId;
    uint16_t AlarmValue;
    bool AlarmDirection;
    DebugLogCategory Severity;
    uint16_t Predecessor;
    uint8_t DebounceValue;
    EventType EventType;
    char *EventName;
}AlarmHandlingItemStruc;
typedef struct
{
    int8_t DebounceCounter;
    bool Status;
    Event *EventPtr;
}AlarmStatusItem;
AlarmStatusItem  AlarmState[MAX_SYSTEM_ALARMS];

/*#define FLASH_MAP _Pragma("location = MOTOR_MAP_IN_FLASH")*/
/*
* Use this pragma directive to specify the location�the absolute address�of the global
* or static variable whose declaration follows the pragma directive (only if using it without #define for example: #pragma location = MOTOR_MAP_IN_FLASH)
* The variables must be declared either __no_init or const!
*/
AlarmHandlingItemStruc  *AlarmItem;
const AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
 {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY,"Dispenser 1 Empty"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY,"Dispenser 2 Empty"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY,"Dispenser 3 Empty"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_4_EMPTY,"Dispenser 4 Empty"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_5_EMPTY,"Dispenser 5 Empty"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_6_EMPTY,"Dispenser 6 Empty"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_7_EMPTY,"Dispenser 7 Empty"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_8_EMPTY,"Dispenser 8 Empty"},

 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT,"Dispenser 1 is at the upper limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_UPPER_HARD_LIMIT,"Dispenser 2 is at the upper limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_UPPER_HARD_LIMIT,"Dispenser 3 is at the upper limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_UPPER_HARD_LIMIT,"Dispenser 4 is at the upper limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_UPPER_HARD_LIMIT,"Dispenser 5 is at the upper limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_UPPER_HARD_LIMIT,"Dispenser 6 is at the upper limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_UPPER_HARD_LIMIT,"Dispenser 7 is at the upper limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_UPPER_HARD_LIMIT,"Dispenser 8 is at the upper limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT,"Dispenser 1 is at the lower limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_LOWER_HARD_LIMIT,"Dispenser 2 is at the lower limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_LOWER_HARD_LIMIT,"Dispenser 3 is at the lower limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_LOWER_HARD_LIMIT,"Dispenser 4 is at the lower limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_LOWER_HARD_LIMIT,"Dispenser 5 is at the lower limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_LOWER_HARD_LIMIT,"Dispenser 6 is at the lower limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_LOWER_HARD_LIMIT,"Dispenser 7 is at the lower limit"},
 {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_LOWER_HARD_LIMIT,"Dispenser 8 is at the lower limit"},

 {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,0,0,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_1_HIGH_PRESSURE,"Dispenser 1 High Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,1,1,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_2_HIGH_PRESSURE,"Dispenser 2 High Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,2,2,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_3_HIGH_PRESSURE,"Dispenser 3 High Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,3,3,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE,"Dispenser 4 High Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,4,4,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE,"Dispenser 5 High Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,5,5,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE,"Dispenser 6 High Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,6,6,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE,"Dispenser 7 High Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,7,7,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE,"Dispenser 8 High Pressure"},

 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_1_OVERPRESSURE,"Dispenser 1 Over Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_2_OVERPRESSURE,"Dispenser 2 Over Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_3_OVERPRESSURE,"Dispenser 3 Over Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_4_OVERPRESSURE,"Dispenser 4 Over Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_5_OVERPRESSURE,"Dispenser 5 Over Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_6_OVERPRESSURE,"Dispenser 6 Over Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE,"Dispenser 7 Over Pressure"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE,"Dispenser 8 Over Pressure"},

 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT,"Motor Drier Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT,"Motor Feeder Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT,"Motor Screw Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERCURRENT,"Motor Winder Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERCURRENT,"Motor Puller Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT,"Motor Dispenser1 Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT,"Motor Dispenser2 Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT,"Motor Dispenser3 Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT,"Motor Dispenser4 Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT,"Motor Dispenser5 Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT,"Motor Dispenser6 Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT,"Motor Dispenser7 Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT,"Motor Dispenser8 Over Current"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE,"Motor Drier Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE,"Motor Feeder Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE,"Motor Screw Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE,"Motor Winder Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE,"Motor Puller Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE,"Motor Dispenser1 Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE,"Motor Dispenser2 Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE,"Motor Dispenser3 Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE,"Motor Dispenser4 Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE,"Motor Dispenser5 Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE,"Motor Dispenser6 Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE,"Motor Dispenser7 Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE,"Motor Dispenser8 Over Temperature"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE,"Motor Drier Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE,"Motor Feeder Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE,"Motor Screw Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE,"Motor Winder Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE,"Motor Puller Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE,"Motor Dispenser1 Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE,"Motor Dispenser2 Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE,"Motor Dispenser3 Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE,"Motor Dispenser4 Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE,"Motor Dispenser5 Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE,"Motor Dispenser6 Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE,"Motor Dispenser7 Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE,"Motor Dispenser8 Under Voltage"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_STALL,"Motor Drier Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_STALL,"Motor Feeder Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,        HARDWARE_MOTOR_TYPE__MOTO_SCREW,        x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_STALL,"Motor Screw Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,       HARDWARE_MOTOR_TYPE__MOTO_WINDER,       x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_STALL,"Motor Winder Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,     x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_STALL,"Motor Puller Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_STALL,"Motor Dispenser1 Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_STALL,"Motor Dispenser2 Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_STALL,"Motor Dispenser3 Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_STALL,"Motor Dispenser4 Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_STALL,"Motor Dispenser5 Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_STALL,"Motor Dispenser6 Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_STALL,"Motor Dispenser7 Stall"},
 {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,  x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_STALL,"Motor Dispenser8 Stall"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE,"Mixer Over Temperature"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,"DyeingHead1 Over Temperature"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,"DyeingHead2 Over Temperature"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,"DyeingHead3 Over Temperature"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,"DyeingHead4 Over Temperature"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,"DyeingHead5 Over Temperature"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,"DyeingHead6 Over Temperature"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,"Dryer Over Temperature"},

 {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor1    ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN,"Front door #1 Open"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor2    ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_2_OPEN,"Front door #2 Open"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor3    ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_3_OPEN,"Front door #3 Open"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor4    ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_4_OPEN,"Front door #4 Open"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor      ,1,false,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN,"Rear door Open"},
 {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor,1,false,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN,"Cartridges door Open"},

 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,"DyeingHead 1 PT100 Heating Failure"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,"DyeingHead 2 PT100 Heating Failure"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,"DyeingHead 3 PT100 Heating Failure"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,"DyeingHead 4 PT100 Heating Failure"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,"DyeingHead 5 PT100 Heating Failure"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,"DyeingHead 6 PT100 Heating Failure"},
 {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,"Dryer PT100 Heating Failure"},
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT                         ,"Motor RightLoader Over Current"                },                                           /* 3004 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT                          ,"Motor LeftLoader Over Current"                },                                           /* 3006 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT                          ,"Motor LoadindARM Over Current"                },                                           /* 3009 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_MOTOR_OVERCURRENT /*EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT*/                       ,"Motor WinderDancer Over Current"            },   /* 3036 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_MOTOR_OVERCURRENT /*EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT*/                       ,"Motor PullerDancer Over Current"            },   /* 3037 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT /*EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT*/                       ,"Motor FeederDancer Over Current"            },   /* 3038 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_MOTOR_OVERCURRENT  /*EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT*/                           ,"Motor DryerLid Over Current"                },   /* 4017 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT                    ,"Motor DyeingHeadCover Over Current" },                                       /* 5031 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT       ,"Motor DyeingHeadCleaningMechanism Over Current"},                                       /* 5035 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_OCD          , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT            ,"Motor DyeingHeadCleaningHead Over Current"    },                                       /* 5039 */

 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE                     ,"Motor RightLoader Over Temperature"            },                                           /* 3011 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE                      ,"Motor LeftLoader Over Temperature"            },                                           /* 3013 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE                      ,"Motor LoadArm Over Temperature"                },                                           /* 3016 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE                    ,"Motor WinderDancer Over Temperature"        },                                           /* 3039 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE                    ,"Motor PullerDancer Over Temperature"        },                                           /* 3040 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE                    ,"Motor FeederDancer Over Temperature"        },                                           /* 3041 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE                        ,"Motor DryerLid Over Temperature"            },                                           /* 4018 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE                ,"Motor DyeingHeadCover Over Temperature"        },                                           /* 5032 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE   ,"Motor DyeingHeadCleaning Over Temperature"    },                                           /* 5036 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_TH_SD        , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE        ,"Motor DyeingHeadCleaningHead Over Temperature"},                                           /* 5040 */

 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                                ,"Motor LoadingARM Stall "                   },                                           /* 3018 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              ,"Motor WinderDances Stall "                    },                                           /* 3020 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL                                ,"Motor LoadingARM Stall "                   },                                           /* 3023 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2         ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL                              ,"Motor WinderDances Stall "                    },                                           /* 3042 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_STALL                              ,"Motor PullerDancer Stall "                    },                                           /* 3043 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER    ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL                              ,"Motor FeederDancer Stall "                    },                                           /* 3044 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID        ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_STALL                                  ,"Motor DryerLid Stall "                        },                                           /* 4019 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID           ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL                          ,"Motor DyeingHeadCover Stall "                },                                           /* 5033 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL             ,"Motor DyeingHeadCleaningMechanism Stall "    },                                           /* 5037 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD     ,x_STATUS_STEP_LOSS_A   , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL                  ,"Motor DryeingHeadCleaning Stall "            },                                           /* 5041 */

 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , HARDWARE_MOTOR_TYPE__MOTO_RLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE                        ,"Motor RightLoader Under Voltage"               },                                           /* 3025 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , HARDWARE_MOTOR_TYPE__MOTO_LLOADING        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE                         ,"Motor LeftLoader Under Voltage"                },                                           /* 3027 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE                         ,"Motor LoaderARM Under Voltage"                },                                           /* 3030 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2        , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE                       ,"Motor WinderDancer Under Voltage"            },                                           /* 3045 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE                       ,"Motor PullerDancer Under Voltage"            },                                           /* 3046 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , HARDWARE_MOTOR_TYPE__MOTO_RDANCER   , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE                       ,"Motor FeederDancer Under Voltage"            },                                           /* 3047 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID       , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE                           ,"Motor DryerLid Under Voltage"                },                                           /* 4020 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , HARDWARE_MOTOR_TYPE__MOTO_DH_LID          , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE                   ,"Motor DyeingHeadCover Under Voltage"        },                                           /* 5034 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE                ,"Motor DyeingHeadCleaning Under Voltage"        },                                           /* 5038 */
 {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD    , x_STATUS_UVLO         , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE           ,"Motor DyeingHeadCleaningHead Under Voltage"    },                                           /* 5042 */

 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 125         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE           ," Head Zone 1 Heater Current Out Of Range"    },                                           /* 5018 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE           ," Head Zone 2 Heater Current Out Of Range"    },                                           /* 5019 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE           ," Head Zone 3 Heater Current Out Of Range"    },                                           /* 5020 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 312         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE           ," Head Zone 4 Heater Current Out Of Range"    },                                           /* 5021 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 500         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE         ," Head Zone 5-6 Heater Current Out Of Range"    },                                           /* 5022 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE                        ," Mixer Heater Current Out Of Range"    },                                           /* 6004 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, 800         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE         ," Drier Heater 1 Current Out Of Range"    },                                           /* 6004 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, 400         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE         ," Drier Heater 2 Current Out Of Range"    },                                           /* 6004 */

 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK           ," Head Zone 1 Heater Current Loop Break"    },                                           /* 5018 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK           ," Head Zone 2 Heater Current Loop Break"    },                                           /* 5019 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK           ," Head Zone 3 Heater Current Loop Break"    },                                           /* 5020 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK           ," Head Zone 4 Heater Current Loop Break"    },                                           /* 5021 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK         ," Head Zone 5-6 Heater Current Loop Break"    },                                           /* 5022 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK                        ," Mixer Heater Current Loop Break"    },                                           /* 6004 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK         ," Drier Heater 1 Current Loop Break"    },                                           /* 6004 */
 {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK         ," Drier Heater 2 Current Loop Break"    },                                           /* 6004 */
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF,"Dyeing head Thermal Cut-Off"},

 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK,"Thread Break"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER,"Thread Feeder Tension Control Failure"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,"Thread Puller Tension Control Failure"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,"Thread Winder Tension Control Failure"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,"No cone in winder"},

 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DRYER_DOOR_OPEN,"Dryer Door is open"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__NO_AIR_PRESSURE,"No suction in the waste handling system"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__AIR_FILTER_NOT_INSTALLED,"Air filter missing"},
 {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,"Waste Container Emptying Timeout"},

};

char AlarmStorePath[25] ="0://SysInfo//AlarmPrm.cfg";

//bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
bool EventsNotificationRequestAccepted = false;
//read dispensers limit switches. 25 - send warning. up - stop job and send alarm
//Cone missing
//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;

    Error_init(&eb);

    AlarmHandlingMsgQ = Mailbox_create(sizeof(AlarmHandlingMessageStruc), 20, NULL,&eb);

    int Alarm_i;
    for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
    {
        AlarmState[Alarm_i].Status = false;
        AlarmState[Alarm_i].DebounceCounter = 0;
        AlarmState[Alarm_i].EventPtr = NULL;
    }

    AlarmItem = (AlarmHandlingItemStruc *)ALARM_MAP_IN_FLASH;
    EraseFlashSection(ALARM_MAP_IN_FLASH,sizeof(AlarmHandlingItemStruc)*MAX_SYSTEM_ALARMS);
    ReadAppAndProgram(AlarmItem, sizeof(AlarmHandlingItemStruc)*MAX_SYSTEM_ALARMS, HardCodedAlarmItem);
    LOG_ERROR(AlarmItem[2].EventName,"Flash Test");

    return;
}
void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms, bool checkTamperAlarms)
{
    CheckHardLimitAlarms = checkHardLimitAlarms;
    CheckCurrentAlarms = checkCurrentAlarms;
    CheckTamperAlarms = checkTamperAlarms;
}

JobEndReasonEnum getEndReason(uint32_t AlarmId)
{
    switch (AlarmItem[AlarmId].AlarmSource)
    {
        case ALARM_SOURCE_TYPE__TemperatureAlarm:
            return JOB_TEMPERATURE_ALARM;
        case ALARM_SOURCE_TYPE__LimitSwitchAlarm:
            return JOB_LS_ALARM;
        case ALARM_SOURCE_TYPE__PressureAlarm:
            return JOB_PRESSURE_ALARM;
        case ALARM_SOURCE_TYPE__CurrentAlarm:
            return JOB_CURRENT_ALARM;
        case ALARM_SOURCE_TYPE__MotorAlarm:
            return JOB_MOTOR_ALARM;
        case ALARM_SOURCE_TYPE__CoversAlarm:
            return JOB_TAMPER_ALARM;
        default:
            return JOB_OTHER_ALARM;
    }
}
uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Severity)
{
    //DebugLogCategory reprocessedSeverity = Severity;
    //ProcessParameters ProcessParameterZero;
    switch (AlarmItem[AlarmId].AlarmSource)
    {
        case ALARM_SOURCE_TYPE__TemperatureAlarm:
            //need to discover the heater Id and shut it down
            HeaterCommandRequestMessage(AlarmItem[AlarmId].ModuleDeviceId, HEATER_OFF, 0);
            break;
        case ALARM_SOURCE_TYPE__LimitSwitchAlarm:
        case ALARM_SOURCE_TYPE__HardLimitAlarm:
        case ALARM_SOURCE_TYPE__PressureAlarm:
            if (Severity == DEBUG_LOG_CATEGORY__Info)
            {
                IDS_Dispenser_Alarm_Off(AlarmItem[AlarmId].ModuleDeviceId);
            }
            else
            {
                IDS_Dispenser_Alarm_On (AlarmItem[AlarmId].ModuleDeviceId);
            }
            break;
        case ALARM_SOURCE_TYPE__CurrentAlarm:
            break;
        case ALARM_SOURCE_TYPE__MotorAlarm:
            MotorStop(AlarmItem[AlarmId].ModuleDeviceId,Hard_Hiz);
            break;
        default:
            break;
    }
    /*switch (reprocessedSeverity)*/
	switch (Severity)
    {
    case DEBUG_LOG_CATEGORY__Warning:
        //raise flag fr next job
        break;
    case DEBUG_LOG_CATEGORY__Critical:

//        watchdogCriticalAlarm = true;
        LOG_ERROR(AlarmId,"Critical Alarm - Watchdog activated to reset  hardware");
/*
        //stop all dispensers
        for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++)
        {
            MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz);
        }
        //stop all heating
        memset (ProcessParameterZero,0,sizeof(ProcessParameterZero));
        HandleProcessParameters(ProcessParameterZero);
        */
        //intentional fall through
    case DEBUG_LOG_CATEGORY__Error:
        if (JobIsActive())
        {
            JobEndReason = getEndReason(AlarmId);
            AbortJob(AlarmItem[AlarmId].EventName);
            Report(AlarmItem[AlarmId].EventName, __FILE__,__LINE__,AlarmId, RpMessage, DEBUG_LOG_CATEGORY__Error, 0);
        }
        /*switch (AlarmItem[AlarmId].AlarmSource)
        {
            case ALARM_SOURCE_TYPE__TemperatureAlarm:
                //need to discover the heater Id and shut it down
  //              HeaterCommandRequestMessage(                        HARDWARE_PID_CONTROL_TYPE__MixerHeater, false,
  //                      ProcessParams->mixertemp);
                break;
            case ALARM_SOURCE_TYPE__LimitSwitchAlarm:
                if ((AlarmItem[AlarmId].EventType>=EVENT_TYPE__Dispenser1Empty)&&(AlarmItem[AlarmId].EventType<=EVENT_TYPE__Dispenser8Empty))
                {
                    Disp_i = AlarmItem[AlarmId].EventType- EVENT_TYPE__Dispenser1Empty;
                    MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz);
                    if (JobIsActive())
                    {
                        if (DispenserUsedInJob[Disp_i] == false)
                            AlarmItem[AlarmId].Severity = DEBUG_LOG_CATEGORY__Info;
                    }
                }
                break;
            case ALARM_SOURCE_TYPE__PressureAlarm:
                Disp_i = AlarmItem[AlarmId].EventType- EVENT_TYPE__Dispenser1Pressure;
                MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz);
                if (JobIsActive())
                {
                    if (DispenserUsedInJob[Disp_i] == false)
                        AlarmItem[AlarmId].Severity = DEBUG_LOG_CATEGORY__Info;
                }
                break;
            case ALARM_SOURCE_TYPE__CurrentAlarm:
                break;
            case ALARM_SOURCE_TYPE__MotorAlarm:
                break;
            default:
                break;
        }*/

        break;

    case DEBUG_LOG_CATEGORY__Info:
    default:
        //do nothing
        break;

    }
    return OK;
}
JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
{
    //JobTicket* JobTicket = CurrentJob;
    EventType HeaterEventType[MAX_HEATERS_NUM*2] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,
                                                  EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,
                                                  EVENT_TYPE__MIXER_OVERTEMPERATURE};
    EventType HeaterEventTypeUnder[MAX_HEATERS_NUM*2] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,
                                                  EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,
                                                  EVENT_TYPE__MIXER_UNDERTEMPERATURE_B};
    int Dispenser_i,Alarm_i,Heater_i,AlarmId=0;
    HeaterState HeaterState;

    //for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++)
    //{
    //    DispenserInUse[Dispenser_i] = false;
    //}
    JobEndReasonEnum status = JOB_OK;
    IDS_MapDispenserUsedinJob(CurrentJob);
    if (n_segments == 0)
        return OK;

    /*for (Segment_i=0;Segment_i<JobTicket->n_segments;Segment_i++)
        {
        for (Brush_i=0;Brush_i<JobTicket->segments[Segment_i]->n_brushstops;Brush_i++)
            {
                if (JobTicket->segments[Segment_i]->brushstops[Brush_i]->n_dispensers)
                {
                    for (Dispenser_i = 0;Dispenser_i < JobTicket->segments[Segment_i]->brushstops[Brush_i]->n_dispensers;Dispenser_i++)
                    {
                        //prepare the SW structures
                        DispenserId = JobTicket->segments[Segment_i]->brushstops[Brush_i]->dispensers[Dispenser_i]->index;
                        if (JobTicket->segments[Segment_i]->brushstops[Brush_i]->dispensers[Dispenser_i]->nanolitterpersecond>0.0)
                        {
                            DispenserInUse[DispenserId] = true;
                        }
                    }//for dispenser
                }//if dispensers
            }//for brush
        }//for segments
        */
    if (Configured[Module_IDS])
    {
        for (Dispenser_i=0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++)
        {
            if (DispenserUsedInJob[Dispenser_i] == true)
            {
                for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++)
                {
                    if (AlarmItem[Alarm_i].EventType == (EVENT_TYPE__DISPENSER_1_EMPTY+Dispenser_i))
                    {
                        if (AlarmState[Alarm_i].Status == true)
                        {
                            status = ERROR;
                            AlarmId = Alarm_i;
                            break;
                        }
                    }
                }
            }
        }
    }
    for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++)
    {
        if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__CoversAlarm)
        {
            if (AlarmState[Alarm_i].Status == true)
            {
                status = ERROR;
                AlarmId = Alarm_i;
                break;
            }
        }
        if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__MotorAlarm)
        {
            if (AlarmState[Alarm_i].Status == true)
            {
                if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
				{
	                status = ERROR;
    	            AlarmId = Alarm_i;
        	        break;
				}
            }
        }
    }
    if (Configured[Module_Heaters])
    {
        if (HeaterCheckReady()==false)
        {
            for (Heater_i = 0;Heater_i<MAX_HEATERS_NUM;Heater_i++)
            {
                LoadHeaterState((HeaterType)Heater_i,&HeaterState);
                if (HeaterState.setpoint)//temperature is set - heater active
                {
                    for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++)
                    {
                        if (AlarmItem[Alarm_i].EventType == HeaterEventType[Heater_i])
                        {
                            if (AlarmState[Alarm_i].Status == true)
                            {
                                status = ERROR;
                                AlarmId = Alarm_i;
                                break;
                            }
                        }
                        if (AlarmItem[Alarm_i].EventType == HeaterEventTypeUnder[Heater_i])
                        {
                            if (AlarmState[Alarm_i].Status == true)
                            {
                                status = ERROR;
                                AlarmId = Alarm_i;
                                break;
                            }
                        }
                    }
                }
            }
        }
    }
    if (status == ERROR)
    {
        JobEndReason = getEndReason(AlarmId);
        //AbortJob(AlarmItem[AlarmId].EventName);
        //PrepareReady(Module_Alarms,ModuleFail);
        Report(AlarmItem[AlarmId].EventName, __FILE__,__LINE__,AlarmId, RpMessage, DEBUG_LOG_CATEGORY__Error, 0);
    }
    return JobEndReason;
}

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;
}
void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value)
{
    AlarmHandlingMessageStruc Message;

    //send message to the Millisec task
    Message.messageId = AlarmHandlingAlarm;
    Message.AlarmId = AlarmId;
    Message.Value = value;
    if (AlarmHandlingMsgQ != NULL)
        Mailbox_post(AlarmHandlingMsgQ , &Message, BIOS_NO_WAIT);
}
void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value)
{
    int Alarm_i;
    for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
    {
        if (AlarmItem[Alarm_i].EventType == AlarmId)
        {
            if (AlarmState[Alarm_i].Status != value)
            {
                if (value == true)
                {
                    // 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 = AlarmItem[Alarm_i].EventName;
                        AlarmState[Alarm_i].Status = value;
                        Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
                    }
                }
                else
                {
                    Report("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;
                }
            }
            break;
        }
    }
}

uint32_t AlarmHandlingStart(void)
{

    //void *AlarmItemsTableptr;
    //if (EventsNotificationRequestAccepted == false)
    //    return ERROR;
    if ( AlarmHandlingActive == false)
    {
            AlarmHandlingActive = true;
            AlarmHandlingControlId = AddControlCallback(AlarmHandling_ControlTrigger,eTenMillisecond,TemplateDataReadCBFunction,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;
    int32_t value;
    //int32_t ivalue;
    bool Status = false;
    for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
    {
        Status = false;
        if (tick%AlarmItem[Alarm_i].Frequency == 0)
        {
            switch (AlarmItem[Alarm_i].AlarmSource)
            {
            /*case ALARM_SOURCE_TYPE__TemperatureAlarm:
                ivalue = MillisecGetTemperatures((TEMPERATURE_SENSOR_ID_ENUM)AlarmItem[Alarm_i].DeviceId);
                if (AlarmItem[Alarm_i].AlarmDirection == true)
                {
                    if (ivalue/100 >= AlarmItem[Alarm_i].AlarmValue)
                    {
                        //LOG_ERROR (ivalue/100,"Temperature spike");
                        Status = true;
                    }
                }
                else
                {
                    if (ivalue/100 <= AlarmItem[Alarm_i].AlarmValue)
                    {
                        //LOG_ERROR (ivalue/100,"iTemperature spike");
                        Status = true;
                    }
                }
                break;*/
            case ALARM_SOURCE_TYPE__CoversAlarm:
                if (CheckTamperAlarms)
                {
                    value = Get_COVER_1_State(AlarmItem[Alarm_i].DeviceId);
                    if (value == AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                else
                {
                    value = false;
                }
                break;
            case ALARM_SOURCE_TYPE__LimitSwitchAlarm:
                value = IDS_CheckDispenserLimitSwitch((LimitSwitchAlarms)AlarmItem[Alarm_i].DeviceId);
                if (value == AlarmItem[Alarm_i].AlarmValue)
                {
                    Status = true;
                }
                break;
            case ALARM_SOURCE_TYPE__HardLimitAlarm:
                if (CheckHardLimitAlarms)
                {
                    if (AlarmItem[Alarm_i].AlarmDirection == true)
                    {
                        value = Read_Notification_Disp_UP(AlarmItem[Alarm_i].DeviceId,NULL);
                    }
                    else
                    {
                        value = Read_Notification_Disp_Down(AlarmItem[Alarm_i].DeviceId,NULL);
                    }
                }
                else
                {
                    value = false;
                }
                break;
            case ALARM_SOURCE_TYPE__PressureAlarm:
                value = GetDispenserPressure(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 ALARM_SOURCE_TYPE__CurrentAlarm:
                if (CheckCurrentAlarms)
                {
                    value = Get_Heaters_Current_Integer(AlarmItem[Alarm_i].DeviceId);
                    if (AlarmItem[Alarm_i].AlarmDirection == true)
                    {
                        if ((value >= (AlarmItem[Alarm_i].AlarmValue*1.07))||(value <= (AlarmItem[Alarm_i].AlarmValue*0.80)))
                        {
                            Status = true;
                        }
                    }
                    else
                    {
                        if (value == 0)
                        {
                            Status = true;
                        }
                    }
                }
                else
                {
                    value = false;
                }
                break;
            case ALARM_SOURCE_TYPE__MotorAlarm:
                if (isMotorConfigured((TimerMotors_t)AlarmItem[Alarm_i].DeviceId) == false)
                {
                    Status = false;
                    break;
                }
                value = MotorGetStatus((TimerMotors_t)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)==false)
                    {
                        Status = true;
                    }
                }
                break;
            case ALARM_SOURCE_TYPE__FluidLevelAlarm:
                value = Get_MidTank_Int100_Sensor(AlarmItem[Alarm_i].DeviceId);
                if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE)
                {
                    if (value*100 > AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                else
                {
                    if (value*100 < AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                break;
            case ALARM_SOURCE_TYPE__TemperatureAlarm:
            case ALARM_SOURCE_TYPE__DoNotPollAlarm:
                Status =  AlarmState[Alarm_i].Status;
                break;
            default:
                break;
            } //switch
            if (AlarmItem[Alarm_i].DebounceValue > 0) //handle debouncing
            {
                if (Status == true) //increase counter
                {
                    AlarmState[Alarm_i].DebounceCounter++;
                    if (AlarmState[Alarm_i].Status == false) // alarm is not set yet
                    {
                        if (AlarmState[Alarm_i].DebounceCounter < AlarmItem[Alarm_i].DebounceValue) //had not reached the debounce value
                        {
                            Status = false; //do not set the alarm
                        } //else alarm will be set
                    }
                    else // alarm is already set
                    {
                        AlarmState[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue; // do not go over the debounce value
                    }
                }
                else //status  == false - decrease counter
                {
                    AlarmState[Alarm_i].DebounceCounter--;
                    if (AlarmState[Alarm_i].Status == true) // alarm is set
                    {
                        if (AlarmState[Alarm_i].DebounceCounter > 0) // had not reached zero yet
                        {
                            Status = true; // do not reset the alarm yet
                        }   // else reset the alarm
                    }
                    else // if the alarm is off
                    {
                        AlarmState[Alarm_i].DebounceCounter = 0; //do not go below 0
                    }
                }
            }
            if (AlarmItem[Alarm_i].Predecessor!=0xFF)
            {
                if (AlarmState[AlarmItem[Alarm_i].Predecessor].Status == true)  //higher hierarchy alarm is on
                    Status = false;
            }
            if (Status !=  AlarmState[Alarm_i].Status) //change in alarm Status
            {
                if (Status == true) // alarm on
                {
                    AlarmState[Alarm_i].Status = true;
                    AlarmHandlingConsequentActions(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 = AlarmItem[Alarm_i].EventName;
                    }
                    Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
                }
                else // alarm off
                {
                    AlarmState[Alarm_i].Status = false;
                    AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info);
                    // report the alarm!
                    if (AlarmState[Alarm_i].EventPtr)
                        my_free(AlarmState[Alarm_i].EventPtr);
                    Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i);
                }
            }
        }
    }
    //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

    if ((tick%eOneSecond == 0)&&(EventsNotificationRequestAccepted==true))
        SendEventNotifications();
    return OK;
}
/******************************************************************************
 *  ======== messageTsk ========
 *  Task for this function is created statically. See the project's .cfg file.
 *  this message task is created statically in system initialization,
 ******************************************************************************/
void AlarmHandlingTask(UArg arg0, UArg arg1)
{
    AlarmHandlingMessageStruc Message;
    //char str[60];
    //uint16_t length;
    //Clock_setTimeout(HostKAClock, 1000);
    //Clock_start(HostKAClock);
    AlarmHandlingInit();
    AlarmHandling_Task_Handle = Task_self();
    while(1)
    {
        Mailbox_pend(AlarmHandlingMsgQ , &Message, BIOS_WAIT_FOREVER);
        switch (Message.messageId)
        {
            case AlarmHandlingTrigger:
                AlarmHandlingLoop(Message.tick);
                break;
            case AlarmHandlingAlarm:
                AlarmHandlingInternalSetAlarm(Message.AlarmId, Message.Value);
                break;
            /*case AlarmHandlingCalculateTemperature:
                CalculateTemperatures(Message.SensorId,Message.Data);
                break;*/
            default:
                break;
        }
    }
}
//StartEventsNotificationResponse StartEventsNotification = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
StartEventsNotificationResponse response = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
int LargeMessagesAH = 0;
void SendEventNotifications(void)
{
    MessageContainer responseContainer;
    //StartEventsNotificationResponse response = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
    int i,e=0;

    if (AlarmHandlingActive == false)
        return;
    if (AlarmHandlingToken[0] == 0)
        return;
    if (SuspendLargeMessages == true)
    {
        LargeMessagesAH++;
        return;
    }

    response.n_events = 0;

    for (i = 0;i<MAX_SYSTEM_ALARMS;i++)
    {
        if (AlarmState[i].Status == true)
        {
            response.n_events++;
        }
    }

    if (response.n_events)
    {
        response.events = (Event **)my_malloc(sizeof(Event*)*response.n_events);
        if(response.events)
        {
            for (i = 0;i<MAX_SYSTEM_ALARMS;i++)
            {
                if (AlarmState[i].Status == true)
                {
                    if (AlarmState[i].EventPtr)
                    {
                        response.events[e]=AlarmState[i].EventPtr;
                        e++;
                    }
                }
            }
        }
        else
        {
            LOG_ERROR(response.n_events,"events malloc error");
            return;
        }
    }
    else
    {
        response.events = NULL;
    }
    responseContainer = createAllocatedContainer(MESSAGE_TYPE__StartEventsNotificationResponse,  AlarmHandlingToken, false, &response, &start_events_notification_response__pack, &start_events_notification_response__get_packed_size,&alarm_response_buffer);
    responseContainer.continuous = true;

    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
    if (container_buffer)
    {
        size_t container_size = message_container__pack(&responseContainer, container_buffer);

//        if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full
        if (SendCharsWithType(container_buffer, container_size,MESSAGE_TYPE__StartEventsNotificationResponse) == false) //comm tx mailbox full
        {
            //AlarmHandlingToken[0] = 0;
            my_free(container_buffer);
        }
    }
    if (response.events)
        my_free(response.events);
    if (responseContainer.data.data)
        my_free(responseContainer.data.data);
}
uint32_t ResolveEventRequestFunc(MessageContainer* requestContainer)
{
    int Alarm_i;
    //uint32_t status = NOT_SUPPORTED;
    ResolveEventRequest *request = resolve_event_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
    MessageContainer responseContainer;

    ResolveEventResponse response = RESOLVE_EVENT_RESPONSE__INIT;
    for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
    {
        if (AlarmItem[Alarm_i].EventType == request->type)
        {
            AlarmState[Alarm_i].Status = false;
            if (AlarmState[Alarm_i].EventPtr)
                my_free(AlarmState[Alarm_i].EventPtr);
            //status = OK;
            break;
        }
    }

    responseContainer = createContainer(MESSAGE_TYPE__ResolveEventResponse,  requestContainer->token, false, &response, &resolve_event_response__pack, &resolve_event_response__get_packed_size);
     responseContainer.continuous = false;
     uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
     size_t container_size = message_container__pack(&responseContainer, container_buffer);
     my_free(responseContainer.data.data);
     SendChars(container_buffer, container_size);

 return OK;
}
uint32_t StartEventsNotificationRequestFunc(MessageContainer* requestContainer)
{
    uint32_t status = NOT_SUPPORTED;
    //MessageContainer responseContainer;

//    ReportInitParams InitParams;
    //ControlStart();
    EventsNotificationRequestAccepted = true;
    //AlarmHandlingStart();

    StartEventsNotificationRequest* request = start_events_notification_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
    ustrncpy (AlarmHandlingToken, requestContainer->token,36);
    start_events_notification_request__free_unpacked(request,NULL);
    return status;
}
uint32_t StopEventsNotificationRequestFunc(MessageContainer* requestContainer)
{

    MessageContainer responseContainer;

    StopEventsNotificationRequest* request = stop_events_notification_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StopEventsNotificationResponse response = STOP_EVENTS_NOTIFICATION_RESPONSE__INIT;

    //AlarmHandlingStop();

    EventsNotificationRequestAccepted = false;

    responseContainer = createContainer(MESSAGE_TYPE__StopEventsNotificationResponse,  requestContainer->token, false, &response, &stop_events_notification_response__pack, &stop_events_notification_response__get_packed_size);
    responseContainer.continuous = false;
    uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    my_free(responseContainer.data.data);
    SendChars(container_buffer, container_size);

return OK;
}