aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/PPC/Modules/Tango.PPC.MachineSettings/Views
ModeNameSize
-rw-r--r--MainView.xaml9038logstatsplain
-rw-r--r--MainView.xaml.cs654logstatsplain
generated by cgit v1.3.1 (git 2.54.0) at 2026-07-26 03:13:49 +0000
/*
 * 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 "drivers/FPGA/Full_Vme/FPGA_Programming_Up.h"
#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
#include "drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h"
#include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
#include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
#include <Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h>
#include "Common/SWUpdate/FileSystem.h"
#include "drivers/Flash_ram/MCU_E2Prom.h"

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

#include <PMR/Hardware/HardwareDancerType.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"

#include "drivers/Valves/Valve.h"

#include "StateMachines/Initialization/PowerIdle.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;

int MotorConfiguredTimeout = 100;
double     CurrentAlarmHighLimit ,CurrentAlarmLowLimit;
bool    CheckHardLimitAlarms = false,CheckCurrentAlarms = false,CheckTamperAlarms = false,CheckMotorAlarms = false;
uint8_t alarm_response_buffer[500];

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

//**********************************************************************
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 400+1
/*typedef enum
{
    TemperatureAlarm,
    LimitSwitchAlarm,
    PressureAlarm,
    CurrentAlarm,
    MotorAlarm,
    CoversAlarm,
    DoNotPollAlarm,
    HardLimitAlarm,
    TachoAlarm,
    FluidLevelAlarm,
}AlarmSource;*/
#define OVER_VALUE true
#define UNDER_VALUE false
#define CURRENT4AMP 400
#define CURRENT2AMP 200
#define MACHINE_FANS_MIN_RPM 1000
#define MACHINE_FANS_STOP 0
#define MACHINE_NOT_USE_MIDDLE_FANS 0 //the middle FAN is not used !!!

#define ELECTRICAL_CABINET_FANS_MIN_RPM 1000
#define ELECTRICAL_CABINET_FANS_STOP 0
#define DRYER_FAN_MIN_RPM 1000
#define DRYER_FAN_STOP 0

#define MASKDRYERBIG 1
#define MASKDRYERSMALL0 2
#define MASKDRYERSMALL1 4
#define MASKDRYERSMALL2 8
#define MASKDRYERSMALL3 16
#define MASKSYSTEMLEFT 32
#define MASKSYSTEMRIGHT 64
#define MASKSYSTEMnotUSED 128
#define MASKSYSTEMMIDDLE 48
typedef enum
{
    MACHINE_FANS,
    ELECTRICAL_CABINET_FANS,
    DRYER_FAN,
    ARC_HEAD_FAN_IN,
    ARC_HEAD_FAN_OUT,
    WHS_FAN_1, //COOLER 1
    WHS_FAN_2, //COOLER 2
    WHS_FAN_3, //COOLER 3
    WHS_FAN_4, //COOLER 4
    WHS_FAN_5, //PRE-COOLER 1
    WHS_FAN_6, //PRE-COOLER 2
    NUM_OF_FANS,
} Fans_t;

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;
    bool isPersistent;
}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!
*/
uint32_t * pAlarmItemSize = (uint32_t *)(ALARM_MAP_IN_FLASH);
uint32_t AlarmItemSize ;
AlarmHandlingItemStruc  *AlarmItem  = NULL;//(AlarmHandlingItemStruc *)(ALARM_MAP_IN_FLASH+4);
AlarmHandlingItemStruc  *HardCodedAlarmItem=NULL;
//AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
//* 7016    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY},
//* 7017    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY},
//* 7018    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY},
//* 7019    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_4_EMPTY},
//* 7020    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_5_EMPTY},
//* 7021    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_6_EMPTY},
//* 7022    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_7_EMPTY},
//* 7023    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_8_EMPTY},

//* 7064    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT},
//* 7065    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_UPPER_HARD_LIMIT},
//* 7066    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_UPPER_HARD_LIMIT},
//* 7067    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_UPPER_HARD_LIMIT},
//* 7068    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_UPPER_HARD_LIMIT},
//* 7069    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_UPPER_HARD_LIMIT},
//* 7070    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_UPPER_HARD_LIMIT},
//* 7071    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_UPPER_HARD_LIMIT},
//* 7072    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT},
//* 7073    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_LOWER_HARD_LIMIT},
//* 7074    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_LOWER_HARD_LIMIT},
//* 7075    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_LOWER_HARD_LIMIT},
//* 7076    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_LOWER_HARD_LIMIT},
//* 7077    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_LOWER_HARD_LIMIT},
//* 7078    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_LOWER_HARD_LIMIT},
//* 7079    */     {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_LOWER_HARD_LIMIT},

//* 7080    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,0,0,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_1_HIGH_PRESSURE},
//* 7081    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,1,1,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_2_HIGH_PRESSURE},
//* 7082    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,2,2,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_3_HIGH_PRESSURE},
//* 7083    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,3,3,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE},
//* 7084    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,4,4,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE},
//* 7085    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,5,5,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE},
//* 7086    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,6,6,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE},
//* 7087    */     {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,7,7,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE},

//* 7000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_1_OVERPRESSURE},
//* 7001    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_2_OVERPRESSURE},
//* 7002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_3_OVERPRESSURE},
//* 7003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_4_OVERPRESSURE},
//* 7004    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_5_OVERPRESSURE},
//* 7005    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_6_OVERPRESSURE},
//* 7006    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE},
//* 7007    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE},

//* 8000    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_1_LOW_LEVEL},
//* 8001    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_2_LOW_LEVEL},
//* 8002    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_3_LOW_LEVEL},
//* 8003    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_4_LOW_LEVEL},
//* 8004    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_5_LOW_LEVEL},
//* 8005    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_6_LOW_LEVEL},
//* 8006    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_7_LOW_LEVEL},
//* 8007    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,300//*300cc*/,false,DEBUG_LOG_CATEGORY__Warning,  0xFF,2,EVENT_TYPE__MID_TANK_8_LOW_LEVEL},
//* 8008    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_EMPTY},
//* 8009    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_EMPTY},
//* 8010    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_EMPTY},
//* 8011    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_EMPTY},
//* 8012    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_EMPTY},
//* 8013    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_EMPTY},
//* 8014    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_EMPTY},
//* 8015    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,200//*200cc*/,false,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_EMPTY},

//* 8016    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,0,0,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_1_OVERFLOW},
//* 8017    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,1,1,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_2_OVERFLOW},
//* 8018    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,2,2,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_3_OVERFLOW},
//* 8019    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,3,3,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_4_OVERFLOW},
//* 8020    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,4,4,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_5_OVERFLOW},
//* 8021    */     //{eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,5,5,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_6_OVERFLOW},
//* 8022    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,6,6,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_7_OVERFLOW},
//* 8023    */     {eOneSecond,ALARM_SOURCE_TYPE__FluidLevelAlarm,7,7,1800//*1800cc*/,true,DEBUG_LOG_CATEGORY__Error,    0xFF,2,EVENT_TYPE__MID_TANK_8_OVERFLOW},


//* 4000    */     {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  },
//* 3003    */     {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 },
//* 3008    */     {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  },
//* 3007    */     {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 },
//* 3005    */     {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 },
//* 7032    */     {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},
//* 7033    */     {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},
//* 7034    */     {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},
//* 7035    */     {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},
//* 7036    */     {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},
//* 7037    */     {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},
//* 7038    */     {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},
//* 7039    */     {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},
//* 4001    */     {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},
//* 3010    */     {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},
//* 3015    */     {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 },
//* 3014    */     {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},
//* 3012    */     {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},
//* 7040    */     {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},
//* 7041    */     {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},
//* 7042    */     {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},
//* 7043    */     {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},
//* 7044    */     {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},
//* 7045    */     {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},
//* 7046    */     {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},
//* 7047    */     {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},
//* 4003    */     {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 },
//* 3024    */     {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},
//* 3029    */     {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 },
//* 3028    */     {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},
//* 3026    */     {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},
//* 7056    */     {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},
//* 7057    */     {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},
//* 7058    */     {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},
//* 7059    */     {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},
//* 7060    */     {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},
//* 7061    */     {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},
//* 7062    */     {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},
//* 7063    */     {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},
//* 4002    */     {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    },
//* 3017    */     {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   },
//* 3022    */     {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    },
//* 3021    */     {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   },
//* 3019    */     {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   },
//* 7048    */     {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},
//* 7049    */     {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},
//* 7050    */     {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},
//* 7051    */     {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},
//* 7052    */     {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},
//* 7053    */     {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},
//* 7054    */     {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},
//* 7055    */     {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},

