aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/PPC/Tango.PPC.UI/Dialogs/TechnicianModeLoginView.xaml
blob: 24a5416ba3fb3083f401321c75ed48763c78afd4 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<UserControl x:Class="Tango.PPC.UI.Dialogs.TechnicianModeLoginView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
              xmlns:local="clr-namespace:Tango.PPC.UI.Dialogs"
             xmlns:touch="clr-namespace:Tango.Touch.Controls;assembly=Tango.Touch"
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d" 
             Background="{StaticResource TangoPrimaryBackgroundBrush}"  d:DesignHeight="555" d:DesignWidth="560" Width="600" Height="250" d:DataContext="{d:DesignInstance Type=local:TechnicianModeLoginViewVM, IsDesignTimeCreatable=False}">

    <UserControl.InputBindings>
        <KeyBinding Key="Return" Command="{Binding OKCommand}"></KeyBinding>
    </UserControl.InputBindings>

    <Grid Margin="10">
        <DockPanel>
            <StackPanel DockPanel.Dock="Bottom" HorizontalAlignment="Right" Orientation="Horizontal">
                <touch:TouchButton Command="{Binding CloseCommand}" Style="{StaticResource TangoMessageBoxButton}" DockPanel.Dock="Right" Width="120" Height="50" VerticalAlignment="Bottom">CANCEL</touch:TouchButton>
                <touch:TouchButton Command="{Binding OKCommand}" Style="{StaticResource TangoMessageBoxButton}" DockPanel.Dock="Right" Width="120" Height="50" VerticalAlignment="Bottom">OK</touch:TouchButton>
            </StackPanel>
            <DockPanel>
                <Image Source="/Images/technician-mode.png" Stretch="Uniform" VerticalAlignment="Top" Height="70"></Image>
                <StackPanel Margin="10 0 0 0">
                    <TextBlock FontSize="{StaticResource TangoHeaderFontSize}">Technician Mode</TextBlock>
                    <TextBlock Margin="0 10 0 0" TextWrapping="Wrap">Please enter the technician mode password.</TextBlock>
                    <touch:TouchTextBox x:Name="txtPassword" KeyboardAction="Go" Margin="0 30 40 0" IsPassword="True" Text="{Binding Password,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}" />
                </StackPanel>
            </DockPanel>
        </DockPanel>
    </Grid>
