Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c


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
pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */<UserControl x:Class="Tango.PPC.Jobs.Views.MainView"
             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:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:vm="clr-namespace:Tango.PPC.Jobs.ViewModels"
             xmlns:views="clr-namespace:Tango.PPC.Jobs.Views"
             xmlns:global="clr-namespace:Tango.PPC.Jobs"
             xmlns:local="clr-namespace:Tango.PPC.Jobs.Views"
             xmlns:controls="clr-namespace:Tango.SharedUI.Controls;assembly=Tango.SharedUI"
             mc:Ignorable="d" 
             d:DesignHeight="1280" d:DesignWidth="800" d:DataContext="{d:DesignInstance Type=vm:MainViewVM, IsDesignTimeCreatable=False}" DataContext="{x:Static global:ViewModelLocator.MainViewVM}">
    <Grid>
        <controls:NavigationControl TransitionType="Slide" TransitionDuration="00:00:0.2" KeepElementsAttached="True">
            <views:JobsView />
            <views:JobSummeryView />
            <views:JobView />
            <views:JobEurekaView />
            <views:TwineCatalogView />
            <views:JobProgressView />
        </controls:NavigationControl>
    </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/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 EventType;
    uint16_t AlarmValue;
    uint8_t AlarmSource;
    uint8_t DeviceId;
    uint8_t ModuleDeviceId;
    uint8_t Severity;
    uint8_t DebounceValue;
    bool isPersistent;
    bool AlarmDirection;
}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;

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

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();
                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].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].Severity =        AlarmParametersTable->alarmitem[i]->severity;
                    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+1);
            return JOB_OUT_OF_DYE;
        case ALARM_SOURCE_TYPE__PressureAlarm:
            usnprintf(AlarmReasonStr, 100, "Over pressure in dispenser %d",AlarmItem[AlarmId].DeviceId+1);
            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+1);
            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;
    }

    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;
                    }
                }
            }
    }
    for (Alarm_i = 0;Alarm_i<NumOfSystemAlarms;Alarm_i++)
    {
        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:
                    //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;

}