//* 6000    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE},
//* 5000    */     {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},
//* 5001    */     {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},
//* 5002    */     {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},
//* 5003    */     {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},
//* 5004    */     {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},
//* 5005    */     {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                   },
//* 4005    */     {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      },

//* 2008    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,  0,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
//* 2017    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,  1,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },

//* 2002    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor1_EC      ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN},
//* 2003    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor2_PPC     ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_2_OPEN},
//* 2004    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor3_DH_DRYER,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_3_OPEN},
//* 2005    */  //   {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor4_MIDTANKS,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__FRONT_COVER_4_OPEN},
//* 2007    */  //  {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor           ,1,true,true,DEBUG_LOG_CATEGORY__Error,  0xFF,5,EVENT_TYPE__REAR_COVER_OPEN     },

//* 2006    */     {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor     ,1,true,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN},

//* 6001    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A},
//* 5006    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A},
//* 5007    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A},
//* 5008    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A},
//* 5009    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A},
//* 5010    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A},
//* 5011    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A},

//* 4007    */     {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A},
//* 6002    */     {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},
//* 5012    */     {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},
//* 5013    */     {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},
//* 5014    */     {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},
//* 5015    */     {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},
//* 5016    */     {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},
//* 5017    */     {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                   },
//* 4008    */     {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      },

//* 3004    */     {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                            },                                           //* 3004 */
//* 3006    */     {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                            },                                           //* 3006 */
//* 3009    */     {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                            },                                           //* 3009 */
//* 3036    */     {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*/            },   //* 3036 */
//* 3037    */     {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*/            },   //* 3037 */
//* 3038    */     {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*/            },   //* 3038 */
//* 4017    */     {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*/                },   //* 4017 */
//* 5031    */     {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                    },                                       //* 5031 */
//* 5035    */     {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       },                                       //* 5035 */
//* 5039    */     {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            },                                       //* 5039 */

//* 3011    */     {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                     },                                           //* 3011 */
//* 3013    */     {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                      },                                           //* 3013 */
//* 3016    */     {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                      },                                           //* 3016 */
//* 3039    */     {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                    },                                           //* 3039 */
//* 3040    */     {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                                },                                           //* 3040 */
//* 3041    */     {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                   },                                           //* 3041 */
//* 4018    */     {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                       },                                           //* 4018 */
//* 5032    */     {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          },                                           //* 5032 */
//* 5036    */     {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  },                                           //* 5036 */
//* 5040    */     {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       },                                           //* 5040 */

//* 3018    */     {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                             },                                           //* 3018 */
//* 3020    */     {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                              },                                           //* 3020 */
//* 3023    */     {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                             },                                           //* 3023 */
//* 3042    */     {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                              },                                           //* 3042 */
//* 3043    */     {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                                       },                                           //* 3043 */
//* 3044    */     {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                                        },                                           //* 3044 */
//* 4019    */     {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                                  },                                           //* 4019 */
//* 5033    */     {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                         },                                           //* 5033 */
//* 5037    */     {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            },                                           //* 5037 */
//* 5041    */     {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                 },                                           //* 5041 */

//* 3025    */     {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                         },                                           //* 3025 */
//* 3027    */     {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                          },                                           //* 3027 */
//* 3030    */     {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                         },                                           //* 3030 */
//* 3045    */     {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                      },                                           //* 3045 */
//* 3046    */     {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                                },                                           //* 3046 */
//* 3047    */     {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                                    },                                           //* 3047 */
//* 4020    */     {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                           },                                           //* 4020 */
//* 5034    */     {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                  },                                           //* 5034 */
//* 5038    */     {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         },                                           //* 5038 */
//* 5042    */     {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             },                                           //* 5042 */

//* 5018    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 125         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE              },                                           //* 5018 */
//* 5019    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE          },                                           //* 5019 */
//* 5020    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE          },                                           //* 5020 */
//* 5021    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 312         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE          },                                           //* 5021 */
//* 5022    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 500         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE       },                                           //* 5022 */
//* 6004    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 187         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE                       },                                       //* 6004 */
//* 4011    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, CURRENT4AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE           },                                           //* 6004 */
//* 4012    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, CURRENT2AMP         , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE           },                                           //* 6004 */

//* 5023    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1  , HEATER_HEAD_CURRENT_ZONE_1  , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK              },                                           //* 5018 */
//* 5024    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2    , HEATER_HEAD_CURRENT_ZONE_2    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK           },                                           //* 5019 */
//* 5025    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3    , HEATER_HEAD_CURRENT_ZONE_3    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK           },                                           //* 5020 */
//* 5026    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4    , HEATER_HEAD_CURRENT_ZONE_4    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK           },                                           //* 5021 */
//* 5027    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6    , HEATER_HEAD_CURRENT_ZONE_5_6    , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK       },                                           //* 5022 */
//* 6005    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT        , HEATER_MIXCHIP_CURRENT        , 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK                       },                                        //* 6004 */
//* 4013    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK          },                                           //* 6004 */
//* 4014    */     {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, 0         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 5, EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK          },                                           //* 6004 */
//* 5028    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF},

//* 9005    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_TIME},
//* 9008    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE},

//* 3000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK},
//* 3001    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER},
//* 3048    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER},
//* 3049    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER},
//* 3002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST},

//* 4004    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DRYER_DOOR_OPEN},
//* 9003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__NO_AIR_PRESSURE},
//* 9000    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__AIR_FILTER_NOT_INSTALLED},
//* 9002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT},

//* 2014    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MACHINE_STATE_HW_CONFIG_FAILED},

//* 2009    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_MIN_RPM           , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__MACHINE_FANS_RPM_TOO_LOW            }, //*2009*/
//* 2010    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, MACHINE_FANS           , MACHINE_FANS           , MACHINE_FANS_STOP              , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__MACHINE_FANS_STOPPED                }, //*2010*/
//* 2011    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_MIN_RPM, FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_RPM_TOO_LOW }, //*2011*/
//* 2012    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS, ELECTRICAL_CABINET_FANS_STOP   , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__ELECTRICAL_CABINET_FANS_STOPPED     }, //*2012*/
//* 4015    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_MIN_RPM              , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF, 5, EVENT_TYPE__DRYER_FAN_RPM_TOO_LOW               }, //*4015*/
//* 4016    */     {eOneSecond, ALARM_SOURCE_TYPE__TachoAlarm, DRYER_FAN              , DRYER_FAN              , DRYER_FAN_STOP                 , FALSE , DEBUG_LOG_CATEGORY__Critical, 0xFF, 5, EVENT_TYPE__DRYER_FAN_STOPPED                   }, //*4016*/

//*  8024    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_1_FILL_TIMEOUT},
//*  8025    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_2_FILL_TIMEOUT},
//*  8026    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_3_FILL_TIMEOUT},
//*  8027    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_4_FILL_TIMEOUT},
//*  8028    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_5_FILL_TIMEOUT},
//*  8029    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_6_FILL_TIMEOUT},
//*  8030    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_7_FILL_TIMEOUT},
//*  8031    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MID_TANK_8_FILL_TIMEOUT},

//*  10002    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__NO_WASTE_CARTRIDGE_AVAILABLE},
//*  10003    */     {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__ALL_WASTE_CARTRIDGES_FULL}

//};