</UserControl>
/*
 * 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/SSI_Comm/SSI_Comm.h>
#include <inc/hw_ints.h>

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

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

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

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

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

#include "StateMachines/Printing/PrintingSTM.h"

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

Task_Handle AlarmHandling_Task_Handle;
Mailbox_Handle          AlarmHandlingMsgQ = NULL;

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

uint8_t alarm_response_buffer[500];

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

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

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

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

/*#define FLASH_MAP _Pragma("location = MOTOR_MAP_IN_FLASH")*/
/*
* Use this pragma directive to specify the location�the absolute address�of the global
* or static variable whose declaration follows the pragma directive (only if using it without #define for example: #pragma location = MOTOR_MAP_IN_FLASH)
* The variables must be declared either __no_init or const!
*/
AlarmHandlingItemStruc  *AlarmItem;
const AlarmHandlingItemStruc  HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={
 {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY,"Dispenser 1 Empty"},
 {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY,"Dispenser 2 Empty"},
 {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY,"Dispenser 3 Empty"},
 {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_4_EMPTY,"Dispenser 4 Empty"},
 {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_5_EMPTY,"Dispenser 5 Empty"},
 {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_6_EMPTY,"Dispenser 6 Empty"},
 {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_7_EMPTY,"Dispenser 7 Empty"},
 {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_8_EMPTY,"Dispenser 8 Empty"},
 {eOneSecond,PressureAlarm,0,0,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_1_OVERPRESSURE,"Dispenser 1 Over Pressure"},
 {eOneSecond,PressureAlarm,1,1,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_2_OVERPRESSURE,"Dispenser 2 Over Pressure"},
 {eOneSecond,PressureAlarm,2,2,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_3_OVERPRESSURE,"Dispenser 3 Over Pressure"},
 {eOneSecond,PressureAlarm,3,3,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_4_OVERPRESSURE,"Dispenser 4 Over Pressure"},
 {eOneSecond,PressureAlarm,4,4,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_5_OVERPRESSURE,"Dispenser 5 Over Pressure"},
 {eOneSecond,PressureAlarm,5,5,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_6_OVERPRESSURE,"Dispenser 6 Over Pressure"},
 {eOneSecond,PressureAlarm,6,6,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_7_OVERPRESSURE,"Dispenser 7 Over Pressure"},
 {eOneSecond,PressureAlarm,7,7,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_8_OVERPRESSURE,"Dispenser 8 Over Pressure"},
 {eOneSecond,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,"MotorDryerOverCurrent"},
 {eOneSecond,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,"MotorFeederOverCurrent"},
 {eOneSecond,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,"MotorScrewOverCurrent"},
 {eOneSecond,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,"MotorWinderOverCurrent"},
 {eOneSecond,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,"MotorPoolerOverCurrent"},
 {eOneSecond,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,"MotorDispenser1OverCurrent"},
 {eOneSecond,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,"MotorDispenser2OverCurrent"},
 {eOneSecond,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,"MotorDispenser3OverCurrent"},
 {eOneSecond,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,"MotorDispenser4OverCurrent"},
 {eOneSecond,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,"MotorDispenser5OverCurrent"},
 {eOneSecond,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,"MotorDispenser6OverCurrent"},
 {eOneSecond,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,"MotorDispenser7OverCurrent"},
 {eOneSecond,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,"MotorDispenser8OverCurrent"},
 {eOneSecond,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,"MotorDryerOverTemperature"},
 {eOneSecond,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,"MotorFeederOverTemperature"},
 {eOneSecond,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,"MotorScrewOverTemperature"},
 {eOneSecond,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,"MotorWinderOverTemperature"},
 {eOneSecond,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,"MotorPoolerOverTemperature"},
 {eOneSecond,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,"MotorDispenser1OverTemperature"},
 {eOneSecond,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,"MotorDispenser2OverTemperature"},
 {eOneSecond,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,"MotorDispenser3OverTemperature"},
 {eOneSecond,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,"MotorDispenser4OverTemperature"},
 {eOneSecond,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,"MotorDispenser5OverTemperature"},
 {eOneSecond,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,"MotorDispenser6OverTemperature"},
 {eOneSecond,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,"MotorDispenser7OverTemperature"},
 {eOneSecond,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,"MotorDispenser8OverTemperature"},
 {eOneSecond,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,"MotorDryerUnderVoltage"},
 {eOneSecond,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,"MotorFeederUnderVoltage"},
 {eOneSecond,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,"MotorScrewUnderVoltage"},
 {eOneSecond,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,"MotorWinderUnderVoltage"},
 {eOneSecond,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,"MotorPoolerUnderVoltage"},
 {eOneSecond,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,"MotorDispenser1UnderVoltage"},
 {eOneSecond,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,"MotorDispenser2UnderVoltage"},
 {eOneSecond,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,"MotorDispenser3UnderVoltage"},
 {eOneSecond,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,"MotorDispenser4UnderVoltage"},
 {eOneSecond,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,"MotorDispenser5UnderVoltage"},
 {eOneSecond,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,"MotorDispenser6UnderVoltage"},
 {eOneSecond,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,"MotorDispenser7UnderVoltage"},
 {eOneSecond,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,"MotorDispenser8UnderVoltage"},
 {eOneSecond,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,"MotorDryerStall"},
 {eOneSecond,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,"MotorFeederStall"},
 {eOneSecond,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,"MotorScrewStall"},
 {eOneSecond,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,"MotorWinderStall"},
 {eOneSecond,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,"MotorPoolerStall"},
 {eOneSecond,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,"MotorDispenser1Stall"},
 {eOneSecond,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,"MotorDispenser2Stall"},
 {eOneSecond,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,"MotorDispenser3Stall"},
 {eOneSecond,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,"MotorDispenser4Stall"},
 {eOneSecond,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,"MotorDispenser5Stall"},
 {eOneSecond,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,"MotorDispenser6Stall"},
 {eOneSecond,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,"MotorDispenser7Stall"},
 {eOneSecond,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,"MotorDispenser8Stall"},
 {eHundredMillisecond,TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE,"Mixer Over Temperature"},
 {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,"DyeingHead1 Over Temperature"},
 {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,"DyeingHead2 Over Temperature"},
 {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,"DyeingHead3 Over Temperature"},
 {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,"DyeingHead4 Over Temperature"},
 {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,"DyeingHead5 Over Temperature"},
 {eHundredMillisecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,"DyeingHead6 Over Temperature"},
 {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,"Dryer Over Temperature"},

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

 {eOneSecond,TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"},
 {eOneSecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"},
 {eOneSecond,TemperatureAlarm,MIXER_PT100,   HARDWARE_PID_CONTROL_TYPE__MixerHeater        ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,"DyeingHead 1 PT100 Heating Failure"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,"DyeingHead 2 PT100 Heating Failure"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,"DyeingHead 3 PT100 Heating Failure"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,"DyeingHead 4 PT100 Heating Failure"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,"DyeingHead 5 PT100 Heating Failure"},
 {eOneSecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6       ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,"DyeingHead 6 PT100 Heating Failure"},
 {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,  HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,"Dryer PT100 Heating Failure"},
 { eOneSecond, 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                         ," MotorRightLoaderOverCurrent "                },                                           /* 3004 */
 { eOneSecond, 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                          ," MotorLeftLoaderOverCurrent  "                },                                           /* 3006 */
 { eOneSecond, 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                          ," MotorLoadindARMOverCurrent  "                },                                           /* 3009 */
 { eOneSecond, 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*/                       ," MotorWinderDancerOverCurrent    "            },   /* 3036 */
 { eOneSecond, 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*/                       ," MotorPullerDancerOverCurrent    "            },   /* 3037 */
 { eOneSecond, 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*/                       ," MotorFeederDancerOverCurrent    "            },   /* 3038 */
 { eOneSecond, 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*/                           ," MotorDryerLidOverCurrent    "                },   /* 4017 */
 { eOneSecond, 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                    ," MotorDyeingHeadCoverOverCurrent "            },                                       /* 5031 */
 { eOneSecond, 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       ," MotorDyeingHeadCleaningMechanismOverCurrent "},                                       /* 5035 */
 { eOneSecond, 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            ," MotorDyeingHeadCleaningHeadOverCurrent  "    },                                       /* 5039 */

 { eOneSecond, 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                     ," MotorRightLoaderOverTemperature "            },                                           /* 3011 */
 { eOneSecond, 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                      ," MotorLeftLoaderOverTemperature  "            },                                           /* 3013 */
 { eOneSecond, 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                      ," MotorLoadArmOverTemperature "                },                                           /* 3016 */
 { eOneSecond, 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                    ," MotorWinderDancerOverTemperature    "        },                                           /* 3039 */
 { eOneSecond, 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                    ," MotorPullerDancerOverTemperature    "        },                                           /* 3040 */
 { eOneSecond, 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                    ," MotorFeederDancerOverTemperature    "        },                                           /* 3041 */
 { eOneSecond, 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                        ," MotorDryerLidOverTemperature    "            },                                           /* 4018 */
 { eOneSecond, 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                ," MotorDyeingHeadCoverOverTemperature "        },                                           /* 5032 */
 { eOneSecond, 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   ," MotorDyeingHeadCleaningOverTemperature  "    },                                           /* 5036 */
 { eOneSecond, 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        ," MotorDyeingHeadCleaningHeadOverTemperature  "},                                           /* 5040 */

 { eOneSecond, 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                                ," MotorLoadingARMStall     "                   },                                           /* 3018 */
 { eOneSecond, 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                              ," MotorWinderDancesStall  "                    },                                           /* 3020 */
 { eOneSecond, 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                                ," MotorLoadingARMStall     "                   },                                           /* 3023 */
 { eOneSecond, 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                              ," MotorWinderDancesStall  "                    },                                           /* 3042 */
 { eOneSecond, 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                              ," MotorPullerDancerStall  "                    },                                           /* 3043 */
 { eOneSecond, 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                              ," MotorFeederDancerStall  "                    },                                           /* 3044 */
 { eOneSecond, 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                                  ," MotorDryerLidStall  "                        },                                           /* 4019 */
 { eOneSecond, 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                          ," MotorDyeingHeadCoverStall   "                },                                           /* 5033 */
 { eOneSecond, 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             ," MotorDyeingHeadCleaningMechanismStall   "    },                                           /* 5037 */
 { eOneSecond, 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                  ," MotorDryeingHeadCleaningStall   "            },                                           /* 5041 */

 { eOneSecond, 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                        ," MotorRightLoaderUnderVoltage "               },                                           /* 3025 */
 { eOneSecond, 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                         ," MotorLeftLoaderUnderVoltage "                },                                           /* 3027 */
 { eOneSecond, 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                         ," MotorLoaderARMUnderVoltage  "                },                                           /* 3030 */
 { eOneSecond, 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                       ," MotorWinderDancerUnderVoltage   "            },                                           /* 3045 */
 { eOneSecond, 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                       ," MotorPullerDancerUnderVoltage   "            },                                           /* 3046 */
 { eOneSecond, 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                       ," MotorFeederDancerUnderVoltage   "            },                                           /* 3047 */
 { eOneSecond, 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                           ," MotorDryerLidUnderVoltage   "                },                                           /* 4020 */
 { eOneSecond, 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                   ," MotorDyeingHeadCoverUnderVoltage    "        },                                           /* 5034 */
 { eOneSecond, 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                ," MotorDyeingHeadCleaningUnderVoltage "        },                                           /* 5038 */
 { eOneSecond, 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           ," MotorDyeingHeadCleaningHeadUnderVoltage "    },                                           /* 5042 */

// { eOneSecond, CurrentAlarm, HEAD_ZONE_1  , HEAD_ZONE_1  , 312         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE           ," Head Zone 1 Heater Current Out Of Range "    },                                           /* 5018 */
// { eOneSecond, CurrentAlarm, HEAD_ZONE_2    , HEAD_ZONE_2    , 187         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE           ," Head Zone 2 Heater Current Out Of Range "    },                                           /* 5019 */
// { eOneSecond, CurrentAlarm, HEAD_ZONE_3    , HEAD_ZONE_3    , 187         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE           ," Head Zone 3 Heater Current Out Of Range "    },                                           /* 5020 */
// { eOneSecond, CurrentAlarm, HEAD_ZONE_4    , HEAD_ZONE_4    , 312         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE           ," Head Zone 4 Heater Current Out Of Range "    },                                           /* 5021 */
// { eOneSecond, CurrentAlarm, HEAD_ZONE_5_6    , HEAD_ZONE_5_6    , 312         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE         ," Head Zone 5-6 Heater Current Out Of Range "    },                                           /* 5022 */
// { eOneSecond, CurrentAlarm, MIXCHIP        , MIXCHIP        , 187         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE                        ," Mixer Heater Current Out Of Range "    },                                           /* 6004 */
// { eOneSecond, CurrentAlarm, DRYER_CURRENT_1, DRYER_CURRENT_1, 1         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE         ," Drier Heater 1 Current Out Of Range "    },                                           /* 6004 */
// { eOneSecond, CurrentAlarm, DRYER_CURRENT_2, DRYER_CURRENT_2, 1         , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE         ," Drier Heater 2 Current Out Of Range "    },                                           /* 6004 */
// {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF,"Dyeing head Thermal Cut-Off"},

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

 {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_1_OVERPRESSURE,"Dispenser 1 OverPressure"},
 {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_2_OVERPRESSURE,"Dispenser 2 OverPressure"},
 {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_3_OVERPRESSURE,"Dispenser 3 OverPressure"},
 {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_4_OVERPRESSURE,"Dispenser 4 OverPressure"},
 {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_5_OVERPRESSURE,"Dispenser 5 OverPressure"},
 {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_6_OVERPRESSURE,"Dispenser 6 OverPressure"},
 {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE,"Dispenser 7 OverPressure"},
 {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE,"Dispenser 8 OverPressure"},

 {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DRYER_DOOR_OPEN,"Dryer Door is open"},
 {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__NO_AIR_PRESSURE,"No suction in the waste handling system"},
 {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__AIR_FILTER_NOT_INSTALLED,"Air filter missing"},
};

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

bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false};
bool EventsNotificationRequestAccepted = false;
//read dispensers limit switches. 25 - send warning. up - stop job and send alarm
//Cone missing
//Dyeing head over temperature
//mixer over temperature
//dryer over temperature
//heaters failure
//dispenser pressure
//valve OCD
//Motor Status
//machine cover open
void AlarmHandlingInit(void)
{
    Error_Block eb;

    Error_init(&eb);

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

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

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

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

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

        break;

    case DEBUG_LOG_CATEGORY__Info:
    default:
        //do nothing
        break;

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

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

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

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


    return OK;
}
void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value)
{
    AlarmHandlingMessageStruc Message;

    //send message to the Millisec task
    Message.messageId = AlarmHandlingAlarm;
    Message.AlarmId = AlarmId;
    Message.Value = value;
    if (AlarmHandlingMsgQ != NULL)
        Mailbox_post(AlarmHandlingMsgQ , &Message, BIOS_NO_WAIT);
}
void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value)
{
    int Alarm_i;
    for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
    {
        if (AlarmItem[Alarm_i].EventType == AlarmId)
        {
            if (AlarmState[Alarm_i].Status != value)
            {
                AlarmState[Alarm_i].Status = value;
                if (value == true)
                {
                    // no need to call consequent actionsAlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity);
                    // report the alarm!
                    AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
                    if (AlarmState[Alarm_i].EventPtr)
                    {
                        event__init(AlarmState[Alarm_i].EventPtr);
                        AlarmState[Alarm_i].EventPtr->has_type = true;
                        AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
                        AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName;
                        Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
                    }
                }
                else
                {
                    Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
                    if (AlarmState[Alarm_i].EventPtr)
                        my_free(AlarmState[Alarm_i].EventPtr);
                }
            }
            break;
        }
    }
}

