From 860105b29a85031b0fbdc4feb6fa71483e9b76f1 Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Mon, 10 Dec 2018 16:40:34 +0200 Subject: Screw operation logs for debug --- Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) (limited to 'Software/Embedded_SW/Embedded/Modules/Thread') diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c index eafe9e5a0..4f7b747e7 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c @@ -174,6 +174,7 @@ InternalWinderCfg.segmentoffsetpulses numOfSteps = InternalWinderCfg.startoffsetpulses*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep; */ +char ScrewStr[100]; uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) { uint32_t Steps,i,winderspeed=0; @@ -233,8 +234,12 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) temp /= ScrewSpeed; if (ScrewRunningTime != temp) { + usnprintf(ScrewStr, 254, "Winder: Steps,Speed, Time, WinderSpeed{ %d, %d ,%d, %d} ",ScrewNumberOfSteps,ScrewSpeed,temp,WinderReferenceSpeed); + // Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index, Counter[index]); + // #warning PID is now only proportional (above) + Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0); //LOG_ERROR(temp , "new winder speed"); - Report("new winder speed",__FILE__,__LINE__,temp,RpWarning,ScrewSpeed,0); + //Report("new winder speed",__FILE__,__LINE__,temp,RpWarning,ScrewSpeed,0); } ScrewRunningTime = temp;//(SYS_CLK_FREQ*Steps)/ScrewSpeed; -- cgit v1.3.1 From fc23da7f3510cce58308841eefb96d59868317ff Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Mon, 17 Dec 2018 09:41:17 +0200 Subject: Version 1.3.0.2 Reset Cause in log, remove some logs, improve memory on alarm handling. stop heaters and dispensers on alarm without job. split microsecond and control tasks to high and low priorities. Heaters PID with multiplications - use with new CFG. --- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- .../Embedded_SW/Embedded/Common/Utilities/Utils.c | 2 +- .../Embedded/Common/report/reportInit.c | 14 +- .../Embedded/Communication/CommunicationTask.c | 19 +- .../Embedded_SW/Embedded/Communication/Container.c | 31 +- .../Embedded_SW/Embedded/Drivers/Valves/Valve.c | 4 +- Software/Embedded_SW/Embedded/Embedded.cfg | 140 ++++---- .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 376 ++++++++++++--------- .../Embedded/Modules/Control/MillisecTask.c | 82 ++++- .../Embedded_SW/Embedded/Modules/Control/control.c | 91 ++++- .../Embedded/Modules/Diagnostics/Diagnostics.c | 4 +- .../Embedded/Modules/Heaters/Heaters_ex.h | 2 + .../Embedded/Modules/Heaters/Heaters_print.c | 61 +++- Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h | 1 + .../Embedded_SW/Embedded/Modules/IDS/IDS_maint.c | 10 + .../Embedded_SW/Embedded/Modules/IDS/IDS_print.c | 15 +- .../Embedded/Modules/Thread/Thread_Winder.c | 12 +- .../Embedded/Modules/Thread/Thread_print.c | 12 +- .../Embedded/StateMachines/Printing/JobSTM.c | 1 + .../Embedded/StateMachines/Printing/PrintingSTM.h | 2 +- 20 files changed, 571 insertions(+), 310 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules/Thread') diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index 2da8581c0..9749b7e71 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {001,002,002,000}; +TangoVersion_t _gTangoVersion = {001,003,000,002}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c index 686bf9157..4dd705dc6 100644 --- a/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c +++ b/Software/Embedded_SW/Embedded/Common/Utilities/Utils.c @@ -16,7 +16,7 @@ static const float speedCoef = 5.3051647697298445256294587790838f;//(200 micro s //***************************************************************************** -#define MAX_MEM_LOG 300 +#define MAX_MEM_LOG 100 int freeIndex=0,malloc_index=0; uint32_t malloc_size[MAX_MEM_LOG+1]; uint32_t malloc_time[MAX_MEM_LOG+1]; diff --git a/Software/Embedded_SW/Embedded/Common/report/reportInit.c b/Software/Embedded_SW/Embedded/Common/report/reportInit.c index 825c23082..850228ec9 100644 --- a/Software/Embedded_SW/Embedded/Common/report/reportInit.c +++ b/Software/Embedded_SW/Embedded/Common/report/reportInit.c @@ -168,7 +168,19 @@ uint32_t ReportInitMessage(MessageContainer* requestContainer) if (ReportHandle == NULL) status |= 0x8; status |= ReportFunc(ReportResponseFunc , REPORT_ADD, ReportHandle); start_debug_log_request__free_unpacked(request,NULL); - LOG_ERROR(127,"test"); + /* + #define SYSCTL_CAUSE_HSRVREQ 0x00001000 // Hardware System Service Request + #define SYSCTL_CAUSE_HIB 0x00000040 // Hibernate reset + #define SYSCTL_CAUSE_WDOG1 0x00000020 // Watchdog 1 reset + #define SYSCTL_CAUSE_SW 0x00000010 // Software reset + #define SYSCTL_CAUSE_WDOG0 0x00000008 // Watchdog 0 reset + #define SYSCTL_CAUSE_BOR 0x00000004 // Brown-out reset + #define SYSCTL_CAUSE_POR 0x00000002 // Power on reset + #define SYSCTL_CAUSE_EXT 0x00000001 // External reset + */ + uint32_t RESC = SysCtlResetCauseGet (); + LOG_ERROR(RESC,"Reset Reason Register"); + SysCtlResetCauseClear(RESC); return status; } uint32_t StopReportInitMessage(MessageContainer* requestContainer) diff --git a/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c b/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c index 9711cebb3..7175bc602 100644 --- a/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c +++ b/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c @@ -219,20 +219,21 @@ void communicationTxTask(UArg arg0, UArg arg1) { Mailbox_pend(CommunicationTxMsgQ , &Message, BIOS_WAIT_FOREVER); UnSentMessages--; - /*switch (Message.messageId) + if ( Message.msgSize > COMM_MAX_BUFFER_SIZE) + { + LOG_ERROR(Message.msgSize , "message too long"); + } + else { - case 1:*/ if (CommType == isUSB) USBCDCD_sendData(Message.Buff, Message.msgSize,10); else if (CommType == isUART) Uart_Tx(Message.Buff, Message.msgSize); - if (diagnosticscontainer_buffer == Message.Buff) - diagnosticscontainer_buffer = 0; - my_free(Message.Buff); - /*break; - default: - break; - }*/ + } + if (diagnosticscontainer_buffer == Message.Buff) + diagnosticscontainer_buffer = 0; + my_free(Message.Buff); + SysCtlDelay(40000); //wait one millisecond between messages } } diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c index 4329f2eeb..8543f0493 100644 --- a/Software/Embedded_SW/Embedded/Communication/Container.c +++ b/Software/Embedded_SW/Embedded/Communication/Container.c @@ -45,17 +45,18 @@ #include "Common/report/report.h" #include "Connection.h" -#define MAX_CONT_LOG 500 +#define MAX_CONT_LOG 100 uint16_t TxmsgId[MAX_CONT_LOG+1] = {0}; uint16_t TxLength[MAX_CONT_LOG+1] = {0}; uint32_t TxAddr[MAX_CONT_LOG+1] = {0}; uint16_t Txindex = 0; -/*uint32_t msgId[50] = {0}; -uint32_t Length[50] = {0}; -uint32_t DataLength[50] = {0}; +uint32_t msgId[MAX_CONT_LOG+1] = {0}; +uint32_t Length[MAX_CONT_LOG+1] = {0}; +uint32_t DataLength[MAX_CONT_LOG+1] = {0}; byte index = 0; -*/ + + MessageContainer createContainer(MessageType type, char* token, protobuf_c_boolean completed, void* response, size_t (*packPtr)(void*, uint8_t*), size_t (*sizePtr)(void*)) { MessageContainer container = MESSAGE_CONTAINER__INIT; @@ -75,13 +76,7 @@ MessageContainer createContainer(MessageType type, char* token, protobuf_c_boole container.data.data = response_buffer; container.data.len = response_size; - /*TxmsgId[Txindex] = type; - TxLength[Txindex] = response_size; - TxAddr[Txindex] = response_buffer; - if (Txindex++>=MAX_CONT_LOG) - Txindex = 0;*/ - - if (SuspendLargeMessages == true) + // if (SuspendLargeMessages == true) { // Report("EndJobMessage",__FILE__,__LINE__,(int)type,RpWarning,(int)response_size,0); TxmsgId[Txindex] = type; @@ -103,11 +98,11 @@ void receive_callback(char* buffer, size_t length) return; // HeatingTestSendResonse(0, false,true,true, /*OriginalMotorSpd_2PPS[index]*/length,requestContainer->type,0,0, "Container"); -/* msgId[index] = requestContainer->type; + msgId[index] = requestContainer->type; Length[index] = length; DataLength[index] = requestContainer->data.len; - if (index++>=50) - index = 0;*/ + if (index++>=MAX_CONT_LOG) + index = 0; REPORT_MSG(requestContainer->type,"Message received"); switch(requestContainer->type) { @@ -379,8 +374,12 @@ void receive_callback(char* buffer, size_t length) message_container__free_unpacked(requestContainer, NULL); } +bool SendResult,KeepSendResult = true; bool SendChars(char* buffer,size_t length) { - return CommunicationTaskSendMessage(buffer, length); + SendResult = CommunicationTaskSendMessage(buffer, length); + if (SendResult == false) + KeepSendResult = false; + return SendResult; } diff --git a/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c b/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c index 39d010375..77cf0f80b 100644 --- a/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c +++ b/Software/Embedded_SW/Embedded/Drivers/Valves/Valve.c @@ -342,7 +342,7 @@ uint32_t Valve3WayCallBackFunction(uint32_t IfIndex, uint32_t BusyFlag) //stop this control loop if (RemoveControlCallback(Valve3WayControlId[ValveId], Valve3WayCallBackFunction )==OK) { - Report("Remove control callback",__FILE__,__LINE__,(int)ValveId,RpWarning,(int)Valve3WayControlId[ValveId],0); + //Report("Remove control callback",__FILE__,__LINE__,(int)ValveId,RpWarning,(int)Valve3WayControlId[ValveId],0); Valve3WayControlId[ValveId] = 0xFF; } else @@ -369,7 +369,7 @@ uint32_t Control3WayValvesWithCallback (Valves_t _ValveId, bool direction, callb if (Valve3WayControlId[_ValveId] == 0xFF) Report("Add control callback failed",__FILE__,__LINE__,(int)_ValveId,RpWarning,(int)Valve3WayControlId[_ValveId],0); else - Report("Add control callback",__FILE__,__LINE__,(int)_ValveId,RpWarning,(int)Valve3WayControlId[_ValveId],0); + //Report("Add control callback",__FILE__,__LINE__,(int)_ValveId,RpWarning,(int)Valve3WayControlId[_ValveId],0); EnableDisableDispenserValve(_ValveId, ENABLE); diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg index 6ba47d133..4f2dfa09c 100644 --- a/Software/Embedded_SW/Embedded/Embedded.cfg +++ b/Software/Embedded_SW/Embedded/Embedded.cfg @@ -17,7 +17,7 @@ var Task = xdc.useModule('ti.sysbios.knl.Task'); BIOS.heapSize = 30767; // bios heapmem //Memory.defaultHeapSize = 48767; -Program.heap = 50000; //sysmem +Program.heap = 40000; //sysmem Clock.timerId = 7; @@ -109,74 +109,76 @@ Program.global.ReconnectSem = Semaphore.create(null, semaphore7Params); // deleteFxn: '&myDeleteFxn', switchFxn: '&mySwitchFxn' });*/ -var task8Params = new Task.Params(); -task8Params.instance.name = "MilliSecond"; -task8Params.stackSize = 2048; -task8Params.priority = 12; -Program.global.millisec = Task.create("&MillisecTask", task8Params); - -var task7Params = new Task.Params(); -task7Params.instance.name = "control"; -task7Params.stackSize = 2048; -task7Params.priority = 11; -Program.global.control = Task.create("&controlTask", task7Params); - -var task2Params = new Task.Params(); -task2Params.instance.name = "communication"; -task2Params.priority = 10; -task2Params.stackSize = 8192; -Program.global.communication = Task.create("&communicationTask", task2Params); - -var task9Params = new Task.Params(); -task9Params.instance.name = "HeatersControl"; -task9Params.priority = 9; -Program.global.HeatersControl = Task.create("&HeatersControlTask", task9Params); - -var task5Params = new Task.Params(); -task5Params.instance.name = "process"; -task5Params.stackSize = 2048; -task5Params.priority = 8; -Program.global.process = Task.create("&jobTask", task5Params); -/* -var task8Params = new Task.Params(); -task8Params.instance.name = "MilliSecondLow"; -task8Params.stackSize = 2048; -task8Params.priority = 7; -Program.global.millisec = Task.create("&MillisecTask", task8Params); - -var task7Params = new Task.Params(); -task7Params.instance.name = "controlLow"; -task7Params.stackSize = 2048; -task7Params.priority = 7; -Program.global.control = Task.create("&controlTask", task7Params); -*/ -var task10Params = new Task.Params(); -task10Params.instance.name = "communicationTx"; -task10Params.priority = 7; -Program.global.communicationTx = Task.create("&communicationTxTask", task10Params); - -var task12Params = new Task.Params(); -task12Params.instance.name = "AlarmHandling"; -task12Params.stackSize = 1024; -task12Params.priority = 6; -Program.global.AlarmHandling = Task.create("&AlarmHandlingTask", task12Params); - -var task0Params = new Task.Params(); -task0Params.instance.name = "adcProcess"; -task0Params.stackSize = 512; -task0Params.priority = 6; -Program.global.adcProcess = Task.create("&ADCProcessTask", task0Params); - -var task11Params = new Task.Params(); -task11Params.instance.name = "Diagnostics"; -task11Params.priority = 3; -task11Params.stackSize = 8192; -Program.global.Diagnostics = Task.create("&DiagnosticsTask", task11Params); - -var task6Params = new Task.Params(); -task6Params.instance.name = "report"; -task6Params.priority = 3; -Program.global.report = Task.create("&reportService", task6Params); + +var MillisecTaskParams = new Task.Params(); +MillisecTaskParams.instance.name = "MilliSecond"; +MillisecTaskParams.stackSize = 2048; +MillisecTaskParams.priority = 12; +Program.global.millisec = Task.create("&MillisecTask", MillisecTaskParams); + +var ControlTaskParams = new Task.Params(); +ControlTaskParams.instance.name = "control"; +ControlTaskParams.stackSize = 2048; +ControlTaskParams.priority = 11; +Program.global.control = Task.create("&controlTask", ControlTaskParams); + +var CommRxTaskParams = new Task.Params(); +CommRxTaskParams.instance.name = "communication"; +CommRxTaskParams.priority = 10; +CommRxTaskParams.stackSize = 8192; +Program.global.communication = Task.create("&communicationTask", CommRxTaskParams); + +var HeaterControlTaskParams = new Task.Params(); +HeaterControlTaskParams.instance.name = "HeatersControl"; +HeaterControlTaskParams.priority = 9; +Program.global.HeatersControl = Task.create("&HeatersControlTask", HeaterControlTaskParams); + +var ProcessTaskParams = new Task.Params(); +ProcessTaskParams.instance.name = "process"; +ProcessTaskParams.stackSize = 2048; +ProcessTaskParams.priority = 8; +Program.global.process = Task.create("&jobTask", ProcessTaskParams); + +var CommTxTaskParams = new Task.Params(); +CommTxTaskParams.instance.name = "communicationTx"; +CommTxTaskParams.priority = 7; +CommTxTaskParams.stackSize = 4096; +Program.global.communicationTx = Task.create("&communicationTxTask", CommTxTaskParams); + +var AlarmHandlingTaskParams = new Task.Params(); +AlarmHandlingTaskParams.instance.name = "AlarmHandling"; +AlarmHandlingTaskParams.stackSize = 1024; +AlarmHandlingTaskParams.priority = 6; +Program.global.AlarmHandling = Task.create("&AlarmHandlingTask", AlarmHandlingTaskParams); + +var MillisecLowTaskParams = new Task.Params(); +MillisecLowTaskParams.instance.name = "MilliSecondLow"; +MillisecLowTaskParams.stackSize = 2048; +MillisecLowTaskParams.priority = 5; +Program.global.millisecLow = Task.create("&MillisecLowTask", MillisecLowTaskParams); + +var ControlLowTaskParams = new Task.Params(); +ControlLowTaskParams.instance.name = "controlLow"; +ControlLowTaskParams.stackSize = 2048; +ControlLowTaskParams.priority = 5; +Program.global.controlLow = Task.create("&controlLowTask", ControlLowTaskParams); + +var DiagnosticsTaskParams = new Task.Params(); +DiagnosticsTaskParams.instance.name = "Diagnostics"; +DiagnosticsTaskParams.priority = 4; +DiagnosticsTaskParams.stackSize = 8192; +Program.global.Diagnostics = Task.create("&DiagnosticsTask", DiagnosticsTaskParams); + +var ADCProcessTaskParams = new Task.Params(); +ADCProcessTaskParams.instance.name = "adcProcess"; +ADCProcessTaskParams.stackSize = 512; +ADCProcessTaskParams.priority = 3; +Program.global.adcProcess = Task.create("&ADCProcessTask", ADCProcessTaskParams); + +var ReportTaskParams = new Task.Params(); +ReportTaskParams.instance.name = "report"; +ReportTaskParams.priority = 3; +Program.global.report = Task.create("&reportService", ReportTaskParams); var updateTaskParams = new Task.Params(); updateTaskParams.instance.name = "update"; diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index b5c586b92..0e9ed5e8e 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -89,141 +89,113 @@ typedef struct uint16_t Frequency; //1/10/100/1000 AlarmSource AlarmSource; uint16_t DeviceId; - uint32_t AlarmValue; + uint8_t ModuleDeviceId; + uint16_t AlarmValue; bool AlarmDirection; DebugLogCategory Severity; uint16_t Predecessor; uint8_t DebounceValue; - int8_t DebounceCounter; - bool Status; EventType EventType; - Event *EventPtr; char *EventName; }AlarmHandlingItem; -AlarmHandlingItem AlarmItem[MAX_SYSTEM_ALARMS]={ -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser1Empty,NULL,"Dispenser1Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser2Empty,NULL,"Dispenser2Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser3Empty,NULL,"Dispenser3Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser4Empty,NULL,"Dispenser4Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser5Empty,NULL,"Dispenser5Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser6Empty,NULL,"Dispenser6Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser7Empty,NULL,"Dispenser7Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser8Empty,NULL,"Dispenser8Empty"}, -/*{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_1,false,true,DEBUG_LOG_CATEGORY__Warning,0,0,0,false,EVENT_TYPE__Dispenser1LowLevel,NULL,"Dispenser1LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_2,false,true,DEBUG_LOG_CATEGORY__Warning,1,0,0,false,EVENT_TYPE__Dispenser2LowLevel,NULL,"Dispenser2LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_3,false,true,DEBUG_LOG_CATEGORY__Warning,2,0,0,false,EVENT_TYPE__Dispenser3LowLevel,NULL,"Dispenser3LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_4,false,true,DEBUG_LOG_CATEGORY__Warning,3,0,0,false,EVENT_TYPE__Dispenser4LowLevel,NULL,"Dispenser4LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_5,false,true,DEBUG_LOG_CATEGORY__Warning,4,0,0,false,EVENT_TYPE__Dispenser5LowLevel,NULL,"Dispenser5LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_6,false,true,DEBUG_LOG_CATEGORY__Warning,5,0,0,false,EVENT_TYPE__Dispenser6LowLevel,NULL,"Dispenser6LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_7,false,true,DEBUG_LOG_CATEGORY__Warning,6,0,0,false,EVENT_TYPE__Dispenser7LowLevel,NULL,"Dispenser7LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_8,false,true,DEBUG_LOG_CATEGORY__Warning,7,0,0,false,EVENT_TYPE__Dispenser8LowLevel,NULL,"Dispenser8LowLevel"},*/ -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"Mixer Over Temperature"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"GeneralInternal Over Temperature"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,80,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"GeneralInternal Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead1OverTemperature,NULL,"DyeingHead1 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead2OverTemperature,NULL,"DyeingHead2 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead3OverTemperature,NULL,"DyeingHead3 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead4OverTemperature,NULL,"DyeingHead4 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead5OverTemperature,NULL,"DyeingHead5 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead6OverTemperature,NULL,"DyeingHead6 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer Over Temperature"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer Over Temperature"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer Over Temperature"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"Mixer PT100 Not Working"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalPT100 Not Working,NULL,"GeneralInternalPT100 Not Working"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,80,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalPT100 Not Working,NULL,"GeneralInternalPT100 Not Working"}, -/*{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead1OverTemperature,NULL,"DyeingHead 1 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead2OverTemperature,NULL,"DyeingHead 2 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead3OverTemperature,NULL,"DyeingHead 3 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead4OverTemperature,NULL,"DyeingHead 4 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead5OverTemperature,NULL,"DyeingHead 5 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead6OverTemperature,NULL,"DyeingHead 6 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer PT100 Not Working"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer PT100 Not Working"},*/ -{eOneSecond,PressureAlarm,0,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser1Pressure,NULL,"Dispenser1Pressure"}, -{eOneSecond,PressureAlarm,1,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser2Pressure,NULL,"Dispenser2Pressure"}, -{eOneSecond,PressureAlarm,2,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser3Pressure,NULL,"Dispenser3Pressure"}, -{eOneSecond,PressureAlarm,3,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser4Pressure,NULL,"Dispenser4Pressure"}, -{eOneSecond,PressureAlarm,4,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser5Pressure,NULL,"Dispenser5Pressure"}, -{eOneSecond,PressureAlarm,5,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser6Pressure,NULL,"Dispenser6Pressure"}, -{eOneSecond,PressureAlarm,6,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser7Pressure,NULL,"Dispenser7Pressure"}, -{eOneSecond,PressureAlarm,7,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser8Pressure,NULL,"Dispenser8Pressure"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerOverCurrent,NULL,"MotorDryerOverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederOverCurrent,NULL,"MotorFeederOverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewOverCurrent,NULL,"MotorScrewOverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderOverCurrent,NULL,"MotorWinderOverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerOverCurrent,NULL,"MotorPoolerOverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1OverCurrent,NULL,"MotorDispenser1OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2OverCurrent,NULL,"MotorDispenser2OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3OverCurrent,NULL,"MotorDispenser3OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4OverCurrent,NULL,"MotorDispenser4OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5OverCurrent,NULL,"MotorDispenser5OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6OverCurrent,NULL,"MotorDispenser6OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7OverCurrent,NULL,"MotorDispenser7OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8OverCurrent,NULL,"MotorDispenser8OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerOverTemperature,NULL,"MotorDryerOverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederOverTemperature,NULL,"MotorFeederOverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewOverTemperature,NULL,"MotorScrewOverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderOverTemperature,NULL,"MotorWinderOverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerOverTemperature,NULL,"MotorPoolerOverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1OverTemperature,NULL,"MotorDispenser1OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2OverTemperature,NULL,"MotorDispenser2OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3OverTemperature,NULL,"MotorDispenser3OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4OverTemperature,NULL,"MotorDispenser4OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5OverTemperature,NULL,"MotorDispenser5OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6OverTemperature,NULL,"MotorDispenser6OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7OverTemperature,NULL,"MotorDispenser7OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8OverTemperature,NULL,"MotorDispenser8OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerUnderVoltage,NULL,"MotorDryerUnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederUnderVoltage,NULL,"MotorFeederUnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewUnderVoltage,NULL,"MotorScrewUnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderUnderVoltage,NULL,"MotorWinderUnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerUnderVoltage,NULL,"MotorPoolerUnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1UnderVoltage,NULL,"MotorDispenser1UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2UnderVoltage,NULL,"MotorDispenser2UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3UnderVoltage,NULL,"MotorDispenser3UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4UnderVoltage,NULL,"MotorDispenser4UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5UnderVoltage,NULL,"MotorDispenser5UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6UnderVoltage,NULL,"MotorDispenser6UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7UnderVoltage,NULL,"MotorDispenser7UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8UnderVoltage,NULL,"MotorDispenser8UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerStall,NULL,"MotorDryerStall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederStall,NULL,"MotorFeederStall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewStall,NULL,"MotorScrewStall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderStall,NULL,"MotorWinderStall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerStall,NULL,"MotorPoolerStall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1Stall,NULL,"MotorDispenser1Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2Stall,NULL,"MotorDispenser2Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3Stall,NULL,"MotorDispenser3Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4Stall,NULL,"MotorDispenser4Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5Stall,NULL,"MotorDispenser5Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6Stall,NULL,"MotorDispenser6Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7Stall,NULL,"MotorDispenser7Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8Stall,NULL,"MotorDispenser8Stall"}, -{eOneSecond,DoNotPollAlarm,0,0,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,0,false,EVENT_TYPE__ThreadBreak,NULL,"Thread Break"}, -{eOneSecond,DoNotPollAlarm,0,0,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,0,false,EVENT_TYPE__ThreadTensionControlFailure,NULL,"Thread Tension Control Failure"}, -}; -char TestMessage[5]="Test"; -bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false}; -/* - typedef struct +typedef struct { - uint16_t Frequency; //1/10/100/1000 - AlarmSource AlarmSource; - uint16_t DeviceId; - uint32_t AlarmValue; - bool AlarmDirection; - DebugLogCategory Severity; - uint16_t Predecessor; - uint8_t DebounceValue; int8_t DebounceCounter; bool Status; - EventType EventType; Event *EventPtr; - char *EventName; -}AlarmHandlingItem; - */ +}AlarmStatusItem; +AlarmStatusItem AlarmState[MAX_SYSTEM_ALARMS]; + +const AlarmHandlingItem AlarmItem[MAX_SYSTEM_ALARMS]={ + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser1Empty,"Dispenser1Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser2Empty,"Dispenser2Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser3Empty,"Dispenser3Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser4Empty,"Dispenser4Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser5Empty,"Dispenser5Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser6Empty,"Dispenser6Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser7Empty,"Dispenser7Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser8Empty,"Dispenser8Empty"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__GeneralInternalOverTemperature,"Mixer Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead1OverTemperature,"DyeingHead1 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead2OverTemperature,"DyeingHead2 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead3OverTemperature,"DyeingHead3 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead4OverTemperature,"DyeingHead4 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead5OverTemperature,"DyeingHead5 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead6OverTemperature,"DyeingHead6 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DryerOverTemperature,"Dryer Over Temperature"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__GeneralInternalOverTemperature,"Mixer PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead1OverTemperature,"DyeingHead 1 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead2OverTemperature,"DyeingHead 2 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead3OverTemperature,"DyeingHead 3 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead4OverTemperature,"DyeingHead 4 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead5OverTemperature,"DyeingHead 5 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead6OverTemperature,"DyeingHead 6 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DryerOverTemperature,"Dryer PT100 Not Working"}, + {eOneSecond,PressureAlarm,0,0,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser1Pressure,"Dispenser1Pressure"}, + {eOneSecond,PressureAlarm,1,1,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser2Pressure,"Dispenser2Pressure"}, + {eOneSecond,PressureAlarm,2,2,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser3Pressure,"Dispenser3Pressure"}, + {eOneSecond,PressureAlarm,3,3,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser4Pressure,"Dispenser4Pressure"}, + {eOneSecond,PressureAlarm,4,4,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser5Pressure,"Dispenser5Pressure"}, + {eOneSecond,PressureAlarm,5,5,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser6Pressure,"Dispenser6Pressure"}, + {eOneSecond,PressureAlarm,6,6,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser7Pressure,"Dispenser7Pressure"}, + {eOneSecond,PressureAlarm,7,7,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser8Pressure,"Dispenser8Pressure"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerOverCurrent,"MotorDryerOverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederOverCurrent,"MotorFeederOverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewOverCurrent,"MotorScrewOverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderOverCurrent,"MotorWinderOverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerOverCurrent,"MotorPoolerOverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1OverCurrent,"MotorDispenser1OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2OverCurrent,"MotorDispenser2OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3OverCurrent,"MotorDispenser3OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4OverCurrent,"MotorDispenser4OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5OverCurrent,"MotorDispenser5OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6OverCurrent,"MotorDispenser6OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7OverCurrent,"MotorDispenser7OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8OverCurrent,"MotorDispenser8OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerOverTemperature,"MotorDryerOverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederOverTemperature,"MotorFeederOverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewOverTemperature,"MotorScrewOverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderOverTemperature,"MotorWinderOverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerOverTemperature,"MotorPoolerOverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1OverTemperature,"MotorDispenser1OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2OverTemperature,"MotorDispenser2OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3OverTemperature,"MotorDispenser3OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4OverTemperature,"MotorDispenser4OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5OverTemperature,"MotorDispenser5OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6OverTemperature,"MotorDispenser6OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7OverTemperature,"MotorDispenser7OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8OverTemperature,"MotorDispenser8OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerUnderVoltage,"MotorDryerUnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederUnderVoltage,"MotorFeederUnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewUnderVoltage,"MotorScrewUnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderUnderVoltage,"MotorWinderUnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerUnderVoltage,"MotorPoolerUnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1UnderVoltage,"MotorDispenser1UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2UnderVoltage,"MotorDispenser2UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3UnderVoltage,"MotorDispenser3UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4UnderVoltage,"MotorDispenser4UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5UnderVoltage,"MotorDispenser5UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6UnderVoltage,"MotorDispenser6UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7UnderVoltage,"MotorDispenser7UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8UnderVoltage,"MotorDispenser8UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerStall,"MotorDryerStall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederStall,"MotorFeederStall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewStall,"MotorScrewStall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderStall,"MotorWinderStall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerStall,"MotorPoolerStall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1Stall,"MotorDispenser1Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2Stall,"MotorDispenser2Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3Stall,"MotorDispenser3Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4Stall,"MotorDispenser4Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5Stall,"MotorDispenser5Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6Stall,"MotorDispenser6Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7Stall,"MotorDispenser7Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8Stall,"MotorDispenser8Stall"}, + {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__ThreadBreak,"Thread Break"}, + {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__ThreadTensionControlFailure,"Thread Tension Control Failure"} +}; +char TestMessage[5]="Test"; +bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false}; bool EventsNotificationRequestAccepted = false; //read dispensers limit switches. 25 - send warning. up - stop job and send alarm //Cone missing @@ -243,6 +215,13 @@ void AlarmHandlingInit(void) AlarmHandlingMsgQ = Mailbox_create(sizeof(AlarmHandlingMessageStruc), 20, NULL,&eb); + int Alarm_i; + for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++) + { + AlarmState[Alarm_i].Status = false; + AlarmState[Alarm_i].DebounceCounter = 0; + AlarmState[Alarm_i].EventPtr = NULL; + } return; } JobEndReasonEnum getEndReason(uint32_t AlarmId) @@ -265,14 +244,46 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId) } uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Severity) { - switch (Severity) + //DebugLogCategory reprocessedSeverity = Severity; + //ProcessParameters ProcessParameterZero; + switch (AlarmItem[AlarmId].AlarmSource) + { + case TemperatureAlarm: + //need to discover the heater Id and shut it down + HeaterCommandRequestMessage(AlarmItem[AlarmId].ModuleDeviceId, HEATER_OFF, 0); + break; + case LimitSwitchAlarm: + IDS_StopDispenser (AlarmItem[AlarmId].ModuleDeviceId); + break; + case PressureAlarm: + IDS_StopDispenser (AlarmItem[AlarmId].ModuleDeviceId); + break; + case CurrentAlarm: + break; + case MotorAlarm: + MotorStop(AlarmItem[AlarmId].ModuleDeviceId,Hard_Hiz); + break; + default: + break; + } + /*switch (reprocessedSeverity)*/ + switch (Severity) { case DEBUG_LOG_CATEGORY__Warning: - //raise flag fr next job break; case DEBUG_LOG_CATEGORY__Critical: watchdogCriticalAlarm = true; +/* + //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()) @@ -281,7 +292,42 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever AbortJob(AlarmItem[AlarmId].EventName); Report(AlarmItem[AlarmId].EventName, __FILE__,__LINE__,AlarmId, RpMessage, DEBUG_LOG_CATEGORY__Error, 0); } -//Stop Job + /*switch (AlarmItem[AlarmId].AlarmSource) + { + case TemperatureAlarm: + //need to discover the heater Id and shut it down + // HeaterCommandRequestMessage( HARDWARE_PID_CONTROL_TYPE__MixerHeater, false, + // ProcessParams->mixertemp); + break; + case LimitSwitchAlarm: + if ((AlarmItem[AlarmId].EventType>=EVENT_TYPE__Dispenser1Empty)&&(AlarmItem[AlarmId].EventType<=EVENT_TYPE__Dispenser8Empty)) + { + Disp_i = AlarmItem[AlarmId].EventType- EVENT_TYPE__Dispenser1Empty; + MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz); + if (JobIsActive()) + { + if (DispenserInUse[Disp_i] == false) + AlarmItem[AlarmId].Severity = DEBUG_LOG_CATEGORY__Info; + } + } + break; + case PressureAlarm: + Disp_i = AlarmItem[AlarmId].EventType- EVENT_TYPE__Dispenser1Pressure; + MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz); + if (JobIsActive()) + { + if (DispenserInUse[Disp_i] == false) + AlarmItem[AlarmId].Severity = DEBUG_LOG_CATEGORY__Info; + } + break; + case CurrentAlarm: + break; + case MotorAlarm: + break; + default: + break; + }*/ + break; case DEBUG_LOG_CATEGORY__Debug: case DEBUG_LOG_CATEGORY__Info: @@ -334,7 +380,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) { if (AlarmItem[Alarm_i].EventType == (EVENT_TYPE__Dispenser1Empty+Dispenser_i)) { - if (AlarmItem[Alarm_i].Status == true) + if (AlarmState[Alarm_i].Status == true) { status = ERROR; AlarmId = Alarm_i; @@ -353,7 +399,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) { if (AlarmItem[Alarm_i].EventType == HeaterEventType[Heater_i]) { - if (AlarmItem[Alarm_i].Status == true) + if (AlarmState[Alarm_i].Status == true) { status = ERROR; AlarmId = Alarm_i; @@ -412,24 +458,24 @@ void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value) { if (AlarmItem[Alarm_i].EventType == AlarmId) { - AlarmItem[Alarm_i].Status = value; + AlarmState[Alarm_i].Status = value; if (value == true) { AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); // report the alarm! - AlarmItem[Alarm_i].EventPtr = my_malloc (sizeof(Event)); - if (AlarmItem[Alarm_i].EventPtr) + AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); + if (AlarmState[Alarm_i].EventPtr) { - event__init(AlarmItem[Alarm_i].EventPtr); - AlarmItem[Alarm_i].EventPtr->has_type = true; - AlarmItem[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; - AlarmItem[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; + event__init(AlarmState[Alarm_i].EventPtr); + AlarmState[Alarm_i].EventPtr->has_type = true; + AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; + AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; } } else { - if (AlarmItem[Alarm_i].EventPtr) - my_free(AlarmItem[Alarm_i].EventPtr); + if (AlarmState[Alarm_i].EventPtr) + my_free(AlarmState[Alarm_i].EventPtr); } break; } @@ -546,7 +592,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick) } break; case DoNotPollAlarm: - Status = AlarmItem[Alarm_i].Status; + Status = AlarmState[Alarm_i].Status; break; default: break; @@ -555,64 +601,64 @@ uint32_t AlarmHandlingLoop(uint32_t tick) { if (Status == true) //increase counter { - AlarmItem[Alarm_i].DebounceCounter++; - if (AlarmItem[Alarm_i].Status == false) // alarm is not set yet + AlarmState[Alarm_i].DebounceCounter++; + if (AlarmState[Alarm_i].Status == false) // alarm is not set yet { - if (AlarmItem[Alarm_i].DebounceCounter < AlarmItem[Alarm_i].DebounceValue) //had not reached the debounce value + 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 { - AlarmItem[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue; // do not go over the debounce value + AlarmState[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue; // do not go over the debounce value } } else //status == false - decrease counter { - AlarmItem[Alarm_i].DebounceCounter--; - if (AlarmItem[Alarm_i].Status == true) // alarm is set + AlarmState[Alarm_i].DebounceCounter--; + if (AlarmState[Alarm_i].Status == true) // alarm is set { - if (AlarmItem[Alarm_i].DebounceCounter > 0) // had not reached zero yet + 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 { - AlarmItem[Alarm_i].DebounceCounter = 0; //do not go below 0 + AlarmState[Alarm_i].DebounceCounter = 0; //do not go below 0 } } } if (AlarmItem[Alarm_i].Predecessor!=0xFF) { - if (AlarmItem[AlarmItem[Alarm_i].Predecessor].Status == true) //higher hierarchy alarm is on + if (AlarmState[AlarmItem[Alarm_i].Predecessor].Status == true) //higher hierarchy alarm is on Status = false; } - if (Status != AlarmItem[Alarm_i].Status) //change in alarm Status + if (Status != AlarmState[Alarm_i].Status) //change in alarm Status { if (Status == true) // alarm on { - AlarmItem[Alarm_i].Status = true; + AlarmState[Alarm_i].Status = true; AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); // report the alarm! - AlarmItem[Alarm_i].EventPtr = my_malloc (sizeof(Event)); - if (AlarmItem[Alarm_i].EventPtr) + AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); + if (AlarmState[Alarm_i].EventPtr) { - event__init(AlarmItem[Alarm_i].EventPtr); - AlarmItem[Alarm_i].EventPtr->has_type = true; - AlarmItem[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; - AlarmItem[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; + event__init(AlarmState[Alarm_i].EventPtr); + AlarmState[Alarm_i].EventPtr->has_type = true; + AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; + AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; } Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } else // alarm off { - AlarmItem[Alarm_i].Status = false; + AlarmState[Alarm_i].Status = false; AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info); // report the alarm! - if (AlarmItem[Alarm_i].EventPtr) - my_free(AlarmItem[Alarm_i].EventPtr); + if (AlarmState[Alarm_i].EventPtr) + my_free(AlarmState[Alarm_i].EventPtr); Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i); } } @@ -686,7 +732,7 @@ void SendEventNotifications(void) for (i = 0;itype) { - AlarmItem[Alarm_i].Status = false; - if (AlarmItem[Alarm_i].EventPtr) - my_free(AlarmItem[Alarm_i].EventPtr); + AlarmState[Alarm_i].Status = false; + if (AlarmState[Alarm_i].EventPtr) + my_free(AlarmState[Alarm_i].EventPtr); status = OK; break; } diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c index 68bd680a8..64b6ac4e0 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c @@ -90,6 +90,7 @@ MillisecMotorDataStruc SpeedSetPending[NUM_OF_MOTORS] = {0}; MillisecMotorDataStruc PT100Data[MAX_TEMPERATURE_SENSOR_ID] = {0}; /******************** GLOBAL PARAMETERS ********************************************/ Mailbox_Handle MillisecMsgQ = NULL; +Mailbox_Handle TenMillisecMsgQ = NULL; Mailbox_Handle MotorsMsgQ[NUM_OF_MOTORS] = {NULL}; bool MillisecRestart; static GateMutex_Handle gateMillisecDB; @@ -114,6 +115,7 @@ void MillisecInit(void) Error_init(&eb); MillisecMsgQ = Mailbox_create(sizeof(MillisecMessageStruc), 2, NULL,&eb); + TenMillisecMsgQ = Mailbox_create(sizeof(MillisecMessageStruc), 2, NULL,&eb); for (i=0;i= 999) + backlogindex = 0; + switch (ControlArray[Device_i].ControlTiming) + { + case eOneMillisecond: + break; case eTenMillisecond: if (Ten_msTick) { @@ -374,7 +422,17 @@ uint32_t ControlLoop(uint32_t tick) memset (&ControlArray[Device_i],0,sizeof(ControlDeviceStruc) ); break; default: - LOG_ERROR (ControlArray[Device_i].ControlTiming, "Invalid control timing value"); + if (tick%ControlArray[Device_i].ControlTiming == 0) + { + if(ControlArray[Device_i].ControlDataReadPtr) + ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1); + else + LOG_ERROR (Device_i, "Invalid callback ptr"); + if(ControlArray[Device_i].ControlCallbackPtr) + ControlArray[Device_i].ControlCallbackPtr(ControlArray[Device_i].IfIndex, ControlDatalog[Device_i]); + else + LOG_ERROR (Device_i, "Invalid callback ptr"); + } break; } //switch } //if control active @@ -410,3 +468,30 @@ void controlTask(UArg arg0, UArg arg1) } } } +/****************************************************************************** + * ======== messageTsk ======== + * Task for this function is created statically. See the project's .cfg file. + * this message task is created statically in system initialization, + ******************************************************************************/ +void controlLowTask(UArg arg0, UArg arg1) +{ + ControlMessageStruc Message; + //char str[60]; + //uint16_t length; + //Clock_setTimeout(HostKAClock, 1000); + //Clock_start(HostKAClock); + Control_Task_Handle = Task_self(); + + while(1) + { + Mailbox_pend(TenControlMsgQ , &Message, BIOS_WAIT_FOREVER); + switch (Message.messageId) + { + case OneMillisec: + ControlLowLoop(Message.tick); + break; + default: + break; + } + } +} diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c index 9c4ceb8d7..e2c572a6e 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c @@ -57,8 +57,8 @@ uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue) DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT; -#define DIAGNOSTICS_LIMIT 5 -#define DIAGNOSTICS_DANCER_LIMIT 50 +#define DIAGNOSTICS_LIMIT 3 +#define DIAGNOSTICS_DANCER_LIMIT 30 int DiagnosticsIndex = 0; int DiagnosticCollectionLimit = 2; //number of data samples to collect before sending to the host //int DiagnosticLimit = eHundredMillisecond; //frequency of data collection diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h index e5c12f7b0..482d081b0 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h @@ -20,5 +20,7 @@ bool HeaterGetOverTemperatureState(uint8_t HeaterId); void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState); +uint32_t LoadHeaterSetPoint(HeaterType HeaterType); + uint32_t HeatersEnd(void); uint32_t Heaters_Init(void); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index e12ede228..35b8ea9f7 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -113,6 +113,9 @@ void HeatersControlInit(void) { DCInitialHeating[i] = true; HeaterReady[i] = true; + HeaterCmd[i].targettemperatue = 0; + HeaterCmd[i].command = HEATER_OFF; + HeaterCmd[i].heaterid = i; } HeatersRestart = false; @@ -138,6 +141,15 @@ void HeatersControlStart(void) HeatersStartControlTimer(); } } +uint32_t LoadHeaterSetPoint(HeaterType HeaterType) +{ + if (HeaterType >= MAX_HEATERS_NUM) + { + LOG_ERROR(HeaterType,"Wrong Heater Id"); + return 0; + } + return HeaterCmd[HeaterType].targettemperatue; +} void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState) { int HeaterId = HeaterType; @@ -148,6 +160,8 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState) // HeaterState->setpoint = HeaterCmd[HeaterId].targettemperatue/100; // if (HeaterType >= HEATER_TYPE__HeaterZone1) HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse; + if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) + HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit; HeaterState->has_currentvalue = true; HeaterState->currentvalue = TemperatureSensorRead(HeaterId2PT100Id[HeaterId])/100; HeaterState->has_isactive = true; @@ -314,6 +328,7 @@ uint32_t HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature) */ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) { + CTRL_TIMING_ENUM Frequency = eHundredMillisecond; if(HeaterId >= MAX_HEATERS_NUM) { LOG_ERROR (HeaterId,"HeaterId too high"); @@ -332,6 +347,8 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) HeaterPIDConfig[HeaterId].m_params.Kd = HeaterControl[HeaterId].kd; HeaterPIDConfig[HeaterId].m_params.Kp = HeaterControl[HeaterId].kp; HeaterPIDConfig[HeaterId].m_params.Ki = HeaterControl[HeaterId].ki; + HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier = HeaterControl[HeaterId].setpointramprateorsoftstartramp; + HeaterPIDConfig[HeaterId].m_params.ProportionalErrorMultiplier = HeaterControl[HeaterId].outputonoffhysteresisvalue; HeaterPIDConfig[HeaterId].m_params.dt = HeaterControl[HeaterId].dt; HeaterPIDConfig[HeaterId].m_params.epsilon = HeaterControl[HeaterId].epsilon; //0.1 degree HeaterPIDConfig[HeaterId].m_calculatedError = 0; @@ -341,10 +358,15 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) HeaterPIDConfig[HeaterId].m_mesuredParam = 0; HeaterPIDConfig[HeaterId].m_preError = 0; HeaterPIDConfig[HeaterId].m_SetParam = SetTemperatue*100;//need to update SetParams on presegment stage + + if (HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier) + { + Frequency = eOneSecond*HeaterPIDConfig[HeaterId].m_params.dt; + } if (HeaterId >= MAX_AC_HEATERS) //DC Heaters { if (ControlIdtoHeaterId [HeaterId] == 0xFF) - ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); + ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); HeaterPIDConfig[HeaterId].m_params.dt *=10; DCInitialHeating[HeaterId] = true; HeaterReady[HeaterId] = false; @@ -353,7 +375,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) { if (ControlIdtoHeaterId [HeaterId] == 0xFF) { - ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0); + ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0); HeaterPIDConfig[HeaterId].m_params.dt *=10; } if (MainDryerHeaterMaxTempControl == 0xFF) @@ -449,7 +471,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) { if (HeaterMaxTempFlag[index] == false) { - LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off"); + // LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off"); } DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = true; @@ -468,7 +490,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) { ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); } - LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on"); + // LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on"); } HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false; HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = false; @@ -550,13 +572,20 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) } else //PID active { - //check only for the proportional band limits - HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, - &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); - len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError); + if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0) + { + HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } + else + { + HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } +// len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError); // Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index, Counter[index]); // #warning PID is now only proportional (above) - Report(ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue, HeaterPIDConfig[index].m_calculatedError); +// Report(ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue, HeaterPIDConfig[index].m_calculatedError); HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, (int)(HeaterPIDConfig[index].m_calculatedError/100)); } } @@ -647,8 +676,16 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) { //check only for the proportional band limits HeaterPIDConfig[index].m_mesuredParam = readValue; - HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0) + { + HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } + else + { + HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } // error[index][Counter[index]] = HeaterPIDConfig[index].m_preError; // integral[index][Counter[index]] = HeaterPIDConfig[index].m_integral; // output[index][Counter[index]] = HeaterPIDConfig[index].m_calculatedError; @@ -658,8 +695,8 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) // #warning PID is now only proportional (above) if (index == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2) { - len = usnprintf(heatstr, 254, "PID id, Temp, Integral, Output { %d, %d ,%d, %d}",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError); - Report(heatstr,__FILE__,__LINE__,index,RpWarning,HeaterPIDConfig[index].m_calculatedError,0); + // len = usnprintf(heatstr, 254, "PID id, Temp, Integral, Output { %d, %d ,%d, %d}",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError); + // Report(heatstr,__FILE__,__LINE__,index,RpWarning,HeaterPIDConfig[index].m_calculatedError,0); } HeaterRecalculateHeaterParams(index, (int)(HeaterPIDConfig[index].m_calculatedError/100)); diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h index 7c25fed89..1e15cc1c2 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h @@ -43,6 +43,7 @@ uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request); uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback); uint32_t IDS_StopHomeDispenser (uint32_t deviceID); uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback); +uint32_t IDS_StopDispenser (uint8_t deviceID); uint32_t IDS_CheckDispenserLimitSwitch (LimitSwitchAlarms LS_Id); diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c index e4d4c7b9c..bf03b42de 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c @@ -104,6 +104,16 @@ uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr ca } return ERROR; } +uint32_t IDS_StopDispenser (uint8_t deviceID) +{ + uint32_t status = OK; + TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID; + status |= MotorAbortMovetoLimitSwitch(MotorId); + Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_OFF); + status |= MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep); + status |= MotorStop(deviceID, Hard_Hiz); + return status; +} uint32_t IDS_StopHomeDispenser (uint32_t deviceID) { diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 9db07f271..346ee0246 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -189,8 +189,9 @@ bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int Segmen { TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; MotorStop(HW_Motor_Id,Hard_Hiz); - REPORT_MSG(deviceID,"Dispenser PreSegment called"); + //REPORT_MSG(deviceID,"Dispenser PreSegment called"); IDS_Valve_PresegmentReady( deviceID, ReadValue); + return OK; } //******************************************************************************************************************** uint32_t IDS_Valve_PresegmentReady(uint32_t deviceID, uint32_t ReadValue) @@ -253,7 +254,7 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) //prepare the SW structures DispenserId = JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->index; DispenserPreSegmentReady[DispenserId] = false; - REPORT_MSG(DispenserId,"Dispenser PreSegment Start"); + //REPORT_MSG(DispenserId,"Dispenser PreSegment Start"); } for (Dispenser_i = 0;Dispenser_i < n_dispensers;Dispenser_i++) { @@ -378,9 +379,10 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) { TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; MotorStop(HW_Motor_Id,Hard_Hiz); - REPORT_MSG(deviceID,"Dispenser DTS called"); + //REPORT_MSG(deviceID,"Dispenser DTS called"); IDS_Valve_DistanceToSpoolReady( deviceID, ReadValue); - } + return OK; +} //******************************************************************************************************************** uint32_t IDS_Valve_DistanceToSpoolReady(uint32_t deviceID, uint32_t ReadValue) @@ -421,8 +423,9 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) uint32_t IDS_Valve_EndValveReady(uint32_t deviceID, uint32_t ReadValue) { TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; - REPORT_MSG(deviceID,"Dispenser End called"); + //REPORT_MSG(deviceID,"Dispenser End called"); MotorStop(HW_Motor_Id,Hard_Hiz); + return OK; } //******************************************************************************************************************** uint32_t IDSEndState(void *JobDetails) @@ -430,10 +433,10 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) int Dispenser_i; IDS_Active = false; Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste); + REPORT_MSG(0,"Dispenser End Start"); for ( Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++) { //MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz); - REPORT_MSG(Dispenser_i,"Dispenser End Start"); Control3WayValvesWithCallback (Dispenser_i, MidTank_Dispenser, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer } diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c index 22fcf3e6f..d92e6a330 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c @@ -220,7 +220,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) winderspeed+=WinderMotorSpeed[i]; } winderspeed/=MAX_WINDER_SPEED_CALCULATION; - //LOG_ERROR(winderspeed, "WinderSpeedUpdated"); + //REPORT_MSG(winderspeed, "WinderSpeedUpdated"); Report("WinderSpeedUpdated",__FILE__,__LINE__,winderspeed,RpWarning,ScrewNumberOfSteps,0); WinderReferenceSpeed = winderspeed; @@ -238,7 +238,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) // Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index, Counter[index]); // #warning PID is now only proportional (above) Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0); - //LOG_ERROR(temp , "new winder speed"); + //REPORT_MSG(temp , "new winder speed"); //Report("new winder speed",__FILE__,__LINE__,temp,RpWarning,ScrewSpeed,0); } ScrewRunningTime = temp;//(SYS_CLK_FREQ*Steps)/ScrewSpeed; @@ -283,7 +283,7 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId) //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed); usnprintf(Message, 80, "SCREW speed Rot/sec %d horizon %d pulses %d",(int)RotationsPerSecond,(int)screw_horizontal_speed,(int)ScrewSpeed); - //LOG_ERROR(segmentfirst_speed,Message); + //REPORT_MSG(segmentfirst_speed,Message); //Report(Message,__FILE__,__LINE__,Dispenser_i,RpWarning,segmentfirst_speed,0); SendJobProgress(0.0,0,false, Message); @@ -299,11 +299,11 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId) temp *= InternalWinderCfg.segmentoffsetpulses; temp /= ScrewSpeed; ScrewRunningTime = temp;//(SYS_CLK_FREQ*InternalWinderCfg.segmentoffsetpulses)/ScrewSpeed; - LOG_ERROR(ScrewNumberOfSteps,"Winder pre segment - ScrewNumberOfSteps"); - LOG_ERROR(ScrewRunningTime,"Winder pre segment - ScrewRunningTime"); + REPORT_MSG(ScrewNumberOfSteps,"Winder pre segment - ScrewNumberOfSteps"); + REPORT_MSG(ScrewRunningTime,"Winder pre segment - ScrewRunningTime"); // MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection); //ScrewDirection = 1-ScrewDirection; - LOG_ERROR(ScrewSpeed,"Winder pre segment - ScrewSpeed"); + REPORT_MSG(ScrewSpeed,"Winder pre segment - ScrewSpeed"); //MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed); ScrewsStartControlTimer (); ScrewControlId = AddControlCallback(Screw100msecDirectionChange, eHundredMillisecond,TemplateDataReadCBFunction,0,0,0); diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c index 76c0fbfd8..0e0a9f987 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c @@ -670,7 +670,7 @@ uint32_t ThreadPreSegmentState(void *JobDetails) LOG_ERROR (dyeingspeed," job speed zero"); return ERROR; } - LOG_ERROR (dyeingspeed," ThreadPreSegmentState"); + REPORT_MSG (dyeingspeed," ThreadPreSegmentState"); SetOriginMotorSpeed(process_speed); ThreadControlActive = true; @@ -718,17 +718,17 @@ uint32_t ThreadPreSegmentState(void *JobDetails) int REPSegmentId = 0; void ThreadInterSegmentEnded(void) { - LOG_ERROR (REPSegmentId,"ThreadInterSegmentEnded"); + REPORT_MSG (REPSegmentId,"ThreadInterSegmentEnded"); PreSegmentReady(Module_Thread,ModuleDone); } void ThreadSegmentEnded(void) { - LOG_ERROR (REPSegmentId," ThreadSegmentState"); + REPORT_MSG (REPSegmentId," ThreadSegmentState"); SegmentReady(Module_Thread,ModuleDone); } void ThreadDistanceToSpoolEnded(void) { - LOG_ERROR (REPSegmentId," ThreadDistanceToSpoolEnded"); + REPORT_MSG (REPSegmentId," ThreadDistanceToSpoolEnded"); DistanceToSpoolReady(Module_Thread,ModuleDone); } double seglength = 0.0; @@ -739,7 +739,7 @@ uint32_t ThreadSegmentState(void *JobDetails, int SegmentId) REPSegmentId = SegmentId; seglength = JobTicket->segments[SegmentId]->length; CurrentSegmentId = SegmentId; - LOG_ERROR (seglength," ThreadSegmentState"); + REPORT_MSG (seglength," ThreadSegmentState"); ThreadUpdateProcessLength (seglength,(void *)ThreadSegmentEnded); return OK; } @@ -748,7 +748,7 @@ uint32_t ThreadSegmentState(void *JobDetails, int SegmentId) uint32_t ThreadDistanceToSpoolState(void ) { seglength = dryerbufferlength; - LOG_ERROR (seglength,"ThreadDistanceToSpoolState"); + REPORT_MSG (seglength,"ThreadDistanceToSpoolState"); ThreadUpdateProcessLength (seglength,(void *)ThreadDistanceToSpoolEnded); return OK; } diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c index 49a01de82..3d3cdaa3d 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c @@ -59,6 +59,7 @@ #include "./printingSTM.h" #include "modules/thread/thread_ex.h" +#include "modules/AlarmHandling/AlarmHandling.h" #include "modules/ids/ids_ex.h" #include "Modules/heaters/heaters_ex.h" #include "Modules/control/control.h" diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h index 503fbeed9..5c90bb972 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.h @@ -172,7 +172,7 @@ uint32_t PreSegmentReady(int ModuleId, ModuleStateEnum result); uint32_t SegmentReady(int ModuleId, ModuleStateEnum result); uint32_t DistanceToSpoolReady(int ModuleId, ModuleStateEnum result); uint32_t PrintingHWConfiguration(void *Configuration); -//uint32_t EndState(void *JobDetails, char *Message); +uint32_t EndState(void *JobDetails, char *Message); bool GetHeatersPrepareWaiting(void); -- cgit v1.3.1 From 5cb32e4d23885b476f34547f2bc36e4b057ead0e Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Mon, 17 Dec 2018 14:54:33 +0200 Subject: Winder bugs. improved trace, improved control (callback invoked after time requested elabsed) --- .../Embedded_SW/Embedded/Drivers/Motors/Motor.c | 2 +- .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 40 +++++++++-------- .../Embedded_SW/Embedded/Modules/Control/control.c | 34 ++++++++++++--- .../Embedded_SW/Embedded/Modules/Control/control.h | 3 +- .../Embedded/Modules/Thread/Thread_Winder.c | 50 +++++++++++++--------- 5 files changed, 83 insertions(+), 46 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules/Thread') diff --git a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c index cfba461ff..8a54526a5 100644 --- a/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c +++ b/Software/Embedded_SW/Embedded/Drivers/Motors/Motor.c @@ -392,7 +392,7 @@ uint32_t MotorMoveWithCallback (TimerMotors_t _motorId,bool direction, uint32_t MotorStop(_motorId,Hard_Hiz ); MotorMove(_motorId,direction,Steps ); - MotorMoveControlId[_motorId] = AddControlCallback( MotorMoveCallBackFunction, eTenMillisecond, MotorControlGetnBusyState,(IfTypeMotors*0x100+_motorId), _motorId, 0 ); + MotorMoveControlId[_motorId] = AddControlCallback( MotorMoveCallBackFunction, /*eTenMillisecond*/20, MotorControlGetnBusyState,(IfTypeMotors*0x100+_motorId), _motorId, 0 ); return MotorMoveControlId[_motorId]; } diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 0e9ed5e8e..35f12dd50 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -372,38 +372,44 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) }//if dispensers }//for brush }//for segments - for (Dispenser_i=0;Dispenser_i= 999) + backlogindex = 0; + + if(ControlArray[Device_i].ControlDataReadPtr) + ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1); + else + LOG_ERROR (Device_i, "Invalid callback ptr"); + if(ControlArray[Device_i].ControlCallbackPtr) + ControlArray[Device_i].ControlCallbackPtr(ControlArray[Device_i].IfIndex, ControlDatalog[Device_i]); + else + LOG_ERROR (Device_i, "Invalid callback ptr"); + } + /* ControlBacklog[backlogindex]=Device_i; if ( ++backlogindex >= 999) backlogindex = 0; @@ -422,8 +442,10 @@ uint32_t ControlLowLoop(uint32_t tick) memset (&ControlArray[Device_i],0,sizeof(ControlDeviceStruc) ); break; default: + //LOG_ERROR(tick, "Default Timing checked"); if (tick%ControlArray[Device_i].ControlTiming == 0) { + Report("Default Timing checked",__FILE__,__LINE__,tick,RpWarning,ControlArray[Device_i].ControlTiming,0); if(ControlArray[Device_i].ControlDataReadPtr) ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1); else @@ -434,7 +456,7 @@ uint32_t ControlLowLoop(uint32_t tick) LOG_ERROR (Device_i, "Invalid callback ptr"); } break; - } //switch + } //switch*/ } //if control active } //for //ROM_IntMasterEnable(); diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.h b/Software/Embedded_SW/Embedded/Modules/Control/control.h index 0aba4b4ba..b3e574d2a 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.h +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h @@ -37,10 +37,11 @@ typedef enum void ControlInit(void); void ControlStop(void); void ControlStart(void); -uint32_t AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint32_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ); +uint32_t AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ); int RemoveControlCallback(uint32_t deviceId, ControlCBFunction Callback ); uint32_t TemplateDataReadCBFunction (uint32_t deviceId, uint32_t Parameter1); extern Task_Handle Control_Task_Handle; +extern uint32_t millisecondCounter; #endif diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c index d92e6a330..2b6d3aaea 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c @@ -124,7 +124,7 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue) //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,InternalWinderCfg.segmentoffsetpulses); //REPORT_MSG(numOfSteps, "Winder_PrepareStage2"); - REPORT_MSG(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency, "Winder_PrepareStage2"); + REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2"); status |= MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_SCREW, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize),numOfSteps, Winder_ScrewAtOffsetCallback); //set motor location 0 here @@ -141,7 +141,7 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag) ScrewSpeed = 0; ScrewControlId = 0xFF; ScrewNumberOfSteps = 0; - REPORT_MSG(BusyFlag, "Winder_ScrewAtOffsetCallback"); + REPORT_MSG(millisecondCounter, "Winder_ScrewAtOffsetCallback"); MotorStop (HARDWARE_MOTOR_TYPE__MOTO_SCREW,Soft_Hiz); //per L6470 errata between mov and run commands PrepareReady(Module_Winder, ModuleDone); return OK; @@ -175,15 +175,20 @@ InternalWinderCfg.segmentoffsetpulses numOfSteps = InternalWinderCfg.startoffsetpulses*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep; */ char ScrewStr[100]; +//char TempScrewStr[100]; +double WinderReferenceSpeed=0; +int32_t TotalWinderSpeed=0; uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) { - uint32_t Steps,i,winderspeed=0; + uint32_t Steps,i; double temp; - uint32_t WinderReferenceSpeed = OriginalMotorSpd_2PPS[WINDER_MOTOR]; - float screw_horizontal_speed = 0; - float RotationsPerSecond; + double screw_horizontal_speed = 0; + double RotationsPerSecond; + int32_t Averagewinderspeed = 0; + TotalWinderSpeed-=WinderMotorSpeed[WinderMotorSpeedCounter]; WinderMotorSpeed[WinderMotorSpeedCounter] = CurrentControlledSpeed[WINDER_MOTOR]; + TotalWinderSpeed+=WinderMotorSpeed[WinderMotorSpeedCounter]; if (WinderMotorSpeedCounter++>=MAX_WINDER_SPEED_CALCULATION) { WinderMotorSpeedCounter=0; @@ -215,18 +220,18 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) } if (WinderMotorSpeedRollOver) { - for (i=0;i Date: Thu, 20 Dec 2018 15:07:17 +0200 Subject: Version 1.3.0.5: break sensor debounce (10 msec default). temperature spikes ignored in heating control. thread winding improved. --- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- .../Embedded_SW/Embedded/Modules/Heaters/Heaters.h | 1 - .../Embedded/Modules/Heaters/Heaters_print.c | 31 +++++++-- .../Embedded/Modules/Thread/Thread_Winder.c | 9 ++- .../Embedded/Modules/Thread/Thread_ex.h | 2 +- .../Embedded/Modules/Thread/Thread_init.c | 9 ++- .../Embedded/Modules/Thread/Thread_print.c | 80 ++++++++++++---------- .../Embedded/StateMachines/Printing/PrintingSTM.c | 2 +- 8 files changed, 86 insertions(+), 50 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules/Thread') diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index e416f25d5..2e588a5e1 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {001,003,000,004}; +TangoVersion_t _gTangoVersion = {001,003,000,005}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h index 7d0a94cbb..601f5ce31 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h @@ -54,7 +54,6 @@ extern HeaterCommand HeaterCmd[MAX_HEATERS_NUM]; extern uint32_t Heater_timerBase; uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_outputproportionalpowerlimit); -void HeatingTestSendResonse(uint32_t status, bool last,bool heater1Active,bool heater2Active, int temperature1, int temperature2,int Heater1Percentage,int Heater2Percentage, char* Message); uint32_t HeaterRecalculateHeaterParams(uint32_t deviceId, uint32_t new_outputproportionalpowerlimit); uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index e036af974..205e3fcce 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -85,6 +85,7 @@ Mailbox_Handle HeatersControlMsgQ = NULL; bool InitialHeating = true; bool DCInitialHeating[MAX_HEATERS_NUM] = {true}; bool HeaterReady[MAX_HEATERS_NUM] = {true}; +uint32_t HeaterPreviousRead[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters /******************** FUNCTIONS ********************************************/ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue); @@ -93,6 +94,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue); uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue); void HeatersStartControlTimer (void); + //********************************************************************** //******************** CODE *******************************************/ //********************************************************************** @@ -155,6 +157,7 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState) int HeaterId = HeaterType; double temp = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]); + HeaterState->has_heatertype = true; HeaterState->heatertype = HeaterType; HeaterState->has_setpoint = true; @@ -373,6 +376,7 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) HeaterPIDConfig[HeaterId].m_params.dt *=10; DCInitialHeating[HeaterId] = true; HeaterReady[HeaterId] = false; + HeaterPreviousRead[HeaterId] = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]); } else if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters { @@ -380,6 +384,9 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) { ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0); HeaterPIDConfig[HeaterId].m_params.dt *=10; + HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id); + HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); + HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]); } if (MainDryerHeaterMaxTempControl == 0xFF) MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0); @@ -462,6 +469,12 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) LOG_ERROR (IfIndex, "Wrong Interface "); return 0xFFFFFFFF; } + if (abs(readValue - HeaterPreviousRead[index])>2000) + { + Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index); + return ERROR; + } + HeaterPreviousRead[index] = readValue; if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain) { MainPT100Read = readValue; @@ -524,6 +537,13 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) //LOG_ERROR (0, "unconfigured"); return ERROR; } + if (abs(readValue - HeaterPreviousRead[index])>2000) + { + Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index); + return ERROR; + } + HeaterPreviousRead[index] = readValue; + // check if the read value is within the proportional band if (InitialHeating) { @@ -638,11 +658,12 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) //LOG_ERROR (index, "unconfigured"); return ERROR; } -/* - HeatingTestSendResonse(0, false,GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary), - Temperature[0],Temperature[1], - HeaterPIDConfig[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].m_calculatedError, HeaterPIDConfig[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].m_calculatedError,"Standard"); -*/ + if (abs(readValue - HeaterPreviousRead[index])>2000) + { + Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index); + return ERROR; + } + HeaterPreviousRead[index] = readValue; // check if the read value is within the proportional band if (DCInitialHeating[index]==true) { diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c index 2b6d3aaea..6915cc657 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c @@ -180,7 +180,7 @@ double WinderReferenceSpeed=0; int32_t TotalWinderSpeed=0; uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) { - uint32_t Steps,i; + uint32_t Steps; double temp; double screw_horizontal_speed = 0; double RotationsPerSecond; @@ -232,6 +232,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) } screw_horizontal_speed = ScrewNumberOfSteps / InternalWinderCfg.NumberOfRotationPerPassage; RotationsPerSecond = WinderReferenceSpeed / (double)MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround; + ROM_IntMasterDisable(); ScrewSpeed = screw_horizontal_speed*RotationsPerSecond; CurrentControlledSpeed[SCREW_MOTOR] = ScrewSpeed; temp = SYS_CLK_FREQ; @@ -239,6 +240,8 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) temp /= ScrewSpeed; if (ScrewRunningTime != temp) { + ScrewRunningTime = temp;//(SYS_CLK_FREQ*Steps)/ScrewSpeed; + ROM_IntMasterEnable(); //usnprintf(TempScrewStr, 100, "Winder: Horizon,Rotation, PPR, RPP{ %d, %d ,%d, %d} ",(int)screw_horizontal_speed,(int)RotationsPerSecond,(int)InternalWinderCfg.NumberOfRotationPerPassage,(int)MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround); usnprintf(ScrewStr, 100, "Winder: Steps,Speed, Time, WinderSpeed{ %d, %d ,%d, %d} ",(int)ScrewNumberOfSteps,(int)ScrewSpeed,(int)temp,(int)WinderReferenceSpeed); // Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index, Counter[index]); @@ -248,9 +251,9 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) //REPORT_MSG(temp , "new winder speed"); //Report("new winder speed",__FILE__,__LINE__,temp,RpWarning,ScrewSpeed,0); } - ScrewRunningTime = temp;//(SYS_CLK_FREQ*Steps)/ScrewSpeed; /********************************************************************************/ + ROM_IntMasterEnable(); return OK; } @@ -409,7 +412,7 @@ void ScrewTimerInterrupt(int ARG0) { TimerDisable(Screw_timerBase, TIMER_A); } - //Report("ScrewTimerInterrupt dir, duration, speed", __FILE__,ScrewCurrentDirection,ScrewRunningTime, RpMessage, ScrewSpeed, 0); + Report("ScrewTimerInterrupt dir, duration, speed", __FILE__,ScrewCurrentDirection,ScrewRunningTime, RpMessage, ScrewSpeed, 0); // // Enable all interrupts. // diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h index c5e3edc85..34be77177 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h @@ -29,7 +29,7 @@ uint32_t ThreadConfigBreakSensor(void *request); uint32_t ThreadGetMotorSpeed(threadMotorsEnum MotorId); double ThreadGetMotorCalculatedError(int DancerId); uint32_t ThreadPrepareState(void *JobDetails); -uint32_t ThreadPreSegmentState(void *JobDetails); +uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId); uint32_t ThreadSegmentState(void *JobDetails, int SegmentId); uint32_t ThreadDistanceToSpoolState(void); uint32_t ThreadEndState(void *JobDetails); diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c index 41daa4002..f641737ee 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c @@ -21,8 +21,10 @@ double NormalizedErrorCoEfficient[MAX_THREAD_MOTORS_NUM] = {0}; int DancerStopActivityLimit[MAX_THREAD_MOTORS_NUM] = {0}; HardwareDancer DancersCfg[MAX_SYSTEM_DANCERS] = {0}; +#define BREAK_SENSOR_LIMIT 10 + bool BreakSensorenabled; -int32_t BreakSensordebouncetimemilli; +int32_t BreakSensordebouncetimemilli = BREAK_SENSOR_LIMIT; HardwarePidControlType ThreadMotorIdToControlId[MAX_THREAD_MOTORS_NUM] = {HARDWARE_PID_CONTROL_TYPE__MotorFeeder,HARDWARE_PID_CONTROL_TYPE__MotorDryer,HARDWARE_PID_CONTROL_TYPE__MotorPooler,HARDWARE_PID_CONTROL_TYPE__MotorWinder,0}; @@ -116,7 +118,10 @@ uint32_t ThreadConfigBreakSensor(void *request) if (SensorCfg) { BreakSensorenabled = SensorCfg->enabled; - BreakSensordebouncetimemilli = SensorCfg->debouncetimemilli; + if (SensorCfg->debouncetimemilli) + { + BreakSensordebouncetimemilli = SensorCfg->debouncetimemilli; + } return OK; } return ERROR; diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c index 0e0a9f987..72391e3a9 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c @@ -355,6 +355,8 @@ void testDancersControl() bool dancerinvalid = false; int MotorFailedSample[MAX_THREAD_MOTORS_NUM] = {0,0,0,0,0}; char Message[60]; +uint16_t BreakSensorCounter = 0; +uint16_t BreakSensorLatchCounter = 0; uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) { //#define MAX_CONTROL_SAMPLES 6 @@ -425,16 +427,29 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) { if (ReadBreakSensor()==ERROR) { - //consider applying the debouce parameters later - //BreakSensordebouncetimemilli - JobEndReason = JOB_THREAD_BREAK; - ThreadControlActive = false; - SendJobProgress(0.0,0,false, "ReadBreakSensor Error"); - SegmentReady(Module_Thread,ModuleFail); - AlarmHandlingSetAlarm(EVENT_TYPE__ThreadBreak,true); - //EndState(CurrentJob,"ReadBreakSensor Error" ); - LOG_ERROR(index, "ReadBreakSensor Error"); - return OK; + BreakSensorCounter++; + BreakSensorLatchCounter++; + if (BreakSensorCounter>=BreakSensordebouncetimemilli) + { + //consider applying the debouce parameters later + //BreakSensordebouncetimemilli + JobEndReason = JOB_THREAD_BREAK; + ThreadControlActive = false; + SendJobProgress(0.0,0,false, "ReadBreakSensor Error"); + SegmentReady(Module_Thread,ModuleFail); + AlarmHandlingSetAlarm(EVENT_TYPE__ThreadBreak,true); + //EndState(CurrentJob,"ReadBreakSensor Error" ); + LOG_ERROR(index, "ReadBreakSensor Error"); + return OK; + } //passed limit + }//ReadBreakSensor()==ERROR + else //reset counter - we are looking for consequent calls + { + if (BreakSensorCounter) + { + LOG_ERROR(BreakSensorCounter, "ReadBreakSensor Spike"); + } + BreakSensorCounter = 0; } } } @@ -525,7 +540,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request) //MotorsConfigMessage(request); ThreadPrepareState(request); - ThreadPreSegmentState(request); + ThreadPreSegmentState(request,0); return OK; } bool InitialProcess = false; @@ -659,7 +674,7 @@ void SetOriginMotorSpeed(float process_speed) } //******************************************************************************************************************** -uint32_t ThreadPreSegmentState(void *JobDetails) +uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId) { //set the speed only before the first segment, speed is constant across all job segments and intersegments JobTicket* JobTicket = JobDetails; @@ -671,32 +686,25 @@ uint32_t ThreadPreSegmentState(void *JobDetails) return ERROR; } REPORT_MSG (dyeingspeed," ThreadPreSegmentState"); - - SetOriginMotorSpeed(process_speed); - ThreadControlActive = true; - PrepareState = false; - // set the new speed in the dryer motor to the speed of the new segment - MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING, OriginalMotorSpd_2PPS[DRYER_MOTOR]); - //only for testing - when control works, these motors will take their speed from the dryer - //MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, OriginalMotorSpd_2PPS[POOLER_MOTOR]); - //only for testing - when control works, these motors will take their speed from the dryer - //MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, OriginalMotorSpd_2PPS[FEEDER_MOTOR]); - -//#warning rocker disabled - if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].maxfrequency > 0) + if (SegmentId == 0) // do all this only in the beginning of the job. do not touch after that (assuming spool does not change mid job) { - MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize); - MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 1); - } - if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].maxfrequency > 0) - { - MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize); - MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 1); - } -// #warning rocker disabled - -// MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize, 0, GPI_LS_RLOADMOTOR_UP, EndState); //TODO + SetOriginMotorSpeed(process_speed); + ThreadControlActive = true; + PrepareState = false; + // set the new speed in the dryer motor to the speed of the new segment + MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING, OriginalMotorSpd_2PPS[DRYER_MOTOR]); + if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].maxfrequency > 0) + { + MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize); + MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 1); + } + if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].maxfrequency > 0) + { + MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize); + MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 1); + } + } // activate control fr all motors //set speed for both rocker motors //wait for all motors to get to the required speed (set the target speed for the control to check) diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c index 46ec6450c..6c76bab86 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c @@ -214,7 +214,7 @@ static uint32_t PreSegmentState(void *JobDetails, int SegmentId) } if (Configured[Module_Thread]) { - ThreadPreSegmentState(JobDetails); + ThreadPreSegmentState(JobDetails,SegmentId); } if (Configured[Module_Winder]) { -- cgit v1.3.1 From 2769e72857ebc543d8f40a3cbca218f2f010a77d Mon Sep 17 00:00:00 2001 From: Shlomo Hecht Date: Thu, 27 Dec 2018 12:09:52 +0200 Subject: Version 1.3.0.8 changes for connection resiliance: priorities, diagnostics and alarm handling --- .../Embedded_SW/Embedded/Common/SW_Info/SW_Info.c | 2 +- .../Embedded/Communication/CommunicationTask.c | 2 +- .../Embedded_SW/Embedded/Communication/Container.c | 2 +- Software/Embedded_SW/Embedded/Embedded.cfg | 38 +++++++++++----------- .../Embedded/Modules/AlarmHandling/AlarmHandling.c | 8 ++--- .../Embedded/Modules/Thread/Thread_Winder.c | 22 ++++++------- .../Embedded/Modules/Thread/Thread_print.c | 2 +- .../Embedded/StateMachines/Printing/JobSTM.c | 6 ++-- .../Embedded/StateMachines/Printing/PrintingSTM.c | 6 ++-- 9 files changed, 46 insertions(+), 42 deletions(-) (limited to 'Software/Embedded_SW/Embedded/Modules/Thread') diff --git a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c index eadfdd1d0..1bbd5a8ad 100644 --- a/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c +++ b/Software/Embedded_SW/Embedded/Common/SW_Info/SW_Info.c @@ -20,7 +20,7 @@ typedef struct } TangoVersion_t; -TangoVersion_t _gTangoVersion = {001,003,000,006}; +TangoVersion_t _gTangoVersion = {1,3,0,8}; #define BUILD_DATE __DATE__ char Dat[50] = BUILD_DATE; char _gTangoName [MAX_STRING_LEN] = "Tango01 ";//d diff --git a/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c b/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c index 5afc618ff..eb4ebbaf1 100644 --- a/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c +++ b/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c @@ -126,7 +126,7 @@ uint32_t CommunicationTaskMessageReceived(uint32_t buffer,uint16_t msgSize) * this communication task is created statically in system initialization, in blocking mode * over one of the chosen ommunication methods (USB or Blutooth). ******************************************************************************/ -uint32_t cLength[50] = {0}; +uint32_t cLength[51] = {0}; byte cindex = 0; void communicationTask(UArg arg0, UArg arg1) { diff --git a/Software/Embedded_SW/Embedded/Communication/Container.c b/Software/Embedded_SW/Embedded/Communication/Container.c index 0c3ad2f8e..8543f0493 100644 --- a/Software/Embedded_SW/Embedded/Communication/Container.c +++ b/Software/Embedded_SW/Embedded/Communication/Container.c @@ -76,7 +76,7 @@ MessageContainer createContainer(MessageType type, char* token, protobuf_c_boole container.data.data = response_buffer; container.data.len = response_size; - if (SuspendLargeMessages == true) + // if (SuspendLargeMessages == true) { // Report("EndJobMessage",__FILE__,__LINE__,(int)type,RpWarning,(int)response_size,0); TxmsgId[Txindex] = type; diff --git a/Software/Embedded_SW/Embedded/Embedded.cfg b/Software/Embedded_SW/Embedded/Embedded.cfg index 240a79a6f..f12df421c 100644 --- a/Software/Embedded_SW/Embedded/Embedded.cfg +++ b/Software/Embedded_SW/Embedded/Embedded.cfg @@ -122,16 +122,17 @@ ControlTaskParams.stackSize = 2048; ControlTaskParams.priority = 11; Program.global.control = Task.create("&controlTask", ControlTaskParams); -var CommRxTaskParams = new Task.Params(); -CommRxTaskParams.instance.name = "communication"; -CommRxTaskParams.priority = 10; -CommRxTaskParams.stackSize = 8192; -Program.global.communication = Task.create("&communicationTask", CommRxTaskParams); +var AlarmHandlingTaskParams = new Task.Params(); +AlarmHandlingTaskParams.instance.name = "AlarmHandling"; +AlarmHandlingTaskParams.stackSize = 1024; +AlarmHandlingTaskParams.priority = 10; +Program.global.AlarmHandling = Task.create("&AlarmHandlingTask", AlarmHandlingTaskParams); -var HeaterControlTaskParams = new Task.Params(); -HeaterControlTaskParams.instance.name = "HeatersControl"; -HeaterControlTaskParams.priority = 9; -Program.global.HeatersControl = Task.create("&HeatersControlTask", HeaterControlTaskParams); +var CommTxTaskParams = new Task.Params(); +CommTxTaskParams.instance.name = "communicationTx"; +CommTxTaskParams.priority = 9; +CommTxTaskParams.stackSize = 4096; +Program.global.communicationTx = Task.create("&communicationTxTask", CommTxTaskParams); var ProcessTaskParams = new Task.Params(); ProcessTaskParams.instance.name = "process"; @@ -139,17 +140,16 @@ ProcessTaskParams.stackSize = 2048; ProcessTaskParams.priority = 8; Program.global.process = Task.create("&jobTask", ProcessTaskParams); -var CommTxTaskParams = new Task.Params(); -CommTxTaskParams.instance.name = "communicationTx"; -CommTxTaskParams.priority = 7; -CommTxTaskParams.stackSize = 4096; -Program.global.communicationTx = Task.create("&communicationTxTask", CommTxTaskParams); +var HeaterControlTaskParams = new Task.Params(); +HeaterControlTaskParams.instance.name = "HeatersControl"; +HeaterControlTaskParams.priority = 7; +Program.global.HeatersControl = Task.create("&HeatersControlTask", HeaterControlTaskParams); -var AlarmHandlingTaskParams = new Task.Params(); -AlarmHandlingTaskParams.instance.name = "AlarmHandling"; -AlarmHandlingTaskParams.stackSize = 1024; -AlarmHandlingTaskParams.priority = 6; -Program.global.AlarmHandling = Task.create("&AlarmHandlingTask", AlarmHandlingTaskParams); +var CommRxTaskParams = new Task.Params(); +CommRxTaskParams.instance.name = "communicationRx"; +CommRxTaskParams.priority = 6; +CommRxTaskParams.stackSize = 8192; +Program.global.communication = Task.create("&communicationTask", CommRxTaskParams); var MillisecLowTaskParams = new Task.Params(); MillisecLowTaskParams.instance.name = "MilliSecondLow"; diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index c54976195..8d5955636 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -498,8 +498,8 @@ uint32_t AlarmHandlingEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue) uint32_t AlarmHandlingStart(void) { - if (EventsNotificationRequestAccepted == false) - return ERROR; + //if (EventsNotificationRequestAccepted == false) + // return ERROR; if ( AlarmHandlingActive == false) { AlarmHandlingActive = true; @@ -684,7 +684,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick) //Motor Status //machine cover open - if (tick%eOneSecond == 0) + if ((tick%eOneSecond == 0)&&(EventsNotificationRequestAccepted==true)) SendEventNotifications(); return OK; } @@ -814,7 +814,7 @@ uint32_t StartEventsNotificationRequestFunc(MessageContainer* requestContainer) // ReportInitParams InitParams; //ControlStart(); EventsNotificationRequestAccepted = true; - AlarmHandlingStart(); + //AlarmHandlingStart(); StartEventsNotificationRequest* request = start_events_notification_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); ustrncpy (AlarmHandlingToken, requestContainer->token,36); diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c index 6915cc657..fed1311bd 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c @@ -181,7 +181,7 @@ int32_t TotalWinderSpeed=0; uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) { uint32_t Steps; - double temp; + double temp,tempScrewSpeed; double screw_horizontal_speed = 0; double RotationsPerSecond; int32_t Averagewinderspeed = 0; @@ -232,16 +232,17 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) } screw_horizontal_speed = ScrewNumberOfSteps / InternalWinderCfg.NumberOfRotationPerPassage; RotationsPerSecond = WinderReferenceSpeed / (double)MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround; - ROM_IntMasterDisable(); - ScrewSpeed = screw_horizontal_speed*RotationsPerSecond; + tempScrewSpeed = screw_horizontal_speed*RotationsPerSecond; + //ROM_IntMasterDisable(); CurrentControlledSpeed[SCREW_MOTOR] = ScrewSpeed; temp = SYS_CLK_FREQ; temp *= ScrewNumberOfSteps; - temp /= ScrewSpeed; - if (ScrewRunningTime != temp) + temp /= tempScrewSpeed; + if ((ScrewRunningTime != temp)||(ScrewSpeed != tempScrewSpeed)) { + ScrewSpeed = tempScrewSpeed; ScrewRunningTime = temp;//(SYS_CLK_FREQ*Steps)/ScrewSpeed; - ROM_IntMasterEnable(); + //ROM_IntMasterEnable(); //usnprintf(TempScrewStr, 100, "Winder: Horizon,Rotation, PPR, RPP{ %d, %d ,%d, %d} ",(int)screw_horizontal_speed,(int)RotationsPerSecond,(int)InternalWinderCfg.NumberOfRotationPerPassage,(int)MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround); usnprintf(ScrewStr, 100, "Winder: Steps,Speed, Time, WinderSpeed{ %d, %d ,%d, %d} ",(int)ScrewNumberOfSteps,(int)ScrewSpeed,(int)temp,(int)WinderReferenceSpeed); // Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index, Counter[index]); @@ -253,7 +254,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) } /********************************************************************************/ - ROM_IntMasterEnable(); + //ROM_IntMasterEnable(); return OK; } @@ -313,6 +314,7 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId) REPORT_MSG(ScrewRunningTime,"Winder pre segment - ScrewRunningTime"); // MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection); //ScrewDirection = 1-ScrewDirection; + REPORT_MSG(SegmentId,"Winder pre segment - SegmentId"); REPORT_MSG(ScrewSpeed,"Winder pre segment - ScrewSpeed"); //MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed); ScrewsStartControlTimer (); @@ -398,12 +400,10 @@ void ScrewTimerInterrupt(int ARG0) { ROM_TimerIntClear(Screw_timerBase, TIMER_TIMA_TIMEOUT); // Clear the timer interrupt ROM_IntMasterDisable(); - //ScrewDirectionChange(0,NOTBUSY); if (SCREW_TimerActivated == true) { MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection); -// ScrewCurrentDirection = 1-ScrewCurrentDirection; MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed); ROM_TimerLoadSet(Screw_timerBase, TIMER_A,(int)ScrewRunningTime); ScrewDirectionChangeCounter++; @@ -412,11 +412,11 @@ void ScrewTimerInterrupt(int ARG0) { TimerDisable(Screw_timerBase, TIMER_A); } - Report("ScrewTimerInterrupt dir, duration, speed", __FILE__,ScrewCurrentDirection,ScrewRunningTime, RpMessage, ScrewSpeed, 0); + ROM_IntMasterEnable(); + //Report("ScrewTimerInterrupt dir, duration, speed", __FILE__,ScrewCurrentDirection,ScrewRunningTime, RpMessage, ScrewSpeed, 0); // // Enable all interrupts. // - ROM_IntMasterEnable(); return ; } diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c index 72391e3a9..94858cae2 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c @@ -462,7 +462,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) usnprintf(Message, 60, "Dancer %d limit %d value %d Zero %d",DancerId,DancerStopActivityLimit[index],avreageSampleValue,DancersCfg[DancerId].zeropoint); //JobAbortedByUser = true; ThreadControlActive = false; - MotorGetStatusFromFPGA(ThreadMotorIdToMotorId[index]); + //MotorGetStatusFromFPGA(ThreadMotorIdToMotorId[index]); JobEndReason = JOB_WINDER_DANCER_FAIL+DancerId; SendJobProgress(0.0,0,false, Message); //EndState(CurrentJob,Message ); diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c index 34ac6a857..e044808ca 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c @@ -925,7 +925,8 @@ Void jobTask(UArg arg0, UArg arg1) job_request__free_unpacked(CurrentRequest,NULL); CurrentRequest = NULL; SuspendLargeMessages = false; - DiagnosticsStart(); + LOG_ERROR(4,"ResumeLargeMessages PrintingResultsOk"); + //DiagnosticsStart(); //CleanState(CurrentJob); break; case PrintingResultsFail: @@ -935,7 +936,8 @@ Void jobTask(UArg arg0, UArg arg1) job_request__free_unpacked(CurrentRequest,NULL); CurrentRequest = NULL; SuspendLargeMessages = false; - DiagnosticsStart(); + LOG_ERROR(3,"ResumeLargeMessages PrintingResultsFail"); + //DiagnosticsStart(); //send message data as a validation error message to host ExitState(Message.messageData); diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c index 12c925bd8..85421fae5 100644 --- a/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c +++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/PrintingSTM.c @@ -333,9 +333,10 @@ uint32_t DistanceToSpoolReady(int ModuleId, ModuleStateEnum result) else { SuspendLargeMessages = true; - DiagnosticsStop(); + //DiagnosticsStop(); PrtMessage->messageId = FinishResultsFail; SendJobProgress(0.0, 0, false, "DistanceToSpool Fail"); + LOG_ERROR(1,"SuspendLargeMessages DistanceToSpoolReady"); } //memcpy(Message.messageData,JobDetails,MAX_MSG_LEN); Message.msglen = 10; @@ -374,7 +375,8 @@ uint32_t EndState(void *JobDetails, char *Message) { //ROM_IntMasterDisable(); SuspendLargeMessages = true; - DiagnosticsStop(); + LOG_ERROR(2,"SuspendLargeMessages EndState"); + //DiagnosticsStop(); if (Configured[Module_Winder]) { PrepareWaiting[Module_Winder] = ModuleIdle; -- cgit v1.3.1