char AlarmStorePath[30] ="0://SysInfo//Alarm.cfg";
uint16_t FluidLevelWarning = 20,FluidLevelError = 50;
int NumOfSystemAlarms = MAX_SYSTEM_ALARMS;
//bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
bool EventsNotificationRequestAccepted = false;
char AlarmReasonStr[100];
//read dispensers limit switches. 25 - send warning. up - stop job and send alarm
//Cone missing
//Dyeing head over temperature
//mixer over temperature
//dryer over temperature
//heaters failure
//dispenser pressure
//valve OCD
//Motor Status
//machine cover open
AlarmParameters * AlarmParametersTable = NULL;
uint32_t AlarmHandlingLoadFile(void)
{
    FRESULT Fresult = FR_OK;
    uint8_t* buffer = NULL;
    uint32_t Bytes = 0,i,p_size = 0,F_count = 0,AlarmPtr;
    Fresult = FileRead(AlarmStorePath, &Bytes, &buffer);
    AlarmHandlingItemStruc  FileAlarmItem[4];
    int maxAlarms = 0;

    if (Fresult == FR_OK)
    {
        AlarmParametersTable = alarm_parameters__unpack(NULL, Bytes, buffer);
        if (AlarmParametersTable)
        {
            if (AlarmParametersTable->n_alarmitem)
            {
                maxAlarms = AlarmParametersTable->n_alarmitem;
                p_size = AlarmParametersTable->n_alarmitem*sizeof(AlarmHandlingItemStruc);
                ReportWithPackageFilter(AlarmFilter,"Writing alarm size", __FILE__,pAlarmItemSize,AlarmParametersTable->n_alarmitem, RpMessage, p_size, 0);
                EraseFlashSection(ALARM_SECTION_FLASH);
                ReadAppAndProgram(pAlarmItemSize, 4,&p_size);
                AlarmPtr = (int)pAlarmItemSize+4;
                p_size = 0;
                F_count = 0;
                for (i = 0; i < AlarmParametersTable->n_alarmitem ;i++)
                {
                    FileAlarmItem[F_count].AlarmDirection = AlarmParametersTable->alarmitem[i]->alarmdirection;
                    FileAlarmItem[F_count].AlarmDirection =  AlarmParametersTable->alarmitem[i]->alarmdirection;
                    //FileAlarmItem[F_count].Frequency =       AlarmParametersTable->alarmitem[i]->frequency;  //1/10/100/1000
                    FileAlarmItem[F_count].AlarmSource =     AlarmParametersTable->alarmitem[i]->alarmsource;
                    FileAlarmItem[F_count].DeviceId =        AlarmParametersTable->alarmitem[i]->deviceid;
                    FileAlarmItem[F_count].ModuleDeviceId =  AlarmParametersTable->alarmitem[i]->moduledeviceid;
                    FileAlarmItem[F_count].AlarmValue =      AlarmParametersTable->alarmitem[i]->alarmvalue;
                    FileAlarmItem[F_count].AlarmDirection =  AlarmParametersTable->alarmitem[i]->alarmdirection;
                    FileAlarmItem[F_count].Severity =        AlarmParametersTable->alarmitem[i]->severity;
                    //FileAlarmItem[F_count].Predecessor =     AlarmParametersTable->alarmitem[i]->predecessor;
                    FileAlarmItem[F_count].DebounceValue =   AlarmParametersTable->alarmitem[i]->debouncevalue;
                    FileAlarmItem[F_count].EventType =       AlarmParametersTable->alarmitem[i]->eventtype;
                    FileAlarmItem[F_count].isPersistent =    AlarmParametersTable->alarmitem[i]->ispersistent;
                    p_size+= sizeof(AlarmHandlingItemStruc);
                    F_count++;

                    if (F_count == 4)
                    {
                        //ReportWithPackageFilter(AlarmFilter,"Writing four alarms", __FILE__,AlarmPtr,F_count, RpMessage, p_size, 0);
                        F_count = 0;
                        ReadAppAndProgram(AlarmPtr, p_size,FileAlarmItem);
                        AlarmPtr+=p_size;
                        p_size = 0;
                    }
                }
                if (F_count)// finish the reminder of the file
                {
                    ReportWithPackageFilter(AlarmFilter,"Writing additional alarms", __FILE__,AlarmPtr,F_count, RpMessage, p_size, 0);
                    //F_count = p_size%4;
                    //p_size += (4-F_count);
                    ReadAppAndProgram(AlarmPtr, p_size,FileAlarmItem);
                }
                free (buffer);
                ReportWithPackageFilter(AlarmFilter,"AlarmHandlingLoadFile", __FILE__,__LINE__,p_size, RpMessage, AlarmParametersTable->n_alarmitem, 0);
            }
            alarm_parameters__free_unpacked(AlarmParametersTable,NULL);
        }
        else
        {
            ReportWithPackageFilter(AlarmFilter,"no alarms alarm size", __FILE__,pAlarmItemSize,AlarmParametersTable->n_alarmitem, RpMessage, p_size, 0);
            ReadAppAndProgram(pAlarmItemSize, 4,0);
            return 0;
        }
    }
    else
    {
        ReportWithPackageFilter(AlarmFilter,"no alarms file", __FILE__,pAlarmItemSize,AlarmParametersTable->n_alarmitem, RpMessage, p_size, 0);
        ReadAppAndProgram(pAlarmItemSize, 4,0);
        return 0;
    }
    return maxAlarms;
}

void AlarmHandlingInit(void)
{
    Error_Block eb;
    uint32_t Bytes;

    Error_init(&eb);

    AlarmHandlingMsgQ = Mailbox_create(sizeof(AlarmHandlingMessageStruc), 40, 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;
    }

    memcpy(&Bytes,(void *)pAlarmItemSize,sizeof(Bytes));
    REPORT_MSG(Bytes,"Bytes read from flash");

    if ((Bytes)&&(Bytes < 12000))
    {
        AlarmItem = (AlarmHandlingItemStruc *)((int)(ALARM_MAP_IN_FLASH+4));
        NumOfSystemAlarms = Bytes/sizeof(AlarmHandlingItemStruc);
        ReportWithPackageFilter(AlarmFilter,"AlarmHandlingLoadFile", __FILE__,Bytes,NumOfSystemAlarms, RpMessage, sizeof(AlarmHandlingItemStruc), 0);
    }
    else
    {
        Bytes = AlarmHandlingLoadFile();

        //Bytes = AlarmHandlingFlashLoad();
        REPORT_MSG(Bytes,"Bytes read from file");
        if ((Bytes)&&(Bytes <= MAX_SYSTEM_ALARMS))
            {
                AlarmItem = (AlarmHandlingItemStruc *)((int)(ALARM_MAP_IN_FLASH+4));
                NumOfSystemAlarms = Bytes;
                ReportWithPackageFilter(AlarmFilter,"AlarmHandlingLoadFile", __FILE__,Bytes,NumOfSystemAlarms, RpMessage, sizeof(AlarmHandlingItemStruc), 0);
            }
    }
    //AlarmItem  = HardCodedAlarmItem; //back to hard coded until flash problem are solved


    return;
}
void     AlarmHandlingSetCurrentLimits(double currentalarmhighlimit,double currentalarmlowlimit)
{
    CurrentAlarmHighLimit = currentalarmhighlimit;
    CurrentAlarmLowLimit = currentalarmlowlimit;
    ReportWithPackageFilter(AlarmFilter,"Alarm Current Limits", __FILE__,__LINE__,(int)(currentalarmhighlimit*100), RpMessage, (int)(currentalarmlowlimit*100), 0);
}
uint32_t AlarmhandlingFlags = 0;
void     AlarmHandlingLoadFlags(void)
{
    MCU_E2PromRead(EEPROM_ALARM_SUPPORT,&AlarmhandlingFlags);

    CheckHardLimitAlarms = (AlarmhandlingFlags && 0x0001);
    CheckCurrentAlarms = (AlarmhandlingFlags && 0x0002);
    CheckTamperAlarms = (AlarmhandlingFlags && 0x0004);
    CheckMotorAlarms = (AlarmhandlingFlags && 0x0008);
    usnprintf(AlarmReasonStr, 100, "Alarm group from EEPPROM Current %d Motor %d Tamper %d",CheckCurrentAlarms,CheckMotorAlarms,CheckTamperAlarms);
    ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,0, RpMessage, 1*CheckHardLimitAlarms+2*CheckCurrentAlarms+3*CheckTamperAlarms+4*CheckMotorAlarms, 0);
}