uint32_t AlarmHandlingStart(void)
{

    //void *AlarmItemsTableptr;
    //if (EventsNotificationRequestAccepted == false)
    //    return ERROR;
    if ( AlarmHandlingActive == false)
    {
            AlarmHandlingActive = true;
            AlarmHandlingControlId = AddControlCallback(AlarmHandling_ControlTrigger,eTenMillisecond,TemplateDataReadCBFunction,0,0,0);
    }
    return OK;
}
uint32_t AlarmHandlingStop(void)
{
    if ( AlarmHandlingActive == true)
    {
        AlarmHandlingActive = false;
        if (AlarmHandlingControlId != 0xFF)
            RemoveControlCallback(AlarmHandlingControlId,AlarmHandling_ControlTrigger);

        AlarmHandlingControlId = 0xFF;
    }
    return OK;
}

uint32_t AlarmHandlingLoop(uint32_t tick)
{
    int Alarm_i;
    uint32_t value;
    //int32_t ivalue;
    bool Status = false;
    for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++)
    {
        Status = false;
        if (tick%AlarmItem[Alarm_i].Frequency == 0)
        {
            switch (AlarmItem[Alarm_i].AlarmSource)
            {
            /*case TemperatureAlarm:
                ivalue = TemperatureSensorRead((TEMPERATURE_SENSOR_ID_ENUM)AlarmItem[Alarm_i].DeviceId);
                if (AlarmItem[Alarm_i].AlarmDirection == true)
                {
                    if (ivalue/100 >= AlarmItem[Alarm_i].AlarmValue)
                    {
                        //LOG_ERROR (ivalue/100,"Temperature spike");
                        Status = true;
                    }
                }
                else
                {
                    if (ivalue/100 <= AlarmItem[Alarm_i].AlarmValue)
                    {
                        //LOG_ERROR (ivalue/100,"iTemperature spike");
                        Status = true;
                    }
                }
                break;*/
            case CoversAlarm:
                value = Get_COVER_1_State(AlarmItem[Alarm_i].DeviceId);
                if (value == AlarmItem[Alarm_i].AlarmValue)
                {
                    Status = true;
                }
                break;
            case LimitSwitchAlarm:
                value = IDS_CheckDispenserLimitSwitch((LimitSwitchAlarms)AlarmItem[Alarm_i].DeviceId);
                if (value == AlarmItem[Alarm_i].AlarmValue)
                {
                    Status = true;
                }
                break;
            case PressureAlarm:
                value = GetDispenserPressure(AlarmItem[Alarm_i].DeviceId);
                if (AlarmItem[Alarm_i].AlarmDirection == true)
                {
                    if (value >= AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                else
                {
                    if (value <= AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                break;
            case CurrentAlarm:
                value = Get_Heaters_Current_Integer(AlarmItem[Alarm_i].DeviceId);
                if (AlarmItem[Alarm_i].AlarmDirection == true)
                {
                    if (value >= AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                else
                {
                    if (value <= AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                break;
            case MotorAlarm:
                if (isMotorConfigured((TimerMotors_t)AlarmItem[Alarm_i].DeviceId) == false)
                {
                    Status = false;
                    break;
                }
                value = MotorGetStatus((TimerMotors_t)AlarmItem[Alarm_i].DeviceId);
                if (AlarmItem[Alarm_i].AlarmDirection == true)
                {
                    if (value && AlarmItem[Alarm_i].AlarmValue)
                    {
                        Status = true;
                    }
                }
                else
                {
                    if ((value && AlarmItem[Alarm_i].AlarmValue)==false)
                    {
                        Status = true;
                    }
                }
                break;
            case TemperatureAlarm:
            case DoNotPollAlarm:
                Status =  AlarmState[Alarm_i].Status;
                break;
            default:
                break;
            } //switch
            if (AlarmItem[Alarm_i].DebounceValue > 0) //handle debouncing
            {
                if (Status == true) //increase counter
                {
                    AlarmState[Alarm_i].DebounceCounter++;
                    if (AlarmState[Alarm_i].Status == false) // alarm is not set yet
                    {
                        if (AlarmState[Alarm_i].DebounceCounter < AlarmItem[Alarm_i].DebounceValue) //had not reached the debounce value
                        {
                            Status = false; //do not set the alarm
                        } //else alarm will be set
                    }
                    else // alarm is already set
                    {
                        AlarmState[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue; // do not go over the debounce value
                    }
                }
                else //status  == false - decrease counter
                {
                    AlarmState[Alarm_i].DebounceCounter--;
                    if (AlarmState[Alarm_i].Status == true) // alarm is set
                    {
                        if (AlarmState[Alarm_i].DebounceCounter > 0) // had not reached zero yet
                        {
                            Status = true; // do not reset the alarm yet
                        }   // else reset the alarm
                    }
                    else // if the alarm is off
                    {
                        AlarmState[Alarm_i].DebounceCounter = 0; //do not go below 0
                    }
                }
            }
            if (AlarmItem[Alarm_i].Predecessor!=0xFF)
            {
                if (AlarmState[AlarmItem[Alarm_i].Predecessor].Status == true)  //higher hierarchy alarm is on
                    Status = false;
            }
            if (Status !=  AlarmState[Alarm_i].Status) //change in alarm Status
            {
                if (Status == true) // alarm on
                {
                    AlarmState[Alarm_i].Status = true;
                    AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity);
                    // report the alarm!
                    AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event));
                    if (AlarmState[Alarm_i].EventPtr)
                    {
                        event__init(AlarmState[Alarm_i].EventPtr);
                        AlarmState[Alarm_i].EventPtr->has_type = true;
                        AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
                        AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName;
                    }
                    Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
                }
                else // alarm off
                {
                    AlarmState[Alarm_i].Status = false;
                    AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info);
                    // report the alarm!
                    if (AlarmState[Alarm_i].EventPtr)
                        my_free(AlarmState[Alarm_i].EventPtr);
                    Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i);
                }
            }
        }
    }
    //read dispensers limit switches. 25 - send warning. up - stop job and send alarm
    //Cone missing
    //Dyeing head over temperature
    //mixer over temperature
    //dryer over temperature
    //heaters failure
    //dispenser pressure
    //valve OCD
    //Motor Status
    //machine cover open

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

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

    response.n_events = 0;

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

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

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

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

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

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

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

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

    MessageContainer responseContainer;

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

    StopEventsNotificationResponse response = STOP_EVENTS_NOTIFICATION_RESPONSE__INIT;

    //AlarmHandlingStop();

    EventsNotificationRequestAccepted = false;

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

return OK;
}