/* * AlarmHandling.c * * Created on: 24 may 2018 * Author: shlomo */ #include "include.h" #include "Modules/General/GeneralHardware.h" #include "AlarmHandling.h" #include #include #include #include #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 #include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h" #include #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 #include #include #include #include #include #include #include #include #include #include #include #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=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=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_ihas_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;ibase.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 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;idata.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; }