void     AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms, bool checkTamperAlarms, bool checkMotorAlarms)
{
    uint32_t flags = 0;
    CheckHardLimitAlarms = checkHardLimitAlarms;
    CheckCurrentAlarms = checkCurrentAlarms;
    CheckTamperAlarms = checkTamperAlarms;
    CheckMotorAlarms = checkMotorAlarms;
    usnprintf(AlarmReasonStr, 100, "Alarm group setting Current %d Motor %d Tamper %d",CheckCurrentAlarms,CheckMotorAlarms,CheckTamperAlarms);
    ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,0, RpMessage, 1*CheckHardLimitAlarms+2*CheckCurrentAlarms+3*CheckTamperAlarms+4*CheckMotorAlarms, 0);

    if (CheckHardLimitAlarms) flags |= 0x1;
    if (CheckCurrentAlarms) flags |= 0x2;
    if (CheckTamperAlarms) flags |= 0x4;
    if (CheckMotorAlarms) flags |= 0x8;
    if (AlarmhandlingFlags != flags)
    {
        MCU_E2PromProgram(EEPROM_ALARM_SUPPORT,flags);
        AlarmhandlingFlags = flags;
    }
}
JobEndReasonEnum getEndReason(uint32_t AlarmId)
{
    switch (AlarmItem[AlarmId].AlarmSource)
    {
        case ALARM_SOURCE_TYPE__TemperatureAlarm:
            if (AlarmItem[AlarmId].Severity == DEBUG_LOG_CATEGORY__Critical)
            {
                usnprintf(AlarmReasonStr, 100, "Safety Critical Alarm %d",AlarmItem[AlarmId].EventType);
                return JOB_SAFETY_CRITICAL_ALARM;
            }
            else
            {
                usnprintf(AlarmReasonStr, 100, "Temperature problem in heater %d",AlarmItem[AlarmId].DeviceId);
                return JOB_TEMPERATURE_ALARM;
            }
        case ALARM_SOURCE_TYPE__LimitSwitchAlarm:
            usnprintf(AlarmReasonStr, 100, "Dispenser %d empty",AlarmItem[AlarmId].DeviceId);
            return JOB_OUT_OF_DYE;
        case ALARM_SOURCE_TYPE__PressureAlarm:
            usnprintf(AlarmReasonStr, 100, "Over pressure in dispenser %d",AlarmItem[AlarmId].DeviceId);
            return JOB_PRESSURE_ALARM;
        case ALARM_SOURCE_TYPE__CurrentAlarm:
            usnprintf(AlarmReasonStr, 100, "over/under current (%d) in %d",AlarmId,AlarmItem[AlarmId].DeviceId);
            return JOB_CURRENT_ALARM;
        case ALARM_SOURCE_TYPE__MotorAlarm:
            usnprintf(AlarmReasonStr, 100, "Motor alarm (%d) %d",AlarmId,AlarmItem[AlarmId].DeviceId);
            return JOB_MOTOR_ALARM;
        case ALARM_SOURCE_TYPE__CoversAlarm:
            usnprintf(AlarmReasonStr, 100, "Machine door %d removed during a run",AlarmItem[AlarmId].DeviceId);
            return JOB_TAMPER_ALARM;
        case ALARM_SOURCE_TYPE__HardLimitAlarm:
            usnprintf(AlarmReasonStr, 100, "Dispenser %d hit the hard limit",AlarmItem[AlarmId].DeviceId);
            return JOB_LS_ALARM;
        case ALARM_SOURCE_TYPE__DoNotPollAlarm:
            if (AlarmItem[AlarmId].Severity == DEBUG_LOG_CATEGORY__Critical)
            {
                usnprintf(AlarmReasonStr, 100, "Safety Critical Alarm %d",AlarmItem[AlarmId].EventType);
                return JOB_SAFETY_CRITICAL_ALARM;
            }
            else
            {
                usnprintf(AlarmReasonStr, 100, "Alarm %d type %d caused a job stop",AlarmId,AlarmItem[AlarmId].EventType);
                return JOB_OTHER_ALARM;
            }
        case ALARM_SOURCE_TYPE__FluidLevelAlarm:
            usnprintf(AlarmReasonStr, 100, "Midtank %d is empty",AlarmItem[AlarmId].DeviceId+1);
            return JOB_OUT_OF_DYE;
        default:
            usnprintf(AlarmReasonStr, 100, "Alarm %d type %d caused a job stop",AlarmId,AlarmItem[AlarmId].EventType);
            return JOB_OTHER_ALARM;
    }
}
uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Severity)
{
    if (AlarmItem == NULL)
        return ERROR;

    DebugLogCategory reprocessedSeverity = Severity;
    //ProcessParameters ProcessParameterZero;
    switch (AlarmItem[AlarmId].AlarmSource)
    {
        case ALARM_SOURCE_TYPE__TemperatureAlarm:
            //need to discover the heater Id and shut it down
            if ((Severity == DEBUG_LOG_CATEGORY__Error)||(Severity == DEBUG_LOG_CATEGORY__Critical))
            {
                ReportWithPackageFilter(AlarmFilter,"Heating alarm, turning heating off", __FILE__,__LINE__,AlarmId, RpMessage, Severity, 0);
                //HeaterCommandRequestMessage(AlarmItem[AlarmId].ModuleDeviceId, HEATER_OFF, 0);
                HeatersEnd();
            }
            break;
        case ALARM_SOURCE_TYPE__LimitSwitchAlarm:
        case ALARM_SOURCE_TYPE__HardLimitAlarm:
        case ALARM_SOURCE_TYPE__PressureAlarm:
            ReportWithPackageFilter(AlarmFilter,"Dispenser alarm, stop job and dispenser", __FILE__,AlarmItem[AlarmId].ModuleDeviceId,AlarmId, RpMessage, AlarmItem[AlarmId].AlarmSource, 0);
            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:
            if ((Severity == DEBUG_LOG_CATEGORY__Error)||(Severity == DEBUG_LOG_CATEGORY__Critical))
            {
                ReportWithPackageFilter(AlarmFilter,"Motor alarm, motor stopped", __FILE__,AlarmItem[AlarmId].ModuleDeviceId,AlarmId, RpMessage, AlarmItem[AlarmId].AlarmSource, 0);
                MotorStop(AlarmItem[AlarmId].ModuleDeviceId,Hard_Hiz);
            }
            if ((AlarmItem[AlarmId].ModuleDeviceId >= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1)&&(AlarmItem[AlarmId].ModuleDeviceId <= HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8)) //dispenser motor alarm
            {
                if (Severity == DEBUG_LOG_CATEGORY__Info)
                {
                    IDS_Dispenser_Alarm_Off(AlarmItem[AlarmId].ModuleDeviceId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
                }
                else
                {
                    IDS_Dispenser_Alarm_On (AlarmItem[AlarmId].ModuleDeviceId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1);
                }
            }
            break;
        case ALARM_SOURCE_TYPE__FluidLevelAlarm:
            if (Severity == DEBUG_LOG_CATEGORY__Error)
            {
                ReportWithPackageFilter(AlarmFilter,"fluid level alarm", __FILE__,AlarmItem[AlarmId].ModuleDeviceId,AlarmId, RpMessage, AlarmItem[AlarmId].AlarmSource, 0);
                if (AlarmItem[AlarmId].EventType >= EVENT_TYPE__MID_TANK_1_OVERFLOW)
                {
                    Valve_Set(IDS_Id_to_AirValve[AlarmItem[AlarmId].DeviceId], AlarmItem[AlarmId].DeviceId );   //AlarmItem[AlarmId].DeviceId/ON
                    Valve_Set(IDS_Id_to_CartrideValve[AlarmItem[AlarmId].DeviceId], AlarmItem[AlarmId].DeviceId );   //Atm_MidTank_OFF/ON
                }
                if ((JobIsActive())&&(DispenserUsedInJob[AlarmItem[AlarmId].DeviceId] == false))
                {
                    reprocessedSeverity = DEBUG_LOG_CATEGORY__Warning;
                }

            }

            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())
        {
            ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,AlarmId, RpMessage, Severity, 0);
            JobEndReason = getEndReason(AlarmId);
            AbortJob(AlarmReasonStr);
            //Report(AlarmReasonStr, __FILE__,__LINE__,AlarmId, RpMessage, Severity, 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;
}
bool FileAnalysis = false;
bool FileAnalysisGetState(void)
{
    return FileAnalysis;
}

JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob)
{
    //JobTicket* JobTicket = CurrentJob;
        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 FoundReason = JOB_OK,tempFoundReason;
    Task_Handle TaskHandle1 = Task_self();
    int pri = Task_getPri(TaskHandle1);

    ACTIVITY_GREEN_LED_ON;
    Task_setPri(TaskHandle1, 11);
    FileAnalysis = true;
    Task_sleep(10);
    Report("Task_setPri", __FILE__, pri, 3, RpWarning,   (int)TaskHandle1, 0);
    IDS_MapDispenserUsedinJob(CurrentJob);
    Task_setPri(TaskHandle1, pri);
    Report("Task_setPri", __FILE__, __LINE__, pri, RpWarning,   (int)Task_self(), 0);
    Task_sleep(10);
    ACTIVITY_GREEN_LED_OFF;
    FileAnalysis = false;
    if (n_segments == 0)
    {
        ReportWithPackageFilter(AlarmFilter,"no segments in the job", __FILE__,__LINE__,0, DEBUG_LOG_CATEGORY__Warning, 222, 0);
        return JOB_FILE_PROBLEM;
    }
    if (AlarmItem == NULL)
    {
        ReportWithPackageFilter(AlarmFilter,"missing alarm file", __FILE__,__LINE__,0, DEBUG_LOG_CATEGORY__Warning, 223, 0);
        usnprintf(AlarmReasonStr, 100, "No alarm file in the machine",111);
        return JOB_NO_ALARM_FILE;
    }

    /*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<NumOfSystemAlarms;Alarm_i++)
                {
                    if (AlarmItem[Alarm_i].EventType == (EVENT_TYPE__DISPENSER_1_EMPTY+Dispenser_i))
                    {
                        if (AlarmState[Alarm_i].Status == true)
                        {
                            FoundReason = JOB_LS_ALARM;
                            AlarmId = Alarm_i;
                            break;
                        }
                    }
                }
            }
        }
    }
    for (Alarm_i = 0;Alarm_i<NumOfSystemAlarms;Alarm_i++)
    {
        if ((AlarmState[Alarm_i].Status == true)&&(AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical))
        {
            FoundReason = JOB_SAFETY_CRITICAL_ALARM;
            ReportWithPackageFilter(AlarmFilter,"critical alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
            AlarmId = Alarm_i;
            break;
        }

        if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__CoversAlarm)
        {
            if ((AlarmState[Alarm_i].Status == true)&&(AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error))
            {
                FoundReason = JOB_TAMPER_ALARM;
                ReportWithPackageFilter(AlarmFilter,"tamper alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                AlarmId = Alarm_i;
                break;
            }
        }
        if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__FluidLevelAlarm)
        {
            if (AlarmState[Alarm_i].Status == true)
            {
                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error)
                {
                    if (DispenserUsedInJob[AlarmItem[Alarm_i].DeviceId] == true)
                    {
                        FoundReason = JOB_OUT_OF_DYE;
                        ReportWithPackageFilter(AlarmFilter,"fluid level alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                        AlarmId = Alarm_i;
                        break;
                    }
                }
            }
        }
        if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__MotorAlarm)
        {
            if (AlarmState[Alarm_i].Status == true)
            {
                if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
				{
	                FoundReason = JOB_MOTOR_ALARM;
                    ReportWithPackageFilter(AlarmFilter,"motor alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
    	            AlarmId = Alarm_i;
        	        break;
				}
            }
        }
    }
    if (Configured[Module_Heaters])
    {
        if (HeaterCheckReady()==false)
        {
            for (Heater_i=HEATER_TYPE__DryerAirHeater;Heater_i<HEATER_TYPE_MAX_HEATERS;Heater_i++)
            {
                LoadHeaterState((HeaterType)Heater_i,&HeaterState);
                if (HeaterState.setpoint)//temperature is set - heater active
                {
                    for (Alarm_i = 0;Alarm_i<NumOfSystemAlarms;Alarm_i++)
                    {
                        if (AlarmItem[Alarm_i].EventType == HeaterEventType[Heater_i])
                        {
                            if (AlarmState[Alarm_i].Status == true)
                            {
                                FoundReason = JOB_TEMPERATURE_ALARM;
                                AlarmId = Alarm_i;
                                ReportWithPackageFilter(AlarmFilter,"temperature alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                                break;
                            }
                        }
                        if (AlarmItem[Alarm_i].EventType == HeaterUnderEventType_B[Heater_i])
                        {
                            if (AlarmState[Alarm_i].Status == true)
                            {
                                FoundReason = JOB_TEMPERATURE_ALARM;
                                AlarmId = Alarm_i;
                                ReportWithPackageFilter(AlarmFilter,"temperature alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                                break;
                            }
                        }
                    }
                }
            }
        }
    }
    if ((IFS_Availability[1] == IFS_RECOGNIZED_INIT_PASSED)&&(IFS_Availability[2] == IFS_RECOGNIZED_INIT_PASSED)) //ifs installed -check cartridges
    {
            tempFoundReason = Waste_CheckState(&AlarmId);
            if (tempFoundReason!=JOB_OK)
            {
                for (Alarm_i = 0;Alarm_i<NumOfSystemAlarms;Alarm_i++)
                {
                    if (AlarmId == (AlarmItem[Alarm_i].EventType))
                    {
                        FoundReason = tempFoundReason;
                        AlarmId = Alarm_i;
                        ReportWithPackageFilter(AlarmFilter,"waste handling alarm preventing job", __FILE__,AlarmId,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                        break;
                    }
                }
            }
    }
    if ((AlarmState[Alarm_i].Status == true)&&(FoundReason == JOB_OK))
    {
        if(AlarmItem[Alarm_i].Severity>=DEBUG_LOG_CATEGORY__Error)
        {
            ReportWithPackageFilter(AlarmFilter,"an alarm existing before job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
            switch (AlarmItem[Alarm_i].EventType )
            {
                case EVENT_TYPE__INSUFFICIENT_AIR_FLOW:
                case EVENT_TYPE__VOC_SENSOR_ALARM_TIME:
#warning unmark to prevent job on voc alarm//case EVENT_TYPE__VOC_SENSOR_ALARM_SLOPE:
                //case EVENT_TYPE__POWER_UP_BIT_FAILURE:
                    FoundReason = JOB_WASTE_HANDLING_PROBLEM;
                    AlarmId = Alarm_i;
                    ReportWithPackageFilter(AlarmFilter,"an alarm preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                    break;
                case EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE:
                case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE:
                case EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2:
                    FoundReason = JOB_TEMPERATURE_ALARM;
                    AlarmId = Alarm_i;
                    ReportWithPackageFilter(AlarmFilter,"machine internal over-temperature is preventing job", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                    break;
                default:
                    break;
            }
        }
    }
    if (FoundReason == JOB_OK)
    {
        FoundReason = Winder_Check_Cone();
        if (FoundReason!=JOB_OK)
        {
            for (Alarm_i = 0;Alarm_i<NumOfSystemAlarms;Alarm_i++)
            {
                if (AlarmItem[Alarm_i].EventType == EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST)
                {
                    AlarmId = Alarm_i;
                    ReportWithPackageFilter(AlarmFilter,"cone not in place - preventing job", __FILE__,AlarmId,AlarmItem[Alarm_i].EventType, AlarmItem[Alarm_i].Severity, AlarmItem[Alarm_i].DeviceId, 0);
                    break;
                }
            }
        }
    }
    if (FoundReason != JOB_OK)
    {
        JobEndReason = getEndReason(AlarmId);
        if (JobEndReason!=FoundReason)
        {
            ReportWithPackageFilter(AlarmFilter,"end reason mismatch!!!", __FILE__,AlarmId,JobEndReason, RpMessage, FoundReason, 0);
            JobEndReason=FoundReason;
        }
        //AbortJob(AlarmReasonStr);
        //PrepareReady(Module_Alarms,ModuleFail);
        ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,__LINE__,AlarmId, RpMessage, DEBUG_LOG_CATEGORY__Error, 0);
		return (FoundReason);
    }
    return JOB_OK;
}

uint32_t AlarmHandling_ControlTrigger(uint32_t IfIndex, uint32_t ReadValue)
{
    AlarmHandlingMessageStruc Message;

    if (AlarmHandlingActive == false)
        return OK;
    //send message to the Millisec task
    Message.messageId = AlarmHandlingTrigger;
    Message.msglen = sizeof(AlarmHandlingMessageStruc);
    AlarmHandlingTick +=100;
    Message.tick = AlarmHandlingTick;
    if (AlarmHandlingMsgQ != NULL)
        Mailbox_post(AlarmHandlingMsgQ , &Message, BIOS_NO_WAIT);


    return OK;
}
void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value);
StartEventsNotificationResponse PersistentEventsResponse = START_EVENTS_NOTIFICATION_RESPONSE__INIT;

void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value)
{
    //AlarmHandlingInternalSetAlarm( AlarmId, 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,Event_i;
    Event **re_events;
    if (AlarmItem == NULL)
        return;
    for (Alarm_i = 0;Alarm_i < NumOfSystemAlarms;Alarm_i++)
    {
        if (AlarmItem[Alarm_i].EventType == AlarmId)
        {
            //if (0) // PERSISTENT ALARM
  			if (AlarmItem[Alarm_i].isPersistent == true) // PERSISTENT ALARM simulate   Currently looking for "true" value, otherwise the currently existing OFF event appears
            {
  	            if (value == true) // PERSISTENT ALARM simulate   Currently looking for "true" value, otherwise the currently existing OFF event appears
  	            {
  	                if (PersistentEventsResponse.events == NULL)
  	                    PersistentEventsResponse.events = (Event **)my_malloc(sizeof(Event*)*(PersistentEventsResponse.n_events+1));
  	                else
  	                {
  	                    re_events = (Event **)my_malloc(sizeof(Event*)*(PersistentEventsResponse.n_events+1));
  	                    for (Event_i = 0;Event_i < (PersistentEventsResponse.n_events);Event_i++)
  	                    {
  	                        re_events[Event_i] = PersistentEventsResponse.events[Event_i];
  	                    }
  	                    my_free(PersistentEventsResponse.events);
  	                    PersistentEventsResponse.events = re_events;
  	                }
  	                AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
  	                if (AlarmState[Alarm_i].EventPtr)
  	                {
  	                    event__init(AlarmState[Alarm_i].EventPtr);
  	                    AlarmState[Alarm_i].EventPtr->has_type = true;
  	                    AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
  	                    AlarmState[Alarm_i].EventPtr->message = NULL;//AlarmItem[Alarm_i].EventName;
  	                }
  	                //AlarmState[Alarm_i].Status = true;
  	                PersistentEventsResponse.events[PersistentEventsResponse.n_events] = AlarmState[Alarm_i].EventPtr;
  	                PersistentEventsResponse.n_events++;
  	                ReportWithPackageFilter(AlarmFilter,"Persistent Alarm ", __FILE__,PersistentEventsResponse.n_events,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
  	            }
  	            else return;
            }
            else
            {
                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 = NULL;//AlarmItem[Alarm_i].EventName;
                            AlarmState[Alarm_i].Status = value;
                        }
                        ReportWithPackageFilter(AlarmFilter,"Alarm ON ", __FILE__,AlarmState[Alarm_i].EventPtr,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
                        if ((AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical)&&(JobIsActive()))
                        {
                            ReportWithPackageFilter(AlarmFilter, AlarmReasonStr,__FILE__,__LINE__,Alarm_i,RpError, 0,0);
                            JobEndReason = getEndReason(Alarm_i);
                            SendJobProgress(0.0,0, false, "Critical alarm!!!!");
                            AbortJob("Critical alarm");
                        }
                    }
                    else
                    {
                        ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
                        if (AlarmState[Alarm_i].EventPtr)
                        {
                            my_free(AlarmState[Alarm_i].EventPtr);
                            AlarmState[Alarm_i].EventPtr = NULL;
                        }
                        AlarmState[Alarm_i].Status = value;
                    }
                }
            }
            break;
        }
    }
}

uint32_t AlarmHandlingStart(void)
{

    //void *AlarmItemsTableptr;
    //if (EventsNotificationRequestAccepted == false)
    //    return ERROR;
    if ( AlarmHandlingActive == false)
    {
            AlarmHandlingActive = true;
            //AlarmHandlingControlId = AddControlCallback("Alarm Handling",AlarmHandling_ControlTrigger,eHundredMillisecond,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 Save_Alarm_i;
void *Save_Alarm_ptr;
EventType Save_Alarm_Type;

uint32_t AlarmHandlingLoop(uint32_t tick)
{
    int Alarm_i;
    uint32_t value;
    double doubleValue = 0.0;
/*    uint32_t valueL;
    uint32_t valueR;
    uint32_t valueN;
    uint32_t drawer_big;
    uint32_t drawer_small0;
    uint32_t drawer_small1;
    uint32_t drawer_small2;
    uint32_t drawer_small3;
*/






    //int32_t ivalue;
    bool Status = false;
    if (AlarmItem == NULL)
        return ERROR;
    int AlarmCounter=0;
    if (MotorConfiguredTimeout)
        MotorConfiguredTimeout--;

    for (Alarm_i = 0;Alarm_i < NumOfSystemAlarms;Alarm_i++)
    {
        Status = false;
        if (AlarmItem[Alarm_i].AlarmSource > ALARM_SOURCE_TYPE__FluidLevelAlarm)
            continue;
        AlarmCounter++;
        switch (AlarmItem[Alarm_i].AlarmSource)
        {
            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
                {
                    Status = 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)
                {
                    Status =  AlarmState[Alarm_i].Status;
                }
                else
                {
                    Status = 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)
                    {
                        if (AlarmState[Alarm_i].Status == false)
                            ReportWithPackageFilter(AlarmFilter,"Pressure Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,AlarmItem[Alarm_i].EventType, RpMessage, value, 0);
                        Status = true;
                    }
                }
                else
                {
                    if (value <= AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                break;
            case ALARM_SOURCE_TYPE__CurrentAlarm:
                if ((CheckCurrentAlarms)&&(getIdleState()==false))
                 {
                    if (AlarmItem[Alarm_i].ModuleDeviceId == 0xFF)
                    {
                        if (LoadHeaterSetPoint(HEATER_TYPE__DryerAirHeater) <= 2)
                        {
                            Status = false;
                        }
                        else
                        {
                            if (Get_Heaters_Current_float(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
                            {
                                if (AlarmItem[Alarm_i].AlarmDirection == true)
                                {
                                    if (doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit))
                                    {
                                        Status = true;
                                        //if (AlarmState[Alarm_i].Status == false)
                                        //    ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                    }
                                    if ((doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit))&&(isHeaterReady(AlarmItem[Alarm_i].DeviceId)==false)&&(doubleValue>100))
                                    {
                                        Status = true;
                                        //if (AlarmState[Alarm_i].Status == false)
                                        //    ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                    }
                                }
                                else
                                {
                                    if (doubleValue <= 0.1)
                                    {
                                        Status = true;
                                        //if (AlarmState[Alarm_i].Status == false)
                                        //    ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        if (Head_Type < HEAD_TYPE_UNKNOWN_WITH_CARD) //no current alarms for old head
                        {
                            Status = false;
                        }
                        else
                        {
                            if (Get_Head_Current(AlarmItem[Alarm_i].DeviceId, &doubleValue) == OK)
                             {
                                 if (AlarmItem[Alarm_i].AlarmDirection == true)
                                 {
                                     if ((doubleValue >= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmHighLimit)) || (doubleValue <= (float)(AlarmItem[Alarm_i].AlarmValue*CurrentAlarmLowLimit))&&(doubleValue>100))
                                     {
                                         Status = true;
                                         if (AlarmState[Alarm_i].Status == false)
                                         {
                                             //usnprintf(AlarmReasonStr, 100, "OverCurrent Alarm %d ON dev %d debounce %d/%d value %d",AlarmItem[Alarm_i].EventType,AlarmItem[Alarm_i].DeviceId,AlarmState[Alarm_i].DebounceCounter,AlarmItem[Alarm_i].DebounceValue,(int)(doubleValue*100));
                                             //ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                            // ReportWithPackageFilter(AlarmFilter,"OverCurrent Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                         }
                                     }
                                 }
                                 else
                                 {
                                     if (doubleValue <= 0.1)
                                     {
                                         Status = true;
                                         if (AlarmState[Alarm_i].Status == false)
                                         {
                                             //usnprintf(AlarmReasonStr, 100, "LOOP BREAK Alarm %d ON dev %d debounce %d/%d value %d",AlarmItem[Alarm_i].EventType,AlarmItem[Alarm_i].DeviceId,AlarmState[Alarm_i].DebounceCounter,AlarmItem[Alarm_i].DebounceValue,(int)(doubleValue*100));
                                             //ReportWithPackageFilter(AlarmFilter,AlarmReasonStr, __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                            // ReportWithPackageFilter(AlarmFilter,"loop break Alarm ON ", __FILE__,AlarmItem[Alarm_i].DeviceId,(int)(AlarmItem[Alarm_i].AlarmValue*100), RpMessage, (int)(doubleValue*100), 0);
                                         }
                                     }
                                 }

                             }
                        }
                    }
                 }
                 else
                 {
                     Status = false;
                 }
                 break;
            case ALARM_SOURCE_TYPE__MotorAlarm:
                if (CheckMotorAlarms)
                {
                    if ((FPGA_WD_Occurred == true)||(MotorConfiguredTimeout > 0))
                    {
                        Status = false;
                    }
                    else if (isMotorConfigured((TimerMotors_t)AlarmItem[Alarm_i].DeviceId) == false)
                    {
                        Status = false;
                    }
                    else if (AlarmItem[Alarm_i].DeviceId == HARDWARE_MOTOR_TYPE__MOTO_SCREW)
                    {
                        Status = false;
                    }
                    else
                    {
                        switch (AlarmItem[Alarm_i].AlarmValue)
                        {
                            case 1:
                                Status = MotorGetOverCurrentStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
                                if (Status == true)
                                   Report("------Overcurrent on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
                                break;
                            case 2:
                                Status = MotorGetUnderVoltageStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
                                if (Status == true)
                                   Report("------Undervoltage on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
                                break;
                            case 3:
                                Status = MotorGetStallStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
                                if (Status == true)
                                   Report("------Stall on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
                                break;
                            case 4:
                                Status = MotorGetOverHeatStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
                                if (Status == true)
                                   Report("------Overtemperature on motor------", __FILE__,__LINE__,AlarmItem[Alarm_i].DeviceId, RpMessage, AlarmItem[Alarm_i].EventType, 0);
                                break;
                            default:
                                Status = false;
                        }
                    }
                }
                else
                    Status = false;
                break;
            case ALARM_SOURCE_TYPE__FluidLevelAlarm:
                Status = false;
                if (isDispenserInConfig(AlarmItem[Alarm_i].DeviceId) == false)
                    break;
                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Warning)
                    FluidLevelWarning = AlarmItem[Alarm_i].AlarmValue;
                else if ((AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error)&&(AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE))
                    FluidLevelError = AlarmItem[Alarm_i].AlarmValue;
                value = Get_MidTank_Int1000_Sensor(AlarmItem[Alarm_i].DeviceId);
                if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE)
                {
                    if (value > AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                else
                {
                    if (value < AlarmItem[Alarm_i].AlarmValue)
                    {
                        if (
                            ((AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Warning)&&(value > FluidLevelError))||
                            (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Error)
                           )
                        Status = true;
                    }
                }
                break;

            case ALARM_SOURCE_TYPE__TachoAlarm: // add by shai
                Status = false;
                if (CheckMotorAlarms)
                {

//                ReportWithPackageFilter(AlarmFilter,"------------FANS_RPM[Alarm_i]----------------", __FILE__,__LINE__,Alarm_i, RpMessage, value, 0);
                    switch (AlarmItem[Alarm_i].DeviceId)
                    {
                        case MACHINE_FANS:
                            if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
                            {
                                value = getSystemFansStatus();
/*                                valueR = value & MASKSYSTEMRIGHT;
                                valueL = value & MASKSYSTEMLEFT;
                                valueN = value & MASKSYSTEMnotUSED;


                                if (valueR)
                                      ReportWithPackageFilter(AlarmFilter,"----------- Right FAN System is not connected----------------", __FILE__,__LINE__,valueR, RpMessage, value, 0);
                                else
                                      ReportWithPackageFilter(AlarmFilter,"----------- Right FAN System is connected----------------", __FILE__,__LINE__,valueR, RpMessage, value, 0);
                                if (valueL)
                                      ReportWithPackageFilter(AlarmFilter,"----------- Left FAN System is not connected----------------", __FILE__,__LINE__,valueL, RpMessage, value, 0);
                                else
                                      ReportWithPackageFilter(AlarmFilter,"----------- Left FAN System is connected----------------", __FILE__,__LINE__,valueL, RpMessage, value, 0);
                                if (valueN)
                                      ReportWithPackageFilter(AlarmFilter,"----------- middle FAN System is not connected----------------", __FILE__,__LINE__,valueN, RpMessage, value, 0);
                                else
                                      ReportWithPackageFilter(AlarmFilter,"----------- middle FAN System is connected----------------", __FILE__,__LINE__,valueN, RpMessage, value, 0);
*/
                                if ((value & MASKSYSTEMMIDDLE) >  MACHINE_FANS_STOP)
                                {
                                    Status = true;
                                }
                            }
                            break;
                        case ELECTRICAL_CABINET_FANS:
                            if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
                            {
                                value = getDrawerFansStatus();
/*                                drawer_big    = value & MASKDRYERBIG;
                                drawer_small0 = value & MASKDRYERSMALL0;
                                drawer_small1 = value & MASKDRYERSMALL1;
                                drawer_small2 = value & MASKDRYERSMALL2;
                                drawer_small3 = value & MASKDRYERSMALL3;

                                if (drawer_big)
                                    ReportWithPackageFilter(AlarmFilter,"----------- drawer_big FAN is not connected----------------", __FILE__,__LINE__,drawer_big, RpMessage, value, 0);
                                else
                                    ReportWithPackageFilter(AlarmFilter,"----------- drawer_big FAN is connected----------------", __FILE__,__LINE__,drawer_big, RpMessage, value, 0);

                                if (drawer_small0)
                                    ReportWithPackageFilter(AlarmFilter,"----------- drawer_small0 is not connected----------------", __FILE__,__LINE__,drawer_small0, RpMessage, value, 0);
                                else
                                    ReportWithPackageFilter(AlarmFilter,"----------- drawer_small0 is connected----------------", __FILE__,__LINE__,drawer_small0, RpMessage, value, 0);
                                if (drawer_small1)
                                    ReportWithPackageFilter(AlarmFilter,"----------- drawer_small1  is not connected----------------", __FILE__,__LINE__,drawer_small1, RpMessage, value, 0);
                                else
                                    ReportWithPackageFilter(AlarmFilter,"----------- drawer_small1  is connected----------------", __FILE__,__LINE__,drawer_small1, RpMessage, value, 0);
                                if (drawer_small2)
                                    ReportWithPackageFilter(AlarmFilter,"----------- drawer_small2 is not connected----------------", __FILE__,__LINE__,drawer_small2, RpMessage, value, 0);
                                else
                                    ReportWithPackageFilter(AlarmFilter,"----------- drawer_small2 is connected----------------", __FILE__,__LINE__,drawer_small2, RpMessage, value, 0);
                               if (drawer_small3)
                                    ReportWithPackageFilter(AlarmFilter,"----------- drawer_small3 is not connected----------------", __FILE__,__LINE__,drawer_small3, RpMessage, value, 0);
                               else
                                    ReportWithPackageFilter(AlarmFilter,"----------- drawer_small3  is connected----------------", __FILE__,__LINE__,drawer_small3, RpMessage, value, 0);
                                    */
                               if (AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE)
                               {
                                   if (value > 0)
                                   {
                                       Status = true;
                                   }
                               }
                            }
                            else if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Warning )
                            {
                            //    ReportWithPackageFilter(AlarmFilter,"----------- need to add read RPM from fan----------------", __FILE__,__LINE__,drawer_big, RpMessage, value, 0);
                            }
                            break;
                        case DRYER_FAN :
							if (IsDryerStopped()==STOP)
                            {
                                Status = false;
                                //ReportWithPackageFilter(AlarmFilter,"----------- DRYER_FAN skip-----------", __FILE__,IsDryerStopped(),Alarm_i, RpMessage, Status, 0);
                            }
                            else
                            {

                                value = Get_Dryer_Fan_Tacho();
                                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
                                {
                                    if (value == DRYER_FAN_STOP)
                                    {
                                        Status = true;
                                    }
                                    //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM ----------------", __FILE__,__LINE__,msec_millisecondCounter, RpMessage, value, 0);
                                }
                                else if (AlarmItem[Alarm_i].Severity ==  DEBUG_LOG_CATEGORY__Warning)
                                {
                                    if ((value>0)&&(value < DRYER_FAN_MIN_RPM))
                                    {
                                        Status = true;
                                        //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
                                    }
                                }
                             //ReportWithPackageFilter(AlarmFilter,"----------- DRYER_FAN----------------", __FILE__,value,Alarm_i, RpMessage, Status, 0);
                            }
                            break;
                        default:

		                    //ReportWithPackageFilter(AlarmFilter,"------------FANS_RPM[Alarm_i]----------------", __FILE__,__LINE__,Alarm_i, RpMessage, value, 0);
                            if (AlarmItem[Alarm_i].DeviceId >= WHS_FAN_1 )
                            {
                                value = WHS_Get_fan_tach(AlarmItem[Alarm_i].DeviceId - WHS_FAN_1+1);
                                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
                                    if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value == DRYER_FAN_STOP))
                                    {
                                        Status = true;
                                        //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
                                    }
                                else if (AlarmItem[Alarm_i].Severity ==  DEBUG_LOG_CATEGORY__Warning)
                                {
                                    if ((AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE) && (value < DRYER_FAN_MIN_RPM))
                                    {
                                        Status = true;
                                        //ReportWithPackageFilter(AlarmFilter,"----------- DRYER FAN RPM Error----------------", __FILE__,__LINE__,0, RpMessage, value, 0);
                                    }
                                }
                                if (AlarmItem[Alarm_i].Severity == DEBUG_LOG_CATEGORY__Critical )
                                {
                                    if (AlarmItem[Alarm_i].AlarmDirection == UNDER_VALUE)
                                    {
                                        if (value < AlarmItem[Alarm_i].AlarmValue)
                                        {
                                            Status = true;
                                        }
                                    }
                                }
                            }
                            else
                                Status = false;
                            break;
                    }
                }
                break;
            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
            {
                // report the alarm!
                AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
                if (AlarmState[Alarm_i].EventPtr)
                {
                    event__init(AlarmState[Alarm_i].EventPtr);
                    AlarmState[Alarm_i].EventPtr->has_type = true;
                    AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
                    AlarmState[Alarm_i].EventPtr->message = NULL;//AlarmItem[Alarm_i].EventName;
                }
                AlarmState[Alarm_i].Status = true;
                AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity);
                ReportWithPackageFilter(AlarmFilter,"Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
            }
            else // alarm off
            {
                ReportWithPackageFilter(AlarmFilter,"Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i);
                if (AlarmState[Alarm_i].EventPtr)
                {
                    //ROM_IntMasterDisable();
                    Save_Alarm_i = Alarm_i;
                    Save_Alarm_ptr = AlarmState[Alarm_i].EventPtr;
                    Save_Alarm_Type = AlarmItem[Alarm_i].EventType;
                    my_free(AlarmState[Alarm_i].EventPtr);
                    AlarmState[Alarm_i].EventPtr = NULL;
                    //ROM_IntMasterEnable();
                }
                AlarmState[Alarm_i].Status = false;
                AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info);
            }
        }
    }
    //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*5) == 0)&&(AlarmCounter == 0))
        ReportWithPackageFilter(AlarmFilter,"Error in alarms data!!!!!!!!! ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpFatalError, 0, Alarm_i);

    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 EventsResponse = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
int LargeMessagesAH = 0;
void SendEventNotifications(void)
{
    MessageContainer responseContainer;
    int total_events_number = 0;
    //StartEventsNotificationResponse EventsResponse = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
    int i,e=0;

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

    EventsResponse.n_events = 0;
    //UInt Key = Task_disable();
    for (i = 0;i<NumOfSystemAlarms;i++)
    {
        if (AlarmState[i].Status == true)
        {
            EventsResponse.n_events++;
            if ((AlarmState[i].EventPtr == NULL) ||(AlarmState[i].EventPtr->base.descriptor->sizeof_message != 24))
            {
                LOG_ERROR(i,"bad pointer for event");
                EventsResponse.n_events--;
                AlarmState[i].Status = false;
            }
        }
    }

    total_events_number = PersistentEventsResponse.n_events + EventsResponse.n_events;
    if (PersistentEventsResponse.n_events)
        ReportWithPackageFilter(AlarmFilter,"PersistentEventsResponse found", __FILE__,PersistentEventsResponse.n_events,EventsResponse.n_events, RpMessage, total_events_number, 0);

    if (total_events_number)
    {
        EventsResponse.events = (Event **)my_malloc(sizeof(Event*)*total_events_number);
        if(EventsResponse.events)
        {
            for (i = 0;i<NumOfSystemAlarms;i++)
            {
                if (AlarmState[i].Status == true)
                {
                    if (AlarmState[i].EventPtr)
                    {
                        EventsResponse.events[e]=AlarmState[i].EventPtr;
                        e++;
                        if (e >  EventsResponse.n_events)
                        {
                            ReportWithPackageFilter(AlarmFilter,"Error in alarm numbers - large ", __FILE__,__LINE__,EventsResponse.n_events, RpFatalError, e, 0);
                            break;
                        }
                    }
                }
            }
            if (e!=EventsResponse.n_events)
            {
                ReportWithPackageFilter(AlarmFilter,"Error in alarm numbers - small ", __FILE__,__LINE__,EventsResponse.n_events, RpFatalError, e, 0);
                EventsResponse.n_events = e;
            }
            for (i = 0;i<PersistentEventsResponse.n_events;i++)
            {
                EventsResponse.events[e]=PersistentEventsResponse.events[i];
                e++;
            }
            if (e!=total_events_number)
            {
                ReportWithPackageFilter(AlarmFilter,"Error in alarm numbers  ", __FILE__,total_events_number,EventsResponse.n_events, RpFatalError, e, 0);
            }
            EventsResponse.n_events = e;
        }
        else
        {
            LOG_ERROR(EventsResponse.n_events,"events malloc error");
            //Task_restore(Key);
            return;
        }
    }
    else
    {
        EventsResponse.events = NULL;
    }
    //Task_restore(Key);
    responseContainer = createAllocatedContainer(MESSAGE_TYPE__StartEventsNotificationResponse,  AlarmHandlingToken, false, &EventsResponse, &start_events_notification_response__pack, &start_events_notification_response__get_packed_size,&alarm_response_buffer);
    responseContainer.has_continuous = true;
    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);
        }
    }
    else
        AlarmHandlingStop();
    if (EventsResponse.events)
        my_free(EventsResponse.events);
    if (PersistentEventsResponse.n_events)
    {
        for (i = 0;i<PersistentEventsResponse.n_events;i++)
            my_free(PersistentEventsResponse.events[i]);
        my_free(PersistentEventsResponse.events);
        PersistentEventsResponse.events = NULL;
        PersistentEventsResponse.n_events = 0;
    }

    //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();
    MessageContainer responseContainer;

    StartEventsNotificationResponse response = START_EVENTS_NOTIFICATION_RESPONSE__INIT;

    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);

    responseContainer = createContainer(MESSAGE_TYPE__StartEventsNotificationResponse,  AlarmHandlingToken, false, &response, &start_events_notification_response__pack, &start_events_notification_response__get_packed_size);
    responseContainer.has_continuous = true;
    responseContainer.continuous = true;
    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 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;

}
generated by cgit v1.3.1 (git 2.54.0) at 2026-07-26 03:13:49 +0000