diff options
Diffstat (limited to 'Software/Embedded_SW/Embedded/Modules')
42 files changed, 4134 insertions, 991 deletions
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index 13403cad3..6acdf5d67 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -11,6 +11,7 @@ #include "AlarmHandling.h" #include <driverlib/timer.h> +#include <Drivers/FPGA/Motors_Driver/L6470.h> #include <Drivers/SSI_Comm/SSI_Comm.h> #include <inc/hw_ints.h> @@ -25,6 +26,7 @@ #include "drivers/FPGA/FPGA.h" #include "PMR/Hardware/HardwareDancerType.pb-c.h" #include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h" +#include "drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h" #include "modules/thread/thread_ex.h" #include "modules/heaters/heaters_ex.h" @@ -46,7 +48,6 @@ #include "StateMachines/Printing/PrintingSTM.h" -#include "drivers/FPGA/Moters_Driver/L6470.h" #include "drivers/Motors/Motor.h" #include "drivers/Heater/TemperatureSensor.h" #include "drivers/Flash_ram/FlashProgram.h" @@ -59,6 +60,7 @@ bool AlarmHandlingActive = false; uint32_t AlarmHandlingControlId = 0xFF; uint32_t AlarmHandlingTick = 0; +bool CheckHardLimitAlarms = false,CheckCurrentAlarms = false,CheckTamperAlarms = false; uint8_t alarm_response_buffer[500]; /******************** Functions ********************************************/ @@ -84,7 +86,7 @@ typedef struct AlarmHandlingMessage{ }AlarmHandlingMessageStruc; #define MAX_SYSTEM_ALARMS 300+1 -typedef enum +/*typedef enum { TemperatureAlarm, LimitSwitchAlarm, @@ -93,13 +95,16 @@ typedef enum MotorAlarm, CoversAlarm, DoNotPollAlarm, -}AlarmSource; -#define OVER_VALUE true; -#define UNDER_VALUE false; + HardLimitAlarm, + TachoAlarm, + FluidLevelAlarm, +}AlarmSource;*/ +#define OVER_VALUE true +#define UNDER_VALUE false typedef struct { uint16_t Frequency; //1/10/100/1000 - AlarmSource AlarmSource; + AlarmSourceType AlarmSource; uint16_t DeviceId; uint8_t ModuleDeviceId; uint16_t AlarmValue; @@ -126,183 +131,213 @@ AlarmStatusItem AlarmState[MAX_SYSTEM_ALARMS]; */ AlarmHandlingItemStruc *AlarmItem; const AlarmHandlingItemStruc HardCodedAlarmItem[MAX_SYSTEM_ALARMS]={ - {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY,"Dispenser 1 Empty"}, - {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY,"Dispenser 2 Empty"}, - {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY,"Dispenser 3 Empty"}, - {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_4_EMPTY,"Dispenser 4 Empty"}, - {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_5_EMPTY,"Dispenser 5 Empty"}, - {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_6_EMPTY,"Dispenser 6 Empty"}, - {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_7_EMPTY,"Dispenser 7 Empty"}, - {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_8_EMPTY,"Dispenser 8 Empty"}, - {eOneSecond,PressureAlarm,0,0,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_1_OVERPRESSURE,"Dispenser 1 Over Pressure"}, - {eOneSecond,PressureAlarm,1,1,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_2_OVERPRESSURE,"Dispenser 2 Over Pressure"}, - {eOneSecond,PressureAlarm,2,2,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_3_OVERPRESSURE,"Dispenser 3 Over Pressure"}, - {eOneSecond,PressureAlarm,3,3,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_4_OVERPRESSURE,"Dispenser 4 Over Pressure"}, - {eOneSecond,PressureAlarm,4,4,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_5_OVERPRESSURE,"Dispenser 5 Over Pressure"}, - {eOneSecond,PressureAlarm,5,5,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_6_OVERPRESSURE,"Dispenser 6 Over Pressure"}, - {eOneSecond,PressureAlarm,6,6,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_7_OVERPRESSURE,"Dispenser 7 Over Pressure"}, - {eOneSecond,PressureAlarm,7,7,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_8_OVERPRESSURE,"Dispenser 8 Over Pressure"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT,"MotorDryerOverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT,"MotorFeederOverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT,"MotorScrewOverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERCURRENT,"MotorWinderOverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERCURRENT,"MotorPoolerOverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT,"MotorDispenser1OverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT,"MotorDispenser2OverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT,"MotorDispenser3OverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT,"MotorDispenser4OverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT,"MotorDispenser5OverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT,"MotorDispenser6OverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT,"MotorDispenser7OverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT,"MotorDispenser8OverCurrent"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE,"MotorDryerOverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE,"MotorFeederOverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE,"MotorScrewOverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE,"MotorWinderOverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE,"MotorPoolerOverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE,"MotorDispenser1OverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE,"MotorDispenser2OverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE,"MotorDispenser3OverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE,"MotorDispenser4OverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE,"MotorDispenser5OverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE,"MotorDispenser6OverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE,"MotorDispenser7OverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE,"MotorDispenser8OverTemperature"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE,"MotorDryerUnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE,"MotorFeederUnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE,"MotorScrewUnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE,"MotorWinderUnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE,"MotorPoolerUnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE,"MotorDispenser1UnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE,"MotorDispenser2UnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE,"MotorDispenser3UnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE,"MotorDispenser4UnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE,"MotorDispenser5UnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE,"MotorDispenser6UnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE,"MotorDispenser7UnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE,"MotorDispenser8UnderVoltage"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_STALL,"MotorDryerStall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_STALL,"MotorFeederStall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_STALL,"MotorScrewStall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_STALL,"MotorWinderStall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_STALL,"MotorPoolerStall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_STALL,"MotorDispenser1Stall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_STALL,"MotorDispenser2Stall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_STALL,"MotorDispenser3Stall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_STALL,"MotorDispenser4Stall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_STALL,"MotorDispenser5Stall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_STALL,"MotorDispenser6Stall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_STALL,"MotorDispenser7Stall"}, - {eOneSecond,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_STALL,"MotorDispenser8Stall"}, - {eHundredMillisecond,TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE,"Mixer Over Temperature"}, - {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,"DyeingHead1 Over Temperature"}, - {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,"DyeingHead2 Over Temperature"}, - {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,"DyeingHead3 Over Temperature"}, - {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,"DyeingHead4 Over Temperature"}, - {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,"DyeingHead5 Over Temperature"}, - {eHundredMillisecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,"DyeingHead6 Over Temperature"}, - {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,"Dryer Over Temperature"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_1_EMPTY,"Dispenser 1 Empty"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_2_EMPTY,"Dispenser 2 Empty"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_3_EMPTY,"Dispenser 3 Empty"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_4_EMPTY,"Dispenser 4 Empty"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_5_EMPTY,"Dispenser 5 Empty"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_6_EMPTY,"Dispenser 6 Empty"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_7_EMPTY,"Dispenser 7 Empty"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DISPENSER_8_EMPTY,"Dispenser 8 Empty"}, + + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_UPPER_HARD_LIMIT,"Dispenser 1 is at the upper limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_UPPER_HARD_LIMIT,"Dispenser 2 is at the upper limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_UPPER_HARD_LIMIT,"Dispenser 3 is at the upper limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_UPPER_HARD_LIMIT,"Dispenser 4 is at the upper limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_UPPER_HARD_LIMIT,"Dispenser 5 is at the upper limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_UPPER_HARD_LIMIT,"Dispenser 6 is at the upper limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_UPPER_HARD_LIMIT,"Dispenser 7 is at the upper limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,true,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_UPPER_HARD_LIMIT,"Dispenser 8 is at the upper limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,0,0,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_LOWER_HARD_LIMIT,"Dispenser 1 is at the lower limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,1,1,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_LOWER_HARD_LIMIT,"Dispenser 2 is at the lower limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,2,2,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_LOWER_HARD_LIMIT,"Dispenser 3 is at the lower limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,3,3,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_LOWER_HARD_LIMIT,"Dispenser 4 is at the lower limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,4,4,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_LOWER_HARD_LIMIT,"Dispenser 5 is at the lower limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,5,5,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_LOWER_HARD_LIMIT,"Dispenser 6 is at the lower limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,6,6,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_LOWER_HARD_LIMIT,"Dispenser 7 is at the lower limit"}, + {eOneSecond,ALARM_SOURCE_TYPE__HardLimitAlarm,7,7,true,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_LOWER_HARD_LIMIT,"Dispenser 8 is at the lower limit"}, + + {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,0,0,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_1_HIGH_PRESSURE,"Dispenser 1 High Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,1,1,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_2_HIGH_PRESSURE,"Dispenser 2 High Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,2,2,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_3_HIGH_PRESSURE,"Dispenser 3 High Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,3,3,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_4_HIGH_PRESSURE,"Dispenser 4 High Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,4,4,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_5_HIGH_PRESSURE,"Dispenser 5 High Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,5,5,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_6_HIGH_PRESSURE,"Dispenser 6 High Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,6,6,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_7_HIGH_PRESSURE,"Dispenser 7 High Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__PressureAlarm,7,7,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__DISPENSER_8_HIGH_PRESSURE,"Dispenser 8 High Pressure"}, + + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_1_OVERPRESSURE,"Dispenser 1 Over Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_2_OVERPRESSURE,"Dispenser 2 Over Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_3_OVERPRESSURE,"Dispenser 3 Over Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_4_OVERPRESSURE,"Dispenser 4 Over Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_5_OVERPRESSURE,"Dispenser 5 Over Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_6_OVERPRESSURE,"Dispenser 6 Over Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE,"Dispenser 7 Over Pressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE,"Dispenser 8 Over Pressure"}, + + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERCURRENT,"Motor Drier Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT,"Motor Feeder Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERCURRENT,"Motor Screw Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERCURRENT,"Motor Winder Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERCURRENT,"Motor Puller Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERCURRENT,"Motor Dispenser1 Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERCURRENT,"Motor Dispenser2 Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERCURRENT,"Motor Dispenser3 Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERCURRENT,"Motor Dispenser4 Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERCURRENT,"Motor Dispenser5 Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERCURRENT,"Motor Dispenser6 Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERCURRENT,"Motor Dispenser7 Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERCURRENT,"Motor Dispenser8 Over Current"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_OVERTEMPERATURE,"Motor Drier Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_OVERTEMPERATURE,"Motor Feeder Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_OVERTEMPERATURE,"Motor Screw Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_OVERTEMPERATURE,"Motor Winder Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_OVERTEMPERATURE,"Motor Puller Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_OVERTEMPERATURE,"Motor Dispenser1 Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_OVERTEMPERATURE,"Motor Dispenser2 Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_OVERTEMPERATURE,"Motor Dispenser3 Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_OVERTEMPERATURE,"Motor Dispenser4 Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_OVERTEMPERATURE,"Motor Dispenser5 Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_OVERTEMPERATURE,"Motor Dispenser6 Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_OVERTEMPERATURE,"Motor Dispenser7 Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_OVERTEMPERATURE,"Motor Dispenser8 Over Temperature"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_UNDERVOLTAGE,"Motor Drier Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_UNDERVOLTAGE,"Motor Feeder Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_UNDERVOLTAGE,"Motor Screw Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_UNDERVOLTAGE,"Motor Winder Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_UNDERVOLTAGE,"Motor Puller Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_UNDERVOLTAGE,"Motor Dispenser1 Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_UNDERVOLTAGE,"Motor Dispenser2 Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_UNDERVOLTAGE,"Motor Dispenser3 Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_UNDERVOLTAGE,"Motor Dispenser4 Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_UNDERVOLTAGE,"Motor Dispenser5 Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_UNDERVOLTAGE,"Motor Dispenser6 Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_UNDERVOLTAGE,"Motor Dispenser7 Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_UNDERVOLTAGE,"Motor Dispenser8 Under Voltage"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DRYER_MOTOR_STALL,"Motor Drier Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__FEEDER_MOTOR_STALL,"Motor Feeder Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__SCREW_MOTOR_STALL,"Motor Screw Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__WINDER_MOTOR_STALL,"Motor Winder Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__PULLER_MOTOR_STALL,"Motor Puller Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_1_MOTOR_STALL,"Motor Dispenser1 Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_2_MOTOR_STALL,"Motor Dispenser2 Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_3_MOTOR_STALL,"Motor Dispenser3 Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_4_MOTOR_STALL,"Motor Dispenser4 Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_5_MOTOR_STALL,"Motor Dispenser5 Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_6_MOTOR_STALL,"Motor Dispenser6 Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_7_MOTOR_STALL,"Motor Dispenser7 Stall"}, + {eOneSecond,ALARM_SOURCE_TYPE__MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__DISPENSER_8_MOTOR_STALL,"Motor Dispenser8 Stall"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_OVERTEMPERATURE,"Mixer Over Temperature"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,"DyeingHead1 Over Temperature"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,"DyeingHead2 Over Temperature"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,"DyeingHead3 Over Temperature"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,"DyeingHead4 Over Temperature"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,"DyeingHead5 Over Temperature"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,"DyeingHead6 Over Temperature"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,"Dryer Over Temperature"}, - /*{eHundredMillisecond,CoversAlarm,FrontDoor1 ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN,"Front door #1 Open"}, - {eHundredMillisecond,CoversAlarm,FrontDoor2 ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__FRONT_COVER_2_OPEN,"Front door #2 Open"}, - {eHundredMillisecond,CoversAlarm,FrontDoor3 ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__FRONT_COVER_3_OPEN,"Front door #3 Open"}, - {eHundredMillisecond,CoversAlarm,FrontDoor4 ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__FRONT_COVER_4_OPEN,"Front door #4 Open"}, - {eHundredMillisecond,CoversAlarm,RearDoor ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__REAR_COVER_OPEN,"Rear door Open"}, - {eHundredMillisecond,CoversAlarm,CartridgesDoor,1,false,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN,"Cartridges door Open"},*/ + {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor1 ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__FRONT_COVER_1_OPEN,"Front door #1 Open"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor2 ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__FRONT_COVER_2_OPEN,"Front door #2 Open"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor3 ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__FRONT_COVER_3_OPEN,"Front door #3 Open"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,FrontDoor4 ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__FRONT_COVER_4_OPEN,"Front door #4 Open"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,RearDoor ,1,false,true,DEBUG_LOG_CATEGORY__Error, 0xFF,5,EVENT_TYPE__REAR_COVER_OPEN,"Rear door Open"}, + {eHundredMillisecond,ALARM_SOURCE_TYPE__CoversAlarm,CartridgesDoor,1,false,true,DEBUG_LOG_CATEGORY__Warning,0xFF,5,EVENT_TYPE__CARTRIDGES_COVER_OPEN,"Cartridges door Open"}, - {eOneSecond,TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"}, - {eOneSecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"}, - {eOneSecond,TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,"DyeingHead 1 PT100 Heating Failure"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,"DyeingHead 2 PT100 Heating Failure"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,"DyeingHead 3 PT100 Heating Failure"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,"DyeingHead 4 PT100 Heating Failure"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,"DyeingHead 5 PT100 Heating Failure"}, - {eOneSecond,TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,"DyeingHead 6 PT100 Heating Failure"}, - {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,"Dryer PT100 Heating Failure"}, - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT ," MotorRightLoaderOverCurrent " }, /* 3004 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT ," MotorLeftLoaderOverCurrent " }, /* 3006 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT ," MotorLoadindARMOverCurrent " }, /* 3009 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT ," MotorWinderDancerOverCurrent " }, /* 3036 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT ," MotorPullerDancerOverCurrent " }, /* 3037 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT ," MotorFeederDancerOverCurrent " }, /* 3038 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT ," MotorDryerLidOverCurrent " }, /* 4017 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT ," MotorDyeingHeadCoverOverCurrent " }, /* 5031 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT ," MotorDyeingHeadCleaningMechanismOverCurrent "}, /* 5035 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT ," MotorDyeingHeadCleaningHeadOverCurrent " }, /* 5039 */ + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,"Mixer PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,"DyeingHead 1 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,"DyeingHead 2 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,"DyeingHead 3 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,"DyeingHead 4 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,"DyeingHead 5 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,"DyeingHead 6 PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,"Dryer PT100 Not Heating"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,MIXER_PT100, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,"Mixer PT100 Heating Failure"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,"DyeingHead 1 PT100 Heating Failure"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,"DyeingHead 2 PT100 Heating Failure"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,"DyeingHead 3 PT100 Heating Failure"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,"DyeingHead 4 PT100 Heating Failure"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,"DyeingHead 5 PT100 Heating Failure"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,HEAD6_PT100, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,"DyeingHead 6 PT100 Heating Failure"}, + {eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,"Dryer PT100 Heating Failure"}, + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERCURRENT ,"Motor RightLoader Over Current" }, /* 3004 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERCURRENT ,"Motor LeftLoader Over Current" }, /* 3006 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERCURRENT ,"Motor LoadindARM Over Current" }, /* 3009 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_MOTOR_OVERCURRENT /*EVENT_TYPE__WINDER_DANCER_MOTOR_OVERCURRENT*/ ,"Motor WinderDancer Over Current" }, /* 3036 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_MOTOR_OVERCURRENT /*EVENT_TYPE__PULLER_DANCER_MOTOR_OVERCURRENT*/ ,"Motor PullerDancer Over Current" }, /* 3037 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_MOTOR_OVERCURRENT /*EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERCURRENT*/ ,"Motor FeederDancer Over Current" }, /* 3038 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_MOTOR_OVERCURRENT /*EVENT_TYPE__DRYER_LID_MOTOR_OVERCURRENT*/ ,"Motor DryerLid Over Current" }, /* 4017 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERCURRENT ,"Motor DyeingHeadCover Over Current" }, /* 5031 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERCURRENT ,"Motor DyeingHeadCleaningMechanism Over Current"}, /* 5035 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , x_STATUS_OCD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERCURRENT ,"Motor DyeingHeadCleaningHead Over Current" }, /* 5039 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE ," MotorRightLoaderOverTemperature " }, /* 3011 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE ," MotorLeftLoaderOverTemperature " }, /* 3013 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE ," MotorLoadArmOverTemperature " }, /* 3016 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE ," MotorWinderDancerOverTemperature " }, /* 3039 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE ," MotorPullerDancerOverTemperature " }, /* 3040 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE ," MotorFeederDancerOverTemperature " }, /* 3041 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE ," MotorDryerLidOverTemperature " }, /* 4018 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE ," MotorDyeingHeadCoverOverTemperature " }, /* 5032 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE ," MotorDyeingHeadCleaningOverTemperature " }, /* 5036 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE ," MotorDyeingHeadCleaningHeadOverTemperature "}, /* 5040 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_OVERTEMPERATURE ,"Motor RightLoader Over Temperature" }, /* 3011 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_OVERTEMPERATURE ,"Motor LeftLoader Over Temperature" }, /* 3013 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_OVERTEMPERATURE ,"Motor LoadArm Over Temperature" }, /* 3016 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_OVERTEMPERATURE ,"Motor WinderDancer Over Temperature" }, /* 3039 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_OVERTEMPERATURE ,"Motor PullerDancer Over Temperature" }, /* 3040 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_OVERTEMPERATURE ,"Motor FeederDancer Over Temperature" }, /* 3041 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_OVERTEMPERATURE ,"Motor DryerLid Over Temperature" }, /* 4018 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_OVERTEMPERATURE ,"Motor DyeingHeadCover Over Temperature" }, /* 5032 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_OVERTEMPERATURE ,"Motor DyeingHeadCleaning Over Temperature" }, /* 5036 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , x_STATUS_TH_SD , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_OVERTEMPERATURE ,"Motor DyeingHeadCleaningHead Over Temperature"}, /* 5040 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL ," MotorLoadingARMStall " }, /* 3018 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL ," MotorWinderDancesStall " }, /* 3020 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL ," MotorLoadingARMStall " }, /* 3023 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL ," MotorWinderDancesStall " }, /* 3042 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_STALL ," MotorPullerDancerStall " }, /* 3043 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL ," MotorFeederDancerStall " }, /* 3044 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_STALL ," MotorDryerLidStall " }, /* 4019 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL ," MotorDyeingHeadCoverStall " }, /* 5033 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL ," MotorDyeingHeadCleaningMechanismStall " }, /* 5037 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL ," MotorDryeingHeadCleaningStall " }, /* 5041 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL ,"Motor LoadingARM Stall " }, /* 3018 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL ,"Motor WinderDances Stall " }, /* 3020 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_STALL ,"Motor LoadingARM Stall " }, /* 3023 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_STALL ,"Motor WinderDances Stall " }, /* 3042 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_STALL ,"Motor PullerDancer Stall " }, /* 3043 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_STALL ,"Motor FeederDancer Stall " }, /* 3044 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_STALL ,"Motor DryerLid Stall " }, /* 4019 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_STALL ,"Motor DyeingHeadCover Stall " }, /* 5033 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_STALL ,"Motor DyeingHeadCleaningMechanism Stall " }, /* 5037 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD ,x_STATUS_STEP_LOSS_A , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_STALL ,"Motor DryeingHeadCleaning Stall " }, /* 5041 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE ," MotorRightLoaderUnderVoltage " }, /* 3025 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE ," MotorLeftLoaderUnderVoltage " }, /* 3027 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE ," MotorLoaderARMUnderVoltage " }, /* 3030 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE ," MotorWinderDancerUnderVoltage " }, /* 3045 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE ," MotorPullerDancerUnderVoltage " }, /* 3046 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE ," MotorFeederDancerUnderVoltage " }, /* 3047 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE ," MotorDryerLidUnderVoltage " }, /* 4020 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE ," MotorDyeingHeadCoverUnderVoltage " }, /* 5034 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE ," MotorDyeingHeadCleaningUnderVoltage " }, /* 5038 */ - { eOneSecond, MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE ," MotorDyeingHeadCleaningHeadUnderVoltage " }, /* 5042 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RLOADING , HARDWARE_MOTOR_TYPE__MOTO_RLOADING , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__RIGHT_LOADER_MOTOR_UNDERVOLTAGE ,"Motor RightLoader Under Voltage" }, /* 3025 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LLOADING , HARDWARE_MOTOR_TYPE__MOTO_LLOADING , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LEFT_LOADER_MOTOR_UNDERVOLTAGE ,"Motor LeftLoader Under Voltage" }, /* 3027 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__LOADING_ARM_MOTOR_UNDERVOLTAGE ,"Motor LoaderARM Under Voltage" }, /* 3030 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER2 , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__WINDER_DANCER_MOTOR_UNDERVOLTAGE ,"Motor WinderDancer Under Voltage" }, /* 3045 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , HARDWARE_MOTOR_TYPE__MOTO_LDANCER1 , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__PULLER_DANCER_MOTOR_UNDERVOLTAGE ,"Motor PullerDancer Under Voltage" }, /* 3046 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_RDANCER , HARDWARE_MOTOR_TYPE__MOTO_RDANCER , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__FEEDER_DANCER_MOTOR_UNDERVOLTAGE ,"Motor FeederDancer Under Voltage" }, /* 3047 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , HARDWARE_MOTOR_TYPE__MOTO_DRYER_LID , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DRYER_LID_MOTOR_UNDERVOLTAGE ,"Motor DryerLid Under Voltage" }, /* 4020 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_LID , HARDWARE_MOTOR_TYPE__MOTO_DH_LID , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_COVER_MOTOR_UNDERVOLTAGE ,"Motor DyeingHeadCover Under Voltage" }, /* 5034 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_MECHANISM_MOTOR_UNDERVOLTAGE ,"Motor DyeingHeadCleaning Under Voltage" }, /* 5038 */ + {eOneSecond, ALARM_SOURCE_TYPE__MotorAlarm, HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD , x_STATUS_UVLO , FALSE , DEBUG_LOG_CATEGORY__Error , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_CLEANING_HEAD_MOTOR_UNDERVOLTAGE ,"Motor DyeingHeadCleaningHead Under Voltage" }, /* 5042 */ -// { eOneSecond, CurrentAlarm, HEAD_ZONE_1 , HEAD_ZONE_1 , 312 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE ," Head Zone 1 Heater Current Out Of Range " }, /* 5018 */ -// { eOneSecond, CurrentAlarm, HEAD_ZONE_2 , HEAD_ZONE_2 , 187 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE ," Head Zone 2 Heater Current Out Of Range " }, /* 5019 */ -// { eOneSecond, CurrentAlarm, HEAD_ZONE_3 , HEAD_ZONE_3 , 187 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE ," Head Zone 3 Heater Current Out Of Range " }, /* 5020 */ -// { eOneSecond, CurrentAlarm, HEAD_ZONE_4 , HEAD_ZONE_4 , 312 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE ," Head Zone 4 Heater Current Out Of Range " }, /* 5021 */ -// { eOneSecond, CurrentAlarm, HEAD_ZONE_5_6 , HEAD_ZONE_5_6 , 312 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE ," Head Zone 5-6 Heater Current Out Of Range " }, /* 5022 */ -// { eOneSecond, CurrentAlarm, MIXCHIP , MIXCHIP , 187 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE ," Mixer Heater Current Out Of Range " }, /* 6004 */ -// { eOneSecond, CurrentAlarm, DRYER_CURRENT_1, DRYER_CURRENT_1, 1 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE ," Drier Heater 1 Current Out Of Range " }, /* 6004 */ -// { eOneSecond, CurrentAlarm, DRYER_CURRENT_2, DRYER_CURRENT_2, 1 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE ," Drier Heater 2 Current Out Of Range " }, /* 6004 */ -// {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF,"Dyeing head Thermal Cut-Off"}, + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1 , HEATER_HEAD_CURRENT_ZONE_1 , 125 , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_OUT_OF_RANGE ," Head Zone 1 Heater Current Out Of Range" }, /* 5018 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2 , HEATER_HEAD_CURRENT_ZONE_2 , 187 , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_OUT_OF_RANGE ," Head Zone 2 Heater Current Out Of Range" }, /* 5019 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3 , HEATER_HEAD_CURRENT_ZONE_3 , 187 , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_OUT_OF_RANGE ," Head Zone 3 Heater Current Out Of Range" }, /* 5020 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4 , HEATER_HEAD_CURRENT_ZONE_4 , 312 , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_OUT_OF_RANGE ," Head Zone 4 Heater Current Out Of Range" }, /* 5021 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6 , HEATER_HEAD_CURRENT_ZONE_5_6 , 500 , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_OUT_OF_RANGE ," Head Zone 5-6 Heater Current Out Of Range" }, /* 5022 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT , HEATER_MIXCHIP_CURRENT , 187 , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__MIXER_CURRENT_OUT_OF_RANGE ," Mixer Heater Current Out Of Range" }, /* 6004 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, 800 , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_OUT_OF_RANGE ," Drier Heater 1 Current Out Of Range" }, /* 6004 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, 400 , TRUE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_OUT_OF_RANGE ," Drier Heater 2 Current Out Of Range" }, /* 6004 */ - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK,"Thread Break"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER,"Thread Feeder Tension Control Failure"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,"Thread Puller Tension Control Failure"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,"Thread Winder Tension Control Failure"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,"No cone in winder"}, + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_1 , HEATER_HEAD_CURRENT_ZONE_1 , 0 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_1_CURRENT_LOOP_BREAK ," Head Zone 1 Heater Current Loop Break" }, /* 5018 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_2 , HEATER_HEAD_CURRENT_ZONE_2 , 0 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_2_CURRENT_LOOP_BREAK ," Head Zone 2 Heater Current Loop Break" }, /* 5019 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_3 , HEATER_HEAD_CURRENT_ZONE_3 , 0 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_3_CURRENT_LOOP_BREAK ," Head Zone 3 Heater Current Loop Break" }, /* 5020 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_4 , HEATER_HEAD_CURRENT_ZONE_4 , 0 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_4_CURRENT_LOOP_BREAK ," Head Zone 4 Heater Current Loop Break" }, /* 5021 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_HEAD_CURRENT_ZONE_5_6 , HEATER_HEAD_CURRENT_ZONE_5_6 , 0 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DYEING_HEAD_ZONE_5_6_CURRENT_LOOP_BREAK ," Head Zone 5-6 Heater Current Loop Break" }, /* 5022 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_MIXCHIP_CURRENT , HEATER_MIXCHIP_CURRENT , 0 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__MIXER_CURRENT_LOOP_BREAK ," Mixer Heater Current Loop Break" }, /* 6004 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_1, HEATER_DRYER_CURRENT_1, 0 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_1_CURRENT_LOOP_BREAK ," Drier Heater 1 Current Loop Break" }, /* 6004 */ + {eOneSecond, ALARM_SOURCE_TYPE__CurrentAlarm, HEATER_DRYER_CURRENT_2, HEATER_DRYER_CURRENT_2, 0 , FALSE , DEBUG_LOG_CATEGORY__Warning , 0xFF , 2 , EVENT_TYPE__DRYER_HEATERS_ZONE_2_CURRENT_LOOP_BREAK ," Drier Heater 2 Current Loop Break" }, /* 6004 */ + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DYEING_HEAD_THERMAL_CUTOFF,"Dyeing head Thermal Cut-Off"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_1_OVERPRESSURE,"Dispenser 1 OverPressure"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_2_OVERPRESSURE,"Dispenser 2 OverPressure"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_3_OVERPRESSURE,"Dispenser 3 OverPressure"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_4_OVERPRESSURE,"Dispenser 4 OverPressure"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_5_OVERPRESSURE,"Dispenser 5 OverPressure"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_6_OVERPRESSURE,"Dispenser 6 OverPressure"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_7_OVERPRESSURE,"Dispenser 7 OverPressure"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DISPENSER_8_OVERPRESSURE,"Dispenser 8 OverPressure"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_BREAK,"Thread Break"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_FEEDER_DANCER,"Thread Feeder Tension Control Failure"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,"Thread Puller Tension Control Failure"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,"Thread Winder Tension Control Failure"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,"No cone in winder"}, + + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__DRYER_DOOR_OPEN,"Dryer Door is open"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__NO_AIR_PRESSURE,"No suction in the waste handling system"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Critical,0xFF,0,EVENT_TYPE__AIR_FILTER_NOT_INSTALLED,"Air filter missing"}, + {eOneSecond,ALARM_SOURCE_TYPE__DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT,"Waste Container Emptying Timeout"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__DRYER_DOOR_OPEN,"Dryer Door is open"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__NO_AIR_PRESSURE,"No suction in the waste handling system"}, - {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Safety,0xFF,0,EVENT_TYPE__AIR_FILTER_NOT_INSTALLED,"Air filter missing"}, }; -char AlarmStorePath[25] = "0://SysInfo//AlarmPrm.cfg"; +char AlarmStorePath[25] ="0://SysInfo//AlarmPrm.cfg"; -bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false}; +//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 @@ -337,21 +372,28 @@ void AlarmHandlingInit(void) return; } +void AlarmHandlingSetFlags(bool checkHardLimitAlarms,bool checkCurrentAlarms, bool checkTamperAlarms) +{ + CheckHardLimitAlarms = checkHardLimitAlarms; + CheckCurrentAlarms = checkCurrentAlarms; + CheckTamperAlarms = checkTamperAlarms; +} + JobEndReasonEnum getEndReason(uint32_t AlarmId) { switch (AlarmItem[AlarmId].AlarmSource) { - case TemperatureAlarm: + case ALARM_SOURCE_TYPE__TemperatureAlarm: return JOB_TEMPERATURE_ALARM; - case LimitSwitchAlarm: + case ALARM_SOURCE_TYPE__LimitSwitchAlarm: return JOB_LS_ALARM; - case PressureAlarm: + case ALARM_SOURCE_TYPE__PressureAlarm: return JOB_PRESSURE_ALARM; - case CurrentAlarm: + case ALARM_SOURCE_TYPE__CurrentAlarm: return JOB_CURRENT_ALARM; - case MotorAlarm: + case ALARM_SOURCE_TYPE__MotorAlarm: return JOB_MOTOR_ALARM; - case CoversAlarm: + case ALARM_SOURCE_TYPE__CoversAlarm: return JOB_TAMPER_ALARM; default: return JOB_OTHER_ALARM; @@ -363,12 +405,13 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever //ProcessParameters ProcessParameterZero; switch (AlarmItem[AlarmId].AlarmSource) { - case TemperatureAlarm: + case ALARM_SOURCE_TYPE__TemperatureAlarm: //need to discover the heater Id and shut it down HeaterCommandRequestMessage(AlarmItem[AlarmId].ModuleDeviceId, HEATER_OFF, 0); break; - case LimitSwitchAlarm: - case PressureAlarm: + case ALARM_SOURCE_TYPE__LimitSwitchAlarm: + case ALARM_SOURCE_TYPE__HardLimitAlarm: + case ALARM_SOURCE_TYPE__PressureAlarm: if (Severity == DEBUG_LOG_CATEGORY__Info) { IDS_Dispenser_Alarm_Off(AlarmItem[AlarmId].ModuleDeviceId); @@ -378,9 +421,9 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever IDS_Dispenser_Alarm_On (AlarmItem[AlarmId].ModuleDeviceId); } break; - case CurrentAlarm: + case ALARM_SOURCE_TYPE__CurrentAlarm: break; - case MotorAlarm: + case ALARM_SOURCE_TYPE__MotorAlarm: MotorStop(AlarmItem[AlarmId].ModuleDeviceId,Hard_Hiz); break; default: @@ -393,7 +436,6 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever //raise flag fr next job break; case DEBUG_LOG_CATEGORY__Critical: - case DEBUG_LOG_CATEGORY__Safety: // watchdogCriticalAlarm = true; LOG_ERROR(AlarmId,"Critical Alarm - Watchdog activated to reset hardware"); @@ -417,35 +459,35 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever } /*switch (AlarmItem[AlarmId].AlarmSource) { - case TemperatureAlarm: + case ALARM_SOURCE_TYPE__TemperatureAlarm: //need to discover the heater Id and shut it down // HeaterCommandRequestMessage( HARDWARE_PID_CONTROL_TYPE__MixerHeater, false, // ProcessParams->mixertemp); break; - case LimitSwitchAlarm: + case ALARM_SOURCE_TYPE__LimitSwitchAlarm: if ((AlarmItem[AlarmId].EventType>=EVENT_TYPE__Dispenser1Empty)&&(AlarmItem[AlarmId].EventType<=EVENT_TYPE__Dispenser8Empty)) { Disp_i = AlarmItem[AlarmId].EventType- EVENT_TYPE__Dispenser1Empty; MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz); if (JobIsActive()) { - if (DispenserInUse[Disp_i] == false) + if (DispenserUsedInJob[Disp_i] == false) AlarmItem[AlarmId].Severity = DEBUG_LOG_CATEGORY__Info; } } break; - case PressureAlarm: + case ALARM_SOURCE_TYPE__PressureAlarm: Disp_i = AlarmItem[AlarmId].EventType- EVENT_TYPE__Dispenser1Pressure; MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz); if (JobIsActive()) { - if (DispenserInUse[Disp_i] == false) + if (DispenserUsedInJob[Disp_i] == false) AlarmItem[AlarmId].Severity = DEBUG_LOG_CATEGORY__Info; } break; - case CurrentAlarm: + case ALARM_SOURCE_TYPE__CurrentAlarm: break; - case MotorAlarm: + case ALARM_SOURCE_TYPE__MotorAlarm: break; default: break; @@ -463,24 +505,26 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever } JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) { - JobTicket* JobTicket = CurrentJob; + //JobTicket* JobTicket = CurrentJob; EventType HeaterEventType[MAX_HEATERS_NUM*2] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE, EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE, EVENT_TYPE__MIXER_OVERTEMPERATURE}; EventType HeaterEventTypeUnder[MAX_HEATERS_NUM*2] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B, EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B, EVENT_TYPE__MIXER_UNDERTEMPERATURE_B}; - int Segment_i,Brush_i,Dispenser_i,DispenserId,Alarm_i,Heater_i,AlarmId=0; + int Dispenser_i,Alarm_i,Heater_i,AlarmId=0; HeaterState HeaterState; - for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++) - { - DispenserInUse[Dispenser_i] = false; - } + //for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++) + //{ + // DispenserInUse[Dispenser_i] = false; + //} JobEndReasonEnum status = JOB_OK; - if (JobTicket->n_segments == 0) + IDS_MapDispenserUsedinJob(CurrentJob); + if (n_segments == 0) return OK; - for (Segment_i=0;Segment_i<JobTicket->n_segments;Segment_i++) + + /*for (Segment_i=0;Segment_i<JobTicket->n_segments;Segment_i++) { for (Brush_i=0;Brush_i<JobTicket->segments[Segment_i]->n_brushstops;Brush_i++) { @@ -498,11 +542,12 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) }//if dispensers }//for brush }//for segments + */ if (Configured[Module_IDS]) { for (Dispenser_i=0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++) { - if (DispenserInUse[Dispenser_i] == true) + if (DispenserUsedInJob[Dispenser_i] == true) { for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++) { @@ -521,7 +566,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) } for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++) { - if (AlarmItem[Alarm_i].AlarmSource == CoversAlarm) + if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__CoversAlarm) { if (AlarmState[Alarm_i].Status == true) { @@ -530,7 +575,7 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) break; } } - if (AlarmItem[Alarm_i].AlarmSource == MotorAlarm) + if (AlarmItem[Alarm_i].AlarmSource == ALARM_SOURCE_TYPE__MotorAlarm) { if (AlarmState[Alarm_i].Status == true) { @@ -622,7 +667,6 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value) { if (AlarmState[Alarm_i].Status != value) { - AlarmState[Alarm_i].Status = value; if (value == true) { // no need to call consequent actionsAlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); @@ -630,18 +674,27 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value) AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); if (AlarmState[Alarm_i].EventPtr) { + //ROM_IntMasterDisable(); 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); + AlarmState[Alarm_i].Status = value; } + //ROM_IntMasterEnable(); + Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } else { - Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); + Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); if (AlarmState[Alarm_i].EventPtr) + { + //ROM_IntMasterDisable(); my_free(AlarmState[Alarm_i].EventPtr); + AlarmState[Alarm_i].EventPtr = NULL; + //ROM_IntMasterEnable(); + } + AlarmState[Alarm_i].Status = value; } } break; @@ -678,7 +731,7 @@ uint32_t AlarmHandlingStop(void) uint32_t AlarmHandlingLoop(uint32_t tick) { int Alarm_i; - uint32_t value; + int32_t value; //int32_t ivalue; bool Status = false; for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++) @@ -688,8 +741,8 @@ uint32_t AlarmHandlingLoop(uint32_t tick) { switch (AlarmItem[Alarm_i].AlarmSource) { - /*case TemperatureAlarm: - ivalue = TemperatureSensorRead((TEMPERATURE_SENSOR_ID_ENUM)AlarmItem[Alarm_i].DeviceId); + /*case ALARM_SOURCE_TYPE__TemperatureAlarm: + ivalue = MillisecGetTemperatures((TEMPERATURE_SENSOR_ID_ENUM)AlarmItem[Alarm_i].DeviceId); if (AlarmItem[Alarm_i].AlarmDirection == true) { if (ivalue/100 >= AlarmItem[Alarm_i].AlarmValue) @@ -707,21 +760,45 @@ uint32_t AlarmHandlingLoop(uint32_t tick) } } break;*/ - case CoversAlarm: - value = Get_COVER_1_State(AlarmItem[Alarm_i].DeviceId); - if (value == AlarmItem[Alarm_i].AlarmValue) + case ALARM_SOURCE_TYPE__CoversAlarm: + if (CheckTamperAlarms) { - Status = true; + value = Get_COVER_1_State(AlarmItem[Alarm_i].DeviceId); + if (value == AlarmItem[Alarm_i].AlarmValue) + { + Status = true; + } + } + else + { + value = false; } break; - case LimitSwitchAlarm: + case ALARM_SOURCE_TYPE__LimitSwitchAlarm: value = IDS_CheckDispenserLimitSwitch((LimitSwitchAlarms)AlarmItem[Alarm_i].DeviceId); if (value == AlarmItem[Alarm_i].AlarmValue) { Status = true; } break; - case PressureAlarm: + case ALARM_SOURCE_TYPE__HardLimitAlarm: + if (CheckHardLimitAlarms) + { + if (AlarmItem[Alarm_i].AlarmDirection == true) + { + value = Read_Notification_Disp_UP(AlarmItem[Alarm_i].DeviceId,NULL); + } + else + { + value = Read_Notification_Disp_Down(AlarmItem[Alarm_i].DeviceId,NULL); + } + } + else + { + value = false; + } + break; + case ALARM_SOURCE_TYPE__PressureAlarm: value = GetDispenserPressure(AlarmItem[Alarm_i].DeviceId); if (AlarmItem[Alarm_i].AlarmDirection == true) { @@ -738,24 +815,31 @@ uint32_t AlarmHandlingLoop(uint32_t tick) } } break; - case CurrentAlarm: - value = Get_Heaters_Current_Integer(AlarmItem[Alarm_i].DeviceId); - if (AlarmItem[Alarm_i].AlarmDirection == true) + case ALARM_SOURCE_TYPE__CurrentAlarm: + if (CheckCurrentAlarms) { - if (value >= AlarmItem[Alarm_i].AlarmValue) + value = Get_Heaters_Current_Integer(AlarmItem[Alarm_i].DeviceId); + if (AlarmItem[Alarm_i].AlarmDirection == true) { - Status = true; + if ((value >= (AlarmItem[Alarm_i].AlarmValue*1.07))||(value <= (AlarmItem[Alarm_i].AlarmValue*0.80))) + { + Status = true; + } + } + else + { + if (value == 0) + { + Status = true; + } } } else { - if (value <= AlarmItem[Alarm_i].AlarmValue) - { - Status = true; - } + value = false; } break; - case MotorAlarm: + case ALARM_SOURCE_TYPE__MotorAlarm: if (isMotorConfigured((TimerMotors_t)AlarmItem[Alarm_i].DeviceId) == false) { Status = false; @@ -777,8 +861,25 @@ uint32_t AlarmHandlingLoop(uint32_t tick) } } break; - case TemperatureAlarm: - case DoNotPollAlarm: + case ALARM_SOURCE_TYPE__FluidLevelAlarm: + value = Get_MidTank_Int100_Sensor(AlarmItem[Alarm_i].DeviceId); + if (AlarmItem[Alarm_i].AlarmDirection == OVER_VALUE) + { + if (value*100 > AlarmItem[Alarm_i].AlarmValue) + { + Status = true; + } + } + else + { + if (value*100 < AlarmItem[Alarm_i].AlarmValue) + { + Status = true; + } + } + break; + case ALARM_SOURCE_TYPE__TemperatureAlarm: + case ALARM_SOURCE_TYPE__DoNotPollAlarm: Status = AlarmState[Alarm_i].Status; break; default: @@ -826,8 +927,6 @@ uint32_t AlarmHandlingLoop(uint32_t tick) { if (Status == true) // alarm on { - AlarmState[Alarm_i].Status = true; - AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); // report the alarm! AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); if (AlarmState[Alarm_i].EventPtr) @@ -837,15 +936,21 @@ uint32_t AlarmHandlingLoop(uint32_t tick) AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; } + AlarmState[Alarm_i].Status = true; + AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } else // alarm off { - AlarmState[Alarm_i].Status = false; - AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info); - // report the alarm! if (AlarmState[Alarm_i].EventPtr) + { + //ROM_IntMasterDisable(); my_free(AlarmState[Alarm_i].EventPtr); + AlarmState[Alarm_i].EventPtr = NULL; + //ROM_IntMasterEnable(); + } + AlarmState[Alarm_i].Status = false; + AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info); Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i); } } @@ -927,20 +1032,33 @@ void SendEventNotifications(void) response.n_events++; } } - response.events = (Event **)my_malloc(sizeof(Event*)*response.n_events); - if(response.events) + + if (response.n_events) { - for (i = 0;i<MAX_SYSTEM_ALARMS;i++) + response.events = (Event **)my_malloc(sizeof(Event*)*response.n_events); + if(response.events) { - if (AlarmState[i].Status == true) + for (i = 0;i<MAX_SYSTEM_ALARMS;i++) { - if (AlarmState[i].EventPtr) + if (AlarmState[i].Status == true) { - response.events[e]=AlarmState[i].EventPtr; - e++; + if (AlarmState[i].EventPtr) + { + response.events[e]=AlarmState[i].EventPtr; + e++; + } } } } + else + { + LOG_ERROR(response.n_events,"events malloc error"); + return; + } + } + else + { + response.events = NULL; } responseContainer = createAllocatedContainer(MESSAGE_TYPE__StartEventsNotificationResponse, AlarmHandlingToken, false, &response, &start_events_notification_response__pack, &start_events_notification_response__get_packed_size,&alarm_response_buffer); responseContainer.continuous = true; diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h index 4f9db2fc1..09dfa3f3d 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.h @@ -21,5 +21,6 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob); uint32_t StartEventsNotificationRequestFunc(MessageContainer* requestContainer); uint32_t StopEventsNotificationRequestFunc(MessageContainer* requestContainer); uint32_t ResolveEventRequestFunc(MessageContainer* requestContainer); +void AlarmHandlingSetFlags(bool CheckHardLimitAlarms,bool CheckCurrentAlarms, bool checkTamperAlarms); #endif /* MODULES_ALARMHANDLING_ALARMHANDLING_H_ */ diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c index a580dce02..193769265 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c @@ -84,6 +84,8 @@ typedef struct MillisecMessage{ uint32_t Dancer_Data[NUM_OF_DANCERS] = {0}; float Speed_Data = 0; uint32_t DrawerFansStatus = 0; +uint32_t SystemFansStatus = 0; +uint8_t Gas_PPM = 0; bool watchdogCriticalAlarm = false; @@ -443,18 +445,50 @@ uint32_t MillisecLoop(uint32_t tick) #endif return OK; } +int TemperatureSum[MAX_TEMPERATURE_SENSOR_ID]; +int TemperatureMin[MAX_TEMPERATURE_SENSOR_ID]; +int TemperatureMax[MAX_TEMPERATURE_SENSOR_ID]; +int TemperatureCount[MAX_TEMPERATURE_SENSOR_ID]; +int TemperatureCalc[MAX_TEMPERATURE_SENSOR_ID]; +void MillisecUpdateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId,int temperature) +{ + //if(TemperatureCount[SensorId]++>=10) + // TemperatureCount[SensorId] = 0; + TemperatureCount[SensorId]++; + if (TemperatureMax[SensorId]<temperature) TemperatureMax[SensorId]=temperature; + if (TemperatureMin[SensorId]>temperature) TemperatureMin[SensorId]=temperature; + TemperatureSum[SensorId]+=temperature; +} +int MillisecCalculateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId) +{ + int calc = 0; + TemperatureSum[SensorId]-=TemperatureMax[SensorId]; + TemperatureSum[SensorId]-=TemperatureMin[SensorId]; + calc = TemperatureSum[SensorId] / (TemperatureCount[SensorId]-2); + + TemperatureSum[SensorId] = 0; + TemperatureCount[SensorId] = 0; + TemperatureMin[SensorId] = 30000; + TemperatureMax[SensorId] = -30000; + return calc; +} +int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId) +{ + return TemperatureCalc[SensorId]; +} uint32_t MillisecLowLoop(uint32_t tick) { - uint8_t Motor_i,Disp_i,Heater_i; + uint8_t Motor_i,Disp_i,Heater_i,temp; TEMPERATURE_SENSOR_ID_ENUM Sensor_i; //static int temp=0; //call all modules Millisec functions //test dancers and speed encoders //check all callback units (state machine waiting for completion of a change) - bool Ten_msTick, Hundred_msTick, Onesecond_Tick,O900Millisecond_Tick,OneMinute_Tick; + bool Ten_msTick, Hundred_msTick , m90msecTick, Onesecond_Tick,O900Millisecond_Tick,OneMinute_Tick; Ten_msTick = (tick%eTenMillisecond == 0) ?true:false; Hundred_msTick = (tick%eHundredMillisecond == 0) ?true:false; + m90msecTick = (tick%eHundredMillisecond == 90) ?true:false; O900Millisecond_Tick = (tick%eOneSecond == 900) ?true:false; Onesecond_Tick = (tick%eOneSecond == 0) ?true:false; OneMinute_Tick = (tick%eOneMinute == 0) ?true:false; @@ -469,18 +503,27 @@ uint32_t MillisecLowLoop(uint32_t tick) if(Machine_Idle_Mode == true) Machine_Idle_Breathing_Led(); } + if (m90msecTick) + { + for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++) + { + MillisecReadFromTempSensor(Sensor_i, NULL); + } + } if (Hundred_msTick) { Speed_Data = Calculate_Speed_Sensor_Velocity(); + Read_Buttons_Reg(); for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++) { - MillisecReadFromTempSensor(Sensor_i, NULL); + MillisecUpdateTemperatures (Sensor_i,TemperatureSensorRead(Sensor_i)); } if (GeneralHwReady == true) { if (watchdogCriticalAlarm == false) { Control_WD(ENABLE,5); //activate heaters/dispenser watchdog, 0.5 seconds + //LOG_ERROR (1111, "Control_WD"); } } } @@ -497,7 +540,9 @@ uint32_t MillisecLowLoop(uint32_t tick) //Read_MidTank_Pressure_Sensor(Disp_i); } FPGA_GetAllDispensersValveBusyOCD(); - DrawerFansStatus = Read_Fans_Tacho(); + temp = Read_Fans_Tacho(); + DrawerFansStatus = temp & 0x1F; + SystemFansStatus = temp & 0xE0; KeepAliveOneSecondCall(); for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++) { @@ -506,9 +551,14 @@ uint32_t MillisecLowLoop(uint32_t tick) if (isMotorConfigured(Motor_i)) MotorGetStatusFromFPGA(Motor_i); } - for (Heater_i = 0;Heater_i < NUM_OF_HEATERS;Heater_i++) + for (Heater_i = 0;Heater_i < NUM_OF_CURRENT_HEATERS;Heater_i++) + { + Read_Heaters_Current(Heater_i); + } + Gas_PPM = Calculate_Gas_Power_Consumption(); + for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++) { - Read_Head_MixChip_Heaters_Current(Heater_i); + TemperatureCalc[Sensor_i] = MillisecCalculateTemperatures ( Sensor_i); } } if (OneMinute_Tick) @@ -617,6 +667,15 @@ uint32_t getDrawerFansStatus(void) { return DrawerFansStatus; } +uint8_t getGasReading(void) +{ + return Gas_PPM; +} + +uint32_t getSystemFansStatus(void) +{ + return SystemFansStatus; +} #ifdef HUNDRED_MICROSECONDS_DANCER_READ uint32_t DancerData[NUM_OF_DANCERS]; uint32_t Control_Read_Dancer_Position(HardwareDancerType DancerId, uint32_t Parameter1, uint32_t Parameter2) diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h index 61c7df7ee..be82d9e98 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h +++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h @@ -31,6 +31,10 @@ uint32_t getADCData(int DeviceId); */ float getSensorSpeedData(void); uint32_t getDrawerFansStatus(void); +uint32_t getSystemFansStatus(void); +uint8_t getGasReading(void); +int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId); + void MillisecInit(void); void MillisecStop(void); diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c index 52b52d93b..b316fd73f 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c @@ -69,7 +69,7 @@ typedef struct uint32_t StartTick; DataReadCBFunction ControlDataReadPtr; ControlCBFunction ControlCallbackPtr; - uint16_t ControlTiming; + uint32_t ControlTiming; }ControlDeviceStruc; typedef enum @@ -166,11 +166,51 @@ uint32_t ControlActivityLed( uint32_t Parameter1) ACTIVITY_RED_LED_OFF; // Heaters indication - all the Heaters OFF if(power.color == fastBILNK) Pannel_Leds(POWER_ON_OFF,MODE_OFF); - + else if((power.color == BLINK) && (counter % Blink_Freq == 0) ) { Pannel_Leds(POWER_ON_OFF,MODE_OFF); } + /////////////////////////////////////////////////////////// + if(jog.color == fastBILNK) + Pannel_Leds(THREAD_JOGGING,MODE_OFF); + else + if((jog.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(THREAD_JOGGING,MODE_OFF); + } + /////////////////////////////////////////////////////////// + if(load.color == fastBILNK) + Pannel_Leds(THREAD_LOAD,MODE_OFF); + else + if((load.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(THREAD_LOAD,MODE_OFF); + } + /////////////////////////////////////////////////////////// + if(cart1.color == fastBILNK) + Pannel_Leds(CART_1,MODE_OFF); + else + if((cart1.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_1,MODE_OFF); + } + /////////////////////////////////////////////////////////// + if(cart2.color == fastBILNK) + Pannel_Leds(CART_2,MODE_OFF); + else + if((cart2.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_2,MODE_OFF); + } + /////////////////////////////////////////////////////////// + if(cart3.color == fastBILNK) + Pannel_Leds(CART_3,MODE_OFF); + else + if((cart3.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_3,MODE_OFF); + } flag = false; } else @@ -181,11 +221,53 @@ uint32_t ControlActivityLed( uint32_t Parameter1) if(power.color == fastBILNK) Pannel_Leds(POWER_ON_OFF,MODE_ON); - + else if((power.color == BLINK) && (counter % Blink_Freq == 0) ) { Pannel_Leds(POWER_ON_OFF,MODE_ON); } + /////////////////////////////////////////////////////////// + if(jog.color == fastBILNK) + Pannel_Leds(THREAD_JOGGING,MODE_ON); + else + if((jog.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(THREAD_JOGGING,MODE_ON); + } + /////////////////////////////////////////////////////////// + if(load.color == fastBILNK) + Pannel_Leds(THREAD_LOAD,MODE_ON); + else + if((load.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(THREAD_LOAD,MODE_ON); + } + /////////////////////////////////////////////////////////// + if(cart1.color == fastBILNK) + Pannel_Leds(CART_1,MODE_ON); + else + if((cart1.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_1,MODE_ON); + } + /////////////////////////////////////////////////////////// + if(cart2.color == fastBILNK) + Pannel_Leds(CART_2,MODE_ON); + else + if((cart2.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_2,MODE_ON); + } + /////////////////////////////////////////////////////////// + if(cart3.color == fastBILNK) + Pannel_Leds(CART_3,MODE_ON); + else + if((cart3.color == BLINK) && (counter % Blink_Freq == 0) ) + { + Pannel_Leds(CART_3,MODE_ON); + } + + flag = true; } @@ -224,7 +306,7 @@ void ControlStart(void) * both these callbacks can be removed. if a new call is arriving, it invalidates the previous one (no dual control or data) * ***************************************************************************************************************************************************/ -uint32_t AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ) +uint32_t AddControlCallback( ControlCBFunction Callback, uint32_t CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ) { assert(Callback); assert(DriverfPtr); diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.h b/Software/Embedded_SW/Embedded/Modules/Control/control.h index 8d7e219ac..380040e34 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.h +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h @@ -19,7 +19,8 @@ typedef enum { eTenMillisecond = 10, eHundredMillisecond = 100, eOneSecond = 1000, - eOneMinute = 60000 + eOneMinute = 60000, + eOneHour = 3600000 }CTRL_TIMING_ENUM; typedef enum { @@ -37,7 +38,7 @@ typedef enum void ControlInit(void); void ControlStop(void); void ControlStart(void); -uint32_t AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ); +uint32_t AddControlCallback( ControlCBFunction Callback, uint32_t CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ); int RemoveControlCallback(uint32_t deviceId, ControlCBFunction Callback ); //The safe remove command can be used ONLY when called from the control callback itself int SafeRemoveControlCallback(uint32_t deviceId , ControlCBFunction Callback); diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c index 7bd537e9c..b0a1945db 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/DiagnosticActions.c @@ -120,16 +120,11 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer) Valve_Set(IDS_Id_to_CartrideValve[portId], request->value ); //Atm_MidTank_OFF/ON break; case INTERFACE_IOS__GPO_DRYER_SSR3_CTRL: -#ifdef DEMO_TEMPERATURE - HeaterTestActive[0] = false; -#endif + //CLEANER_PUMP_SSR3_CTRL if (request->value == true) - ActivateHeater(0); + ActivateCleanerPump(); else - DeActivateHeater(0); -#ifdef DEMO_TEMPERATURE - HeaterTestActive[0] = true; -#endif + DeActivateCleanerPump(); break; case INTERFACE_IOS__GPO_DRYER_SSR1_CTRL: #ifdef DEMO_TEMPERATURE @@ -260,6 +255,18 @@ uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer) else Valve_Set(VALVE_MIXCHIP_WASTECH,0); break; + case INTERFACE_IOS__GPO_BLOWER_PWM: + if (request->value == true) + Control_Dryer_Fan(START,75);//use START or STOP, 0 - 100%(); + else + Control_Dryer_Fan(STOP,0);//use START or STOP, 0 - 100%(); + break; + case INTERFACE_IOS__GPO_WASTECH_PUMP2://valve + Valve_Set(VALVE_WASTE_TANK, request->value); + break; + case INTERFACE_IOS__GPO_WHS_WTANKPUMP2: + SetWastePump( request->value); + break; default: responseContainer.has_error = true; responseContainer.error = ERROR_CODE__GENERAL_ERROR; diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c index 72dd92d54..5ef216264 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c @@ -29,6 +29,7 @@ #include "Modules/AlarmHandling/AlarmHandling.h" #include "Modules/heaters/heaters_ex.h" #include "modules/thread/thread_ex.h" +#include "modules/waste/waste.h" #include "PMR/Hardware/HardwareDancerType.pb-c.h" #include <PMR/Diagnostics/StartDiagnosticsRequest.pb-c.h> @@ -45,6 +46,10 @@ #include "StateMachines/Printing/PrintingSTM.h" +#include <drivers/FPGA/FPGA_Comm.h> + +extern F2_CTRL_REG F2_CTRL_Reg; + char DiagnosticsToken[36+1] = {0}; bool DiagnosticsActive = false; @@ -67,31 +72,32 @@ int DiagnosticCollectionLimit = 2; //number of data samples to collect before s int DiagnosticLimit =eHundredMillisecond; //frequency of data collection int DiagnosticFastLimit = eTenMillisecond; //frequency of data collection -//DigitalPin DigitalPinArray[1][DIAGNOSTICS_LIMIT]; -double dancer1angle[DIAGNOSTICS_LIMIT]; -double dancer2angle[DIAGNOSTICS_LIMIT]; -double dancer3angle[DIAGNOSTICS_LIMIT]; +//DigitalPin DigitalPinArray[1][DIAGNOSTICS_LIMIT+1]; +double dancer1angle[DIAGNOSTICS_LIMIT+1]; +double dancer2angle[DIAGNOSTICS_LIMIT+1]; +double dancer3angle[DIAGNOSTICS_LIMIT+1]; -double feedermotorfrequency[DIAGNOSTICS_LIMIT]; -double dryermotor[DIAGNOSTICS_LIMIT]; -double pollermotor[DIAGNOSTICS_LIMIT]; -double windermotor[DIAGNOSTICS_LIMIT]; -double screwmotor[DIAGNOSTICS_LIMIT]; -double mixertemperature[DIAGNOSTICS_LIMIT]; -double headzone1temperature[DIAGNOSTICS_LIMIT]; -double headzone2temperature[DIAGNOSTICS_LIMIT]; -double headzone3temperature[DIAGNOSTICS_LIMIT]; -double headzone4temperature[DIAGNOSTICS_LIMIT]; -double headzone5temperature[DIAGNOSTICS_LIMIT]; -double headzone6temperature[DIAGNOSTICS_LIMIT]; -double dryerzone1temperature[DIAGNOSTICS_LIMIT]; -double dryerzone2temperature[DIAGNOSTICS_LIMIT]; -double dryerzone3temperature[DIAGNOSTICS_LIMIT]; +double feedermotorfrequency[DIAGNOSTICS_LIMIT+1]; +double dryermotor[DIAGNOSTICS_LIMIT+1]; +double pollermotor[DIAGNOSTICS_LIMIT+1]; +double windermotor[DIAGNOSTICS_LIMIT+1]; +double screwmotor[DIAGNOSTICS_LIMIT+1]; +double mixertemperature[DIAGNOSTICS_LIMIT+1]; +double headzone1temperature[DIAGNOSTICS_LIMIT+1]; +double headzone2temperature[DIAGNOSTICS_LIMIT+1]; +double headzone3temperature[DIAGNOSTICS_LIMIT+1]; +double headzone4temperature[DIAGNOSTICS_LIMIT+1]; +double headzone5temperature[DIAGNOSTICS_LIMIT+1]; +double headzone6temperature[DIAGNOSTICS_LIMIT+1]; +double dryerzone1temperature[DIAGNOSTICS_LIMIT+1]; +double dryerzone2temperature[DIAGNOSTICS_LIMIT+1]; +double dryerzone3temperature[DIAGNOSTICS_LIMIT+1]; -double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT]; -double dispenserspressure[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT]; +double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1]; +double dispenserspressure[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT+1]; double MidTankpressure[MAX_SYSTEM_DISPENSERS][1]; +double HeatersCurrent[NUM_OF_CURRENT_HEATERS][1]; DoubleArray DispenserFreq[MAX_SYSTEM_DISPENSERS]; DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS]; @@ -99,15 +105,15 @@ DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS]; HeaterState **heatersstates; HeaterState HeaterInfo[HEATER_TYPE__MixerHeater+1]; DigitalInterfaceState **digitalinterfacestates; -DigitalInterfaceState DigitalOutputState[MAX_HEATERS_NUM+2]; -/*double dispenser1motorfrequency[DIAGNOSTICS_LIMIT]; -double dispenser2motorfrequency[DIAGNOSTICS_LIMIT]; -double dispenser3motorfrequency[DIAGNOSTICS_LIMIT]; -double dispenser4motorfrequency[DIAGNOSTICS_LIMIT]; -double dispenser5motorfrequency[DIAGNOSTICS_LIMIT]; -double dispenser6motorfrequency[DIAGNOSTICS_LIMIT]; -double dispenser7motorfrequency[DIAGNOSTICS_LIMIT]; -double dispenser8motorfrequency[DIAGNOSTICS_LIMIT]; +DigitalInterfaceState DigitalOutputState[MAX_HEATERS_NUM+8]; +/*double dispenser1motorfrequency[DIAGNOSTICS_LIMIT+1]; +double dispenser2motorfrequency[DIAGNOSTICS_LIMIT+1]; +double dispenser3motorfrequency[DIAGNOSTICS_LIMIT+1]; +double dispenser4motorfrequency[DIAGNOSTICS_LIMIT+1]; +double dispenser5motorfrequency[DIAGNOSTICS_LIMIT+1]; +double dispenser6motorfrequency[DIAGNOSTICS_LIMIT+1]; +double dispenser7motorfrequency[DIAGNOSTICS_LIMIT+1]; +double dispenser8motorfrequency[DIAGNOSTICS_LIMIT+1]; */ Task_Handle Diagnostics_Task_Handle; Mailbox_Handle DiagnosticsMsgQ = NULL; @@ -163,8 +169,8 @@ void DiagnosticsInit(void) heater_state__init(&HeaterInfo[i]); heatersstates[i] = &HeaterInfo[i]; } - digitalinterfacestates = (DigitalInterfaceState**)my_malloc(sizeof(DigitalInterfaceState *)*MAX_HEATERS_NUM); - for (i = 0;i<MAX_HEATERS_NUM;i++ ) + digitalinterfacestates = (DigitalInterfaceState**)my_malloc(sizeof(DigitalInterfaceState *)*(MAX_HEATERS_NUM+8)); + for (i = 0;i<(MAX_HEATERS_NUM+8);i++ ) { digital_interface_state__init(&DigitalOutputState[i]); DigitalOutputState[i].has_interfaceio = true; @@ -182,15 +188,15 @@ void SetDiagnosticCollectionLimit(int limit) } uint8_t HeaterCounterIndex[MAX_HEATERS_NUM]= {0,0,0,0,0,0,0,0,0,0}; -double HeaterTemperature[MAX_HEATERS_NUM][DIAGNOSTICS_LIMIT]; +double HeaterTemperature[MAX_HEATERS_NUM][DIAGNOSTICS_LIMIT+1]; uint8_t DancerCounterIndex[NUM_OF_DANCERS]= {0,0,0}; -double DancerValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT]; +double DancerValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT+1]; int8_t DancerErrorCounterIndex[NUM_OF_DANCERS]= {0,0,0}; -double DancerErrorValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT]; +double DancerErrorValue[NUM_OF_DANCERS][DIAGNOSTICS_DANCER_LIMIT+1]; uint8_t MotorCounterIndex[MAX_THREAD_MOTORS_NUM]= {0,0,0}; -double MotorValue[MAX_THREAD_MOTORS_NUM][DIAGNOSTICS_LIMIT]; +double MotorValue[MAX_THREAD_MOTORS_NUM][DIAGNOSTICS_LIMIT+1]; uint8_t SpeedCounterIndex= 0; -double SpeedValue[DIAGNOSTICS_DANCER_LIMIT]; +double SpeedValue[DIAGNOSTICS_DANCER_LIMIT+1]; void DiagnosticLoadMotor(int MotorId, int frequency) { @@ -208,7 +214,10 @@ void DiagnosticLoadMotor(int MotorId, int frequency) void DiagnosticsLoadDigitalValues(void) { DigitalOutputState[0].interfaceio = INTERFACE_IOS__GPO_DRYER_SSR3_CTRL; - DigitalOutputState[0].value = GetHeaterState(0); + if(F2_CTRL_Reg.ushort & CLEANER_PUMP_SSR3_CTRL) + DigitalOutputState[0].value = true; + else + DigitalOutputState[0].value = false; DigitalOutputState[1].interfaceio = INTERFACE_IOS__GPO_DRYER_SSR1_CTRL; DigitalOutputState[1].value = GetHeaterState(1); @@ -243,6 +252,18 @@ void DiagnosticsLoadDigitalValues(void) DigitalOutputState[11].interfaceio = INTERFACE_IOS__GPO_LED4; DigitalOutputState[11].value = DataUpdated; + DigitalOutputState[12].interfaceio = INTERFACE_IOS__GPI_WCONTAINER_FULL; + DigitalOutputState[12].value = WHS_IsContainerOverflow(); + + DigitalOutputState[13].interfaceio = INTERFACE_IOS__GPI_WCONTAINER_WARN; + DigitalOutputState[13].value = WHS_IsContainerFull(); + + DigitalOutputState[14].interfaceio = INTERFACE_IOS__GPO_SPARE1_1; /*waste lower cartridge presence*/ + DigitalOutputState[14].value = WHS_WasteCartridgeLowerPresent(); + + DigitalOutputState[15].interfaceio = INTERFACE_IOS__GPO_SPARE1_2; /*waste middle cartridge presence*/ + DigitalOutputState[15].value = WHS_WasteCartridgeMiddlePresent(); + } void DiagnosticLoadTemperature(int HeaterId, int temperature) { @@ -330,23 +351,27 @@ void Diagnostic100msecCollection(void) DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR)); DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR)); } - DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, TemperatureSensorRead( MIXER_PT100)); - DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP1)); - DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP2)); - DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP3)); - DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP4)); - DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP5)); - DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, TemperatureSensorRead(HEAD6_PT100)); + DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100)); + DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1)); + DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2)); + DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP3)); + DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP4)); + DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5)); + DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100)); - DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP1)); - DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP2)); - DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP3)); + DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1)); + DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2)); + DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP3)); for (i=0;i<MAX_SYSTEM_DISPENSERS;i++) { dispensermotorfrequency[i][DiagnosticsIndex] = IdsGetMotorSpeed(i); dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i); } + for (i=0;i<NUM_OF_CURRENT_HEATERS;i++) + { + HeatersCurrent[i][0] = Get_Heaters_Current(i); + } /* dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1); dispenser2motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2); dispenser3motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3); @@ -551,12 +576,30 @@ void SendDiagnostics(void) DiagnosticsMonitor.midtank7level = MidTankpressure[6]; DiagnosticsMonitor.n_midtank8level = 1; DiagnosticsMonitor.midtank8level = MidTankpressure[7]; + + DiagnosticsMonitor.n_drierzone1heatercurrent = 1; + DiagnosticsMonitor.drierzone1heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_1]; + DiagnosticsMonitor.n_drierzone2heatercurrent = 1; + DiagnosticsMonitor.drierzone2heatercurrent = HeatersCurrent[HEATER_DRYER_CURRENT_2]; + DiagnosticsMonitor.n_mixer1heatercurrent = 1; + DiagnosticsMonitor.mixer1heatercurrent = HeatersCurrent[HEATER_MIXCHIP_CURRENT]; + DiagnosticsMonitor.n_headzone1heatercurrent = 1; + DiagnosticsMonitor.headzone1heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_1]; + DiagnosticsMonitor.n_headzone2heatercurrent = 1; + DiagnosticsMonitor.headzone2heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_2]; + DiagnosticsMonitor.n_headzone3heatercurrent = 1; + DiagnosticsMonitor.headzone3heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_3]; + DiagnosticsMonitor.n_headzone4heatercurrent = 1; + DiagnosticsMonitor.headzone4heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_4]; + DiagnosticsMonitor.n_headzone5_6heatercurrent = 1; + DiagnosticsMonitor.headzone5_6heatercurrent = HeatersCurrent[HEATER_HEAD_CURRENT_ZONE_5_6]; + response.monitors = &DiagnosticsMonitor; //response.digitalpins = DigitalPinArray; response.n_componentsstates = 0; DiagnosticsLoadDigitalValues(); - response.n_digitalinterfacestates = MAX_HEATERS_NUM; + response.n_digitalinterfacestates = MAX_HEATERS_NUM+6; response.digitalinterfacestates = digitalinterfacestates; for (i=HEATER_TYPE__DryerAirHeater;i<=HEATER_TYPE__MixerHeater;i++) diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index 97bb2e245..0e35e09a7 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -40,6 +40,8 @@ #include "StateMachines/Printing/PrintingSTM.h" #include "StateMachines/Initialization/InitSequence.h" +#include "StateMachines/Initialization/PowerIdle.h" +#include "StateMachines/Initialization/PowerOffSequence.h" uint32_t EmbeddedParametersInit(void); uint32_t EmbeddedParametersWrite(void * buffer, uint16_t size); @@ -58,7 +60,7 @@ uint32_t HWConfigurationInit(void) uint8_t* buffer = NULL; uint32_t Bytes = 0,i,j,k=0; uint32_t status = OK; - UploadHardwareConfigurationRequest* UploadRequest; + UploadHardwareConfigurationRequest* UploadRequest=0; GeneralHwReady = false; Control_WD(ENABLE,250); @@ -140,7 +142,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_dispenserbuildpressurelag = true; EmbeddedParameters.dispenserbuildpressurelag=50; EmbeddedParameters.has_acheatersloweroperationlimit = true; - EmbeddedParameters.acheatersloweroperationlimit = 995; + EmbeddedParameters.acheatersloweroperationlimit = 980; EmbeddedParameters.has_acheatersupperoperationlimit = true; EmbeddedParameters.acheatersupperoperationlimit = 1005; EmbeddedParameters.has_dcheatersloweroperationlimit = true; @@ -148,7 +150,43 @@ void LoadConfigurationParameters(ConfigurationParameters *Params) EmbeddedParameters.has_dcheatersupperoperationlimit = true; EmbeddedParameters.dcheatersupperoperationlimit = 1002; EmbeddedParameters.has_midtankpressurecorrection = true; - EmbeddedParameters.midtankpressurecorrection = 0.5; + EmbeddedParameters.midtankpressurecorrection = 0.0; + EmbeddedParameters.has_dispenserpresegmentwfcf = true; + EmbeddedParameters.dispenserpresegmentwfcf = 80; + EmbeddedParameters.has_startheatingoninitsequence = true; + EmbeddedParameters.startheatingoninitsequence = false; +//size_t n_generalparameters; +// EmbeddedParameters.*generalparameters; + EmbeddedParameters.has_currentalarmlowlimit = true; + EmbeddedParameters.currentalarmlowlimit = 0.80; + EmbeddedParameters.has_currentalarmhighlimit = true; + EmbeddedParameters.currentalarmhighlimit= 1.07; + EmbeddedParameters.has_ids_segmentrefilltimeout = true; + EmbeddedParameters.ids_segmentrefilltimeout = 5000; + EmbeddedParameters.has_ids_presegmentbuilduptime = true; + EmbeddedParameters.ids_presegmentbuilduptime = 5000; + EmbeddedParameters.has_ids_cleaningspeed = true; + EmbeddedParameters.ids_cleaningspeed = 50; + EmbeddedParameters.has_ids_cleaningstopbeforesegmenttime = true; + EmbeddedParameters.ids_cleaningstopbeforesegmenttime = 3000; + EmbeddedParameters.has_ids_cleaningstartspraypresegmenttime = true; + EmbeddedParameters.ids_cleaningstartspraypresegmenttime = 1000; + EmbeddedParameters.has_ids_leftcleaningmotorspeed = true; + EmbeddedParameters.ids_leftcleaningmotorspeed = 30; + EmbeddedParameters.has_ids_rightcleaningmotorspeed = true; + EmbeddedParameters.ids_rightcleaningmotorspeed = 23; + EmbeddedParameters.has_switchtoidletimeinseconds = true; + EmbeddedParameters.switchtoidletimeinseconds = 3600; + EmbeddedParameters.has_idledriertemperature = true; + EmbeddedParameters.idledriertemperature = 80; + EmbeddedParameters.has_idleheadtemperature = true; + EmbeddedParameters.idleheadtemperature = 80; + EmbeddedParameters.has_idlemixertemperature = true; + EmbeddedParameters.idlemixertemperature = 0; + EmbeddedParameters.has_powerofftemperaturelimit = true; + EmbeddedParameters.powerofftemperaturelimit = 50; + EmbeddedParameters.has_ids_presegment_wfcf_timebeforesegment = true; + EmbeddedParameters.ids_presegment_wfcf_timebeforesegment = 1500; uint8_t* response_buffer = my_malloc(configuration_parameters__get_packed_size(&EmbeddedParameters)); size_t response_size = 0; if (response_buffer) @@ -169,27 +207,39 @@ uint32_t EmbeddedParametersInit(void) ConfigurationParameters *Params; Fresult = FileRead(EmbeddedParametersPath, &Bytes, &buffer); - if (Fresult == FR_OK) + /*if (Fresult == FR_OK) { - Params = configuration_parameters__unpack(NULL, Bytes, buffer)/*(ConfigurationParameters *)buffer*/; + Params = configuration_parameters__unpack(NULL, Bytes, buffer); LoadConfigurationParameters(Params); DataUpdated=true; free (buffer); - configuration_parameters__free_unpacked(NULL,Params); + configuration_parameters__free_unpacked(Params,NULL); } - else + else*/ { LoadConfigurationParameters(0); } IDS_Dispenser_SetTimeOutValues(EmbeddedParameters.closevalvetimeout, EmbeddedParameters.openvalvetimeout); IDS_Dispenser_SetBackLashValues(EmbeddedParameters.initialdispenserpressure, EmbeddedParameters.initialdispensertimeout, EmbeddedParameters.initialdispensertimelag); IDS_Dispenser_SetPrepareValues(EmbeddedParameters.dispenserbuildpressurespeed, EmbeddedParameters.dispenserbuildpressurelimit, EmbeddedParameters.dispenserbuildpressuretimeout, EmbeddedParameters.dispenserbuildpressurelag); + IDS_Dispenser_SetPreSegmentWFCFValues(EmbeddedParameters.dispenserpresegmentwfcf, EmbeddedParameters.ids_presegment_wfcf_timebeforesegment); + IDS_Dispenser_SetPreSegmentCleaningValues(EmbeddedParameters.ids_cleaningspeed,EmbeddedParameters.ids_cleaningstartspraypresegmenttime ,EmbeddedParameters.ids_cleaningstopbeforesegmenttime,EmbeddedParameters.ids_leftcleaningmotorspeed,EmbeddedParameters.ids_rightcleaningmotorspeed); + Heaters_SetOverHeatTimeOutValues( EmbeddedParameters.overheatcountlimit, EmbeddedParameters.underheatcountlimit); Heaters_SetOperationLimits(EmbeddedParameters.acheatersloweroperationlimit,EmbeddedParameters.acheatersupperoperationlimit,EmbeddedParameters.dcheatersloweroperationlimit,EmbeddedParameters.dcheatersupperoperationlimit); MidTankPressureCorrection(EmbeddedParameters.midtankpressurecorrection); SetDiagnosticCollectionLimit(EmbeddedParameters.diagnosticcollectionlimit); ThreadSetBreakSensorLimit(EmbeddedParameters.breaksensorlimit); + PowerOffSetTemperatureThreshold(EmbeddedParameters.powerofftemperaturelimit); + + InitSequenceSetStartHeating (EmbeddedParameters.startheatingoninitsequence); + bool a1,a2,a3; + a1 = (EmbeddedParameters.generalparameters[0] < 0.5)?false:true; + a2 = (EmbeddedParameters.generalparameters[1] < 0.5)?false:true; + a3 = (EmbeddedParameters.generalparameters[2] < 0.5)?false:true; + AlarmHandlingSetFlags(a1,a2,a3); + PowerIdleSetParameters(EmbeddedParameters.switchtoidletimeinseconds,EmbeddedParameters.idledriertemperature,EmbeddedParameters.idleheadtemperature,EmbeddedParameters.idlemixertemperature); return Fresult; } diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.c b/Software/Embedded_SW/Embedded/Modules/General/buttons.c index 0550c8ca7..74cb81aac 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.c +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.c @@ -22,33 +22,14 @@ #include "Modules/Thread/Thread_ex.h" #include "Modules/General/buttons.h" +#include "StateMachines/Initialization/PowerOffSequence.h" +#include "StateMachines/Initialization/PowerIdle.h" -int MachineOnOff(); -int ch_to_power_down(); -int ch_to_power_up(); +int PowerDown(); +int PowerUp(); int thredJog(); -/* -typedef enum -{ - OFFPB = 0, - COUNTPB , - SHORTPB , - LONGPB , - REPLONGPB //repeat long PB -}PBstat; -*/ -typedef enum -{ - MSEC = 0, - lESS200 , - LESS500 , - LESS5000 , - MORE5000 -}timems; - - //enum PBstat OnOffPBstate = OFFPB; //enum PBstat ret @@ -56,9 +37,9 @@ typedef enum -button power , jog, load; -uint32_t ButtonsCallBackFunction(uint32_t IfIndex, uint32_t ReadValue); -uint32_t ButtonsCBFunction(uint32_t IfIndex, uint32_t ReadValue); +button power, jog, load, cart1, cart2, cart3; +uint32_t ButtonPowerCallBackFunction(uint32_t IfIndex, uint32_t ReadValue); +uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue); uint32_t ShortLongOffPB(uint8_t OnOffPB, button *pBtn); uint32_t StateMachine( button *pBtn); @@ -66,12 +47,14 @@ uint32_t StateMachine( button *pBtn); uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue); uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue); uint8_t thraedJogging(uint8_t off); -uint32_t setJoggingEnableCondition( button *pBtn); -uint32_t joggingMachine(uint8_t OnOffPB, button *pBtn); +//uint32_t setJoggingEnableCondition( button *pBtn); +uint32_t joggingMachine( button *pBtn); //uint8_t OnOffPB, uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue); uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue); +uint32_t LoadStatMachine( button *pBtn); + /* void Power_Reset(); @@ -81,7 +64,50 @@ bool Read_PWR_Button();//TODO move to GPIO folder */ +int PowerDown() +{ + bool ret = !OK; + ret = PowerOffInit(); + return ret; +} + +int PowerUp() +{ + bool ret = OK; + + return ret; +} + +bool SetPowerMachineState(PBmachineState state) +{ + bool ret = OK; + switch ( state ) + { + case sttOFF: + case sttON: + case sttIDLE: + power.state = state; + break; + case sttDISABLE: + case sttENABLE: + case sttJOGGING: + jog.state = state; + break; + case sttRDY: + case sttPRELOAD: + case sttLOADING: + case sttLOADSUCSESS: + case sttLOADFAIL: + load.state = state; + break; + default: + break; + } + + + return ret; +} /* * read GPIO status * port: GPIO_PORTN_BASE @@ -89,27 +115,34 @@ bool Read_PWR_Button();//TODO move to GPIO folder * * return !GPIOstatus */ -uint32_t ButtonsCallBackFunction(uint32_t IfIndex, uint32_t ReadValue) +uint32_t ButtonPowerCallBackFunction(uint32_t IfIndex, uint32_t ReadValue) { - if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7)) + return Read_PWR_Button(); + /* + * + if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7)) return 0x00; else return 0x01; + */ } uint32_t ButtonJogCallBackFunction(uint32_t IfIndex, uint32_t ReadValue) { - if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7)) - return 0x00; - else - return 0x01; + return Get_Thread_Jogging_Button(); +// +// if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7)) +// return 0x00; +// else +// return 0x01; } uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue) { - if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7)) - return 0x00; - else - return 0x01; + return Get_Thread_Load_Button(); +// if(ROM_GPIOPinRead(GPIO_PORTN_BASE, GPIO_PIN_7)) +// return 0x00; +// else +// return 0x01; } //uint32_t AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ); @@ -119,32 +152,28 @@ uint32_t ButtonLoadCallBackFunction(uint32_t IfIndex, uint32_t ReadValue) uint32_t Buttons_Init(void) { - - power.bttn_status = 0 ; -// power.bttn_name = "power"; //option - power.bttn_status = 0; // 0=release 1=press + strcpy(power.bttn_name, "power"); + power.bttn_status = release; // 0=release 1=press power.Action = OFFPB ; //off,short,long,count,replong - power.color = colorOFF; //off, blue, blink, bithing - power.state = sttOFF; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING + power.color = BLUE; //off, blue, blink, bithing + power.state = sttON; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING power.count = 0; - AddControlCallback( ButtonsCBFunction, BUTTOMS_SAMPLE_TIME, ButtonsCallBackFunction, 0,0,0 ); // eFiftyMillisecond + AddControlCallback( ButtonPowerCBFunction, BUTTOMS_SAMPLE_TIME, ButtonPowerCallBackFunction, 0,0,0 ); // eFiftyMillisecond - jog.bttn_status = 0 ; -// power.bttn_name = "power"; //option - jog.bttn_status = 0; // 0=release 1=press + strcpy(jog.bttn_name, "jog"); + jog.bttn_status = release; // 0=release 1=press jog.Action = OFFPB ; //OFFPB,short,long,count,replong jog.color = colorOFF; //colorOFF, BLUE, BLINK, jog.state = sttOFF; // sttDISABLE, sttENABLE, sttJOGGING jog.count = 0; AddControlCallback( ButtonJogCBFunction, BUTTOMS_SAMPLE_TIME, ButtonJogCallBackFunction, 0,0,0 ); // - load.bttn_status = 0 ; -// power.bttn_name = "power"; //option - load.bttn_status = 0; // 0=release 1=press + strcpy(load.bttn_name, "load"); + load.bttn_status = release; // 0=release 1=press load.Action = OFFPB ; //OFFPB,short,long,count,replong load.color = colorOFF; //colorOFF, BLUE, BLINK, - load.state = sttOFF; // sttDISABLE, sttENABLE, sttJOGGING + load.state = sttRDY; // load.count = 0; AddControlCallback( ButtonLoadCBFunction, BUTTOMS_SAMPLE_TIME, ButtonLoadCallBackFunction, 0,0,0 ); // @@ -153,7 +182,7 @@ return OK; //read the buttons data here and handle -uint32_t ButtonsCBFunction(uint32_t IfIndex, uint32_t ReadValue) +uint32_t ButtonPowerCBFunction(uint32_t IfIndex, uint32_t ReadValue) { ShortLongOffPB(ReadValue,&power); return 0; @@ -161,51 +190,35 @@ uint32_t ButtonsCBFunction(uint32_t IfIndex, uint32_t ReadValue) uint32_t ButtonJogCBFunction(uint32_t IfIndex, uint32_t ReadValue) { - setJoggingEnableCondition(&jog); - joggingMachine(ReadValue, &jog); + jog.bttn_status = ReadValue; + //if (ReadValue == press) + { + //setJoggingEnableCondition(&jog); + joggingMachine(&jog); + } return 0; } uint32_t ButtonLoadCBFunction(uint32_t IfIndex, uint32_t ReadValue) { - // ShortLongOffPB(ReadValue,&load); - return 0; -} - -/*---------------------------------------------------------------------------------*/ - - - -//OnOffPB = getPBstatus(POWER_PB); + uint8_t parameter = 2; + if ((load.bttn_status == release) && (ReadValue == press)) + { + REPORT_MSG(parameter," ------------ Start thread loading empty function ----------------- "); + load.bttn_status = press; + LoadStatMachine(&load); + } + else load.bttn_status = ReadValue; -/* - * - * - */ -int Get_timer() -{ - // to go timer return 0; } -int ClearTimer() -{ - //to do clear timer - return 0; -} -int StartTimer() -{ - // to do start timer - return 0; -} -int StopTimer() -{ - // to do start timer - return 0; -} +/*---------------------------------------------------------------------------------*/ + + /* --------------------------------------------------------- * --- ShortLongOffPB(int OnOffPB, enum PBstat *ret) ---- @@ -222,7 +235,6 @@ int StopTimer() ------------------------------------------------------------*/ -//ShortLongOffPB( OnOffPB, &ret) uint32_t ShortLongOffPB(uint8_t OnOffPB, button *pBtn) @@ -237,14 +249,16 @@ uint32_t ShortLongOffPB(uint8_t OnOffPB, button *pBtn) if( OnOffPB ) { pBtn->Action = COUNTPB ; + REPORT_MSG(parameter," ------------ Start count PB Power ----------------- "); } break; case COUNTPB: // last OnOffPBstate was COUNTPB if (OnOffPB) { - if( pBtn->count > 5 ) //250ms + if( pBtn->count > 5 ) //5*50ms=250ms { pBtn->Action = SHORTPB ; + REPORT_MSG(parameter," ------------ Start count PB Power ----------------- "); } } else @@ -259,14 +273,14 @@ uint32_t ShortLongOffPB(uint8_t OnOffPB, button *pBtn) if (pBtn->count > 100) //5000ms { pBtn->Action = LONGPB ; - REPORT_MSG(parameter,"Long PB "); + REPORT_MSG(parameter," ------------ Long PB Power ----------------- "); StateMachine(pBtn); pBtn->count = 0; } } else { - REPORT_MSG(parameter,"Short PB "); + REPORT_MSG(parameter," ------------ Short PB Power ----------------- "); StateMachine(pBtn); pBtn->count = 0; pBtn->Action = OFFPB ; @@ -310,6 +324,7 @@ uint32_t ShortLongOffPB(uint8_t OnOffPB, button *pBtn) uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1) { uint8_t parameter = 1; + Report(" ------------ StateMachine state action ----------------- ",__FILE__,__LINE__,pBtn->state,RpWarning,pBtn->Action,0); switch (pBtn->state)// sttON/sttOFF/sttIDLE { @@ -317,8 +332,11 @@ uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1) switch (pBtn->Action) { case LONGPB: //Power Down - pBtn->state = sttOFF; // todo - REPORT_MSG(parameter,"Power state is OFF "); + pBtn->state = sttOFF; + pBtn->color = colorOFF; + Pannel_Leds(POWER_ON_OFF,MODE_OFF);//AVI+ + PowerDown();// todo + REPORT_MSG(parameter," ------------ Power state is OFF ----------------- "); break; // case SHORTPB: //idle ????? // setMachineStatus = IDLE; // ????/ @@ -335,8 +353,11 @@ uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1) // break; case SHORTPB: //powerup? // to do ? - pBtn->state = sttON; //todo - REPORT_MSG(parameter,"Power state is ON "); + pBtn->state = sttON; + pBtn->color = BLUE ; + Pannel_Leds(POWER_ON_OFF,MODE_ON);//AVI+ + PowerUp(); //todo + REPORT_MSG(parameter," ------------ Power state is ON ----------------- "); break; default: break; @@ -346,14 +367,18 @@ uint32_t StateMachine( button *pBtn) //short press(=0)/long press(=1) switch (pBtn->Action) { case LONGPB: //Power off from idle - pBtn->state = sttOFF; // todo + pBtn->state = sttOFF; + pBtn->color = colorOFF; + Pannel_Leds(POWER_ON_OFF,MODE_OFF);//AVI+ + PowerDown(); // todo Pannel_Leds(POWER_ON_OFF,MODE_OFF); //AVI+ - TODO option MODE_ON to stop Breathing and the led will turn off in power down - REPORT_MSG(parameter,"Power state is OFF "); + REPORT_MSG(parameter," ------------ Power state is OFF ----------------- "); break; case SHORTPB: //Wake up from idle - pBtn->state = sttON;// to do ? + pBtn->state = sttON; + PowerUp(); // to do ? Pannel_Leds(POWER_ON_OFF,MODE_ON); //AVI+ - REPORT_MSG(parameter,"Power state is ON "); + REPORT_MSG(parameter," ------------ Power state is ON ----------------- "); break; default: break; @@ -382,29 +407,36 @@ return 0; -uint32_t setJoggingEnableCondition( button *pBtn) -{ - if (0 -// 1. -// 2. -// 3. -// ... - ) - { - pBtn->state = sttDISABLE; - REPORT_MSG(pBtn->state,"Jogging : sttDISABLE "); - ThreadAbortJoggingFunc(); - } - - else - { - pBtn->state = sttENABLE; - REPORT_MSG(pBtn->state,"Jogging : sttENABLE "); - ThreadJoggingFunc(40); - } - -return 0; -} +//uint32_t setJoggingEnableCondition( button *pBtn) +//{ +// uint8_t parameter = 3; +// +// if (0 +//// to do : what are the conditions for enable / disable +//// 1. +//// 2. +//// 3. +//// ... +// ) +// { +// pBtn->state = sttDISABLE; +// REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition sttDISABLE ----------------- "); +// pBtn->color = colorOFF; +// Pannel_Leds(THREAD_JOGGING, MODE_OFF); //AVI+ +// // ThreadAbortJoggingFunc(); +// } +// +// else +// { +// pBtn->state = sttENABLE; +//// REPORT_MSG(parameter," ------------ Jogging : setJoggingEnableCondition sttENABLE ----------------- "); +// pBtn->color = BLUE; +// Pannel_Leds(THREAD_JOGGING, MODE_ON); //AVI+ +// //ThreadJoggingFunc(40); +// } +// +//return 0; +//} @@ -419,28 +451,74 @@ return 0; */ -uint32_t joggingMachine(uint8_t OnOffPB, button *pBtn) +uint32_t joggingMachine( button *pBtn) //uint8_t OnOffPB, { + + uint8_t parameter = 4; + if (sttDISABLE == pBtn->state) { // jogging is disable + REPORT_MSG(parameter," ------------joggingMachine: Jogging is Disable ----------------- "); + pBtn->Action = OFFPB; pBtn->color = colorOFF; Pannel_Leds(THREAD_JOGGING,MODE_OFF);//AVI+ } else { - if (!OnOffPB) + if ( (pBtn->Action != OFFPB) && (pBtn->bttn_status == release)) { + REPORT_MSG(parameter," ------------joggingMachine: Jogging OnOffPB == 00----------------- "); + REPORT_MSG(parameter," ------------joggingMachine: stop Jogging ----------------- "); + pBtn->Action = OFFPB; ThreadAbortJoggingFunc(); // to do!!!! pBtn->color = BLUE; - Pannel_Leds(THREAD_JOGGING,MODE_ON);//AVI+ + Pannel_Leds(THREAD_JOGGING, MODE_ON);//AVI+ } - else + else if ((pBtn->Action == OFFPB) && (pBtn->bttn_status == press)) { + pBtn->Action = LONGPB; + REPORT_MSG(parameter," ------------joggingMachine: Jogging OnOffPB == 1 ----------------- "); + REPORT_MSG(parameter," ------------joggingMachine: start Jogging ----------------- "); pBtn->color = BLINK; ThreadJoggingFunc(40); } +// if (pBtn->bttn_status == press)ThreadJoggingFunc(40); +// else +// { +// pBtn->Action = OFFPB; +// REPORT_MSG(parameter," ??????????????????? joggingMachine: start Jogging ???????????????????"); +// } } + + + +// if (OnOffPB == release) +// { +// REPORT_MSG(parameter," ------------joggingMachine: Jogging OnOffPB == 00----------------- "); +// REPORT_MSG(parameter," ------------joggingMachine: stop Jogging ----------------- "); +// pBtn->Action = OFFPB; +// ThreadAbortJoggingFunc(); // to do!!!! +// pBtn->color = BLUE; +// Pannel_Leds(THREAD_JOGGING, MODE_ON);//AVI+ +// } +// else +// { +// if (pBtn->Action == OFFPB) +// { +// pBtn->Action = LONGPB; +// REPORT_MSG(parameter," ------------joggingMachine: Jogging OnOffPB == 1 ----------------- "); +// REPORT_MSG(parameter," ------------joggingMachine: start Jogging ----------------- "); +// pBtn->color = BLINK; +// ThreadJoggingFunc(40); +// } +// else +// { +// REPORT_MSG(parameter," ??????????????????? joggingMachine: start Jogging ???????????????????"); +// } +// +// } +// } return 0; } @@ -450,12 +528,16 @@ return 0; /*------ THREAD LOAD/UNLOAD ----------*/ -int LoadStatMachine( PBstat PBAction, button *pBtn) +uint32_t LoadStatMachine( button *pBtn) { + uint8_t parameter = 5; + //REPORT_MSG(parameter," ------------ start loading ----------------- "); + Report(" ------------ start loading ----------------- ",__FILE__,__LINE__,pBtn->state,RpWarning,pBtn->color,0); switch (pBtn->state) { case sttRDY : + REPORT_MSG(parameter," ------------ load.state = sttRDY ----------------- "); switch (pBtn->Action) { case (SHORTPB): @@ -464,26 +546,35 @@ int LoadStatMachine( PBstat PBAction, button *pBtn) pBtn->state = sttPRELOAD; pBtn->color = BLINK; if (ThreadLoadStateMachine( THREAD_LOAD_INIT)) - { - pBtn->state = sttPRELOAD ; // to do - pBtn->color = BLUE; - } - else pBtn->state = sttDISABLE ; + { + pBtn->state = sttPRELOAD ; // to do + pBtn->color = BLUE; + Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+ + } + else + { + pBtn->state = sttDISABLE ; + Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+ + } break; default : break; } break; case sttPRELOAD: + REPORT_MSG(parameter," ------------ load.state = sttPRELOAD ----------------- "); switch (pBtn->Action) { case (SHORTPB): case (LONGPB): case (REPLONGPB): - if (ThreadLoadStateMachine( THREAD_LOAD_INITIAL_TENSION)) + pBtn->color = BLUE; + Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+ + if (ThreadLoadStateMachine( THREAD_LOAD_INITIAL_TENSION)) { pBtn->state = sttLOADSUCSESS ; // to do pBtn->color = BLUE; + Pannel_Leds(THREAD_LOAD, MODE_ON);//AVI+ } else { @@ -496,6 +587,7 @@ int LoadStatMachine( PBstat PBAction, button *pBtn) } break; case sttLOADING: + REPORT_MSG(parameter," ------------ load.state = sttLOADING ----------------- "); break; // case sttLOADSUCSESS ????? // break; @@ -503,7 +595,9 @@ int LoadStatMachine( PBstat PBAction, button *pBtn) // break; default: //sttDISABLE + REPORT_MSG(parameter," ------------ load.state = default ----------------- "); pBtn->color = colorOFF; + Pannel_Leds(THREAD_LOAD, MODE_OFF);//AVI+ break; } return OK; diff --git a/Software/Embedded_SW/Embedded/Modules/General/buttons.h b/Software/Embedded_SW/Embedded/Modules/General/buttons.h index d0cea022c..2d14eb000 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/buttons.h +++ b/Software/Embedded_SW/Embedded/Modules/General/buttons.h @@ -3,6 +3,12 @@ typedef enum { + release = 0, + press +} PB_Status; + +typedef enum +{ colorOFF = 0, BLUE, BLINK, @@ -23,31 +29,37 @@ typedef enum { sttOFF = 0, sttON, + sttIDLE, + sttDISABLE, sttENABLE, - sttIDLE, sttJOGGING, + sttRDY, sttPRELOAD, sttLOADING, sttLOADSUCSESS, sttLOADFAIL -} PBmachinState; +} PBmachineState; typedef struct Button { char bttn_name[10]; //option int bttn_status; // 0=release 1=press - /* enum */ PBstat Action; //offPB,shortPB,longPB,countPB,replongPB - /* enum */ PBcolor color; //off, blue, blink, bithing - /* enum */ PBmachinState state; //sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING + PBstat Action; // enum : offPB,shortPB,longPB,countPB,replongPB + PBcolor color; // enum : off, blue, blink, bithing + PBmachineState state; // enum : sttOFF, sttON, sttDISABLE, sttENABLE, sttIDLE, sttJOGGING uint32_t count; }button; -extern button power , jog, load; +extern button power, jog, load, cart1, cart2, cart3; uint32_t Buttons_Init(void); uint32_t Button_load_Init(void); uint32_t Button_JOG_Init(void); +bool SetPowerMachineState(PBmachineState state); + + + #endif diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c index dd9f8deae..277891861 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/process.c +++ b/Software/Embedded_SW/Embedded/Modules/General/process.c @@ -20,6 +20,7 @@ #include "modules/ids/ids_ex.h" #include "third_party/fatfs/src/ffconf.h" #include "Common/SWUpdate/FileSystem.h" +#include "StateMachines/Initialization/PowerIdle.h" @@ -38,11 +39,29 @@ int32_t tableindex = 0; char ProcessParamsConfigPath[50] = "0://SysInfo//ProcessP.cfg"; ProcessParameters ProcessParametersKeep; +void HeatersStopControlOnHeatersOff(ProcessParameters* ProcessParams) +{ + uint32_t temp_sum = 0; + temp_sum += ProcessParams->dryerzone1temp; + temp_sum += ProcessParams->dryerzone2temp; + temp_sum += ProcessParams->dryerzone3temp; + temp_sum += ProcessParams->mixertemp; + temp_sum += ProcessParams->headzone1temp; + temp_sum += ProcessParams->headzone2temp; + temp_sum += ProcessParams->headzone3temp; + temp_sum += ProcessParams->headzone4temp; + temp_sum += ProcessParams->headzone5temp; + temp_sum += ProcessParams->headzone6temp; + if (temp_sum == 0)// heating off + { + HeatersControlStop(); + REPORT_MSG(temp_sum,"Heating control off - temperatures off"); + } +} uint32_t HandleProcessParameters(ProcessParameters* ProcessParams) { uint32_t status = 0; - if (ProcessParams==NULL) { status = ERROR_CODE__INVALID_PARAMETER; @@ -145,6 +164,7 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams) HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, false, ProcessParams->dryerzone3temp); */ + HeatersStopControlOnHeatersOff(ProcessParams); dyeingspeed = ProcessParams->dyeingspeed; dryerbufferlength = ProcessParams->dryerbufferlength; mininkuptake = ProcessParams->mininkuptake; @@ -191,6 +211,7 @@ void ProcessRequestFunc(MessageContainer* requestContainer) //REPORT_MSG (ProcessParams->dryerzone1temp,"Process Params Dryer"); + PowerIdleOutOfIdleState(); if (status == 0) status = HandleProcessParameters(ProcessParams); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h index 8a77f98a2..0b65d9e5e 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h @@ -27,4 +27,5 @@ void Heaters_SetOperationLimits(int acheatersloweroperationlimit,int acheatersu uint32_t HeatersEnd(void); +void HeatersControlStop(void); uint32_t Heaters_Init(void); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c index 6fbfa5884..7c4bb1761 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c @@ -29,7 +29,7 @@ /******************** STRUCTURES AND ENUMs ********************************************/ -typedef enum { +/*typedef enum { HeatersInitialState, HeatersInit, HeatersControlledOp, @@ -43,7 +43,7 @@ typedef enum { HeatersOverHeat, HeatersOnTest }HEATERS_EVENTS_ENUM; - +*/ /******************** GLOBAL PARAMETERS ********************************************/ HeaterPIDControlConfig HeaterControl[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0,0,0}; bool AcHeaterConfigured[MAX_AC_HEATERS] = {0,0,0}; diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index bc5448e7b..8fe0a9fd8 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -17,11 +17,12 @@ #include "PMR/Diagnostics/HeaterType.pb-c.h" #include "PMR/Diagnostics/HeaterState.pb-c.h" #include "PMR/common/MessageContainer.pb-c.h" -#include "PMR/Diagnostics/EventType.pb-c.h" +#include "PMR/Diagnostics/EventType.pb-c.h" #include "../AlarmHandling/AlarmHandling.h" #include "../control/control.h" #include "../control/pidalgo.h" +#include "../control/MillisecTask.h" #include <ti/sysbios/knl/Task.h> #include <driverlib/timer.h> @@ -81,7 +82,7 @@ uint32_t OverHeatCounter [MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0}; uint32_t UnderHeatCounter [MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0}; uint32_t MainDryerHeaterMaxTempControl = 0xFF; uint32_t SecondDryerHeaterMaxTempControl = 0xFF; - +uint32_t DisasterControlId = 0xFF; #define DRYER_AIR_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP1 #define DRYER_MAIN_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP2 #define DRYER_SECONDARY_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP3 @@ -90,7 +91,7 @@ uint32_t SecondDryerHeaterMaxTempControl = 0xFF; //old uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,TEMP_SENSE_AN_ENCLOSURETEMP3}; uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HEAD6_PT100,MIXER_PT100}; -HEATERS_CURRENT HeaterId2CurrentId[MAX_HEATERS_NUM] = {NUM_OF_HEATERS,DRYER_CURRENT_1,DRYER_CURRENT_2,HEAD_ZONE_1,HEAD_ZONE_2,HEAD_ZONE_3,HEAD_ZONE_4,HEAD_ZONE_5_6,HEAD_ZONE_5_6,MIXCHIP}; +HEATERS_CURRENT HeaterId2CurrentId[MAX_HEATERS_NUM] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEATER_HEAD_CURRENT_ZONE_1,HEATER_HEAD_CURRENT_ZONE_2,HEATER_HEAD_CURRENT_ZONE_3,HEATER_HEAD_CURRENT_ZONE_4,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_MIXCHIP_CURRENT}; uint32_t DryerInternalPT100Id = DRYER_AIR_PT100; bool HeatersRestart = false; @@ -122,11 +123,16 @@ EventType HeaterUnderEventType_B[MAX_HEATERS_NUM] = {EVENT_TYPE__DRYER_ZONE_1_UN EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B, EVENT_TYPE__MIXER_UNDERTEMPERATURE_B}; +int HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {0,0,0,0,0,0,0,0,0,0}; +#define DISASTER_COUNTER_LIMIT 10 + /******************** FUNCTIONS ********************************************/ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue); uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue); uint32_t HeaterControlCBFunction(uint32_t deviceID, uint32_t readValue); uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue); +uint32_t HeatersDisasterControl(uint32_t x,uint32_t y); + uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue); void HeatersStartControlTimer (void); @@ -205,27 +211,32 @@ uint32_t LoadHeaterSetPoint(HeaterType HeaterType) void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState) { int HeaterId = HeaterType; - double temp = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]); - //double temp = HeaterPreviousRead[HeaterId];//TemperatureSensorRead(HeaterId2PT100Id[HeaterId]); + double temp = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]); + //double temp = HeaterPreviousRead[HeaterId];//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]); HeaterState->has_heatertype = true; HeaterState->heatertype = HeaterType; HeaterState->has_setpoint = true; HeaterState->setpoint = HeaterCmd[HeaterId].targettemperatue/100; - // HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse; + //HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse; HeaterState->has_currentvalue = true; - HeaterState->currentvalue = temp/100;//TemperatureSensorRead(HeaterId2PT100Id[HeaterId])/100; + HeaterState->currentvalue = temp/100;//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId])/100; HeaterState->has_isactive = true; HeaterState->isactive = GetHeaterState(HeaterId); HeaterState->has_isrampingup = true; HeaterState->isrampingup = 1-HeaterReady[HeaterId]; HeaterState->has_isinsetpoint = true; HeaterState->isinsetpoint = HeaterReady[HeaterId]; - /*if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) + if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain) { HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit; //HeaterState->isrampingup = InitialHeating; - }*/ + } + if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary) + { + HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit; + //HeaterState->isrampingup = InitialHeating; + } return; } uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId) @@ -277,6 +288,9 @@ uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId) HeaterReady[HeaterId] = true; } + AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false); + AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false); + AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false); return status; } @@ -382,23 +396,24 @@ uint32_t HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature) PrepareHeater(HeaterId,Temperature); //prepare the heaters control info //set the power balance handler (if not set yet) // if the heater is off (?) start it. - ActivateHeater(HeaterId); + //ActivateHeater(HeaterId); //set the heater operation mode to fast heating - depended on the current temperature // timers are prepared but not started yet!!! only when the system is hot. } else if ((HeaterState == HEATER_ON)&& (OnOff == HEATER_ON)) //set temperature { - if (abs(HeaterPIDConfig[HeaterId].m_SetParam - HeaterCmd[HeaterId].targettemperatue)>0.5) //#bug 221 + HeaterPIDConfig[HeaterId].m_SetParam = HeaterCmd[HeaterId].targettemperatue; + /*/if (abs(HeaterPIDConfig[HeaterId].m_SetParam - HeaterCmd[HeaterId].targettemperatue)>0.5) //#bug 221 { PrepareHeater(HeaterId,Temperature); //prepare the heaters control info } else { - HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);// + HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId);// LOG_ERROR(HeaterId,"ReRead Heater Temp"); - } - HeaterPIDConfig[HeaterId].m_SetParam = HeaterCmd[HeaterId].targettemperatue; + }*/ + PrepareHeater(HeaterId,Temperature); //prepare the heaters control info // if the heater is not on return (?). //set the target operation temperature //set the heater operation mode to fast heating - depended on the current temperature @@ -412,7 +427,7 @@ uint32_t HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature) } //usnprintf(ACheatstr, 254, "HeaterCommandRequestMessage(Id %d,OnOff %d,Temperature %d)",HeaterId, OnOff, Temperature); - Report("HeaterCommandRequestMessage",__FILE__,Temperature,HeaterId,RpWarning,HeaterState, 0); + //Report("HeaterCommandRequestMessage",__FILE__,Temperature,HeaterId,RpWarning,HeaterState, 0); //Report("HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, 0, 0); return OK; @@ -422,6 +437,91 @@ uint32_t HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature) * called by: Communication from host * initialized all global data */ +void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue) +{ + if (ControlIdtoHeaterId [HeaterId] == 0xFF) + { + ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0); + //HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(DryerInternalPT100Id); + HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);// + //Report("PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0); + HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);//MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); + HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);// = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]); + } + //turn all alarms off + AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false); + AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false); + AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false); + + if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF) + ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); + + Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); + Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]); + + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0); + if (MainDryerHeaterMaxTempControl == 0xFF) + MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0); + if (SecondDryerHeaterMaxTempControl == 0xFF) + SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0); + //InitialHeating = true; + HeaterReady[HeaterId] = false; + if (BlowerCfg.enabled == true) + { + Turn_the_Blower_On();//Turn on with the Default_Voltage + if (BlowerCfg.heatingvoltage) + Control_Voltage_To_Blower(BlowerCfg.heatingvoltage); + else + Control_Voltage_To_Blower(BlowerCfg.voltage-500); + + } + if (SetTemperatue) + { + Control_Dryer_Fan(START,75);//use START or STOP, 0 - 100% + } +} +/* + * PrepareHeater + * called by: Communication from host + * initialized all global data + */ +int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue) +{ + if (DisasterControlId == 0xFF) + DisasterControlId = AddControlCallback( HeatersDisasterControl, eOneSecond,TemplateDataReadCBFunction,0,0, 0); + + if (ControlIdtoHeaterId [HeaterId] == 0xFF) + ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); + //HeaterPIDConfig[HeaterId].m_params.dt *=10; + //DCInitialHeating[HeaterId] = true; + HeaterReady[HeaterId] = false; + HeaterRecalculateHeaterParams(HeaterId, 0); + + //turn all alarms off + AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false); + AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false); + AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false); + + Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]); + + HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]); + if((abs(HeaterPreviousRead[HeaterId]-MINIMUM_HEATER_READ)<1)||(abs(MAXIMUM_HEATER_READ-HeaterPreviousRead[HeaterId])<10)) + { + LOG_ERROR (HeaterId,"PT100 not working properly"); + return ERROR; + } + //Report("PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0); + if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF) + ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); + + return OK; +} +/* + * PrepareHeater + * called by: Communication from host + * initialized all global data + */ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) { double temp ; @@ -452,13 +552,19 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) HeaterPIDConfig[HeaterId].m_preError = 0; HeaterPIDConfig[HeaterId].m_SetParam = SetTemperatue*100;//need to update SetParams on presegment stage - temp = SetTemperatue*(100+HeaterControl[HeaterId].outputproportionalband); - temp = SetTemperatue*110.0; + int band = 10; + /*if (HeaterControl[HeaterId].outputproportionalband) + { + band = HeaterControl[HeaterId].outputproportionalband; + }*/ + temp = SetTemperatue*(100+band); + //temp = SetTemperatue*110.0; HeaterControl[HeaterId].sensormaxvalue = (int)temp; - temp = SetTemperatue*(100-HeaterControl[HeaterId].outputproportionalband); - temp = SetTemperatue*90.0; + temp = SetTemperatue*(100-band); + //temp = SetTemperatue*90.0; HeaterControl[HeaterId].sensorminvalue = (int)temp; + Report("Temperature limits",__FILE__,HeaterId,HeaterControl[HeaterId].sensormaxvalue,RpWarning,HeaterControl[HeaterId].sensorminvalue, 0); if (HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier) { @@ -466,64 +572,12 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) } if (HeaterId >= MAX_AC_HEATERS) //DC Heaters { - if (ControlIdtoHeaterId [HeaterId] == 0xFF) - ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); - //HeaterPIDConfig[HeaterId].m_params.dt *=10; - //DCInitialHeating[HeaterId] = true; - HeaterReady[HeaterId] = false; - HeaterRecalculateHeaterParams(HeaterId, 0); - - Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]); - - HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//TemperatureSensorRead(HeaterId2PT100Id[HeaterId]); - if((abs(HeaterPreviousRead[HeaterId]-MINIMUM_HEATER_READ)<1)||(abs(MAXIMUM_HEATER_READ-HeaterPreviousRead[HeaterId])<10)) - { - LOG_ERROR (HeaterId,"PT100 not working properly"); + if (PrepareDCHeater(HeaterId,Frequency,SetTemperatue)!=OK) return ERROR; - } - Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0); - if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF) - ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); - } else if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters { - if (ControlIdtoHeaterId [HeaterId] == 0xFF) - { - ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0); - //HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id); - HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);// - Report("PrepareHeater Read", __FILE__,__LINE__,HeaterId, SetTemperatue, HeaterPreviousRead[HeaterId], 0); - HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);//TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); - HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);// = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]); - } - if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF) - ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); - - Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); - Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]); - - HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0); - HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0); - if (MainDryerHeaterMaxTempControl == 0xFF) - MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0); - if (SecondDryerHeaterMaxTempControl == 0xFF) - SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0); - //InitialHeating = true; - HeaterReady[HeaterId] = false; - if (BlowerCfg.enabled == true) - { - Turn_the_Blower_On();//Turn on with the Default_Voltage - if (BlowerCfg.heatingvoltage) - Control_Voltage_To_Blower(BlowerCfg.heatingvoltage); - else - Control_Voltage_To_Blower(BlowerCfg.voltage-500); - - } - if (SetTemperatue) - { - Control_Dryer_Fan(START,75);//use START or STOP, 0 - 100% - } + PrepareACHeater(HeaterId,Frequency,SetTemperatue); } return OK; } @@ -572,13 +626,11 @@ uint32_t MainPT100Read = 0,SecondaryPT100Read = 0; #ifndef min #define min(a,b) ((a) < (b) ? (a) : (b)) #endif -uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue) +uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) { int index=MAX_HEATERS_NUM; - int32_t MaxreadValue = max (MainPT100Read,SecondaryPT100Read); - int32_t MinreadValue = min (MainPT100Read,SecondaryPT100Read); - /*char str[100]; - uint8_t len = 0;*/ + int32_t MaxreadValue; + int32_t MinreadValue; if (IfIndex>>8 != IfTypeHeaters) { LOG_ERROR (IfIndex, "Wrong Interface type"); @@ -590,11 +642,15 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue) LOG_ERROR (IfIndex, "Wrong Interface "); return 0xFFFFFFFF; } - int32_t readValue = TemperatureSensorRead(HeaterId2PT100Id[index]); + //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]); if (abs(readValue - HeaterPreviousRead[index])>2000) { Report("Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); + DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0); + DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); return ERROR; } HeaterPreviousRead[index] = readValue; @@ -606,30 +662,35 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue) { SecondaryPT100Read = readValue; } + MaxreadValue = max (MainPT100Read,SecondaryPT100Read); + MinreadValue = min (MainPT100Read,SecondaryPT100Read); + if ((MaxreadValue) >= HeaterControl[index].sensormaxvalue) { 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; + HeaterMaxTempFlag[index] = true; + //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0); DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); - HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true; + //HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true; + //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); return OK; } - if ((MinreadValue) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) + if ((MaxreadValue) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue { if (HeaterControl[index].sensorminvalue > 0) { if (HeaterMaxTempFlag[index] == true) { - ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + /* ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature]==false) { 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; @@ -638,7 +699,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue) } return ERROR; } -uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue) +uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) { int index=MAX_HEATERS_NUM; if (IfIndex>>8 != IfTypeHeaters) @@ -647,7 +708,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue) return 0xFFFFFFFF; } index = IfIndex&0xFF; - int32_t readValue = TemperatureSensorRead(HeaterId2PT100Id[index]); + //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]); if (HeaterControl[index].sensormaxvalue == 0) return OK; if ((HeaterPreviousRead[index]) >= HeaterControl[index].sensormaxvalue) @@ -655,19 +716,22 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue) if(OverHeatCounter[index]++ >=Overheat_Count_Limit) { OverHeatCounter[index] = Overheat_Count_Limit; + //?????HeaterReady[index] = false; if (JobIsActive()&&(HeaterReady[index]==true)) { JobEndReason = JOB_TEMPERATURE_ALARM; SendJobProgress(0.0,0,false, "Temperature Error"); - SegmentReady(Module_Heaters,ModuleFail); + AbortJob("Over Temperature Error"); + //SegmentReady(Module_Heaters,ModuleFail); LOG_ERROR(index, "Temperature Error"); return OK; } } DeActivateHeater(index); + HeaterRecalculateHeaterParams(index, 0); HeaterMaxTempFlag[index] = true; //LOG_ERROR ((MinreadValue/100), "Heater Over the max temperature, turned off"); - Report("Heater Over the max temperature, turned off",__FILE__,__LINE__,index,RpWarning,HeaterPreviousRead[index], HeaterControl[index].sensormaxvalue); + Report("Heater Over the max temperature, turned off",__FILE__,index,HeaterPreviousRead[index],RpWarning, HeaterControl[index].sensormaxvalue,0); AlarmHandlingSetAlarm(HeaterEventType[index], true); return OK; } @@ -676,15 +740,16 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue) if(UnderHeatCounter[index]++ >=Underheat_Count_Limit) { UnderHeatCounter[index] = Underheat_Count_Limit; + //???HeaterReady[index] = false; if (JobIsActive()&&(HeaterReady[index]==true)) { JobEndReason = JOB_TEMPERATURE_ALARM; SendJobProgress(0.0,0,false, "Temperature Error"); - SegmentReady(Module_Heaters,ModuleFail); + AbortJob("Under Temperature Error"); LOG_ERROR(index, "Temperature Error"); return OK; } - HeaterMinTempFlag[index] = true; + //HeaterMinTempFlag[index] = true; // Report("Heater under the min temperature",__FILE__,__LINE__,index,RpWarning,HeaterPreviousRead[index], HeaterControl[index].sensormaxvalue); if (HeaterReady[index]==false) AlarmHandlingSetAlarm(HeaterUnderEventType[index], true); @@ -693,7 +758,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue) return OK; } } - else //temperature withing limits + else //temperature within limits { if(UnderHeatCounter[index] ) { @@ -728,29 +793,45 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) if (IfIndex>>8 != IfTypeHeaters) { LOG_ERROR (IfIndex, "Wrong Interface type"); - return 0xFFFFFFFF; + return ERROR; } index = IfIndex&0xFF; if (index != HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters { LOG_ERROR (IfIndex, "Wrong Interface "); - return 0xFFFFFFFF; + return ERROR; } if (HeaterCmd[index].targettemperatue == 0) { - DeActivateHeater(index); + DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + //Heaters OFF until coming into the proportional band + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); //LOG_ERROR (0, "unconfigured"); return ERROR; } if (abs(readValue - HeaterPreviousRead[index])>2000) { - Report("Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); + Report("AC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); if (readValue > HeaterCmd[index].targettemperatue) { - DeActivateHeater(index); + DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); } return ERROR; } + if (HeaterDisasterCounter[index] >= DISASTER_COUNTER_LIMIT) + { + Report("AC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); + DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); + return ERROR; + } HeaterPreviousRead[index] = readValue; // check if the read value is within the proportional band @@ -761,17 +842,22 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); //Heaters OFF until coming into the proportional band + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0); + HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0); return OK; } // if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) - if (readValue < (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)) - { - ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); - ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); - return OK; - } + if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-1000)) + { + if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)) + { + ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + } + return OK; + } - if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target + if ((readValue > (HeaterCmd[index].targettemperatue-1000)/*(HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)*/)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target { ////////////////// //InitialHeating = false; @@ -779,12 +865,8 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0); HeatersControlStart(); //////////////////////// - HeaterReady[index] = true; - Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); - Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]); AlarmHandlingSetAlarm(HeaterUnderEventType[index], false); - HeaterPrepareReady(); if (BlowerCfg.enabled == true) { Turn_the_Blower_On();//Turn on with the Default_Voltage @@ -793,6 +875,17 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) Control_Voltage_To_Blower(BlowerCfg.voltage); } } + if ((HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target + { +////////////////// + //InitialHeating = false; + Report("AC PID Activating",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue-1000), 0); +//////////////////////// + HeaterReady[index] = true; + Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); + + HeaterPrepareReady(); + } return OK; } if(HeaterPIDConfig[index].m_isEnabled && (HeaterPIDConfig[index].m_SetParam != 0)) @@ -813,15 +906,30 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) } else //PID active { - if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0) + if ((readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))) { - 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); + //disable PID outside band + HeaterPIDConfig[index].m_calculatedError = 0; + HeaterPIDConfig[index].m_integral = 0; + } + else if ((readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))) + { + //disable PID outside band + HeaterPIDConfig[index].m_calculatedError = 10000; + HeaterPIDConfig[index].m_integral = 0; } 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); + 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]); @@ -871,15 +979,21 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) } if (abs(readValue - HeaterPreviousRead[index])>2000) { - Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index); + Report("DC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); if (readValue > HeaterCmd[index].targettemperatue) { DeActivateHeater(index); HeaterRecalculateHeaterParams(index, 0); } - return ERROR; } HeaterPreviousRead[index] = readValue; + if (HeaterDisasterCounter[index] >= DISASTER_COUNTER_LIMIT) + { + Report("DC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index); + DeActivateHeater (index); + return ERROR; + } + // check if the read value is within the proportional band if (HeaterReady[index]==false) { @@ -906,6 +1020,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) //DCInitialHeating[index] = false; HeatersControlStart(); HeaterReady[index] = true; + AlarmHandlingSetAlarm(HeaterUnderEventType[index], false); Disable_Reading_Heaters_Current(HeaterId2CurrentId[index]); HeaterPrepareReady(); } @@ -930,15 +1045,31 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) { //check only for the proportional band limits HeaterPIDConfig[index].m_mesuredParam = readValue; - if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0) + if ((readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))) + { + //disable PID outside band + HeaterPIDConfig[index].m_calculatedError = 0; + HeaterPIDConfig[index].m_integral = 0; + } + else if ((readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))) { - 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); + //disable PID outside band + HeaterPIDConfig[index].m_calculatedError = 10000; + HeaterPIDConfig[index].m_integral = 0; } 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); + 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; @@ -992,55 +1123,102 @@ void EightMilliSecondHeatersInterrupt(UArg arg0) return ; } +int HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {28000,28000,28000,17000,17000,17000,17000,17000,17000,11000}; +//int HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {8100,8100,8200,8100,8100,8100,8100,8100,8100,8100}; +uint32_t HeatersDisasterControl(uint32_t x,uint32_t y) +{ + int HeaterId,temperature; + + for ( HeaterId = HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature; HeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;HeaterId++) + { + temperature = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]); + if (temperature>=HeaterDisasterTemp[HeaterId]) + { + Report("Disaster Temperature ",__FILE__,HeaterId,temperature,RpWarning,HeaterDisasterTemp[HeaterId], 0); + if (HeaterDisasterCounter[HeaterId]++ >= DISASTER_COUNTER_LIMIT) + HeaterDisasterCounter[HeaterId] = DISASTER_COUNTER_LIMIT; + } + else if (temperature<0) + { + if (HeaterDisasterCounter[HeaterId]++ <= 0) + HeaterDisasterCounter[HeaterId] = 0; + } + else + { + if (HeaterDisasterCounter[HeaterId]-- <= 0) + HeaterDisasterCounter[HeaterId] = 0; + } + } + return OK; +} uint32_t HeatersControlLoop(uint32_t tick) { //char str[100]; //uint8_t len = 0; int DcHeaterId; + bool AcHeaterDisaster = false; + /*len = usnprintf(str, 100, "\r\n EightMilliSecondHeatersInterrupt SliceCounter %d Owner %d H1000 %d H2000 %d" ,SliceCounter,TimeSliceAllocation[SliceCounter],HeatersRestart,NumberOFSlicesInUse); Report(str, __FILE__,__LINE__,0, RpMessage, SliceCounter, TimeSliceAllocation[SliceCounter]); */ - static bool first = true; - if (first == true) + if (HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] >= DISASTER_COUNTER_LIMIT) { - first = false; + DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + AcHeaterDisaster = true; } - if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature] == true) + if (HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] >= DISASTER_COUNTER_LIMIT) { - if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain) + DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + AcHeaterDisaster = true; + } + + + if (AcHeaterDisaster == false) + { + if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature] == true) { - if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false) + if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain) { - //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain should be active - //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain - ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); - //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary - DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false) + { + //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain should be active + //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain + ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary + DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + } } - } - else if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary) - { - if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false) + else if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary) + { + if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false) + { + //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain + DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary should be active + //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary + ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + } + } + else { - //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain - DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); - //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary should be active - //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary - ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); + //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain + DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); + //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary + DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); } } - else - { - //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain - DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); - //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary - DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); - } } for ( DcHeaterId = HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1; DcHeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;DcHeaterId++) { + if (HeaterDisasterCounter[DcHeaterId] >= DISASTER_COUNTER_LIMIT) + { + DeActivateHeater (DcHeaterId); + continue; + } if (HeaterReady[DcHeaterId] == false) continue; if (DCTimeSliceAllocation[DcHeaterId] > 0) //heater active diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h index d27fb7c56..3d2bcf9ff 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS.h @@ -5,6 +5,7 @@ #include "drivers/motors/motor.h" #include "ids_ex.h" +extern int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS]; extern uint32_t DispenserIdToMotorId[MAX_SYSTEM_DISPENSERS]; extern float DispenserPressure[MAX_SYSTEM_DISPENSERS]; uint32_t DispenserConfigMessage(HardwareDispenser * request); @@ -33,5 +34,9 @@ void IDS_Dispenser_RefillEnded (char DispenserId); void IDS_Dispenser_MovingDirection (char DispenserId, bool direction); uint32_t IDS_Dispenser_Build_Pressure(int DispenserId, callback_fptr callback); +uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed); +uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback); +uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr callback); +uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback); #endif //MODULES_IDS_IDS_H_ diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c new file mode 100644 index 000000000..02f25cb59 --- /dev/null +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_Cleaning.c @@ -0,0 +1,56 @@ +/* + * IDS_Cleaning.c + * + * Created on: 18 áîøõ 2019 + * Author: User + */ +#include "include.h" +#include "ids.h" +#include "ids_ex.h" +#include "../control/control.h" +#include "../control/pidalgo.h" +#include "../thread/thread.h" +#include "PMR/Hardware/Hardwaremotor.pb-c.h" +#include "PMR/Hardware/HardwareDispenser.pb-c.h" +#include "StateMachines/Printing/printingSTM.h" +#include "drivers/motors/motor.h" +#include "drivers/valves/valve.h" + +int SaveLeftRockerSpeed = 50, SaveRightRockerSpeed = 50; +#define CLEANING_DISPENSER_ID 6 +uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed) +{ + uint32_t status = OK; + SaveLeftRockerSpeed = LeftRockerSpeed; + SaveRightRockerSpeed = RightRockerSpeed; + status |= MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD].directionthreadwize); + status |= MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD, RightRockerSpeed); + status |= MotorSetDirection(HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH].directionthreadwize); + status |= MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH, LeftRockerSpeed); + + return status; +} +uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback) +{ + uint32_t status = OK; + status |= MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD].directionthreadwize, SaveRightRockerSpeed, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD], callback,timeout); + status |= MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH].directionthreadwize, SaveLeftRockerSpeed, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH], callback,timeout); + + return status; +} +uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr callback) +{ + uint32_t status = OK; + status = IDS_Dispenser_Start_Motor_and_Open_Valve(CLEANING_DISPENSER_ID, dispenserSpeed, callback); + + return status; + +} +uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback) +{ + uint32_t status = OK; + status = IDS_Dispenser_Close_Valve_And_Stop_Motor(CLEANING_DISPENSER_ID,callback); + + return status; + +} diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c index 1e33b99ca..13142ad5f 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_dispenser.c @@ -13,6 +13,7 @@ #include "drivers/valves/valve.h" #include "PMR/EmbeddedParameters/DispenserRunningData.pb-c.h" #include "PMR/EmbeddedParameters/DispenserData.pb-c.h" +#include "PMR/EmbeddedParameters/DispenserDataResponse.pb-c.h" #include "Common/SWUpdate/FileSystem.h" #include "drivers/Flash_Memory/fatfs/ff.h" @@ -23,9 +24,9 @@ uint32_t CloseValveTimeout = 250; uint32_t OpenValveTimeout = 250; -#define DISPENSER_BUILD_PRESSURE_SPEED 500 +#define DISPENSER_BUILD_PRESSURE_SPEED 900 #define DISPENSER_BUILD_PRESSURE_LIMIT 1.5 -#define DISPENSER_BUILD_PRESSURE_TIMEOUT 20000 +#define DISPENSER_BUILD_PRESSURE_TIMEOUT 60000 #define DISPENSER_BUILD_PRESSURE_LAG 50 uint32_t DispenserPrepareSpeed = DISPENSER_BUILD_PRESSURE_SPEED; @@ -33,7 +34,8 @@ double DispenserPreparePressure = DISPENSER_BUILD_PRESSURE_LIMIT; uint32_t DispenserPrepareTimeout = DISPENSER_BUILD_PRESSURE_TIMEOUT; uint32_t DispenserPrepareTimeLag = DISPENSER_BUILD_PRESSURE_LAG; uint32_t DispenserPrepareTime[MAX_SYSTEM_DISPENSERS] = {0,0,0,0,0,0,0,0}; -uint32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS] = {0, 0, 0, 0, 0, 0, 0, 0,}; + +int32_t CurrentDispenserSpeed[MAX_SYSTEM_DISPENSERS] = {0, 0, 0, 0, 0, 0, 0, 0,}; callback_fptr DispenserCallback[MAX_SYSTEM_DISPENSERS] = {0, 0, 0, 0, 0, 0, 0, 0,}; uint32_t DispenserControlId[MAX_SYSTEM_DISPENSERS] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; @@ -55,17 +57,22 @@ void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout) } //******************************************************************************************************************** -uint32_t IdsGetMotorSpeed(uint32_t DispenserId) +int32_t IdsGetMotorSpeed(uint32_t DispenserId) { return CurrentDispenserSpeed[DispenserId]; } uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t ReadValue) { + uint32_t status; DispenserPrepareTime[DispenserId]+=DispenserPrepareTimeLag; if ((GetDispenserPressure(DispenserId)>=DispenserPreparePressure)||(DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout)) { + if (DispenserPrepareTime[DispenserId]>=DispenserPrepareTimeout) + status = ERROR; + else + status = OK; if (SafeRemoveControlCallback(DispenserControlId[DispenserId], IDS_Dispenser_Build_Pressure_Callback )==OK) DispenserControlId[DispenserId] = 0xFF; else @@ -76,17 +83,18 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re if (DispenserCallback[DispenserId]) { - DispenserCallback[DispenserId](DispenserId,ReadValue); + + DispenserCallback[DispenserId](DispenserId,status); DispenserCallback[DispenserId] = 0; } } - return OK; + return status; } uint32_t IDS_Dispenser_Build_Pressure(int DispenserId, callback_fptr callback) { DispenserCallback[DispenserId] = callback; - Report("Control3WayValvesWithCallback called ",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)0,0); + Report("IDS_Dispenser_Build_Pressure called ",__FILE__,__LINE__,(int)DispenserPrepareSpeed,RpWarning,DispenserPrepareTimeLag,0); Control3WayValvesWithCallback ((Valves_t)DispenserId, CloseValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer if (DispenserControlId[DispenserId] != 0xFF) @@ -97,9 +105,10 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); else { - Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); + //Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); DispenserPrepareTime[DispenserId]=0; TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[DispenserId]; + MotorSetDirection(HW_Motor_Id,MotorsCfg[HW_Motor_Id].directionthreadwize); MotorSetSpeed(HW_Motor_Id, DispenserPrepareSpeed); CurrentDispenserSpeed[DispenserId] = DispenserPrepareSpeed; } @@ -130,7 +139,7 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re uint32_t IDS_Dispenser_Close_Valve_And_Stop_Motor(int DispenserId, callback_fptr callback) { DispenserCallback[DispenserId] = callback; - Report("IDS_Dispenser_Close_Valve_And_Stop_Motor",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0); + //Report("IDS_Dispenser_Close_Valve_And_Stop_Motor",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0); Control3WayValvesWithCallback ((Valves_t)DispenserId, CloseValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer if (DispenserControlId[DispenserId] != 0xFF) @@ -139,22 +148,22 @@ uint32_t IDS_Dispenser_Build_Pressure_Callback(uint32_t DispenserId, uint32_t Re DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_StopMotorCallback, CloseValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 ); if (DispenserControlId[DispenserId] == 0xFF) Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); - else - Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); + //else + // Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); return OK; } uint32_t IDS_Dispenser_OpenValveCallback(uint32_t DispenserId, uint32_t ReadValue) { - Report("IDS_Dispenser_Start_Motor_and_Open_Valve Callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0); + //Report("IDS_Dispenser_Start_Motor_and_Open_Valve Callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0); if (SafeRemoveControlCallback(DispenserControlId[DispenserId], IDS_Dispenser_OpenValveCallback )==OK) DispenserControlId[DispenserId] = 0xFF; else Report("Remove control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); - Report("Control3WayValvesWithCallback called ",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)0,0); + //Report("Control3WayValvesWithCallback called ",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)0,0); Control3WayValvesWithCallback (DispenserId, OpenValve, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer if (DispenserCallback[DispenserId]) @@ -185,13 +194,13 @@ uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpee CurrentDispenserSpeed[DispenserId] = MotorSpeed; if (DispenserControlId[DispenserId] != 0xFF) Report("Cannot Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); - Report("IDS_Dispenser_Start_Motor_and_Open_Valve",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0); + //Report("IDS_Dispenser_Start_Motor_and_Open_Valve",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)msec_millisecondCounter,0); DispenserControlId[DispenserId] = AddControlCallback( IDS_Dispenser_OpenValveCallback, OpenValveTimeout, TemplateDataReadCBFunction,DispenserId, DispenserId, 0 ); if (DispenserControlId[DispenserId] == 0xFF) Report("Add control callback failed",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); - else - Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); + //else + // Report("Add control callback",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)DispenserControlId[DispenserId],0); } return OK; @@ -223,42 +232,58 @@ void IDS_Dispenser_Content_Init (void) for(i=0;i<MAX_SYSTEM_DISPENSERS;i++) { memcpy (&IDS_Dispenser_Data[i],StoredDispenserData->dispenserinfo[i],sizeof(DispenserRunningData)); + IDS_Dispenser_Data[i].has_consumedinnanolitter = true; + IDS_Dispenser_Data[i].has_totalconsumedinnanolitter = true; + IDS_Dispenser_Data[i].has_direction = true; + IDS_Dispenser_Data[i].has_microsteps = true; + IDS_Dispenser_Data[i].has_numberofrefills = true; + IDS_Dispenser_Data[i].has_nanolitterperpulse = true; } free (buffer); - dispenser_data__free_unpacked(NULL,StoredDispenserData); + dispenser_data__free_unpacked(StoredDispenserData,NULL); } return; //================================== } uint16_t seconds_counter = 0; +uint32_t IDS_Dispenser_Store_Data (void) +{ + FRESULT Status = FR_OK; + IDSDispenserData.n_dispenserinfo = MAX_SYSTEM_DISPENSERS; + IDSDispenserData.dispenserinfo = dispenserdata; + uint8_t* response_buffer = my_malloc(dispenser_data__get_packed_size(&IDSDispenserData)); + size_t response_size = 0; + if (response_buffer) + { + response_size = dispenser_data__pack(&IDSDispenserData, response_buffer); + Status = FileWrite(response_buffer,response_size,DispenserStorePath); + my_free(response_buffer); + } + else + return ERROR; + + return Status; +} void IDS_Dispenser_Content_Calculation (char DispenserId) { assert (DispenserId<MAX_SYSTEM_DISPENSERS); int dir = (IDS_Dispenser_Data[DispenserId].direction==1)?1:-1; - TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[DispenserId]; - double consumedintimeframe = MotorDriverRequest[HW_Motor_Id].Speed*IDS_Dispenser_Data[DispenserId].microsteps* + double consumedintimeframe = CurrentDispenserSpeed[DispenserId]*IDS_Dispenser_Data[DispenserId].microsteps* IDS_Dispenser_Data[DispenserId].nanolitterperpulse * dir; + //consumedintimeframe = 10+DispenserId; IDS_Dispenser_Data[DispenserId].consumedinnanolitter += consumedintimeframe; IDS_Dispenser_Data[DispenserId].totalconsumedinnanolitter += consumedintimeframe; if (DispenserId == 0) { - if (seconds_counter++>=3600) + if (seconds_counter++>=600)//3600) { seconds_counter = 0; - IDSDispenserData.n_dispenserinfo = MAX_SYSTEM_DISPENSERS; - IDSDispenserData.dispenserinfo = dispenserdata; - uint8_t* response_buffer = my_malloc(dispenser_data__get_packed_size(&IDSDispenserData)); - size_t response_size = 0; - if (response_buffer) + if (IDS_Dispenser_Data[DispenserId].consumedinnanolitter) { - response_size = dispenser_data__pack(&IDSDispenserData, response_buffer); + REPORT_MSG(IDS_Dispenser_Data[DispenserId].consumedinnanolitter,"Saving Dispenser Data" ); } - - FileWrite(response_buffer,response_size,DispenserStorePath); - my_free(response_buffer); - //dispenser_data__free_unpacked(response_size,NULL); - + IDS_Dispenser_Store_Data(); } } } @@ -268,6 +293,7 @@ void IDS_Dispenser_Set_Flow_Params (char DispenserId,double nanolitterperpulse,c IDS_Dispenser_Data[DispenserId].nanolitterperpulse = nanolitterperpulse; IDS_Dispenser_Data[DispenserId].microsteps = microsteps; IDS_Dispenser_Data[DispenserId].direction = 1; + //Report("IDS_Dispenser_Set_Flow_Params",__FILE__,DispenserId,(int)nanolitterperpulse,RpWarning,microsteps,0); } void IDS_Dispenser_RefillStarted (char DispenserId) { @@ -276,6 +302,7 @@ void IDS_Dispenser_RefillStarted (char DispenserId) IDS_Dispenser_Data[DispenserId].nanolitterperpulse = assumedFlow; IDS_Dispenser_Data[DispenserId].microsteps = 1; IDS_Dispenser_Data[DispenserId].direction = 0; + //Report("IDS_Dispenser_RefillStarted",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)(assumedFlow*100),0); } void IDS_Dispenser_RefillEnded (char DispenserId) { @@ -283,6 +310,7 @@ void IDS_Dispenser_RefillEnded (char DispenserId) IDS_Dispenser_Data[DispenserId].numberofrefills++; IDS_Dispenser_Data[DispenserId].direction = 1; IDS_Dispenser_Data[DispenserId].consumedinnanolitter = 0; + //Report("IDS_Dispenser_RefillEnded",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)IDS_Dispenser_Data[DispenserId].numberofrefills,0); } void IDS_Dispenser_MovingDirection (char DispenserId, bool direction) { @@ -294,5 +322,25 @@ void IDS_Dispenser_MovingDirection (char DispenserId, bool direction) { IDS_Dispenser_Data[DispenserId].direction = 0; } + //Report("IDS_Dispenser_MovingDirection",__FILE__,__LINE__,(int)DispenserId,RpWarning,(int)direction,0); +} +void DispenserDataRequestFunc(MessageContainer* requestContainer) +{ + MessageContainer responseContainer; + + //DisconnectRequest* request = disconnect_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); + DispenserDataResponse response = DISPENSER_DATA_RESPONSE__INIT; + + + response.n_dispenserinfo = MAX_SYSTEM_DISPENSERS; + response.dispenserinfo = dispenserdata; + responseContainer = createContainer(MESSAGE_TYPE__DispenserDataResponse, requestContainer->token, true, &response, &dispenser_data_response__pack, &dispenser_data_response__get_packed_size); + + //------------------------------------------------------------------------------------------- + uint8_t* container_buffer = my_malloc(message_container__get_packed_size(&responseContainer)); + size_t container_size = message_container__pack(&responseContainer, container_buffer); + my_free(responseContainer.data.data); + SendChars((char*)container_buffer, container_size); + } diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h index bf73ed7fa..c691e1e90 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h @@ -29,15 +29,25 @@ typedef enum { LimitSwitchAlarmLow_8, //MOTO_DISPENSER_8 = 13, }LimitSwitchAlarms; +extern bool EnableLubrication; +extern bool EnableIntersegment; +extern double IntersegmentLength; + +extern bool DispenserUsedInJob[MAX_SYSTEM_DISPENSERS]; +bool IDS_MapDispenserUsedinJob(void *JobDetails); + void IDS_ModuleInit (void); void Calculateinit(void); void IDS_Dispenser_Content_Init (void); uint32_t IDSPrepareState(void *JobDetails); -uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId); -uint32_t IDSSegmentState(void *JobDetails, int SegmentId); +uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId); +uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId); uint32_t IDSDistanceToSpoolState(void); -uint32_t IDSEndState(void *JobDetails); +uint32_t IDSEndState(void); + +uint32_t IDS_StartLubrication(void); +uint32_t IDS_StopLubrication(void); uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request); uint32_t IDS_DispenserControlInit(); @@ -49,19 +59,25 @@ uint32_t IDS_Dispenser_Alarm_On (uint8_t deviceID); uint32_t IDS_Dispenser_Alarm_Off (uint8_t deviceID); uint32_t IDS_CheckDispenserLimitSwitch (LimitSwitchAlarms LS_Id); +uint32_t IDS_Dispenser_Build_Pressure(int DispenserId, callback_fptr callback); void IDS_Dispenser_SetTimeOutValues(uint32_t CloseTimeout, uint32_t OpenTimeout); void IDS_Dispenser_SetBackLashValues(double initialdispenserpressure, uint32_t initialdispensertimeout, uint32_t initialdispensertimelag); void IDS_Dispenser_SetPrepareValues( uint32_t DispenserBuildPressureSpeed, double DispenserBuildPressureLimit, uint32_t DispenserBuildPressureTimeout, uint32_t DispenserBuildPressureLag); +void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, double ids_presegment_wfcf_timebeforesegment); +void IDS_Dispenser_SetPreSegmentCleaningValues(double ids_cleaningspeed,double ids_cleaningstartspraypresegmenttime ,double ids_cleaningstopbeforesegmenttime,double ids_leftcleaningmotorspeed,double ids_rightcleaningmotorspeed); uint32_t IDS_Dispenser_Close_Valve_And_Stop_Motor(int DispenserId, callback_fptr callback); uint32_t IDS_Dispenser_Start_Motor_and_Open_Valve(int DispenserId, int MotorSpeed, callback_fptr callback); void IDS_Dispenser_Content_Calculation (char DispenserId); +uint32_t IDS_Dispenser_Store_Data (void); +uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails); float CalculateDispenserPressure (int DispenserId); float GetDispenserPressure(int DispenserId); -uint32_t IdsGetMotorSpeed(uint32_t DispenserId); +int32_t IdsGetMotorSpeed(uint32_t DispenserId); +void DispenserDataRequestFunc(MessageContainer* requestContainer); #endif /* MODULES_IDS_IDS_EX_H_ */ diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c index db5d2738e..74ae94fd4 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c @@ -62,8 +62,8 @@ callback_fptr HomingRequestCallback[MAX_SYSTEM_DISPENSERS]={0,0,0,0,0,0,0,0}; bool HomingActive[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false}; uint32_t DispenserHomingControlId[MAX_SYSTEM_DISPENSERS] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; uint32_t DispenserHomingTime[MAX_SYSTEM_DISPENSERS] = {0,0,0,0,0,0,0,0}; -#define INITIAL_DISPENSER_PRESSURE 0.10 -#define INITIAL_DISPENSER_TIMEOUT_LIMIT 10000 +#define INITIAL_DISPENSER_PRESSURE 2.10 +#define INITIAL_DISPENSER_TIMEOUT_LIMIT 60000 #define INITIAL_DISPENSER_TIMEOUT 100 double InitialDispenserPressure = INITIAL_DISPENSER_PRESSURE; @@ -78,13 +78,14 @@ void IDS_Dispenser_SetBackLashValues(double initialdispenserpressure, uint32 Report("IDS_Dispenser_SetBackLashValues ",__FILE__,InitialDispenserPressure,InitialDispenserTimeout,RpWarning,(int)InitialDispenserTimeLag,0); } -uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t deviceID, uint32_t ReadValue) +uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t motorId, uint32_t ReadValue) { - uint8_t DispenserId = deviceID-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1; + uint8_t DispenserId = motorId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1; if ((GetDispenserPressure(DispenserId)>=InitialDispenserPressure)||(DispenserHomingTime[DispenserId]>InitialDispenserTimeout)) { - MotorStop(deviceID,Hard_Hiz); - MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep); + MotorStop(motorId,Hard_Hiz); + CurrentDispenserSpeed[DispenserId] = 0; + MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep); HomingActive[DispenserId]= false; Report("End backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0); if (SafeRemoveControlCallback(DispenserHomingControlId[DispenserId], IDS_HomeDispenserBackMoveCallback )==OK) @@ -99,15 +100,15 @@ uint32_t IDS_HomeDispenserBackMoveCallback(uint32_t deviceID, uint32_t ReadValue } return OK; } -uint32_t IDS_HomeDispenserCallback(uint32_t deviceID, uint32_t ReadValue) +uint32_t IDS_HomeDispenserCallback(uint32_t motorId, uint32_t ReadValue) { - uint8_t DispenserId = deviceID-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1; + uint8_t DispenserId = motorId-HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1; Read_MidTank_Pressure_Sensor(DispenserId); //close dry air valve in the dispenser Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF); Disable_MidTank_Pressure_Reading(DispenserId); - //MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep); + //MotorSetMicroStep(motorId, MotorsCfg[motorId].microstep); if (HomingRequestCallback[DispenserId]) { HomingRequestCallback[DispenserId](DispenserId,0); @@ -115,11 +116,12 @@ uint32_t IDS_HomeDispenserCallback(uint32_t deviceID, uint32_t ReadValue) } // HomingActive[DispenserId]= false; Report("Start backlash",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)DispenserHomingTime[DispenserId],0); - DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,deviceID, deviceID, 0 ); + DispenserHomingControlId[DispenserId] = AddControlCallback( IDS_HomeDispenserBackMoveCallback, InitialDispenserTimeLag, GetDispenserPressure,motorId, motorId, 0 ); - MotorSetDirection(deviceID,MotorsCfg[deviceID].directionthreadwize); + MotorSetDirection(motorId,MotorsCfg[motorId].directionthreadwize); - MotorSetSpeed(deviceID, 1000); + MotorSetSpeed(motorId, 1000); + CurrentDispenserSpeed[DispenserId] = 1000; IDS_Dispenser_RefillEnded ( DispenserId); @@ -127,72 +129,85 @@ return OK; } -uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback) +uint32_t IDS_HomeDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr callback) { - assert(deviceID < MAX_SYSTEM_DISPENSERS); + assert(DispenserId < MAX_SYSTEM_DISPENSERS); - //if (DispensersAlarmState[deviceID] == true) + //if (DispensersAlarmState[DispenserId] == true) // return ERROR; - if (HomingActive[deviceID] == true) + if (HomingActive[DispenserId] == true) + { + LOG_ERROR (DispenserId,"Homing already active"); return ERROR; + } else - HomingActive[deviceID] = true; + HomingActive[DispenserId] = true; - HomingRequestCallback[deviceID] = callback; + HomingRequestCallback[DispenserId] = callback; - TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID; - if ( Dispenser_Id_to_LS_Id[deviceID] != MAX_GPI) + TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId; + if ( Dispenser_Id_to_LS_Id[DispenserId] != MAX_GPI) { //open dispenser valve dispenser to midtank direction - Control3WayValvesWithCallback ((Valves_t)deviceID, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer //Valve_Set((Valves_t) request->index, MidTank_Dispenser); - MotorSetMicroStep(deviceID, 1); + MotorSetMicroStep(MotorId, 1); SysCtlDelay(180000); //open dry air valve in the dispenser - Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON); + Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_ON); - IDS_Dispenser_RefillStarted(deviceID); - MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed, Dispenser_Id_to_LS_Id[deviceID], IDS_HomeDispenserCallback,0); + IDS_Dispenser_RefillStarted(DispenserId); + MotorMovetoLimitSwitch (MotorId,1-MotorsCfg[MotorId].directionthreadwize, speed, Dispenser_Id_to_LS_Id[DispenserId], IDS_HomeDispenserCallback,0); + CurrentDispenserSpeed[DispenserId] = speed; + CurrentDispenserSpeed[DispenserId] = (-1*CurrentDispenserSpeed[DispenserId]); return OK; } return ERROR; } -uint32_t IDS_Dispenser_Alarm_On (uint8_t deviceID) +uint32_t IDS_Dispenser_Alarm_On (uint8_t DispenserId) { uint32_t status = OK; - DispensersAlarmState[deviceID] = true; - TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID; + DispensersAlarmState[DispenserId] = true; + TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId; status |= MotorAbortMovetoLimitSwitch(MotorId); - Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_OFF); - Enable_MidTank_Pressure_Reading(deviceID); - status |= MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep); - status |= MotorStop(deviceID, Hard_Hiz); + Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF); + Enable_MidTank_Pressure_Reading(DispenserId); + status |= MotorSetMicroStep(DispenserId, MotorsCfg[DispenserId].microstep); + status |= MotorStop(DispenserId, Hard_Hiz); + CurrentDispenserSpeed[DispenserId] = 0; + JobEndReason = JOB_OUT_OF_DYE; return status; } -uint32_t IDS_Dispenser_Alarm_Off (uint8_t deviceID) +uint32_t IDS_Dispenser_Alarm_Off (uint8_t DispenserId) { uint32_t status = OK; - DispensersAlarmState[deviceID] = false; + DispensersAlarmState[DispenserId] = false; return status; } -uint32_t IDS_StopHomeDispenser (uint32_t deviceID) +uint32_t IDS_StopHomeDispenser (uint32_t DispenserId) { - assert(deviceID < MAX_SYSTEM_DISPENSERS); + assert(DispenserId < MAX_SYSTEM_DISPENSERS); - if (HomingActive[deviceID] != true) + Report("IDS_StopHomeDispenser",__FILE__,millisecondCounter,(int)DispenserId,RpWarning,(int)HomingActive[DispenserId],0); + if (HomingActive[DispenserId] != true) + { + LOG_ERROR (DispenserId,"Homing not active"); return ERROR; + } else - HomingActive[deviceID] = false; + HomingActive[DispenserId] = false; - TimerMotors_t MotorId = (deviceID)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1; + TimerMotors_t MotorId = (DispenserId)+HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1; MotorAbortMovetoLimitSwitch(MotorId); //close dry air valve in the dispenser - Disable_MidTank_Pressure_Reading(deviceID); - Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_OFF); - Control3WayValvesWithCallback ((Valves_t)deviceID, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer - MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep); + Disable_MidTank_Pressure_Reading(DispenserId); + Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_OFF); + Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + + MotorSetMicroStep(MotorId, MotorsCfg[MotorId].microstep); + CurrentDispenserSpeed[DispenserId] = 0; return OK; } @@ -213,34 +228,35 @@ uint32_t IDS_CheckDispenserLimitSwitch (LimitSwitchAlarms LS_Id) return FPGA_Read_limit_Switches(Dispenser_Id_to_Alarm_LS_Id[LS_Id]); } -uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback) +uint32_t IDS_EmptyDispenser (uint32_t DispenserId, uint32_t speed , callback_fptr callback) { - assert(deviceID < MAX_SYSTEM_DISPENSERS); + assert(DispenserId < MAX_SYSTEM_DISPENSERS); - //if (DispensersAlarmState[deviceID] == true) + //if (DispensersAlarmState[DispenserId] == true) // return ERROR; - if (HomingActive[deviceID] == true) + if (HomingActive[DispenserId] == true) return ERROR; else - HomingActive[deviceID] = true; - HomingRequestCallback[deviceID] = callback; + HomingActive[DispenserId] = true; + HomingRequestCallback[DispenserId] = callback; - TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID; - if ( Dispenser_Id_to_LS_Empty_Id[deviceID] != MAX_GPI) + TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + DispenserId; + if ( Dispenser_Id_to_LS_Empty_Id[DispenserId] != MAX_GPI) { //open dispenser valve dispenser to midtank direction - Control3WayValvesWithCallback ((Valves_t)deviceID, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + Control3WayValvesWithCallback ((Valves_t)DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer //Valve_Set((Valves_t) request->index, Dispenser_Mixer); - MotorSetMicroStep(deviceID, 1); + MotorSetMicroStep(MotorId, 1); SysCtlDelay(180000); //open dry air valve in the dispenser - //Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_ON); - IDS_Dispenser_RefillStarted(deviceID); - IDS_Dispenser_MovingDirection(deviceID,UP); + //Valve_Set(IDS_Id_to_AirValve[DispenserId], Atm_MidTank_ON); + IDS_Dispenser_RefillStarted(DispenserId); + IDS_Dispenser_MovingDirection(DispenserId,UP); - MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed, Dispenser_Id_to_LS_Empty_Id[deviceID], IDS_HomeDispenserCallback,0); + MotorMovetoLimitSwitch (MotorId,MotorsCfg[MotorId].directionthreadwize, speed, Dispenser_Id_to_LS_Empty_Id[DispenserId], IDS_HomeDispenserCallback,0); + CurrentDispenserSpeed[DispenserId] = speed; return OK; } return ERROR; diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 2be233962..eeab745f8 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -7,14 +7,23 @@ #include "ids.h" #include "ids_ex.h" #include "../control/control.h" +#include "../general/process.h" #include "../control/pidalgo.h" #include "../thread/thread.h" #include "PMR/Hardware/Hardwaremotor.pb-c.h" #include "PMR/Hardware/HardwareDispenser.pb-c.h" +#include "PMR/Printing/JobDescriptionFileBrushStop.pb-c.h" +#include "PMR/Printing/JobDescriptionFileSegment.pb-c.h" +#include "PMR/Printing/JobUploadStrategy.pb-c.h" +#include "PMR/Printing/JobSegment.pb-c.h" +#include "PMR/Printing/JobTicket.pb-c.h" #include "StateMachines/Printing/printingSTM.h" #include "drivers/motors/motor.h" #include "drivers/valves/valve.h" +#include "Common/SWUpdate/FileSystem.h" +#include "drivers/Flash_Memory/fatfs/ff.h" + #include "modules/heaters/heaters.h" #include "drivers/Flash_ram/FlashProgram.h" @@ -31,11 +40,13 @@ typedef struct PID_Config_Params m_params; }DispenserControlConfig_t; HardwarePidControl *DispensersControl;// = (HardwarePidControl *)GENHWCFG_MAP_IN_FLASH + 0x4000; - +#define LUBRICANT_DISPENSER 7 +#define CLEANER_DISPENSER 6 +#define MAX_DYE_DISPENSERS 6 int32_t DispenserSamples[MAX_SYSTEM_DISPENSERS][MAX_CONTROL_SAMPLES] = {0}; int DispenserSamplePointer[MAX_SYSTEM_DISPENSERS] = {0}; double DispenserNormalizedErrorCoEfficient[MAX_SYSTEM_DISPENSERS] = {0}; - +double lubricant_speed = 0.0; HardwarePidControlType ThreadDispenserIdToControlId[MAX_SYSTEM_DISPENSERS] = { HARDWARE_PID_CONTROL_TYPE__Dispenser1,HARDWARE_PID_CONTROL_TYPE__Dispenser2,HARDWARE_PID_CONTROL_TYPE__Dispenser3,HARDWARE_PID_CONTROL_TYPE__Dispenser4,HARDWARE_PID_CONTROL_TYPE__Dispenser5,HARDWARE_PID_CONTROL_TYPE__Dispenser6,HARDWARE_PID_CONTROL_TYPE__Dispenser7,HARDWARE_PID_CONTROL_TYPE__Dispenser8}; bool DispenserReady[MAX_SYSTEM_DISPENSERS] = {true}; @@ -43,7 +54,8 @@ bool IDS_Active = false; /******************** STRUCTURES AND ENUMs ********************************************/ uint32_t IDS_Valve_DistanceToSpoolReady(uint32_t deviceID, uint32_t ReadValue); uint32_t IDS_Valve_PresegmentReady(uint32_t deviceID, uint32_t ReadValue); -bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int SegmentId); +uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue); +//bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int SegmentId); /******************** GLOBAL PARAMETERS ********************************************/ DispenserControlConfig_t DispenserControlConfig[MAX_SYSTEM_DISPENSERS]; uint32_t ControlIdtoDispenserId [MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}; @@ -54,6 +66,45 @@ bool DispenserDistanceToSpoolReady[MAX_SYSTEM_DISPENSERS] = {true,true,t bool DispenserUsedInJob[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false}; bool DispensersAlarmState[ MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false}; int JobBrushStopId = 0; +int lInterSegmentLength = 0; + int InterSegmentStepsLimit = 0,InterSegmentStepsCount = 0; + uint32_t InterSegmentStartSprayCleaner; + uint32_t InterSegmentStartRocking; + uint32_t InterSegmentCenterRockers; + uint32_t LeftRockerSpeed = 20; + uint32_t RighttRockerSpeed = 20; + uint32_t CleaningDispenserSpeed = 40; + uint32_t InterSegmentStartWFCFDispensers; + uint32_t WFCF = 80; + bool EnableCleaning = true; + + void IDS_Dispenser_SetPreSegmentWFCFValues(double dispenserpresegmentwfcf, double ids_presegment_wfcf_timebeforesegment) + { + if (ids_presegment_wfcf_timebeforesegment) + InterSegmentStartWFCFDispensers = ids_presegment_wfcf_timebeforesegment; + if (dispenserpresegmentwfcf) + WFCF = dispenserpresegmentwfcf; + } + void IDS_Dispenser_SetPreSegmentCleaningValues(double ids_cleaningspeed,double ids_cleaningstartspraypresegmenttime ,double ids_cleaningstopbeforesegmenttime,double ids_leftcleaningmotorspeed,double ids_rightcleaningmotorspeed) + { + if ( ids_cleaningspeed) + CleaningDispenserSpeed = ids_cleaningspeed; + if ( ids_cleaningstartspraypresegmenttime ) + { + InterSegmentStartSprayCleaner = ids_cleaningstartspraypresegmenttime; + InterSegmentStartRocking = ids_cleaningstartspraypresegmenttime + 1000; + } + if ( ids_cleaningstopbeforesegmenttime) + InterSegmentCenterRockers = ids_cleaningstopbeforesegmenttime; + if ( ids_leftcleaningmotorspeed) + LeftRockerSpeed = ids_leftcleaningmotorspeed; + if ( ids_rightcleaningmotorspeed) + RighttRockerSpeed = ids_rightcleaningmotorspeed; + } + + uint32_t DispenserPreSegmentControlId = 0xFF; + uint32_t BrushStopControlId = 0xFF; + uint32_t PreSegmentControlId = 0xFF; uint32_t IDS_DispenserControlInit() { @@ -120,53 +171,337 @@ void DispenserPrepareReady(void) return; //not all configured Dispensers are ready } } - REPORT_MSG(Module_IDS,"DispenserPrepareReady"); + REPORT_MSG(Module_IDS,"All Dispensers Prepare Ready"); PrepareReady(Module_IDS,ModuleDone); } //******************************************************************************************************************** uint32_t IDS_PrepareReady(uint32_t deviceID, uint32_t ReadValue) { if (IDS_Active == false) + { + REPORT_MSG(deviceID,"IDS_Active false"); return ERROR; - + } DispenserReady[deviceID] = true; REPORT_MSG(deviceID,"Dispenser prepare ready"); DispenserPrepareReady(); return OK; // all configured heaters are ready } - bool IDS_MapDispenserUsedinJob(void *JobDetails) +/* + void OpenJobFile(); +void CloseJobFile(); +JobDescriptionFileSegment *GetNextSegmentFromJobFile(); +void FreeSegmentFileData(JobDescriptionFileSegment *Segment); +JobDescriptionFileBrushStop *GetNextBrushStopFromJobFile(); +void FreeBrushStopFileData(JobDescriptionFileBrushStop *BrushStop); + + */ + /************************************************************************************************************************************ + uint32_t IDS_MapDispenserUsedinFileJobshort(void *JobDetails) { JobTicket* JobTicket = JobDetails; - int Dispenser_i, Segment_i,Brush_i,DispenserId; + JobDescriptionFileBrushStop *BrushStop; + JobDescriptionFileSegment *Segment; + int Dispenser_i, Brush_i,DispenserId; + FRESULT Fresult = FR_OK; + uint32_t status = OK; + bool lookForLubrication = false; for (Dispenser_i = 0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++) { DispenserUsedInJob[Dispenser_i] = false; } - if (JobTicket->n_segments == 0) - return false; + if (EnableCleaning == true) + DispenserUsedInJob[CLEANER_DISPENSER] = true; + if (JobTicket->enablelubrication == true) + { + DispenserUsedInJob[LUBRICANT_DISPENSER] = true; + lookForLubrication = true; + } - for (Segment_i=0;Segment_i<JobTicket->n_segments;Segment_i++) + Fresult = OpenJobFile(); + if (Fresult == FR_OK) + { + Segment = GetNextSegmentFromJobFile(); + while(Segment) { - for (Brush_i=0;Brush_i<JobTicket->segments[Segment_i]->n_brushstops;Brush_i++) + if ((Segment->has_brushstopscount)&&(Segment->brushstopscount)) { - if (JobTicket->segments[Segment_i]->brushstops[Brush_i]->n_dispensers) + for (Brush_i=0;Brush_i<Segment->brushstopscount;Brush_i++) { - for (Dispenser_i = 0;Dispenser_i < JobTicket->segments[Segment_i]->brushstops[Brush_i]->n_dispensers;Dispenser_i++) + BrushStop = GetNextBrushStopFromJobFile(); + if (BrushStop) { - //prepare the SW structures - DispenserId = JobTicket->segments[Segment_i]->brushstops[Brush_i]->dispensers[Dispenser_i]->index; - if (JobTicket->segments[Segment_i]->brushstops[Brush_i]->dispensers[Dispenser_i]->nanolitterpersecond>0.0) + if (BrushStop->n_dispensers) + { + for (Dispenser_i = 0;Dispenser_i < BrushStop->n_dispensers;Dispenser_i++) + { + //prepare the SW structures + DispenserId = BrushStop->dispensers[Dispenser_i]->index; + if (BrushStop->dispensers[Dispenser_i]->nanolitterpersecond>0.0) + { + DispenserUsedInJob[DispenserId] = true; + if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER)) + { + lookForLubrication = false; + lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); + } + } + }//for dispenser + }//if dispensers + else { - DispenserUsedInJob[DispenserId] = true; + LOG_ERROR (BrushStop->index, "no dispensers in brushstop"); } - }//for dispenser - }//if dispensers - }//for brush - }//for segments + FreeBrushStopFileData(BrushStop); + BrushStop = NULL; + } + else + { + LOG_ERROR (BrushStop, "malloc error"); + status = ERROR; + } + }//for brushstops + }// if brush stop count + FreeSegmentFileData(Segment); + Segment = GetNextSegmentFromJobFile(); + } + FreeSegmentFileData(Segment); + CloseJobFile(); + } + return status; + + } + *************************************************************************************************************************************/ + /************************************************************************************************************************************/ + uint32_t IDS_MapDispenserUsedinFileJob(void *JobDetails) + { + JobTicket* JobTicket = JobDetails; + uint8_t *SegmentPtr = 0, *BrushStopPtr = 0; + JobDescriptionFileBrushStop *BrushStop; + JobDescriptionFileSegment *Segment; + int Dispenser_i, Brush_i,DispenserId; + uint32_t Bytes = 0,readBytes = 0,ImmediateRead = 0,SegmentSize = 0,BrushStopSize = 0; + uint32_t status = OK; + FRESULT Fresult = FR_OK; + FIL *FileHandle = 0; //the system supports a single active file + bool lookForLubrication = false; +/* + Parsing the job description file. +The job description file simply contains an array of segments and their brush stops. +The job description file is meant to be read brush stop by brush stop while the job is in progress. +The following diagram represents a single job description file segment structure. +The process of reading the whole file is simply repeating that reading order. + +Each JobDescriptionFileSegment contains a “BrushStopsCount” field that should be used to determine how many brush stops are associated +with the current segment and how many times the process of reading brush stops should be repeated. +1. 32bit integer containing the next JobFileDescriptionSegment message byte count +2. JobDescriptionFileSegment message +3. 32bit integer containing the next JobDescriptionFileBrushStop message byte count +4. JobDescriptionFileBrushStop message + +1. Read segment message length. +2. Read segment message. +a. Read brush stop message length. +b. Read brush stop message. +c. Go to step 2.a x Segment.BrushStopsCount. +3. Go to step 1 until end of file. + */ + for (Dispenser_i = 0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++) + { + DispenserUsedInJob[Dispenser_i] = false; + } + n_segments = 0; + if (EnableCleaning == true) + DispenserUsedInJob[CLEANER_DISPENSER] = true; + if (JobTicket->enablelubrication == true) + { + DispenserUsedInJob[LUBRICANT_DISPENSER] = true; + lookForLubrication = true; + } + if (JobTicket->uploadstrategy == JOB_UPLOAD_STRATEGY__JobDescriptionFile) + { + FileHandle = my_malloc(sizeof(FIL)); + + Fresult = FileOpen(JobTicket->jobdescriptionfile, &Bytes, FileHandle); + if (Fresult == FR_OK) + { + while((readBytes < Bytes)&&(status == OK)) + { + Fresult = f_read(FileHandle,&SegmentSize,4,&ImmediateRead ); + if (Fresult == FR_OK) + { + readBytes += ImmediateRead; + SegmentPtr = my_malloc (SegmentSize); + if (SegmentPtr) + { + Fresult = f_read(FileHandle,SegmentPtr,SegmentSize,&ImmediateRead ); + if (Fresult == FR_OK) + { + readBytes += ImmediateRead; + n_segments++; + Segment = job_description_file_segment__unpack(NULL, SegmentSize, SegmentPtr); + if ((Segment->has_brushstopscount)&&(Segment->brushstopscount)) + { + REPORT_MSG (Segment->brushstopscount, "Segment->brushstopscount"); + for (Brush_i=0;Brush_i<Segment->brushstopscount;Brush_i++) + { + if (status == ERROR) + break; + Fresult = f_read(FileHandle,&BrushStopSize,4,&ImmediateRead ); + if (Fresult == FR_OK) + { + readBytes += ImmediateRead; + BrushStopPtr = my_malloc (BrushStopSize); + if (BrushStopPtr) + { + Fresult = f_read(FileHandle,BrushStopPtr,BrushStopSize,&ImmediateRead ); + if (Fresult == FR_OK) + { + readBytes += ImmediateRead; + BrushStop = job_description_file_brush_stop__unpack(NULL, BrushStopSize, BrushStopPtr); + REPORT_MSG (BrushStopSize, "BrushStop"); + if (BrushStop->n_dispensers) + { + for (Dispenser_i = 0;Dispenser_i < BrushStop->n_dispensers;Dispenser_i++) + { + //prepare the SW structures + DispenserId = BrushStop->dispensers[Dispenser_i]->index; + if (BrushStop->dispensers[Dispenser_i]->nanolitterpersecond>0.0) + { + DispenserUsedInJob[DispenserId] = true; + } + if ((lookForLubrication == true)&&(DispenserId == LUBRICANT_DISPENSER)) + { + lookForLubrication = false; + lubricant_speed = BrushStop->dispensers[Dispenser_i]->nanolitterpersecond/BrushStop->dispensers[Dispenser_i]->nanoliterperpulse; + REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); + } + }//for dispenser + }//if dispensers + else + { + LOG_ERROR (BrushStop->index, "no dispensers in brushstop"); + } + job_description_file_brush_stop__free_unpacked (BrushStop,NULL); + BrushStop = NULL; + } //read brush stop data + else + { + LOG_ERROR (Fresult, "f_read error"); + status = ERROR; + } + my_free(BrushStopPtr); + BrushStopPtr = NULL; + }//brushstop malloc ok + else + { + LOG_ERROR (BrushStopPtr, "malloc error"); + status = ERROR; + } + }//brushstop size read ok + else + { + LOG_ERROR (Fresult, "f_read error"); + status = ERROR; + } + }//for brushstops + }// if brush stop count + else + { + LOG_ERROR (0, "no brushstops error"); + status = ERROR; + } + job_description_file_segment__free_unpacked(Segment,NULL); + Segment = NULL; + }// read segment data + my_free(SegmentPtr); + SegmentPtr = NULL; + Task_sleep(10); + }//segment malloc + else + { + LOG_ERROR (SegmentPtr, "malloc error"); + status = ERROR; + } + }//segment read size + else + { + LOG_ERROR (Fresult, "f_read error"); + status = ERROR; + } + }//while(readBytes < Bytes) + } + else + { + LOG_ERROR (Fresult, "FileOpen error"); + status = ERROR; + } + }//file job + + if (SegmentPtr) + my_free(SegmentPtr); + if (BrushStopPtr) + my_free(BrushStopPtr); + if (Segment != NULL) + job_description_file_segment__free_unpacked(Segment,NULL); + if (BrushStop != NULL) + job_description_file_brush_stop__free_unpacked (BrushStop,NULL); + Fresult = f_close(FileHandle); + REPORT_MSG (n_segments, "Finished checking the file"); + return status; + + } +/************************************************************************************************************************************/ + bool IDS_MapDispenserUsedinJob(void *JobDetails) + { + JobTicket* JobTicket = JobDetails; + int Dispenser_i, Segment_i,Brush_i,DispenserId; + + if (JobTicket->uploadstrategy == JOB_UPLOAD_STRATEGY__JobDescriptionFile) + { + return (IDS_MapDispenserUsedinFileJob(JobDetails)); + //return (IDS_MapDispenserUsedinFileJobshort(JobDetails)); + } + else + { + for (Dispenser_i = 0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++) + { + DispenserUsedInJob[Dispenser_i] = false; + } + if (n_segments == 0) + return false; + + for (Segment_i=0;Segment_i<n_segments;Segment_i++) + { + for (Brush_i=0;Brush_i<JobTicket->segments[Segment_i]->n_brushstops;Brush_i++) + { + if (JobTicket->segments[Segment_i]->brushstops[Brush_i]->n_dispensers) + { + for (Dispenser_i = 0;Dispenser_i < JobTicket->segments[Segment_i]->brushstops[Brush_i]->n_dispensers;Dispenser_i++) + { + //prepare the SW structures + DispenserId = JobTicket->segments[Segment_i]->brushstops[Brush_i]->dispensers[Dispenser_i]->index; + if (JobTicket->segments[Segment_i]->brushstops[Brush_i]->dispensers[Dispenser_i]->nanolitterpersecond>0.0) + { + DispenserUsedInJob[DispenserId] = true; + if(DispenserId == LUBRICANT_DISPENSER) + { + lubricant_speed = JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond/ + JobTicket->segments[0]->brushstops[0]->dispensers[Dispenser_i]->nanoliterperpulse; + REPORT_MSG (lubricant_speed*100, "LUBRICANT_SPEED*100"); + } + + } + }//for dispenser + }//if dispensers + }//for brush + }//for segments + } - return false; + return true; } @@ -205,9 +540,10 @@ void DispenserPrepareReady(void) //ValveCommand (Enable,MixerDirection); } //set 3 dancers to the profile positions - IDS_MapDispenserUsedinJob(JobDetails); + //IDS_MapDispenserUsedinJob(JobDetails); for (i = 0; i < MAX_SYSTEM_DISPENSERS; i++) { + //IDS_StopHomeDispenser(i); if (DispenserUsedInJob[i] == true) //we actually should check for all dispensers { DispenserReady[i] = false; @@ -215,41 +551,15 @@ void DispenserPrepareReady(void) REPORT_MSG(i,"Dispenser prepare called"); } else + { DispenserReady[i] = true; + //IDS_HomeDispenser (i, 1000 , NULL); + } + } DispenserPrepareReady(); return OK; } -bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int SegmentId) -{ - JobTicket* JobTicket = JobDetails; - int Dispenser_i,n_dispensers; - if (JobTicket->n_segments == 0) - return false; - if (JobTicket->n_segments <= SegmentId) - return false; - if (JobTicket->segments[SegmentId]->brushstops[0]->n_dispensers) - { - n_dispensers = JobTicket->segments[SegmentId]->brushstops[0]->n_dispensers; - for (Dispenser_i = 0;Dispenser_i < n_dispensers;Dispenser_i++) - { - if (DispenserId == JobTicket->segments[SegmentId]->brushstops[0]->dispensers[Dispenser_i]->index) //dispenser is in use next segment - { - if (JobTicket->segments[SegmentId]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond>0) - { - return true; - } - else - { - return false; - } - } - } - } - - return false; - -} //******************************************************************************************************************** uint32_t IDS_Valve_PresegmentValveReady(uint32_t deviceID, uint32_t ReadValue) { @@ -275,16 +585,150 @@ bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int Segmen return OK; //not all configured heaters are ready } } - REPORT_MSG(deviceID,"IDS_Valve_Presegment all Ready!!"); + REPORT_MSG(deviceID,"IDS Presegment Ready!!"); PreSegmentReady(Module_IDS,ModuleDone); return OK; // all configured heaters are ready } + //******************************************************************************************************************** -uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) + JobDescriptionFileBrushStop * FileBrushStop; + char IdsMessage[100]; + + uint32_t IDSPreSegmentStateCallbackRunner(uint32_t IfIndex, uint32_t ReadValue) + { + JobDispenser **Dispensers; + //set the speed only before the first segment, speed is constant accros job + int Dispenser_i,n_dispensers,DispenserId; + TimerMotors_t HW_Motor_Id; + double segmentfirst_speed; +/* + IDS Pre-Segment (Inter-Segment) activity +1. Cleaning +2. Build pressure toward the waste valve +The IDS pre-segment process will be performed before all segments, including the first one. +The dye dispensers will be in one of two states: +1. After being idle – with a high pressure, idle motor and closed valve (will be performed in job prepare or during the previous segment. For Ty time until pressure Pa is achieved) +2. At work – pushing dye to the mixer. +At pre-segment, TW seconds before its end, the active dispensers will start working in the next segment's speed: Ssegment* WFCF. +After TU milliseconds the valve will open. +At segment start, the waste valve will be redirected to the head and the dispensers' speed will be reduced to the next segment's speed +Cleaning: the cleaning process involves: starting the cleaning dispenser in speed Sclean, starting the head rockers motor(s) in speed S1 and S2, +and stopping the dispenser, centering the rockers Tending milliseconds before segment start. +Segment state: +1. Active dispensers are working. +2. Idle dispensers are filling, until TX+TY seconds before segment end. (TX=backlash time, TY=pressure prepare time). Then they reverse direction and start building pressure until segment end or until pressure PA (= prepare pressure) is achieved. +This means that for each Pre-segment we must calculate: TW,TU,Tending, +This means that for each segment we must calculate: Tx,Ty. + + */ +/*uint32_t InterSegmentStartSprayCleaner = 500; +uint32_t InterSegmentStartRocking = 1000; +uint32_t InterSegmentCenterRockers = 3000; +uint32_t InterSegmentStartWFCFDispensers = lInterSegmentLength-1500; +uint32_t IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed); +uint32_t IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback); +uint32_t IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr callback); +uint32_t IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback); +*/ + //InterSegmentStepsLimit = lInterSegmentLength*10;//100 millisec steps + InterSegmentStepsCount+=100; + if (InterSegmentStepsCount == lInterSegmentLength) + { + //IDS_Valve_PresegmentReady(1,0); + Report("End of Pre-segment Handling",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0); + SafeRemoveControlCallback(DispenserPreSegmentControlId,IDSPreSegmentStateCallbackRunner); + } + if (EnableCleaning == true) + { + if (InterSegmentStartSprayCleaner == InterSegmentStepsCount) + { + Report("Start Spray Cleaner",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0); + //IDS_Cleaning_Spray_Cleaning_Solution (int dispenserSpeed,callback_fptr callback); + } + if (InterSegmentStartRocking == InterSegmentStepsCount) + { + Report("Start cleaning rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0); + //IDS_Cleaning_Move_Rockers (int LeftRockerSpeed,int RightRockerSpeed); + } + if (InterSegmentCenterRockers == InterSegmentStepsCount) + { + Report("Stop spray and center rockers",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0); + //IDS_Cleaning_Stop_Cleaning_Solution (callback_fptr callback); + //IDS_Cleaning_Center_And_Stop_Rockers (int timeout,callback_fptr callback); + } + } + if (InterSegmentStartWFCFDispensers == InterSegmentStepsCount) + { + Report("start dispensers at rate * WFCF",__FILE__,__LINE__,InterSegmentStepsCount,RpWarning,(int)lInterSegmentLength,0); + if (FileBrushStop) + { + REPORT_MSG(FileBrushStop->index,"WFCFBrushStopRead Index"); + Dispensers = FileBrushStop->dispensers; + n_dispensers = FileBrushStop->n_dispensers; + if (n_dispensers) + { + for (Dispenser_i = 0; Dispenser_i < n_dispensers; Dispenser_i++) + { + DispenserId = Dispensers[Dispenser_i]->index; + HW_Motor_Id = DispenserIdToMotorId[DispenserId]; + if (MotorsCfg[HW_Motor_Id].hardwaremotortype + != DispenserIdToMotorId[DispenserId]) + continue; + if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER)) + { + continue; + } + //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius) + segmentfirst_speed = Dispensers[Dispenser_i]->nanolitterpersecond + / Dispensers[Dispenser_i]->nanoliterperpulse; + if (Dispensers[Dispenser_i]->dispenserstepdivision + != DISPENSER_STEP_DIVISION__Auto) + { + //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision); + segmentfirst_speed /= + Dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep + IDS_Dispenser_Set_Flow_Params( + DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse, + Dispensers[Dispenser_i]->dispenserstepdivision); + } + else + { + segmentfirst_speed/=8;//MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep + IDS_Dispenser_Set_Flow_Params( + DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse, + MotorsCfg[HW_Motor_Id].microstep); + } + if ((int) segmentfirst_speed > 0) + { + segmentfirst_speed *= (100+WFCF); + segmentfirst_speed /= 100; + DispenserSegmentReady[DispenserId] = false; + //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId, + segmentfirst_speed, + NULL); usnprintf(IdsMessage, 80, + "WFCF Dispenser %d nl/sec %d nl/pulse %d speed %d", + DispenserId, + (int) Dispensers[Dispenser_i]->nanolitterpersecond, + (int) Dispensers[Dispenser_i]->nanoliterperpulse, + (int) segmentfirst_speed); + //REPORT_MSG(segmentfirst_speed,IdsMessage); + Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0); + SendJobProgress(0.0, 0, false, IdsMessage); + } + } + } + } + //startDispensersAtSegmentSpeed*1=WFCFClenerSpray(speed); + } + return OK; + } +uint32_t IDSPreSegmentState(void *SegmentDetails, int SegmentId) { + JobSegment* Segment = SegmentDetails; + JobDispenser **Dispensers; //set the speed only before the first segment, speed is constant accros job - JobTicket* JobTicket = JobDetails; int Dispenser_i,n_dispensers,DispenserId; TimerMotors_t HW_Motor_Id; @@ -294,153 +738,287 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) /* wait for all dispensers to get to the required pressure * move the presegment ready when all dispensers are ready. */ - if (JobTicket->n_segments == 0) - return OK; - if (SegmentId>=JobTicket->n_segments) - { - LOG_ERROR(SegmentId,"Error Segment"); - return ERROR; - } - REPORT_MSG(SegmentId,"IDSPreSegmentState"); - if (JobBrushStopId>=JobTicket->segments[SegmentId]->n_brushstops) + if (JobBrushStopId>=Segment->n_brushstops) { - LOG_ERROR(JobBrushStopId,"Error JobBrushStopId"); + LOG_ERROR(Segment->n_brushstops,"Error JobBrushStopId"); + JobEndReason = JOB_OUT_OF_DYE; + PreSegmentReady(Module_IDS,ModuleFail); return ERROR; } - if (( JobTicket->enableintersegment == true)&&(JobTicket->intersegmentlength>0)) + + + if ((EnableIntersegment == true)&&(IntersegmentLength>0)) { Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste); //if intersegment is defined throw the ink away + if (SegmentId>0) + { + lInterSegmentLength = ((IntersegmentLength*100)*1000/dyeingspeed); + lInterSegmentLength-=(lInterSegmentLength%100); //round to a 100 multiplication + InterSegmentStepsCount = 0; + DispenserPreSegmentControlId = AddControlCallback( IDSPreSegmentStateCallbackRunner, 100,TemplateDataReadCBFunction ,0, 0, 0 ); + if (DispenserPreSegmentControlId == 0xFF) + { + Report("Add control callback failed",__FILE__,__LINE__,(int)100,RpWarning,(int)0,0); + return ERROR; + } + Report("Add control callback ",__FILE__,__LINE__,(int)100,RpWarning,(int)IntersegmentLength,0); + if (EnableCleaning == true) + { + InterSegmentStartSprayCleaner = 500; + InterSegmentStartRocking = 1000; + InterSegmentCenterRockers = 3000; + } + InterSegmentStartWFCFDispensers = lInterSegmentLength-5000; + } } - if (JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->n_dispensers) + if (uploadstrategy == JOB_UPLOAD_STRATEGY__Default) + { + Dispensers = Segment->brushstops[JobBrushStopId]->dispensers; + n_dispensers = Segment->brushstops[JobBrushStopId]->n_dispensers; + } + else { - n_dispensers = JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->n_dispensers; + if (BrushStopControlId != 0xFF) + { + RemoveControlCallback(BrushStopControlId,IDSBrushStopRestartCallback); + BrushStopControlId = 0xFF; + } + FileBrushStop = GetNextBrushStopFromJobFile(); + if (FileBrushStop) + { + REPORT_MSG(FileBrushStop->index,"BrushStopRead Index"); + Dispensers = FileBrushStop->dispensers; + n_dispensers = FileBrushStop->n_dispensers; + } + else + { + LOG_ERROR(FileBrushStop,"BrushStopReadError"); + JobEndReason = JOB_OUT_OF_DYE; + PreSegmentReady(Module_IDS,ModuleFail); + } + } + if (n_dispensers) + { + for (Dispenser_i = 0;Dispenser_i < n_dispensers;Dispenser_i++) + { + DispenserId = Dispensers[Dispenser_i]->index; + DispenserPreSegmentReady[DispenserId] = false; + } for (Dispenser_i = 0;Dispenser_i < n_dispensers;Dispenser_i++) { - DispenserId = JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->index; + DispenserId = Dispensers[Dispenser_i]->index; HW_Motor_Id = DispenserIdToMotorId[DispenserId]; if (MotorsCfg[HW_Motor_Id].hardwaremotortype != DispenserIdToMotorId[DispenserId])//unconfigured dispenser { REPORT_MSG(DispenserId,"Dispenser PreSegment not configured"); + DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped + IDS_Valve_PresegmentReady(DispenserId,0); //27/03/19 to be removed when the presegment handler will be added continue; } - DispenserPreSegmentReady[DispenserId] = false; - REPORT_MSG(DispenserId,"IDS_Valve_Presegment start"); + if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER)) + { + REPORT_MSG(DispenserId,"Dispenser PreSegment cleaner or lubricant"); + DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped + IDS_Valve_PresegmentReady(DispenserId,0); //27/03/19 to be removed when the presegment handler will be added + continue; + } + + //REPORT_MSG(DispenserId,"IDS_Valve_Presegment start"); IDS_Dispenser_Set_Flow_Params(DispenserId,0,0); - if (JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto) + if (Dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto) { - MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision); + MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision); } else { MotorSetMicroStep(HW_Motor_Id, MotorsCfg[HW_Motor_Id].microstep); } + if ((EnableIntersegment == true)&&(IntersegmentLength>0)) + { + MotorStop(HW_Motor_Id,Hard_Hiz); //26/03/19 test without valves + CurrentDispenserSpeed[DispenserId] = 0; + DispenserPreSegmentReady[DispenserId] = true; //27/03/19 check if job should be stopped + REPORT_MSG(DispenserId,"Dispenser stopped pre Segment"); + } + IDS_Valve_PresegmentReady(DispenserId,0); //27/03/19 to be removed when the presegment handler will be added + } + } + //Task_sleep(5); + return OK; +} +//******************************************************************************************************************** + +uint32_t SegmentNumOfBrushStops = 0; +double BrushStopTime = 0; + +void IDS_StartBrushStop(int n_dispensers, JobDispenser** Dispensers) +{ + int Dispenser_i,DispenserId; + TimerMotors_t HW_Motor_Id; + double segmentfirst_speed; + Report("IDS_StartBrushStop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)0,0); + + if (n_dispensers) + { + for (Dispenser_i = 0; Dispenser_i < n_dispensers; Dispenser_i++) + { + DispenserId = Dispensers[Dispenser_i]->index; + HW_Motor_Id = DispenserIdToMotorId[DispenserId]; + if (MotorsCfg[HW_Motor_Id].hardwaremotortype + != DispenserIdToMotorId[DispenserId]) + continue; + if ((DispenserId == CLEANER_DISPENSER)||(DispenserId == LUBRICANT_DISPENSER)) + { + continue; + } + //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius) + segmentfirst_speed = Dispensers[Dispenser_i]->nanolitterpersecond + / Dispensers[Dispenser_i]->nanoliterperpulse; + if (Dispensers[Dispenser_i]->dispenserstepdivision + != DISPENSER_STEP_DIVISION__Auto) + { + //MotorSetMicroStep(HW_Motor_Id, Dispensers[Dispenser_i]->dispenserstepdivision); + segmentfirst_speed /= + Dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep + IDS_Dispenser_Set_Flow_Params( + DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse, + Dispensers[Dispenser_i]->dispenserstepdivision); + } + else + { + segmentfirst_speed/=8;//MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep - if (JobTicket->segments[SegmentId]->brushstops[0]->dispensers[Dispenser_i]->nanolitterpersecond==0) + IDS_Dispenser_Set_Flow_Params( + DispenserId, Dispensers[Dispenser_i]->nanoliterperpulse, + MotorsCfg[HW_Motor_Id].microstep); + } + if ((int) segmentfirst_speed > 0) { - //MotorStop(HW_Motor_Id,Hard_Hiz); - //Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, IDS_Valve_PresegmentValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer - IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,IDS_Valve_PresegmentValveReady); - REPORT_MSG(DispenserId,"Dispenser Not Used Next Segment"); + DispenserSegmentReady[DispenserId] = false; + //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + /*IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId, + segmentfirst_speed, + NULL);*/ + Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer + MotorSetSpeed(HW_Motor_Id, segmentfirst_speed); + CurrentDispenserSpeed[DispenserId] = segmentfirst_speed; + usnprintf(IdsMessage, 80, + "Dispenser %d nl/sec %d nl/pulse %d speed %d", + DispenserId, + (int) Dispensers[Dispenser_i]->nanolitterpersecond, + (int) Dispensers[Dispenser_i]->nanoliterperpulse, + (int) segmentfirst_speed); + //REPORT_MSG(segmentfirst_speed,IdsMessage); + Report(IdsMessage, __FILE__, __LINE__, Dispenser_i, RpWarning, segmentfirst_speed, 0); + SendJobProgress(0.0, 0, false, IdsMessage); } else { - if ((JobTicket->intersegmentlength)&&(SegmentId>0)) //there is an intersegment, stop all the dispensers. otherwise stop only dispensers that are not in use in the next segment. - { - //Control3WayValvesWithCallback ((Valves_t)DispenserId, MidTank_Dispenser, IDS_Valve_PresegmentValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer - IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,IDS_Valve_PresegmentValveReady); - REPORT_MSG(DispenserId,"Dispenser Used Next Segment with intersegment"); - } - else - { - IDS_Valve_PresegmentReady(DispenserId,0); - } - REPORT_MSG(DispenserId,"Dispenser is Used Next Segment"); + DispenserSegmentReady[DispenserId] = true; + //IDS_Dispenser_Close_Valve_And_Stop_Motor(DispenserId,NULL);*/ + MotorStop(HW_Motor_Id, Hard_Hiz); + CurrentDispenserSpeed[DispenserId] = 0; + Report("inActive dispenser stopped", __FILE__, __LINE__, DispenserId, RpWarning, segmentfirst_speed, 0); } } } +} +uint32_t IDSBrushStopRestartCallback(uint32_t IfIndex, uint32_t readValue) +{ + JobDispenser **Dispensers = NULL; + int n_dispensers = 0; + JobSegment* Segment = (void *)IfIndex; + if (uploadstrategy == JOB_UPLOAD_STRATEGY__Default) + { + Dispensers = Segment->brushstops[JobBrushStopId]->dispensers; + n_dispensers = Segment->brushstops[JobBrushStopId]->n_dispensers; + } + else + { + if (FileBrushStop) + FreeBrushStopFileData(FileBrushStop); + FileBrushStop = GetNextBrushStopFromJobFile(); + if (FileBrushStop) + { + REPORT_MSG(FileBrushStop->index,"BrushStopRead Index"); + Dispensers = FileBrushStop->dispensers; + n_dispensers = FileBrushStop->n_dispensers; + } + else + { + LOG_ERROR(FileBrushStop,"BrushStopReadError"); + JobEndReason = JOB_OUT_OF_DYE; + SegmentReady(Module_IDS,ModuleFail); + } + } + if (n_dispensers) + { + IDS_StartBrushStop(n_dispensers, Dispensers); + } + JobBrushStopId++; + Report("brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0); + if (JobBrushStopId >= SegmentNumOfBrushStops) + { + Report("last brushstop",__FILE__,__LINE__,(int)JobBrushStopId,RpWarning,(int)SegmentNumOfBrushStops,0); + SafeRemoveControlCallback(BrushStopControlId,IDSBrushStopRestartCallback); + BrushStopControlId = 0Xff; + } return OK; } //******************************************************************************************************************** +uint32_t IDSSegmentState(void *SegmentDetails, int SegmentId) +{ + JobSegment* Segment = SegmentDetails; + JobDispenser **Dispensers; + int n_dispensers; - uint32_t IDS_Valve_SegmentReady(uint32_t deviceID, uint32_t ReadValue) - { - int i; - DispenserSegmentReady[deviceID] = true; - for (i=0;i<MAX_SYSTEM_DISPENSERS;i++) + Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head); + + SegmentNumOfBrushStops = Segment->n_brushstops; + BrushStopTime = Segment->length/SegmentNumOfBrushStops; //brushstop in meters + BrushStopTime = ((BrushStopTime*100)/dyeingspeed);//brushstop in seconds + BrushStopTime *= 1000; //brushstop in millisecond + Report("IDSSegmentState",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)SegmentNumOfBrushStops,0); + if (uploadstrategy == JOB_UPLOAD_STRATEGY__Default) + { + Dispensers = Segment->brushstops[JobBrushStopId]->dispensers; + n_dispensers = Segment->brushstops[JobBrushStopId]->n_dispensers; + } + else { - if (DispenserSegmentReady[i] == false) + if (FileBrushStop) { - return OK; //not all configured heaters are ready + Dispensers = FileBrushStop->dispensers; + n_dispensers = FileBrushStop->n_dispensers; } - } - SegmentReady(Module_IDS,ModuleDone); - return OK; // all configured heaters are ready - } - - char IdsMessage[100]; -//******************************************************************************************************************** - uint32_t IDSSegmentState(void *JobDetails, int SegmentId) -{ - JobTicket* JobTicket = JobDetails; - int Dispenser_i,n_dispensers,DispenserId; - TimerMotors_t HW_Motor_Id; - double segmentfirst_speed; - int CurrentSegment = SegmentId; - - if (CurrentSegment>=JobTicket->n_segments) + else { - LOG_ERROR(CurrentSegment,"Error Segment"); - return ERROR; + LOG_ERROR(FileBrushStop,"BrushStopReadError"); } - if (JobBrushStopId>=JobTicket->segments[CurrentSegment]->n_brushstops) - { - LOG_ERROR(JobBrushStopId,"Error JobBrushStopId"); - return ERROR; } - Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Head); - if (JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->n_dispensers) - { - n_dispensers = JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->n_dispensers; - for (Dispenser_i = 0;Dispenser_i < n_dispensers;Dispenser_i++) - { - DispenserId = JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->index; - HW_Motor_Id = DispenserIdToMotorId[DispenserId]; - if (MotorsCfg[HW_Motor_Id].hardwaremotortype != DispenserIdToMotorId[DispenserId])//unconfigured dispenser - continue; - //(Speed*uStep*PPR)/((2*PI*Dispenser_Radius) - segmentfirst_speed = JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanolitterpersecond/ - JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse; - if (JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision != DISPENSER_STEP_DIVISION__Auto) - { - //MotorSetMicroStep(HW_Motor_Id, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision); - segmentfirst_speed/=JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision; //the dye supply is calculated based on a 1/8 microstep - IDS_Dispenser_Set_Flow_Params ( DispenserId, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse - , JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->dispenserstepdivision); - } - else - { - //segmentfirst_speed/=MotorsCfg[HW_Motor_Id].microstep; //the dye supply is calculated based on a 1/8 microstep - IDS_Dispenser_Set_Flow_Params ( DispenserId, JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse - ,MotorsCfg[HW_Motor_Id].microstep); - } - if ((int)segmentfirst_speed > 0) - { - DispenserSegmentReady[DispenserId] = false; - //Control3WayValvesWithCallback (DispenserId, Dispenser_Mixer, NULL); //direction: MidTank_Dispenser or Dispenser_Mixer - IDS_Dispenser_Start_Motor_and_Open_Valve(DispenserId,segmentfirst_speed,NULL); - usnprintf(IdsMessage, 80, "Dispenser %d nl/sec %d nl/pulse %d speed %d",Dispenser_i,(int)JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanolitterpersecond, - (int)JobTicket->segments[CurrentSegment]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->nanoliterperpulse,(int)segmentfirst_speed); - //REPORT_MSG(segmentfirst_speed,IdsMessage); - Report(IdsMessage,__FILE__,__LINE__,Dispenser_i,RpWarning,segmentfirst_speed,0); - SendJobProgress(0.0,0,false, IdsMessage); + IDS_StartBrushStop(n_dispensers, Dispensers); + JobBrushStopId++; + if ((BrushStopTime)&&(SegmentNumOfBrushStops > 1)) + { + BrushStopControlId = AddControlCallback( IDSBrushStopRestartCallback, BrushStopTime,TemplateDataReadCBFunction ,SegmentDetails, 0, 0 ); + if (BrushStopControlId == 0xFF) + { + Report("Add control callback failed",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)0,0); + return ERROR; + } + Report("Add control callback ",__FILE__,__LINE__,(int)BrushStopTime,RpWarning,(int)n_dispensers,0); - } - } - } + } + else + { + if (FileBrushStop) + FreeBrushStopFileData(FileBrushStop); + FileBrushStop = NULL; + } return OK; } @@ -466,6 +1044,7 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) return OK; //not all configured heaters are ready } } + REPORT_MSG(deviceID,"IDS_Valve_DistanceToSpoolReady End called"); DistanceToSpoolReady(Module_IDS,ModuleDone); return OK; // all configured heaters are ready } @@ -495,15 +1074,25 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) //TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; //REPORT_MSG(deviceID,"Dispenser End called"); //MotorStop(HW_Motor_Id,Hard_Hiz); + //IDS_HomeDispenser (deviceID, 800 , NULL); + return OK; } //******************************************************************************************************************** - uint32_t IDSEndState(void *JobDetails) + uint32_t IDSEndState(void ) { int Dispenser_i; IDS_Active = false; Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste); REPORT_MSG(0,"Dispenser End Start"); + if (BrushStopControlId != 0xFF) + { + RemoveControlCallback(BrushStopControlId,IDSBrushStopRestartCallback); + BrushStopControlId = 0xFF; + } + if (FileBrushStop) + FreeBrushStopFileData(FileBrushStop); + FileBrushStop = NULL; for ( Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++) { if (DispenserUsedInJob[Dispenser_i] == true) @@ -522,3 +1111,20 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) return OK; } +uint32_t IDS_StartLubrication(void) +{ + IDS_Dispenser_Start_Motor_and_Open_Valve(LUBRICANT_DISPENSER,lubricant_speed,NULL); + REPORT_MSG (lubricant_speed, "IDS_StartLubrication"); + Lubricant_2Way_Valve (START); + return OK; +} +uint32_t IDS_StopLubrication(void) +{ + if(DispenserUsedInJob[LUBRICANT_DISPENSER]) + { + IDS_Dispenser_Close_Valve_And_Stop_Motor(LUBRICANT_DISPENSER,IDS_Valve_EndValveReady); + REPORT_MSG (lubricant_speed, "IDS_StopLubrication"); + Lubricant_2Way_Valve (STOP); + } + return OK; +} diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c index 919e84582..34cb61e27 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c @@ -7,6 +7,10 @@ #include "driverlib/gpio.h" #include "Drivers/USB_Communication/USBCDCD.h" +#include "StateMachines/Initialization/PowerOffSequence.h" + +#include "drivers/Flash_Memory/FATFS/ff.h" +#include "drivers/Flash_Memory/FATFS/Control_File_System.h" //#include "graphics_adapter.h" @@ -19,27 +23,42 @@ void Stub_ProgressRequest(MessageContainer* requestContainer) //writeLine("Progress Request..."); ProgressResponse response = PROGRESS_RESPONSE__INIT; - response.has_progress = true; - int i = 0; - for (i = 0; i < request->amount; i++) + if((request->amount == 0xCF) && (request->delay == 0xCF)) //Create File System on the Drive { - response.progress = i; - responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size); - uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); - size_t container_size = message_container__pack(&responseContainer, container_buffer); - free(responseContainer.data.data); - SendChars((char*)container_buffer, container_size); - //free(container_buffer); - - - int co = 0; - for (co = 0; co < request->delay; co++) + FRESULT iFResult = Init_Flash_File_System(true); + if(iFResult != FR_OK) { - __delay_cycles(1000000); + LOG_ERROR (iFResult, "Error during init Flash File System"); + assert(iFResult); } } + else if((request->amount == 0xDF) && (request->delay == 0xDF)) //Power off + { + PowerOffInit(); + } + else + { + response.has_progress = true; + int i = 0; + for (i = 0; i < request->amount; i++) + { + response.progress = i; + responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, false, &response, &progress_response__pack, &progress_response__get_packed_size); + uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); + size_t container_size = message_container__pack(&responseContainer, container_buffer); + free(responseContainer.data.data); + SendChars((char*)container_buffer, container_size); + //free(container_buffer); + + int co = 0; + for (co = 0; co < request->delay; co++) + { + __delay_cycles(1000000); + } + } + } responseContainer = createContainer(MESSAGE_TYPE__ProgressResponse, requestContainer->token, true, &response, &progress_response__pack, &progress_response__get_packed_size); uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer)); size_t container_size = message_container__pack(&responseContainer, container_buffer); diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c index 61c7afe74..6bfb3f322 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dancer.c @@ -8,6 +8,7 @@ #include <Container.h> #include <DataDef.h> +#include <Drivers/FPGA/Motors_Driver/L6470.h> #include <stdbool.h> #include <stdlib.h> #include <stdio.h> @@ -30,8 +31,6 @@ #include "drivers/FPGA/FPGA.h" #include "drivers/SPI/SPI_Comm.h" -#include "drivers/FPGA/Moters_Driver/L6470.h" - #include "driverlib/ssi.h" #include "drivers/SPI/SPI_Comm.h" #include "drivers/FPGA/FPGA_SSI_Comm.h" diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.c index 7c0a4c980..f3efa3b67 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Dispenser.c @@ -11,18 +11,18 @@ #include "drivers/adc_sampling/adc.h" #include "modules/ids/ids_ex.h" - +#include <Drivers/I2C_Communication/Dispenser_Card/IO_Ports/Dispenser_IO.h> #include "Stub_Status.h" #include <math.h> void Stub_DispenserRequest(MessageContainer* requestContainer) { - uint32_t status = NOT_SUPPORTED; + uint32_t status = PASSED; MessageContainer responseContainer; StubDispenserRequest* request = stub_dispenser_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); - +/* ADCAcquireInit(); SysCtlDelay(10000); ADCAcquireStart(0,1); @@ -32,8 +32,48 @@ void Stub_DispenserRequest(MessageContainer* requestContainer) ADC0SS0Handler(); SysCtlDelay(100000); +*/ + + TCA9534Regs Regs; + + //static bool first_time = true; + + //if(first_time == true) + //if ((Regs.Config[request->dispenserid].bit.DISP_DOWN != TCA9534_INPUT) || (Regs.Config[request->dispenserid].bit.DISP_UP!= TCA9534_INPUT)) + //{ + status |= TCA9534Init(request->dispenserid, &Regs); + //first_time = false; + //} + + if(request->setdirection == true) + { + TCA9534TestRelay(request->dispenserid, &Regs,ENABLE); + } + else + TCA9534TestRelay(request->dispenserid, &Regs,DISABLE); + + delayms(5); + if(request->start == true) + { + TCA9534ByPass(request->dispenserid, &Regs, ENABLE); + + } + else + TCA9534ByPass(request->dispenserid, &Regs, DISABLE); + + delayms(5); + + + /* + if(request->setmicrostepdivision == 1) + TCA9534TestByPassTestRelay(request->dispenserid, &Regs); + delayms(5); + if(request->setspeed == 1) + test_IO(); + delayms(5); + */ //request->dispenserid //request->start @@ -44,17 +84,21 @@ void Stub_DispenserRequest(MessageContainer* requestContainer) StubDispenserResponse response = STUB_DISPENSER_RESPONSE__INIT; - response.dispenserid = (uint32_t)((round)(CalculateDispenserPressure(0x00000004)));//CHAN_DISPENSE_PRESSURE_6); + //response.dispenserid = (uint32_t)((round)(CalculateDispenserPressure(0x00000004)));//CHAN_DISPENSE_PRESSURE_6); + + + status |= TCA9534SetReadInputReg(request->dispenserid); + status |= TCA9534ReadInputReg(request->dispenserid, &Regs); - //response.dispenserid = request->dispenserid; + response.dispenserid = request->dispenserid; response.has_dispenserid = true; - //response.dispenserposition - response.has_dispenserposition = false; + response.dispenserposition = (Read_Notification_Disp_UP(request->dispenserid, &Regs) << 8) | (Read_Notification_Disp_Down(request->dispenserid, &Regs)); + response.has_dispenserposition = true; - //response.inkworninglevel - response.has_inkworninglevel = false; + response.inkworninglevel = (Read_Notification_Realy_On(request->dispenserid, &Regs) << 8) | (Read_Notification_Over_Press(request->dispenserid, &Regs)); + response.has_inkworninglevel = true; status_response(status,&response.status, &response.statusword ,&response.has_statusword); diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c index e2f2013c9..4867587d9 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_HW_Version.c @@ -22,41 +22,7 @@ #include "driverlib/rom.h" -char Read_HW_Version(unsigned char *Brd_ID, unsigned char *Assy_ID) -{ - //TODO Move in GPIO Initialisation - - // ----------- Set HW Version GPIO as Input ----------- - //MAP_GPIOPinTypeGPIOInput(GPIO_PORTS_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1); - //MAP_GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_7); - //MAP_GPIOPinTypeGPIOInput(GPIO_PORTP_BASE, GPIO_PIN_3 | GPIO_PIN_5); - - //Set HW Version GPIO to Pull down - GPIOPadConfigSet(GPIO_PORTS_BASE, GPIO_PIN_3 | GPIO_PIN_2 | GPIO_PIN_1, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD ); - GPIOPadConfigSet(GPIO_PORTJ_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_7, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD ); - GPIOPadConfigSet(GPIO_PORTP_BASE, GPIO_PIN_3 | GPIO_PIN_5, GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD ); - // ------------------------------------------------------ - if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_3) == GPIO_PIN_3) - *Brd_ID |= 0x08; - if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_2) == GPIO_PIN_2) - *Brd_ID |= 0x04; - if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_5) == GPIO_PIN_5) - *Brd_ID |= 0x02; - if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_4) == GPIO_PIN_4) - *Brd_ID |= 0x01; - - if (ROM_GPIOPinRead(GPIO_PORTP_BASE, GPIO_PIN_3) == GPIO_PIN_3) - *Assy_ID |= 0x08; - if (ROM_GPIOPinRead(GPIO_PORTP_BASE, GPIO_PIN_5) == GPIO_PIN_5) - *Assy_ID |= 0x04; - if (ROM_GPIOPinRead(GPIO_PORTS_BASE, GPIO_PIN_1) == GPIO_PIN_1) - *Assy_ID |= 0x02; - if (ROM_GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_7) == GPIO_PIN_7) - *Assy_ID |= 0x01; - - return PASSED; -} void Stub_HWVersionRequest(MessageContainer* requestContainer) { diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.c index 47e1bda34..6848dd1cf 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Heater.c @@ -22,10 +22,11 @@ #include "Drivers/Heater/Heater.h" #include "../control/control.h" #include "Drivers/Heater/TemperatureSensor.h" +#include "Modules/heaters/heaters_ex.h" void Stub_HeaterRequest(MessageContainer* requestContainer) { - uint32_t status = NOT_SUPPORTED; + uint32_t status = PASSED; MessageContainer responseContainer; StubHeaterRequest* request = stub_heater_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); @@ -35,6 +36,11 @@ void Stub_HeaterRequest(MessageContainer* requestContainer) request->heatergroupon */ + if((request->heatergroupid == 0xff) && (request->heatergroupon == false) && (request->heatertemperaturereq == 0)) + { + HeatersEnd(); + } + else if (request->heatergroupon ) status = ActivateHeater(request->heatergroupid); else diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_IntADC.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_IntADC.c index d9d35f363..f7e3b21f6 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_IntADC.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_IntADC.c @@ -47,7 +47,7 @@ void Stub_IntADCReadRequest(MessageContainer* requestContainer) SysCtlDelay(100000); - data = ADC_GetReading(request->adc_device); + data = ADC_GetReading((ADC_TYPE)request->adc_device); status = PASSED; StubIntADCReadResponse response = STUB_INT_ADCREAD_RESPONSE__INIT; diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c index 658205327..7995b1a42 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.c @@ -1,6 +1,7 @@ #include <Container.h> #include <DataDef.h> +#include <Drivers/FPGA/Motors_Driver/L6470.h> #include <PMR/Stubs/StubL6470DriverResponse.pb-c.h> #include <PMR/Stubs/StubL6470DriverRequest.pb-c.h> #include <stdbool.h> @@ -19,10 +20,8 @@ //#include "drivers/FPGA/FPGA.h" #include "drivers/SPI/SPI_Comm.h" -#include "drivers/FPGA/Moters_Driver/L6470.h" - #include "driverlib/ssi.h" - +/* unsigned long Run_Value = 136902 ; unsigned long Pos_Value; unsigned long Mov_Value ; @@ -44,6 +43,28 @@ unsigned long TestUint32_4; unsigned long TestUint32_5; unsigned long TestUint32_6; + */ + extern unsigned long Run_Value ; + extern unsigned long Mov_Value ; + extern unsigned long Pos_Value; + extern bool Direction ; + extern unsigned long Time_2_Change_Direction ; + extern bool Display_Tx_ON_LCD; + extern bool Display_Rx_on_LCD; + extern unsigned long Init_MicroStep ; + extern unsigned long Init_Acc; + extern unsigned long Init_Dec; + extern bool TestBool_1; + extern bool TestBool_2; + extern bool TestBool_3; + extern bool TestBool_4; + extern bool TestBool_5; + extern unsigned long TestUint32_1; + extern unsigned long TestUint32_2; + extern unsigned long TestUint32_3; + extern unsigned long TestUint32_4; + extern unsigned long TestUint32_5; + extern unsigned long TestUint32_6; void Stub_L6470DriverRequest(MessageContainer* requestContainer) { diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.h b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.h deleted file mode 100644 index 0b4702861..000000000 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_L6470.h +++ /dev/null @@ -1,3 +0,0 @@ -void Stub_L6470DriverRequest(MessageContainer* requestContainer); - -void temp_init_spi2(); diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c index 65ede8fac..0854aba40 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Motor.c @@ -1,6 +1,7 @@ #include <Container.h> #include <DataDef.h> +#include <Drivers/FPGA/Motors_Driver/L6470.h> #include <PMR/Stubs/StubMotorInitRequest.pb-c.h> #include <PMR/Stubs/StubMotorInitResponse.pb-c.h> #include <PMR/Stubs/StubMotorRunRequest.pb-c.h> @@ -37,8 +38,6 @@ #include "drivers/FPGA/FPGA.h" #include "drivers/SPI/SPI_Comm.h" -#include "drivers/FPGA/Moters_Driver/L6470.h" - #include "driverlib/ssi.h" #include "drivers/SPI/SPI_Comm.h" #include "Modules/Thread/Thread_ex.h" diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_SpeedSensor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_SpeedSensor.c index eea594817..4e6c4cf84 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_SpeedSensor.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_SpeedSensor.c @@ -9,6 +9,7 @@ #include <Container.h> #include <DataDef.h> +#include <Drivers/FPGA/Motors_Driver/L6470.h> #include <stdbool.h> #include <stdlib.h> #include <stdio.h> @@ -28,8 +29,6 @@ #include "drivers/FPGA/FPGA.h" #include "drivers/SPI/SPI_Comm.h" -#include "drivers/FPGA/Moters_Driver/L6470.h" - #include "driverlib/ssi.h" #include "drivers/SPI/SPI_Comm.h" #include "drivers/FPGA/FPGA_SSI_Comm.h" diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c index f25a79b15..c320cca80 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_TempSensor.c @@ -7,6 +7,7 @@ #include <Container.h> #include <DataDef.h> +#include <Drivers/FPGA/Motors_Driver/L6470.h> #include <stdbool.h> #include <stdlib.h> #include <stdio.h> @@ -29,8 +30,6 @@ #include "drivers/FPGA/FPGA.h" #include "drivers/SPI/SPI_Comm.h" -#include "drivers/FPGA/Moters_Driver/L6470.h" - #include "driverlib/ssi.h" #include "drivers/SPI/SPI_Comm.h" #include "drivers/FPGA/FPGA_SSI_Comm.h" diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.c index 1b6ed8989..c6ea742a7 100644 --- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.c +++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Stub_Valve.c @@ -32,8 +32,15 @@ void Stub_ValveRequest(MessageContainer* requestContainer) request->inkflow request->valveon */ - //Control3WayValvesWithCallback (request->valveid, request->valveon, NULL); - //Valve_Set(request->valveid, request->valveon); + + if(request->inkflow == 3) + { + Control3WayValvesWithCallback (request->valveid, request->valveon, NULL); + } + else + { + Valve_Set(request->valveid, request->valveon); + } StubValveResponse response = STUB_VALVE_RESPONSE__INIT; diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h index 638611c8b..3e2a6aa40 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread.h @@ -64,6 +64,8 @@ extern int MotorSamplePointer[MAX_THREAD_MOTORS_NUM]; extern double NormalizedErrorCoEfficient[MAX_THREAD_MOTORS_NUM]; extern int DancerStopActivityLimit[MAX_THREAD_MOTORS_NUM]; extern MotorControlConfig_t MotorControlConfig[MAX_THREAD_MOTORS_NUM]; +extern int32_t MotorSpeedSamples[MAX_THREAD_MOTORS_NUM][MAX_CONTROL_SAMPLES]; +extern int MotorSpeedSamplePointer[MAX_THREAD_MOTORS_NUM]; uint32_t InternalWinderConfigMessage(HardwareWinder* request); diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c index a82fe37e6..ab5075ab9 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/ThreadLoad.c @@ -38,21 +38,21 @@ /* typedef enum { 0 THREAD_LOAD_INIT, - 1 THREAD_LOAD_REDUCE_HEAT, //HEATERS OFF, DRYER BLOWER OFF, BLOWER LOW, - 2 THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION,//USE NOTATION HOW MANY ROTATIONS IN THE DRYER, OR CHECK AGAINST STOPPER. MOVE SLOWLY - 3 THREAD_LOAD_CENTER_HEAD_ROCKERS, //puthead cleaning rockers to middle position - 4 THREAD_LOAD_OPEN_COVERS, //OPEN DYEING HEAD COVER AND DRYER LID + 1 THREAD_LOAD_REDUCE_HEAT, //HEATERS OFF, DRYER BLOWER OFF, BLOWER LOW, + 2 THREAD_LOAD_SET_LOAD_ARM_TO_START_POSITION, //USE NOTATION HOW MANY ROTATIONS IN THE DRYER, OR CHECK AGAINST STOPPER. MOVE SLOWLY + 3 THREAD_LOAD_CENTER_HEAD_ROCKERS, //puthead cleaning rockers to middle position + 4 THREAD_LOAD_OPEN_COVERS, //OPEN DYEING HEAD COVER AND DRYER LID 5 THREAD_LOAD_LIFT_DANCERS, - 6 THREAD_LOAD_LIFT_ROCKERS, //MACHINE IS READY. SEND MESSAGE, START TIMER TO CLOSE LIDS, WAIT FOR OPERATOR RESPONSE - 7 THREAD_LOAD_INITIAL_TENSION,//CHECK SPOOL PRESENCERUN WINDER UNTIL BREAK SENSOR IS IDENTIFIEING MOVEMENT FOR A SECOND + 6 THREAD_LOAD_LIFT_ROCKERS, //MACHINE IS READY. SEND MESSAGE, START TIMER TO CLOSE LIDS, WAIT FOR OPERATOR RESPONSE + 7 THREAD_LOAD_INITIAL_TENSION, //CHECK SPOOL PRESENCERUN WINDER UNTIL BREAK SENSOR IS IDENTIFIEING MOVEMENT FOR A SECOND 8 THREAD_LOAD_CLOSE_ROCKERS, - 9 THREAD_LOAD_CLOSE_DANCERS, //SEND DANCER MOTORS TO PRESET LOCATION, CHECK THAT THE DANCERS ARE ON THE THREAD + 9 THREAD_LOAD_CLOSE_DANCERS, //SEND DANCER MOTORS TO PRESET LOCATION, CHECK THAT THE DANCERS ARE ON THE THREAD 10 THREAD_LOAD_CLOSE_LIDS, 11 THREAD_LOAD_RESUME_HEATING, - 12 THREAD_LOAD_JOG_FEEDER_TO_MIDDLE_POINT,//JOG THE FEEDER MOTOR UNTIL THE FEEDER DANCER IS AT MIDDLE POSITION - 13 THREAD_LOAD_DRYER_LOADING, //START FEEDER PID, ROTATE LOADING ARM COUNTER THREAD DIRECTION X CIRCLES ACCORDING TO RML. FEEDER SPEED IS 40 - //KEEP NOTATION HOW MANY ROTATIONS IN THE DRYER - 14 THREAD_LOAD_JOG_THREAD, //JOG THREAD SHORTLY TO MAKE SURE SPOOL IS RUNNING. REPORT END OF LOADING + 12 THREAD_LOAD_JOG_FEEDER_TO_MIDDLE_POINT, //JOG THE FEEDER MOTOR UNTIL THE FEEDER DANCER IS AT MIDDLE POSITION + 13 THREAD_LOAD_DRYER_LOADING, //START FEEDER PID, ROTATE LOADING ARM COUNTER THREAD DIRECTION X CIRCLES ACCORDING TO RML. FEEDER SPEED IS 40 + //KEEP NOTATION HOW MANY ROTATIONS IN THE DRYER + 14 THREAD_LOAD_JOG_THREAD, //JOG THREAD SHORTLY TO MAKE SURE SPOOL IS RUNNING. REPORT END OF LOADING 15 THREAD_LOAD_END }THREAD_LOAD_STAGES_ENUM;*/ THREAD_LOAD_STAGES_ENUM LoadStages = THREAD_LOAD_INIT; @@ -78,6 +78,13 @@ //RUN MOTOR A FULL CYCLE //RUN A MOTOR NUMBER OF STEPS //RUN CONTROL FOR A SINGLE DANCER + bool ThreadLoadingActive(void) + { + if ((LoadStages > THREAD_LOAD_INIT)&&(LoadStages < THREAD_LOAD_END)) + return true; + else + return false; + } uint32_t Thread_Load_Init(void) { void* buffer = NULL; @@ -200,6 +207,7 @@ } uint8_t CallbackCounter = 0; uint8_t TimeoutsCounter = 0; + uint32_t Thread_Load_HomingCallback(uint32_t MotorId, uint32_t ReadValue) { Report("Thread Load State Machine Callback.",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0); @@ -222,9 +230,16 @@ else { LoadStages++; - if (LoadStages != THREAD_LOAD_INITIAL_TENSION) //on this satge we should wait for user call + if (LoadStages == THREAD_LOAD_LIFT_ROCKERS) { - ThreadLoadStateMachine(LoadStages); + MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep); + MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].microstep); + MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].microstep); + MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].microstep); + } + if (LoadStages != THREAD_LOAD_INITIAL_TENSION) //on this stage we should wait for user call + { + //ThreadLoadStateMachine(LoadStages); } } } @@ -237,9 +252,9 @@ { REPORT_MSG(LoadStages, "Thread Load State Machine step"); CallbackCounter++; - MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD].directionthreadwize, 200, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD], Thread_Load_HomingCallback,10000); + MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD].directionthreadwize, 80, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANHEAD], Thread_Load_HomingCallback,10000); CallbackCounter++; - MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH].directionthreadwize, 200, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH], Thread_Load_HomingCallback,10000); + MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH].directionthreadwize, 80, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_DH_CLEANMECH], Thread_Load_HomingCallback,10000); return OK; } uint32_t Thread_Load_Open_Covers(void) @@ -270,10 +285,15 @@ //Machine Is Ready. Send Message, Start Timer To Close Lids, Wait For Operator Response { REPORT_MSG(LoadStages, "Thread Load State Machine step"); + MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 1); + MotorSetMicroStep(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 1); + MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 35); + MotorSetKvalRun(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 35); + Task_sleep(10); CallbackCounter++; - MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 300, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,12000); + MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize, 50, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_RLOADING], Thread_Load_HomingCallback,25000); CallbackCounter++; - MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LLOADING,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize, 300, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LLOADING], Thread_Load_HomingCallback,12000); + MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_LLOADING,1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize, 50, Motor_Id_to_LS_IdUp[HARDWARE_MOTOR_TYPE__MOTO_LLOADING], Thread_Load_HomingCallback,25000); return OK; } @@ -340,7 +360,7 @@ { Control_Dryer_Fan(START,75);//use START or STOP, 0 - 100% LoadStages++; - ThreadLoadStateMachine(LoadStages); + //ThreadLoadStateMachine(LoadStages); } return OK; } @@ -357,6 +377,7 @@ { Report("Thread Load State Machine Callback.",__FILE__,__LINE__,LoadStages,RpMessage,NumberOfDrierLoaderCycles,0); REPORT_MSG(MotorId, "Thread_Load_Dryer_Loading_Callback Motor Id"); + MotorMovetoEncoderPosition(HARDWARE_MOTOR_TYPE__MOTO_DRYER_LOADARM,0,0); if(ControlId != 0xFF) { MotorStop(ThreadMotorIdToMotorId[FEEDER_MOTOR],Hard_Hiz); @@ -371,7 +392,7 @@ LoadStages++; if (LoadStages != THREAD_LOAD_INITIAL_TENSION) //on this satge we should wait for user call { - ThreadLoadStateMachine(LoadStages); + //ThreadLoadStateMachine(LoadStages); } } } @@ -417,7 +438,7 @@ //Keep Notation How Many Rotations In The Dryer //LoadArmInfo.LoadArmBackLash = 0; - //LoadArmInfo.LoadArmRounds = 0xFF; + LoadArmInfo.LoadArmRounds = 0xFF; FileWrite(&LoadArmInfo, sizeof(LoadArmInfo),LoadArmPath); return OK; } @@ -428,7 +449,7 @@ ControlId = 0xFF; ThreadAbortJoggingFunc(); LoadStages++; - ThreadLoadStateMachine(LoadStages); + //ThreadLoadStateMachine(LoadStages); return OK; } uint32_t Thread_Load_Jog_Thread(void) diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c index 18aceb767..70f32ce6d 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c @@ -40,6 +40,8 @@ void ScrewsStartControlTimer (void); bool Winder_ScrewHoming = false; bool ScrewCurrentDirection = false; //holds current screw direction uint32_t ScrewDirectionChangeCounter = 1; //holds the current number of runs of the screw - will be used to build the cone +//uint32_t ScrewChangeCounter = 0; +//uint32_t ScrewChangeLimit = 0; uint32_t CalculationDirectionChangeCounter = 1; //holds the current number of runs of the screw - will be used to build the cone uint16_t WinderMotorSpeed[MAX_WINDER_SPEED_CALCULATION]; uint16_t WinderMotorSpeedCounter = 0; @@ -75,7 +77,7 @@ uint32_t InternalWindingConfigMessage(JobSpool* request) InternalWinderCfg.spoolbackingrate = request->backingrate; InternalWinderCfg.startoffsetpulses = request->startoffsetpulses; InternalWinderCfg.SpoolBottomBackingRate = request->bottombackingrate; - InternalWinderCfg.NumberOfRotationPerPassage = request->rotationsperpassage; + InternalWinderCfg.NumberOfRotationPerPassage = 3.1415926*2;//request->rotationsperpassage; InternalWinderCfg.diameter = request->diameter; return status; @@ -135,8 +137,16 @@ 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(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,1000); + if (ReadValue != LIMIT) + { + LOG_ERROR(ReadValue,"Screw failed to reach the limit switch!!"); + //returned with a timeout + Winder_ScrewAtOffsetCallback(0,0); + } + else + { + status |= MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_SCREW, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize),numOfSteps, Winder_ScrewAtOffsetCallback,1000); + } //set motor location 0 here return status; @@ -188,6 +198,8 @@ char ScrewStr[100]; //char TempScrewStr[100]; double WinderReferenceSpeed=0; int32_t TotalWinderSpeed=0; +bool Add100 = false; +double Rotations = 6.0; uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) { //uint32_t Steps; @@ -196,13 +208,21 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) double RotationsPerSecond; int32_t Averagewinderspeed = 0; - TotalWinderSpeed-=WinderMotorSpeed[WinderMotorSpeedCounter]; - WinderMotorSpeed[WinderMotorSpeedCounter] = CurrentControlledSpeed[WINDER_MOTOR]; - TotalWinderSpeed+=WinderMotorSpeed[WinderMotorSpeedCounter]; - if (WinderMotorSpeedCounter++>=MAX_WINDER_SPEED_CALCULATION) + //ScrewChangeCounter++; + //if ((ScrewChangeCounter>3)&&(ScrewChangeCounter<(ScrewChangeLimit-2))) //do not take the winder speed near the limits { - WinderMotorSpeedCounter=0; - WinderMotorSpeedRollOver=true; + TotalWinderSpeed-=WinderMotorSpeed[WinderMotorSpeedCounter]; + WinderMotorSpeed[WinderMotorSpeedCounter] = CurrentControlledSpeed[WINDER_MOTOR]; + TotalWinderSpeed+=WinderMotorSpeed[WinderMotorSpeedCounter]; + if (WinderMotorSpeedCounter++>=MAX_WINDER_SPEED_CALCULATION) + { + if (WinderMotorSpeedRollOver == false) + { + Add100 = true; + } + WinderMotorSpeedCounter=0; + WinderMotorSpeedRollOver=true; + } } if (ScrewDirectionChangeCounter == CalculationDirectionChangeCounter) @@ -213,6 +233,12 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) if (ScrewCurrentDirection == 1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize) //next time going out { + if (Add100 == true) //once per job + { + ScrewNumberOfSteps += 100; + Add100 = false; + } + if ((CalculationDirectionChangeCounter/2)%InternalWinderCfg.spoolbackingrate == 0) { ScrewNumberOfSteps--; @@ -240,7 +266,9 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) WinderReferenceSpeed = Averagewinderspeed; } - screw_horizontal_speed = ScrewNumberOfSteps / InternalWinderCfg.NumberOfRotationPerPassage; + screw_horizontal_speed = ScrewNumberOfSteps / Rotations;//InternalWinderCfg.NumberOfRotationPerPassage; + if (Rotations > 7.0) + Rotations = 6.0; RotationsPerSecond = WinderReferenceSpeed / (double)MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround; tempScrewSpeed = screw_horizontal_speed*RotationsPerSecond; //ROM_IntMasterDisable(); @@ -260,7 +288,7 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) //Report(TempScrewStr,__FILE__,__LINE__,0,RpWarning,0, 0); //Report(ScrewStr,__FILE__,__LINE__,ScrewCurrentDirection,RpWarning,CalculationDirectionChangeCounter, 0); //REPORT_MSG(temp , "new winder speed"); - //Report("new winder speed",__FILE__,__LINE__,temp,RpWarning,ScrewSpeed,0); +// Report("new winder speed",__FILE__,ScrewNumberOfSteps,temp,RpWarning,ScrewSpeed,0); } /********************************************************************************/ @@ -274,7 +302,7 @@ uint32_t WinderPresegmentReady(uint32_t deviceID, uint32_t ReadValue) return PreSegmentReady(Module_Winder,ModuleDone); } -uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId) +uint32_t Winder_Presegment(void *SegmentDetails, uint32_t SegmentId) { //JobTicket* JobTicket = JobDetails; double screw_horizontal_speed = 0; @@ -294,7 +322,9 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId) // * calculate // * 1. calculate speed according to JobTicket->processparameters->dyeingspeed // * calculation input: traverse length in milimeters/pulses, number of rotations per traverse ==> length of traverse per rotation. - screw_horizontal_speed = InternalWinderCfg.segmentoffsetpulses / InternalWinderCfg.NumberOfRotationPerPassage; + ScrewNumberOfSteps = InternalWinderCfg.segmentoffsetpulses;//*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep; + ScrewNumberOfSteps -= 100; + screw_horizontal_speed = ScrewNumberOfSteps / InternalWinderCfg.NumberOfRotationPerPassage; // calculation input#2: number of rotations per second - (basically: speed/winder perimeter. later - according to winder actual speed - calculate according to winder position accumulation in the last second. //RotationsPerSecond = dyeingspeed / (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulleyradius * PI); RotationsPerSecond = OriginalMotorSpd_2PPS[WINDER_MOTOR] / MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround; @@ -315,9 +345,8 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId) // * 3. calculate cart travel length from winding parameters // * 4. start move of travel length // * 5. register motor nBusy callback. this callback will flip between move(traverse length, hardstop) and goto(0), with handline og the coneshape and adjusting maxspeed - ScrewNumberOfSteps = InternalWinderCfg.segmentoffsetpulses;//*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep; temp = SYS_CLK_FREQ; - temp *= InternalWinderCfg.segmentoffsetpulses; + temp *= ScrewNumberOfSteps; temp /= ScrewSpeed; ScrewRunningTime = temp;//(SYS_CLK_FREQ*InternalWinderCfg.segmentoffsetpulses)/ScrewSpeed; REPORT_MSG(ScrewNumberOfSteps,"Winder pre segment - ScrewNumberOfSteps"); @@ -335,6 +364,7 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId) WinderMotorSpeedCounter=0; TotalWinderSpeed = 0; WinderMotorSpeedRollOver=false; + Add100 = false; } PreSegmentReady(Module_Winder,ModuleDone); @@ -352,8 +382,8 @@ uint32_t Winder_End(void) CurrentControlledSpeed[SCREW_MOTOR] = 0; ScrewsStopControlTimer(); //move the cart to the edge so the spool can be easily replaced - MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, 1000, GPI_LS_SCREW_RIGHT, NULL,0); - + //MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_SCREW,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize, 1000, GPI_LS_SCREW_RIGHT, NULL,0); + MotorStop(HARDWARE_MOTOR_TYPE__MOTO_SCREW,Hard_Hiz); return OK; } void Winder_ScrewHomeLimitSwitchInterrupt(void) @@ -397,12 +427,14 @@ void ScrewsStartControlTimer (void) //ROM_TimerConfigure(Screw_timerBase, TIMER_CFG_PERIODIC); // 32 bits Timer TimerEnable(Screw_timerBase, TIMER_A); ROM_IntEnable(INT_TIMER3A); + //IntPrioritySet(Screw_timerBase, 0x40); ROM_TimerIntEnable(Screw_timerBase, TIMER_TIMA_TIMEOUT); ROM_TimerLoadSet(Screw_timerBase, TIMER_A,(int)1200000/*10 millisec*/ ); Report("ScrewsStartControlTimer direction,speed ", __FILE__,__LINE__,ScrewCurrentDirection, RpMessage, ScrewSpeed, 0); return; } +int random = 0; void ScrewTimerInterrupt(int ARG0) { ROM_TimerIntClear(Screw_timerBase, TIMER_TIMA_TIMEOUT); // Clear the timer interrupt @@ -410,9 +442,11 @@ void ScrewTimerInterrupt(int ARG0) if (SCREW_TimerActivated == true) { - MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection); - MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed); ROM_TimerLoadSet(Screw_timerBase, TIMER_A,(int)ScrewRunningTime); + MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection); + MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed+random); + // ScrewChangeCounter = 0; + // ScrewChangeLimit = ScrewRunningTime/12000000; ScrewDirectionChangeCounter++; } else @@ -420,6 +454,10 @@ void ScrewTimerInterrupt(int ARG0) TimerDisable(Screw_timerBase, TIMER_A); } ROM_IntMasterEnable(); + Rotations+=0.03; + /*random++; + if (random >= 2) + random = -1;*/ //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 cd71c73b1..d7ce917c0 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h @@ -31,10 +31,10 @@ 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 SegmentId); -uint32_t ThreadSegmentState(void *JobDetails, int SegmentId); +uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId); +uint32_t ThreadSegmentState(void *SegmentDetails, int SegmentId); uint32_t ThreadDistanceToSpoolState(void); -uint32_t ThreadEndState(void *JobDetails); +uint32_t ThreadEndState(); uint32_t ThreadInitialTestStub(); uint32_t StoreDancerConfigMessage(void); @@ -67,9 +67,11 @@ typedef enum THREAD_LOAD_END }THREAD_LOAD_STAGES_ENUM; uint32_t ThreadLoadStateMachine( THREAD_LOAD_STAGES_ENUM ReadValue); +bool ThreadLoadingActive(void); void ThreadLoadPollRequest(MessageContainer* requestContainer); void ThreadLoadRequest(MessageContainer* requestContainer); + #endif diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c index 435d7aef3..4454565c1 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c @@ -2,6 +2,7 @@ **************************************************************************************************************************/ #include <DataDef.h> +#include <Drivers/FPGA/Motors_Driver/PowerSTEP01.h> #include "include.h" #include "PMR/Hardware/UploadHardWareConfigurationRequest.pb-c.h" @@ -21,6 +22,9 @@ MotorDriverConfigStruc MotorsCfg[NUM_OF_MOTORS]={0}; HardwarePidControl MotorsControl[MAX_THREAD_MOTORS_NUM] = {0}; +int32_t MotorSpeedSamples[MAX_THREAD_MOTORS_NUM][MAX_CONTROL_SAMPLES] = {0}; +int MotorSpeedSamplePointer[MAX_THREAD_MOTORS_NUM] = {0}; + int32_t MotorSamples[MAX_THREAD_MOTORS_NUM][MAX_CONTROL_SAMPLES] = {0}; int MotorSamplePointer[MAX_THREAD_MOTORS_NUM] = {0}; double NormalizedErrorCoEfficient[MAX_THREAD_MOTORS_NUM] = {0}; @@ -52,6 +56,14 @@ uint32_t MotorsConfigMessage(HardwareMotor * request) MotorsCfg[Motor_i].pulseperround = request->pulseperround; MotorsCfg[Motor_i].pulleyradius = request->pulleyradius; MotorsCfg[Motor_i].configword = request->configword; + if(MotorDriverResponse[Motor_i].DriverType == VoltageCombinedMotDriver) + { + MotorsCfg[Motor_i].directionthreadwize = !(request->directionthreadwize);//PowerSTEP01 + } + else + { + MotorsCfg[Motor_i].directionthreadwize = request->directionthreadwize;//L6470 + L6472 + } MotorsCfg[Motor_i].directionthreadwize = request->directionthreadwize; MotorsCfg[Motor_i].kvalhold = request->kvalhold; MotorsCfg[Motor_i].kvalrun = request->kvalrun; @@ -95,7 +107,10 @@ uint32_t MotorPidRequestMessage(HardwarePidControl* request) MotorsControl[Motor_i].pvinputfilterfactormode = 10; //test longer control #endif for (i = 0;i < MotorsControl[Motor_i].pvinputfilterfactormode; i++) + { MotorSamples[Motor_i][i] = 0; //reset the samples value for control beginning + MotorSpeedSamples[Motor_i][i] = 0; + } NormalizedErrorCoEfficient[Motor_i] = (2*PI*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].armlength); temp = 1<<(DancersCfg[ThreadMotorIdToDancerId[Motor_i]].resolutionbits); temp=(10*(temp-1)*DancersCfg[ThreadMotorIdToDancerId[Motor_i]].maximalmovementmm); diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c index 394e2ae13..a4208ad25 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c @@ -30,6 +30,7 @@ #include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h" #include "modules/heaters/heaters.h" #include "modules/General/process.h" +#include "modules/ids/ids_ex.h" #include "Modules/AlarmHandling/AlarmHandling.h" #include "Control/MillisecTask.h" @@ -67,6 +68,12 @@ double TempPoolerTotalProcessedLength = 0.0; double TempTotalProcessedLength = 0.0; bool PrepareState = false; +// job parameters +bool EnableLubrication = false; +bool EnableIntersegment = false; +double IntersegmentLength = 0; + + int CurrentSegmentId = 0; typedef void (* ProcessedLengthFunc)(void); ProcessedLengthFunc ProcessedLengthFuncPtr = NULL; @@ -76,6 +83,11 @@ void ThreadInterSegmentEnded(void); void ThreadDistanceToSpoolEnded(void); uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue); +bool SegmentState = false; +bool PreSegmentState = false; +bool DTSState = false; +void SendSegmentFail(void); + double KeepNormalizedError = 0; bool ThreadControlActive = false; ////////////////////////Slow Motor State//////////////////////////////////// @@ -121,6 +133,7 @@ uint32_t Poolerinitialpos = 0xFFFF; void ThreadUpdateProcessLength (double length, void *Funcptr) { + REPORT_MSG(length,"ThreadUpdateProcessLength"); CurrentRequestedLength = length*100;//Centimetres CurrentProcessedLength = 0; ProcessedLengthFuncPtr = (ProcessedLengthFunc)Funcptr; @@ -353,7 +366,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) //read value is the dancer angle int i,index=MAX_THREAD_MOTORS_NUM; int DancerId; - int32_t TranslatedReadValue, avreageSampleValue = 0; + int32_t TranslatedReadValue, avreageSampleValue = 0,avreageMotorSampleValue = 0; //double tempcalcspeed = 0; uint32_t calculated_speed; double NormalizedError; @@ -372,6 +385,8 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) if(MotorControlConfig[index].m_isEnabled ) { + //if (MotorDriverResponse[ThreadMotorIdToMotorId[index]].Busy == true) + // return OK; DancerId = ThreadMotorIdToDancerId[index]; if (ReadValue < 10) { @@ -427,9 +442,9 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) JobEndReason = JOB_THREAD_BREAK; ThreadControlActive = false; SendJobProgress(0.0,0,false, TMessage); - //SegmentReady(Module_Thread,ModuleFail); - AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true); - EndState(CurrentJob,"ReadBreakSensor Error" ); + SendSegmentFail(); + //AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_BREAK,true); + //EndState(CurrentJob,"ReadBreakSensor Error" ); LOG_ERROR(index, "ReadBreakSensor Error"); return OK; } //passed limit @@ -457,8 +472,8 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) JobEndReason = JOB_WINDER_DANCER_FAIL+DancerId; SendJobProgress(0.0,0,false, TMessage); //EndState(CurrentJob,TMessage ); - SegmentReady(Module_Thread,ModuleFail); - switch (index) + SendSegmentFail(); + /*switch (index) { case POOLER_MOTOR: AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_PULLER_DANCER,true); @@ -469,7 +484,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) case WINDER_MOTOR: AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,true); break; - } + }*/ LOG_ERROR (DancerId, "Dancer Failure"); return OK; } @@ -486,7 +501,23 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) { //KeepNormalizedError = NormalizedError; } + if ((JobCounter % 1000) == 0) + { + if (JobCounter >= 20000) + { + MotorSpeedSamples[index][MotorSpeedSamplePointer[index]] = CurrentControlledSpeed[index];//(-1 * TranslatedReadValue); + MotorSpeedSamplePointer[index]++; + if (MotorSpeedSamplePointer[index] >= MAX_CONTROL_SAMPLES) + MotorSpeedSamplePointer[index] = 0; + for (i=0;i<MAX_CONTROL_SAMPLES;i++) + avreageMotorSampleValue += MotorSpeedSamples[index][i]; + avreageMotorSampleValue = avreageMotorSampleValue / MAX_CONTROL_SAMPLES; + //Report("MotorSpeedUpdated",__FILE__,index,OriginalMotorSpd_2PPS[index],RpWarning,avreageMotorSampleValue,0); + OriginalMotorSpd_2PPS[index] = avreageMotorSampleValue; + } + } calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*OriginalMotorSpd_2PPS[index]; + //calculated_speed = (1-MotorControlConfig[index].m_calculatedError)*CurrentControlledSpeed[index]; if (abs(calculated_speed-CurrentControlledSpeed[index])> MotorControlConfig[index].m_ingnoreValue) { /*if (keepdata == true) @@ -551,6 +582,7 @@ bool InitialProcess = false; uint32_t ThreadPrepareState(void *JobDetails) { int Motor_i, HW_Motor_Id, Pid_Id; + JobTicket* JobTicket = JobDetails; CurrentSegmentId = 0; JobCounter = 0; @@ -563,6 +595,11 @@ bool InitialProcess = false; AlarmHandlingSetAlarm(EVENT_TYPE__THREAD_TENSION_CONTROL_FAILURE_WINDER_DANCER,false); AlarmHandlingSetAlarm(EVENT_TYPE__WINDER_CONE_DOES_NOT_EXIST,false); + EnableLubrication = JobTicket->enablelubrication; + EnableIntersegment = JobTicket->enableintersegment; + IntersegmentLength = JobTicket->intersegmentlength; + + //start thread control for all motors for (Motor_i = 0;Motor_i < MAX_THREAD_MOTORS_NUM;Motor_i++) { @@ -659,7 +696,7 @@ bool InitialProcess = false; void SetOriginMotorSpeed(float process_speed) { - int Motor_i, HW_Motor_Id; + int i,Motor_i, HW_Motor_Id; for (Motor_i = 0; Motor_i <= WINDER_MOTOR; Motor_i++) { HW_Motor_Id = ThreadMotorIdToMotorId[Motor_i]; @@ -671,14 +708,16 @@ void SetOriginMotorSpeed(float process_speed) //MotorControlConfig[Motor_i].m_SetParam = motor_speed; OriginalMotorSpd_2PPS[Motor_i] = (int) motor_speed; CurrentControlledSpeed[Motor_i] = (int) motor_speed; + for (i = 0; i <= MAX_CONTROL_SAMPLES; i++) + MotorSpeedSamples[Motor_i][i] = motor_speed; } } //******************************************************************************************************************** -uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId) +uint32_t ThreadPreSegmentState(void *SegmentDetails, uint32_t SegmentId) { //set the speed only before the first segment, speed is constant across all job segments and intersegments - JobTicket* JobTicket = JobDetails; + //JobSegment* Segment = SegmentDetails; float process_speed = dyeingspeed; if (dyeingspeed == 0) @@ -708,14 +747,22 @@ uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId) MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize); MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 1); } + if (EnableLubrication == true) + { + IDS_StartLubrication(); + } } // 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) //call the job state machine when the thread system is ready - if ((InitialProcess==false) && JobTicket->enableintersegment == true) - { - ThreadUpdateProcessLength (JobTicket->intersegmentlength,(void *)ThreadInterSegmentEnded); + if ((InitialProcess==false) && (EnableIntersegment == true)) //&& (IntersegmentLength >= 1.0)) //fix - avoid intersegment length 0 + {//add initial presegment and cleaning before first segment + ThreadUpdateProcessLength (IntersegmentLength,(void *)ThreadInterSegmentEnded); + REPORT_MSG (IntersegmentLength," ThreadPreSegmentState IntersegmentLength"); + SegmentState = false; + PreSegmentState = true; + DTSState = false; } else { @@ -728,14 +775,26 @@ uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId) return OK; } int REPSegmentId = 0; +void SendSegmentFail(void) +{ + if (SegmentState == true) + SegmentReady(Module_Thread,ModuleFail); + else if (PreSegmentState == true) + PreSegmentReady(Module_Thread,ModuleFail); + else if (DTSState == true) + DistanceToSpoolReady(Module_Thread,ModuleFail); + +} + void ThreadInterSegmentEnded(void) { REPORT_MSG (REPSegmentId,"ThreadInterSegmentEnded"); + //ThreadUpdateProcessLength (0,(void *)NULL); PreSegmentReady(Module_Thread,ModuleDone); } void ThreadSegmentEnded(void) { - REPORT_MSG (REPSegmentId," ThreadSegmentState"); + REPORT_MSG (REPSegmentId," ThreadSegmentEnded"); SegmentReady(Module_Thread,ModuleDone); } void ThreadDistanceToSpoolEnded(void) @@ -745,14 +804,17 @@ void ThreadDistanceToSpoolEnded(void) } double seglength = 0.0; //******************************************************************************************************************** -uint32_t ThreadSegmentState(void *JobDetails, int SegmentId) +uint32_t ThreadSegmentState(void *SegmentDetails, int SegmentId) { - JobTicket* JobTicket = JobDetails; + JobSegment* Segment = SegmentDetails; REPSegmentId = SegmentId; - seglength = JobTicket->segments[SegmentId]->length; + seglength = Segment->length; CurrentSegmentId = SegmentId; REPORT_MSG (seglength," ThreadSegmentState"); ThreadUpdateProcessLength (seglength,(void *)ThreadSegmentEnded); + SegmentState = true; + PreSegmentState = false; + DTSState = false; return OK; } @@ -762,12 +824,15 @@ uint32_t ThreadDistanceToSpoolState(void ) seglength = dryerbufferlength; REPORT_MSG (seglength,"ThreadDistanceToSpoolState"); ThreadUpdateProcessLength (seglength,(void *)ThreadDistanceToSpoolEnded); + SegmentState = false; + PreSegmentState = false; + DTSState = true; return OK; } char Endstr[150]; //******************************************************************************************************************** - uint32_t ThreadEndState(void *JobDetails) + uint32_t ThreadEndState(void ) { int Motor_i; ThreadControlActive = false; @@ -777,6 +842,7 @@ char Endstr[150]; Report(Endstr,__FILE__,__LINE__,(int)TotalProcessedLength,RpWarning,(int)PoolerTotalProcessedLength,0); ThreadUpdateProcessLength (0.0,(void *)NULL); + TotalProcessedLength = 0.0; SetOriginMotorSpeed(0); #ifdef HUNDRED_MICROSECONDS_DANCER_READ MillisecLogClose(); @@ -807,7 +873,7 @@ char Endstr[150]; } MotorStop(HARDWARE_MOTOR_TYPE__MOTO_RLOADING,Hard_Hiz); MotorStop(HARDWARE_MOTOR_TYPE__MOTO_LLOADING,Hard_Hiz); - + IDS_StopLubrication(); return OK; } diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h index e69de29bb..74f7b40ef 100644 --- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h +++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste.h @@ -0,0 +1,113 @@ +#ifndef WASTE_H +#define WASTE_H + + +#define temp_funcion 0 +#define notOK 1 + + +/* +#define SENSORFULL 1 +#define SENSOROVERFLOW 1 +#define SENSOREMPTY 0 + + +#define SENSORnotFULL 0 +#define SENSORnotOVERFLOW 0 +#define SENSORnotEMPTY 1 +*/ +#define PUMPON 1 +#define PUMPOFF 0 + +#define PRECENSE 1 +#define NOTPRECENSE 0 + +typedef unsigned char U8; + +typedef enum +{ + WHS_CarteidgeNotPrecense = 0, + WHS_CarteidgePrecense +} WHS_CarteidgPrecenseSensorStatus; + +typedef enum +{ + WHS_CartridgeCoverCLOSE = 0, + WHS_CartridgeCoverOPEN +} WHS_CarteidgeCoverSensorStatus; + +typedef enum +{ + SENSORFULL = 0, + SENSORnotFULL +} WHS_FullSensorStatus; + +typedef enum +{ + SENSORnotEMPTY = 0, + SENSOREMPTY +} WHS_EmptySensorStatus; + +typedef enum +{ + WHS_empty = 0, + WHS_filling, + WHS_emptying, + WHS_full, + WHS_overflow, + WHS_sttError +} WHS_sttMachin; + +typedef enum +{ + WHS_no_event = 0, + WHS_overflow_sensor, + WHS_full_sensor, + WHS_empty_sensor, + WHS_waste1_presence_sensor, + WHS_waste2_presence_sensor, + WHS_filter_sensor, + WHS_cartridge_cover_sensor, + WHS_Timeout +} WHS_sensor; + +typedef enum +{ + WasteEmpty = 0, + WasteFilling, + WasteFail, + WasteFull +} cartridge_status; + +typedef enum +{ + led_on = 0, + led_off, + led_blink, + led_panic +} led_status; + +typedef enum +{ + waste_cartridge1 = 0, + waste_cartridge2, + no_waste_cartridge +} cartridge_name; + + +U8 WHS_init(void); +U8 WHS_HW_test(void); +bool WHS_IsEmptying(); + +bool WHS_IsContainerFull(); +bool WHS_IsContainerOverflow(); +bool WHS_WasteCartridgeLowerPresent(); +bool WHS_WasteCartridgeMiddlePresent(); +bool WHS_IsPumpActive(); +bool WHS_IsValveOpen(); + +bool SetWastePump( bool power); + + +#endif + diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h index e69de29bb..8b1378917 100644 --- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_ex.h @@ -0,0 +1 @@ + diff --git a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c index e69de29bb..8aa358e32 100644 --- a/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c +++ b/Software/Embedded_SW/Embedded/Modules/Waste/Waste_init.c @@ -0,0 +1,1411 @@ +/* ---- WHS */ +#include <Container.h> +#include <DataDef.h> +#include "include.h" +#include "Modules/Control/control.h" // use for FPGA IO +#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"//#include "FPGA_GPIO.h" // use for FPGA IO +#include "drivers/Valves/Valve.h" +#include "Common/report/report.h" +#include "Modules/Waste/Waste.h" + +#include <PMR/Diagnostics/EventType.pb-c.h> +#include "Modules/AlarmHandling/AlarmHandling.h" + + +#define WasteTankCallBackTime eOneSecond +#define CartridgeCoverCallBackTime eOneSecond +#define CartridgeCoverCallBackFastTime eTenMillisecond +#define CartridgeWaste1CallBackTime eOneSecond +#define CartridgeWaste2CallBackTime eOneSecond +#define STARTCOUNT 1 +#define STOPCOUNT 0 +#define PumpTimeout 1200 // seconds; 20 minutes, per Moty, 15/4/19 + + +/*------------Waste Tank function-----------------------*/ +bool initWHS_WasteTank(); +bool InitWasteCartStatus(); + +bool CartridgeCoverCBFunction(); +U8 CartridgeCoverCallBackFunction(); +WHS_sensor CartridgeWaste1CallBackFunction(); +WHS_sensor CartridgeWaste2CallBackFunction(); +WHS_sensor WasteTankCallBackFunction(); +U8 CartridgeWasteFilling(bool status); +bool WasteTankCBFunction(); + +U8 CartridgePrecenceCBFunction(); +U8 SetCartridgeLED(cartridge_name name,led_status led); + +bool SetWastePump( bool power); +bool SetValveDirection(); +bool RdCartridgeCoverSensor(); +bool RdWasteCartridge1Sensor(); +bool RdWasteCartridge2Sensor(); +bool RdWasteTankFilterSensor(); +bool RdWasteTankOverFlowSensor(); +bool RdWasteTankFullSensor(); +bool RdWasteTankEmptySensor(); +bool RdWasteCartridgeParam(cartridge_name cart_name); +bool CartridgeAuthentication(cartridge_name cart_name); +bool SetActiveWastCartridge(); + + + + +struct waste_cartridge_params +{ + uint32_t serial_number; + cartridge_status status; /*WasteEmpty, WasteFilling, WasteFail, WasteFull*/ + bool autheticate; +}; + +struct pump_params +{ + bool status; + uint32_t time; +}; + + +struct WHS_sensors_status +{ + WHS_CarteidgeCoverSensorStatus cartridge_cover; /*open(1) ,close(0) */ + WHS_CarteidgPrecenseSensorStatus waste_cartridge1_precense_sensor; /*presence(1) ,not_precense(0) */ + bool waste_cartridge1_precense_sensor_flag; /* 1=event 0=no enent */ + WHS_CarteidgPrecenseSensorStatus waste_cartridge2_precense_sensor; /*presence(1) ,not_precense(0) */ + bool waste_cartridge2_precense_sensor_flag; /* 1=event 0=no enent */ + bool waste_tank_filter_sensor; /*presence(1) ,not_precense(0) */ + WHS_EmptySensorStatus waste_tank_empty_sensor; /*enpty(1) ,not_empty(0) */ + WHS_FullSensorStatus waste_tank_full_sensor; /*full(1) ,not_full(0) */ + bool waste_tank_over_flow_sensor; /*over_flow(1) ,not_over_flow(0) */ +}; + + + +struct WHS_information +{ + WHS_sttMachin sttMachine; + struct waste_cartridge_params cartridge_1, cartridge_2; + struct WHS_sensors_status WHS_sensors; + struct pump_params WHS_pump; + bool WHS_valve; + WHS_sensor event; + cartridge_name active_cartridge; + uint32_t Cartridge_Waste1_device_Id; + uint32_t Cartridge_Waste2_device_Id; + uint32_t Cartridge_Cover_device_Id; +}; + +struct WHS_information WHS_info; + +bool WHS_IsContainerFull(){return WHS_info.WHS_sensors.waste_tank_full_sensor;} +bool WHS_IsContainerOverflow(){return WHS_info.WHS_sensors.waste_tank_over_flow_sensor;} +bool WHS_WasteCartridgeLowerPresent(){return WHS_info.WHS_sensors.waste_cartridge1_precense_sensor;} +bool WHS_WasteCartridgeMiddlePresent(){return WHS_info.WHS_sensors.waste_cartridge2_precense_sensor;} +bool WHS_IsPumpActive(){return WHS_info.WHS_pump.status;} +bool WHS_IsValveOpen(){return WHS_info.WHS_valve;} + + + +bool WHS_IsEmptying() +{ + bool ret = false; + if ( WHS_info.sttMachine == WHS_emptying ) + { + ret = true; + } + return ret; +} + +/* -------- cartridge function ----*/ + + +bool RdWasteCartridgeParam(cartridge_name cart_name) +{ + /* + read all parameters from RFid cartridge: + serial number, cartridge_status... + waste_cartridge 1 or 1 + update waste_cartridge struct + */ + if (cart_name == waste_cartridge1) + { + WHS_info.cartridge_1.serial_number = temp_funcion; //to do + WHS_info.cartridge_1.status = temp_funcion; // to do + } + else + { + WHS_info.cartridge_2.serial_number = temp_funcion; + WHS_info.cartridge_2.status = temp_funcion; + } + return OK; +} + +bool CartridgeAuthentication(cartridge_name cart_name) +{ + bool ret = notOK; + // TBD; + switch (cart_name) + { + case waste_cartridge1: + WHS_info.cartridge_1.autheticate = PASSED; + //Pannel_Leds(CART_2, MODE_ON); + break; + case waste_cartridge2: + WHS_info.cartridge_2.autheticate = PASSED; + //Pannel_Leds(CART_3, MODE_ON); + break; + default: + WHS_info.cartridge_1.autheticate = FAILED; + WHS_info.cartridge_2.autheticate = FAILED; + //Pannel_Leds(CART_2, MODE_OFF); + //Pannel_Leds(CART_3, MODE_OFF); + break; + } + ret = OK; + return ret; +} + +/* +bool check_RFID_authentication() +{ + bool ret = notOK; + // rd_waste_cartridge_param(); + if ( 1 ) + ret = OK; + return ret; +} + + +U8 Wr_cartridge_RFid(cartridge_name cartridge, cartridge_status status) +{ + bool ret = notOK; + // TBD; + ret = OK; + return ret; +} + +U8 set_cartridge_2(U8 cartridge_status) +{ + bool ret = notOK; + WHS_info.cartridge_2.status = temp_funcion; + return ret; +} +*/ + +/* ------------------------------*/ + + +bool SetWastePump( bool power) +{ + /* + set the waste pump on/off + off - : + 1. when waste tank is empty + 2. when empting is time out + 3. cartrigde cover is open + 4. when waste1 is not precense AND valve3way==1 + 5. when waste2 is not precense AND valve3way==2 + 6. when autentication with waste cartige is disable + on : + 1. when waste_tank_full + + void Pumps_Control(PUMPS_ENUM Pump_Id, bool Direction) //1 - OPEN, 0 - CLOSE ?? WHS_WTANKPUMP2 or WASTECH_PUMP2 + */ + bool ret = notOK; + if ( power == OPEN ) + { + Pumps_Control(WHS_WTANKPUMP2, OPEN); //waste_pump_power_on(); + REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP ----------------- "); + WHS_info.WHS_pump.status = OPEN; + WHS_info.WHS_pump.time = STARTCOUNT; + ret = OPEN; + } + else + { + Pumps_Control(WHS_WTANKPUMP2, CLOSE); //waste_pump_power_off(); + REPORT_MSG(WHS_empty," ------------ WHS WHS_empty stop PUMP ----------------- "); + WHS_info.WHS_pump.status = CLOSE; + WHS_info.WHS_pump.time = STOPCOUNT; + ret = CLOSE; + } + return ret; +} + + + + +bool SetValveDirection() +{ + /* + * waste_cartridge = 1- OPEN, 0 - CLOSE + * VALVE_WASTE_TANK + * + * */ + bool ret = notOK; + //if (WHS_info.WHS_valve != no_waste_cartridge) + if (WHS_info.active_cartridge == waste_cartridge1) WHS_info.WHS_valve = 1; + else WHS_info.WHS_valve = 2; + { + Valve_Set(VALVE_WASTE_TANK, WHS_info.WHS_valve); + ret = OK; + } + return ret; +} + + +/*-------------------------- function for WHS ------------------------------- */ + +U8 CartridgeWasteFilling(bool status) +{ + bool ret = notOK; + + if ((status == ON) && (WHS_info.active_cartridge != no_waste_cartridge)) + { + + //if (WHS_info.active_cartridge != no_waste_cartridge) // + { + Valve_Set(VALVE_WASTE_TANK, WHS_info.active_cartridge); //set the valve direction + //Pannel_Leds(PANEL_BUTTON_OR_CRAT_ID Pannel_Led_Id, OPERATION_MODE LED_Mode); //set cartridge led color slow blink + //write RFID status + } + SetWastePump(OPEN); + //WHS_info.WHS_pump.time = 0; + REPORT_MSG(WHS_empty," ------------ WHS WHS_empty start PUMP ----------------- "); + ret=OK; + } + else // stop Waste cartridge filling + { + SetWastePump(CLOSE); + Valve_Set(VALVE_WASTE_TANK, waste_cartridge2); //set the valve direction set to low POWER !!! + Pannel_Leds( CART_2, MODE_OFF); //set led color + Pannel_Leds( CART_3, MODE_OFF); //set led color + + //write RFID status + } + return ret; +} + +/* ------read waste tank sensors ----------- */ +bool RdWasteTankEmptySensor() +{ + bool ret = notOK; + WHS_Read_GPI_Registers(); + //WHS_info.WHS_sensors.waste_tank_empty_sensor = WHS_GPI_WCONTAINER_WARN(); + //ret = WHS_info.WHS_sensors.waste_tank_empty_sensor; + ret = WHS_GPI_WCONTAINER_WARN(); + return ret; +} + +bool RdWasteTankFullSensor() +{ + bool ret = notOK; + WHS_Read_GPI_Registers(); + //WHS_info.WHS_sensors.waste_tank_full_sensor = WHS_GPI_WCONTAINER_FULL(); + //ret = WHS_info.WHS_sensors.waste_tank_full_sensor; + ret = WHS_GPI_WCONTAINER_FULL(); + return ret; +} + +bool RdWasteTankOverFlowSensor() +{ + bool ret = notOK; + WHS_Read_GPI_Registers(); + //WHS_info.WHS_sensors.waste_tank_over_flow_sensor = WHS_GPI_WASTE_OVERFULL(); + //ret = WHS_info.WHS_sensors.waste_tank_over_flow_sensor; + ret = WHS_GPI_WASTE_OVERFULL(); + return ret; +} + +/*-------------*/ + + +WHS_sttMachin UpdateStateMachine() +{ + //WHS_sttMachin ret = WHS_sttError ; + + if ( WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORnotFULL) + { + WHS_info.sttMachine = WHS_empty ; + REPORT_MSG(WHS_empty," ------------ WHS WHS_empty ----------------- "); + } + else if ((WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL) && + (WHS_info.WHS_sensors.waste_tank_empty_sensor == SENSORnotEMPTY)) + { + WHS_info.sttMachine = WHS_full ; + REPORT_MSG(WHS_full," ------------ WHS WHS_full ----------------- "); + } + else + { + WHS_info.sttMachine = WHS_sttError ; + REPORT_MSG(WHS_sttError," ------------ WHS sensor Error ----------------- "); + } + +/* if (//(WHS_info.WHS_sensors.waste_tank_over_flow_sensor == SENSORnotOVERFLOW) && + ( WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORnotFULL) && + ((WHS_info.WHS_sensors.waste_tank_empty_sensor == SENSORnotEMPTY) || + (WHS_info.WHS_sensors.waste_tank_empty_sensor == SENSOREMPTY))) + WHS_info.sttMachine = WHS_empty ; + else if (//(WHS_info.WHS_sensors.waste_tank_over_flow_sensor == SENSORnotOVERFLOW) && + (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL) && + (WHS_info.WHS_sensors.waste_tank_empty_sensor == SENSORnotEMPTY)) + WHS_info.sttMachine = WHS_full ; + else if (//(WHS_info.WHS_sensors.waste_tank_over_flow_sensor == SENSOROVERFLOW) && + (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL) && + (WHS_info.WHS_sensors.waste_tank_empty_sensor == SENSORnotEMPTY)) + WHS_info.sttMachine = WHS_overflow ; + else + { + WHS_info.sttMachine = WHS_sttError ; + REPORT_MSG(WHS_sttError," ------------ WHS sensor Error ----------------- "); + } +*/ + return OK; +} + + +bool initWHS_WasteTank() +{ + WHS_info.WHS_sensors.waste_tank_empty_sensor = RdWasteTankEmptySensor(); + WHS_info.WHS_sensors.waste_tank_full_sensor = SENSORnotFULL;//;RdWasteTankFullSensor() + UpdateStateMachine(); + AddControlCallback(WasteTankCBFunction, WasteTankCallBackTime , WasteTankCallBackFunction, 0,0,0);//eOneMinute + return OK; +} + + +/* +WHS_sensor OverflowSensorEvent() +{ + WHS_sensor ret = WHS_no_event; + if (RdWasteTankOverFlowSensor() != WHS_info.WHS_sensors.waste_tank_over_flow_sensor) + { + WHS_info.event = WHS_overflow_sensor; + ret = WHS_overflow_sensor; + WHS_info.WHS_sensors.waste_tank_over_flow_sensor = !(WHS_info.WHS_sensors.waste_tank_over_flow_sensor); + } + return ret; +} +*/ + +WHS_sensor EmptySensorEvent() +{ + WHS_sensor ret = WHS_no_event; + if (RdWasteTankEmptySensor() != WHS_info.WHS_sensors.waste_tank_empty_sensor) + { + WHS_info.event = WHS_empty_sensor; + ret = WHS_empty_sensor; + WHS_info.WHS_sensors.waste_tank_empty_sensor = !WHS_info.WHS_sensors.waste_tank_empty_sensor; + } + return ret; +} + +WHS_sensor FullSensorEvent() +{ + WHS_sensor ret = WHS_no_event; + if ( RdWasteTankFullSensor() != WHS_info.WHS_sensors.waste_tank_full_sensor ) + { + WHS_info.event = WHS_full_sensor; + ret = WHS_full_sensor; + WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor; + } + return ret; +} + +WHS_sensor WasteTankCallBackFunction() +{ + /* detect waste tank sensor event */ + WHS_sensor ret = WHS_no_event; +/* if ( OverflowSensorEvent()) + { + return WHS_info.event; + } + else */ + if (WHS_info.WHS_pump.time) WHS_info.WHS_pump.time += 1; + if (WHS_info.WHS_pump.time == PumpTimeout) + { + WHS_info.WHS_pump.time = 0; + AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT, false); + return WHS_info.event = WHS_Timeout; + } + if ( FullSensorEvent()) + { + return WHS_info.event; + } + else if ( EmptySensorEvent()) + { + return WHS_info.event; + } + + return ret; +} + +/* +bool start_WHS_machin() +{ + AddControlCallback( WasteTankCBFunction, eTenMillisecond, WasteTankCallBackFunction, 0,0,0 );// eOneMinute + return OK; +} + */ + +bool WasteTankCBFunction() +{ + bool ret = notOK; + static bool pump_on_flag = CLOSE; + //uint32_t Cartridge_Cover_device_Id = 0; + + + switch (WHS_info.event) + { + case WHS_empty_sensor: + if (WHS_info.WHS_sensors.waste_tank_empty_sensor == SENSORnotEMPTY) + { + if (WHS_info.sttMachine == WHS_empty) + { + WHS_info.sttMachine = WHS_filling; + REPORT_MSG(WHS_filling," ------------ WHS_filling ----------------- "); + } + else + { + REPORT_MSG(WHS_filling," ------------ WHS EMPTY sensor failed !!!!!!! ----------------- "); + } + } + else //SENSOREMPTY + { + if (WHS_info.sttMachine == WHS_emptying) + { + WHS_info.sttMachine = WHS_empty; + REPORT_MSG(WHS_filling," ------------ WHS_empty ----------------- "); + ret = CartridgeWasteFilling(OFF); + WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction ); + WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackTime, CartridgeCoverCallBackFunction, 0,0,0 );//eOneSecond + //SafeRemoveControlCallback(Cartridge_Cover_device_Id, CartridgeCoverCBFunction ); + } + else + { + REPORT_MSG(WHS_emptying," ------------ WHS EMPTY sensor failed !!!!!!! ----------------- "); + } + } + break; + case WHS_full_sensor: + if (WHS_info.WHS_sensors.waste_tank_full_sensor == SENSORFULL) + { + WHS_info.sttMachine = WHS_full; + REPORT_MSG(WHS_emptying," ------------ WHS_full ----------------- "); + WHS_info.Cartridge_Cover_device_Id = RemoveControlCallback(WHS_info.Cartridge_Cover_device_Id, WasteTankCBFunction ); + WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeCoverCallBackFastTime , CartridgeCoverCallBackFunction, 0,0,0 );//eTenMillisecond + ret = CartridgeWasteFilling(ON); + if (ret != OK) + { + //recreate the full event until cartridge is inserted + WHS_info.WHS_sensors.waste_tank_full_sensor = 1-WHS_info.WHS_sensors.waste_tank_full_sensor; + } + + // cant start a new Job + } + else + { + if (WHS_info.sttMachine == WHS_full) + { + WHS_info.sttMachine = WHS_emptying; + REPORT_MSG(WHS_emptying," ------------ WHS_emptying ----------------- "); + // can start a new JOB + } + else + { + REPORT_MSG(WHS_full," ------------ WHS FULL sensor failed !!!!!!! ----------------- "); + } + } + break; + +/* case WHS_overflow_sensor: + if (WHS_info.WHS_sensors.waste_tank_empty_sensor) + { + + // 1.StopMacine + WHS_info.sttMachine = WHS_overflow; + } + else + { + WHS_info.sttMachine = WHS_full; + } + break; +*/ + case WHS_cartridge_cover_sensor: + if ( WHS_info.WHS_sensors.cartridge_cover == OPEN ) + { + if ( WHS_info.WHS_pump.status == OPEN) + { + CartridgeWasteFilling(CLOSE); + pump_on_flag = OPEN; + } + WHS_info.Cartridge_Waste1_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeWaste1CallBackTime, CartridgeWaste1CallBackFunction, 0,0,0 ); //eOneSecond + WHS_info.Cartridge_Waste2_device_Id = AddControlCallback( WasteTankCBFunction, CartridgeWaste2CallBackTime, CartridgeWaste2CallBackFunction, 0,0,0 ); //eOneSecond + + + + //if (WHS_info.WHS_pump == ON) + //{ + // SetWastePump(OFF); //pump OFF + //} + // prevent NEW Job + // Display "Close cartridge cover" + // pop up message in GUI + } + else // CLOSE + { + //if (WHS_info.sttMachine == WHS_full) CartridgeWasteFilling(OPEN); + SetActiveWastCartridge(); + if (pump_on_flag == OPEN ) + { + CartridgeWasteFilling(OPEN); + pump_on_flag = CLOSE; + } + WHS_info.Cartridge_Waste1_device_Id = RemoveControlCallback(WHS_info.Cartridge_Waste1_device_Id, WasteTankCBFunction ); + WHS_info.Cartridge_Waste2_device_Id = RemoveControlCallback(WHS_info.Cartridge_Waste2_device_Id, WasteTankCBFunction ); + } + break; + case WHS_waste1_presence_sensor : + if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == WHS_CarteidgePrecense ) // waste cartridge 1 is inserted . + { + //SetCartridgeLED(waste_cartridge1, led_on); + Pannel_Leds(CART_2, MODE_ON); + RdWasteCartridgeParam(waste_cartridge1); + SetActiveWastCartridge(); + SetValveDirection(); + if ( CartridgeAuthentication(waste_cartridge1)) // to define authentication + { + //WHS_info.cartridge_1.autheticate = PASSED; //='0' + //???WHS_info.WHS_valve = waste_cartridge1; // or we should do it only before pumping???? + } + else + { + //WHS_info.cartridge_1.autheticate = FAILED; //='1' + SetCartridgeLED(waste_cartridge1, led_off); + } + } + else // waste cartridge 1 take out + { + Pannel_Leds(CART_2, MODE_OFF); + WHS_info.cartridge_1.autheticate = FAILED; + //???if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping???? + //???{ + //???WHS_info.WHS_valve = waste_cartridge; + //???SetValveDirection(); + //???} + //???else + //???{ + //??? + //???} + //??? RdWasteCartridgeParam(waste_cartridge2); + //???WHS_info.WHS_valve = waste_cartridge1; + } + //SetActiveWastCartridge(); + break; + case WHS_waste2_presence_sensor : + if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == WHS_CarteidgePrecense ) // waste cartridge is inserted . + { + Pannel_Leds(CART_3, MODE_ON);//SetCartridgeLED(waste_cartridge2, led_on); + RdWasteCartridgeParam(waste_cartridge2); + if ( CartridgeAuthentication(waste_cartridge2)) // to define authentication + { + //WHS_info.cartridge_2.autheticate = PASSED; //='0' + //???WHS_info.WHS_valve = waste_cartridge2; // or we should do it only before pumping???? + //???SetValveDirection(); // or we should do it only before pumping???? + } + else + { + //WHS_info.cartridge_2.autheticate = FAILED; //='1' + SetCartridgeLED(waste_cartridge2, led_off); + } + } + else // waste cartridge 2 take out + { + Pannel_Leds(CART_3, MODE_OFF); + WHS_info.cartridge_2.autheticate = FAILED; + /* + if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping???? + { + WHS_info.WHS_valve = waste_cartridge; + SetValveDirection(); + } + else + { + + } + RdWasteCartridgeParam(waste_cartridge2); + WHS_info.WHS_valve = waste_cartridge1; + */ + } + //SetActiveWastCartridge(); + break; + case WHS_Timeout: + REPORT_MSG(WHS_emptying," ------------ WHS_Timeout ----------------- "); + AlarmHandlingSetAlarm( EVENT_TYPE__WASTE_CONTAINER_EMPTYING_TIMEOUT, true); + CartridgeWasteFilling(OFF); + break; + case WHS_no_event: + break; + default: //error state + break; + } + WHS_info.event = WHS_no_event; + return ret; +} + + +/*------------------------------- Cartridge Cover -----------------------------------------*/ + +bool RdCartridgeCoverSensor() +{ + uint32_t parameter = 6 ; + + //REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor ----------------- "); + bool ret = notOK; + WHS_Read_GPI_Registers(); + // WHS_info.WHS_sensors.cartridge_cover = Get_COVER_1_State(CartridgesDoor); + // ret = WHS_info.WHS_sensors.cartridge_cover; + ret = Get_COVER_1_State(CartridgesDoor); + if ((ret == OPEN ) && (ret != WHS_info.WHS_sensors.cartridge_cover)) Report(" ------------ RD Cartridge Cover Sensor is = OPEN(1) ----------------- ",__FILE__,__LINE__,ret,RpWarning,ret,0); + if ((ret == CLOSE ) && (ret != WHS_info.WHS_sensors.cartridge_cover)) REPORT_MSG(parameter," ------------ RD Cartridge Cover Sensor is = CLOSE(0) ----------------- "); + return ret; +} + + + + +WHS_sensor CartridgeCoverCallBackFunction() +{ + uint32_t parameter = 6 ; + + + WHS_sensor ret = WHS_no_event; + //ret = RdCartridgeCoverSensor(); + if (WHS_info.WHS_sensors.cartridge_cover != RdCartridgeCoverSensor()) + { + REPORT_MSG(parameter," ------------ find : WHS_cartridge_cover_sensor event ----------------- "); + WHS_info.event = WHS_cartridge_cover_sensor; + WHS_info.WHS_sensors.cartridge_cover = !WHS_info.WHS_sensors.cartridge_cover; + ret = WHS_cartridge_cover_sensor; + } + return ret; +} + +WHS_sensor CartridgeWaste1CallBackFunction() +{ + uint32_t parameter = 6 ; + + WHS_sensor ret = WHS_no_event; + //ret = RdCartridgeCoverSensor(); + if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor != RdWasteCartridge1Sensor()) + { + REPORT_MSG(parameter," ------------ find : WHS_waste1_presence_sensor event ----------------- "); + WHS_info.event = WHS_waste1_presence_sensor; + WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge1_precense_sensor; + ret = WHS_waste1_presence_sensor; + } + return ret; +} + +WHS_sensor CartridgeWaste2CallBackFunction() +{ + uint32_t parameter = 6 ; + + WHS_sensor ret = WHS_no_event; + //ret = RdCartridgeCoverSensor(); + if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor != RdWasteCartridge2Sensor()) + { + REPORT_MSG(parameter," ------------ find : WHS_waste2_presence_sensor event ----------------- "); + WHS_info.event = WHS_waste2_presence_sensor; + WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge2_precense_sensor; + ret = WHS_waste2_presence_sensor; + } + return ret; +} + +/*------------------------------- Cartridge Waste -----------------------------------------*/ +bool InitWasteCartStatus() +{ + uint32_t parameter = 6 ; + + WHS_info.WHS_sensors.cartridge_cover = RdCartridgeCoverSensor(); + + if (RdWasteCartridge1Sensor()) + { + REPORT_MSG(parameter," ------------ WHS_waste1_presence_sensor event ----------------- "); + WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = WHS_CarteidgePrecense; + Pannel_Leds( CART_2, MODE_ON); + } + else + { + REPORT_MSG(parameter," ------------ WHS_waste1_NOT !!! presence_sensor ----------------- "); + WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = WHS_CarteidgeNotPrecense; + Pannel_Leds( CART_2, MODE_OFF); + } + + if (RdWasteCartridge2Sensor()) + { + REPORT_MSG(parameter," ------------ WHS_waste2_presence_sensor event ----------------- "); + WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = WHS_CarteidgePrecense; + Pannel_Leds( CART_3, MODE_ON); + } + else + { + REPORT_MSG(parameter," ------------ WHS_waste1_NOT !!! presence_sensor ----------------- "); + WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = WHS_CarteidgeNotPrecense; + Pannel_Leds( CART_3, MODE_OFF); + } + + + + if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == WHS_CarteidgePrecense) CartridgeAuthentication(waste_cartridge1); + if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == WHS_CarteidgePrecense) CartridgeAuthentication(waste_cartridge2); + SetActiveWastCartridge(); + + if (WHS_info.WHS_sensors.cartridge_cover == WHS_CartridgeCoverOPEN) + { + REPORT_MSG(parameter," ------------ WHS_CartridgeCoverOPEN : add callback for cart1 and cart 1 ----------------- "); + WHS_info.Cartridge_Waste1_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste1CallBackFunction, 0,0,0 ); + WHS_info.Cartridge_Waste2_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeWaste2CallBackFunction, 0,0,0 ); + } + WHS_info.Cartridge_Cover_device_Id = AddControlCallback( WasteTankCBFunction, eOneSecond, CartridgeCoverCallBackFunction, 0,0,0 ); + + return OK; +} + +bool RdWasteCartridge1Sensor() +{ + bool ret = notOK; + WHS_Read_GPI_Registers(); + //WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = Is_Cartridge_Present(CART_2); + //ret = WHS_info.WHS_sensors.waste_cartridge1_precense_sensor; + ret = Is_Cartridge_Present(CART_2); + return ret; +} + +bool RdWasteCartridge2Sensor() +{ + bool ret = notOK; + WHS_Read_GPI_Registers(); + //WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = Is_Cartridge_Present(CART_3); + //ret = WHS_info.WHS_sensors.waste_cartridge2_precense_sensor; + ret = Is_Cartridge_Present(CART_3); + return ret; +} + +bool SetActiveWastCartridge() +{ + uint8_t parameter = 5; + + bool ret = notOK; + if (( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == PRECENSE ) && + (WHS_info.cartridge_1.autheticate == PASSED)) + { + REPORT_MSG(parameter," ------------ WHS : active_cartridge = waste_cartridge 1 ----------------- "); + WHS_info.active_cartridge = waste_cartridge1; + } + else if (( WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == PRECENSE) && + (WHS_info.cartridge_2.autheticate == PASSED)) + { + REPORT_MSG(parameter," ------------ WHS : active_cartridge = waste_cartridge 2 ----------------- "); + WHS_info.active_cartridge = waste_cartridge2; + } + else + { + REPORT_MSG(parameter," ------------ WHS : NO active_cartridge ----------------- "); + WHS_info.active_cartridge = no_waste_cartridge; + } + return ret; + +} + +/* +U8 RdWastePrecenseSensor(cartridge_name name) +{ + + // we have 2 waste_cartridge (waste_cartridge1 and waste_cartridge2) + // bool Is_Cartridge_Present(PANEL_BUTTON_OR_CRAT_ID Cartridge); //use CART_2 or CART_3 + + WHS_Read_GPI_Registers(); + switch (name) + { + case waste_cartridge1: + if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor != Is_Cartridge_Present(CART_2)) + { + WHS_info.WHS_sensors.waste_cartridge1_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge1_precense_sensor; + WHS_info.event = WHS_waste1_presence_sensor; + } + break; + case waste_cartridge2: + if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor != Is_Cartridge_Present(CART_3)) + { + WHS_info.WHS_sensors.waste_cartridge2_precense_sensor = !WHS_info.WHS_sensors.waste_cartridge2_precense_sensor; + WHS_info.event = WHS_waste2_presence_sensor; + } + break; + default : + break; + } + return OK; +} +*/ +/* +U8 cartridge_handeling() +{ + AddControlCallback( CartridgePrecenceCBFunction, eOneMinute, CartridgePrecenceCallBackFunction, 0,0,0 ); // + return OK; +} +*/ + +U8 SetCartridgeLED(cartridge_name name,led_status led) +{ + bool ret = notOK; + return ret; +} + +/* +U8 CartridgePrecenceCBFunction() +{ + if ( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor_flag ) // if we have changes at cartridge1: + { + if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor) // if new cartridge is presence: + { + if (rd_waste_cartridge_param()== OK) //read parameter from RFID + SetCartridgeLED(waste_cartridge1,led_on); //change led status to ON + } + else // if the cartridge is removed + { + SetCartridgeLED(waste_cartridge1, led_off); //change led status to OFF + } + WHS_info.WHS_sensors.waste_cartridge1_precense_sensor_flag = 0; //remove the flag + + } + else if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor_flag ) + { + if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor) + { + + } + else + { + + } + } + return OK; +}*/ +/* +U8 CartridgePrecenceCallBackFunction() +{ + bool ret = notOK; + return ret; +} +*/ + + + + + + + + +bool CartridgeCoverCBFunction() +{ + bool ret = notOK; + if (WHS_info.WHS_sensors.cartridge_cover == OPEN) + { + //if (WHS_info.WHS_pump == ON) + //{ + SetWastePump(OFF); //pump OFF + //} + // prevent NEW Job + // Display "Close cartridge cover" + // pop up message in GUI + } + else + { + // can do a NEW Job + // remove message "Close cartridge cover" + // remove pop up message in GUI + } + WHS_info.event = WHS_no_event; + return ret; +} + + +/*------------------------------------------------------------------------------------------------*/ + + + +U8 WHS_init(void) +{ + InitWasteCartStatus(); + initWHS_WasteTank(); + SetWastePump(CLOSE); + return 0; +} + + + + + + + + + + + + + + + + + +/*---------------------------------- HW Test --------------------------------------------------------------*/ + + + +bool RdWasteTankFilterSensor() +{ + bool ret = notOK; + WHS_Read_GPI_Registers(); + WHS_info.WHS_sensors.waste_tank_filter_sensor = WHS_GPI_SW_FILTER_PRES(); + ret = WHS_info.WHS_sensors.waste_tank_filter_sensor; + return ret; +} + + +U8 RdCartridgeDoor() +{ + bool ret = notOK; + ret = RdCartridgeCoverSensor(); + return ret; +} +U8 RdWaste1() +{ + bool ret = notOK; + ret = RdWasteCartridge1Sensor(); + return ret; +} +U8 RdWaste2() +{ + bool ret = notOK; + ret = RdWasteCartridge2Sensor(); + return ret; +} +U8 SetValve(bool value) +{ + bool ret = notOK; + WHS_info.WHS_valve = value; + ret = SetValveDirection( ); + return ret; +} + +U8 SetPump(bool value) +{ + bool ret = notOK; + ret = SetWastePump(value); + return ret; +} + +U8 RdFilter() +{ + bool ret = notOK; + ret = RdWasteTankFilterSensor(); + return ret; +} +U8 RdEmpty() +{ + bool ret = notOK; + ret = RdWasteTankEmptySensor(); + return ret; +} +U8 RdFull() +{ + bool ret = notOK; + ret = RdWasteTankFullSensor(); + return ret; +} +U8 RdOverFlow() +{ + bool ret = notOK; + RdWasteTankOverFlowSensor(); + return ret; +} + + + +U8 WHS_HW_test() +{ + bool ret = notOK; +/* ret = RdCartridgeDoor(); + while (ret == RdCartridgeDoor()); +*/ +/* --- connect JO271 cable ---*/ + ret = RdWaste1(); + while (ret == RdWaste1());// blue = waste1 + ret = RdWaste2(); + while (ret == RdWaste2());// yellow = waste2 + + /* --- connect JO71 JO72 JO121 cable ---*/ + + ret = SetValve(1); //red LED On + ret = SetValve(0); //red LED Off + + + ret = SetPump(1); // led green (backplan) On + ret = SetPump(0); // led green (backplan) Off + + ret = RdFilter(); + while (ret == RdFilter()); + ret = RdEmpty(); + while (ret == RdEmpty()); + ret = RdFull(); + while (ret == RdFull()); +// ret = RdOverFlow(); +// while (ret == RdOverFlow()); + return ret; +} + + + + + + + + +/*------------------------------------------------------------------------------------------------*/ + +/* +//U8 WasteCartridgeCallBackFunction(); +//U8 WasteCartridgeCBFunction(); + +bool start_WHS_machin(); +U8 CartridgePrecenceCallBackFunction(); +uint32_t EmptyWasteTankFullCBFunction(); +U8 cartridge_handeling(); + +U8 RdWastePrecenseSensor(cartridge_name name); + +U8 rd_waste_cartridge_param(); +U8 set_cartridge_1(U8 cartridge_status); +U8 set_cartridge_2(U8 cartridge_status); +U8 check_sensors_before_start_emptying(); +bool check_RFID_authentication(); + +uint32_t waste_tank_init(void); +uint32_t EmptyWasteTankCBFunction(); + + + +U8 WasteCartridgeCallBackFunction() +{ + bool ret = notOK; + + ret = RdWastePrecenseSensor(waste_cartridge1); + ret = RdWastePrecenseSensor(waste_cartridge2); + return ret; +} + + +U8 Wr_cartridge_RFid(cartridge_name cartridge, cartridge_status status); +WHS_sttMachin UpdateStateMachine(); + +*/ + +// uint32_t updateWasteTankStruct(); +//uint32_t WasteTankFullCallBackFunction(uint32_t IfIndex, uint32_t ReadValue); + +/*--- functipons not in use ----*/ + +/* +U8 check_sensors_before_start_emptying() ???????????????????? +{ + bool ret = notOK; + + if ((WHS_info.WHS_sensors.cartridge_cover == CLOSE) && + (( WHS_info.WHS_sensors.waste_cartridge1_precense_sensor == precense) || + (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor == precense)) && + (WHS_info.WHS_sensors.waste_tank_filter_sensor == 1 )) + { + ret = OK; + } + return ret; +} + + + + +uint32_t updateWasteTankStruct() //----------what is the timing??????----------------- +{ +// bool waste_number =1; + + rd_waste_precense_sensor( ); + RdWasteTankFilterSensor(); + rd_whs_cartridge_cover(); + +// rd_waste_tank_RdWasteTankEmptySensor_sensor(); +// RdWasteTankFullSensor(); +// rd_waste_tank_over_flow_sensor(); + return OK; +} + + + + +uint32_t WasteTankFullCallBackFunction(uint32_t IfIndex, uint32_t ReadValue) +{ + if ( RdWasteTankFullSensor() != WHS_info.WHS_sensors.waste_tank_full_sensor ) + { + WHS_info.event = WHS_full_sensor; + WHS_info.WHS_sensors.waste_tank_full_sensor = !WHS_info.WHS_sensors.waste_tank_full_sensor; + } + return OK; +} + + +uint32_t WasteTankEmptyCallBackFunction(uint32_t IfIndex, uint32_t ReadValue) +{ + if (RdWasteTankEmptySensor() != WHS_info.WHS_sensors.waste_tank_empty_sensor) + { + WHS_info.event = WHS_empty_sensor; + WHS_info.WHS_sensors.waste_tank_empty_sensor = !WHS_info.WHS_sensors.waste_tank_empty_sensor; + } + return OK; +} + +uint32_t WasteTankOverflowCallBackFunction(uint32_t IfIndex, uint32_t ReadValue) +{ + if (rd_waste_tank_over_flow_sensor() != WHS_info.WHS_sensors.waste_tank_over_flow_sensor) + { + WHS_info.event = WHS_overflow_sensor; + WHS_info.WHS_sensors.waste_tank_over_flow_sensor = !(WHS_info.WHS_sensors.waste_tank_over_flow_sensor); + } + return OK; +} + + +U8 CartridgeCoverCallBackFunction() +{ + bool ret = notOK; + return ret; +} + + +U8 CartridgeCoverCBFunction() +{ + bool ret = notOK; + return ret; +} + + + + +uint32_t WHS_machin() +{ + switch( WHS_info.sttMachine ) + { + case WHS_empty: // last OnOffPBstate was OFF + + break; + case WHS_filling : // last OnOffPBstate was COUNTPB + + break; + case WHS_emptying: // last OnOffPBstate was SHORTPB + + break; + case WHS_full: + + break; + case WHS_overflow: + + break; + default: // WHS_sttError + break; + } + return OK; +} + + + + +uint32_t EmptyWasteTankCBFunction() +{ + bool ret = notOK; +//--------try state machine------- + if (WHS_info.event == WHS_no_event) + return OK; + else + { +// WHS_info.sttMachine = UpdateStateMachine(); +// WHS_info.event = WHS_no_event; + switch (WHS_info.event) + { + case WHS_empty_sensor: + if (WHS_info.WHS_sensors.waste_tank_empty_sensor) + { + + } + else + { + ret = CartridgeWasteFilling(OFF); + } + break; + case WHS_full_sensor: + if (WHS_info.WHS_sensors.waste_tank_full_sensor) + { + ret = CartridgeWasteFilling(ON); + // cant start a new Job + } + else + { + // can start a new JOB + WHS_info.sttMachine = WHS_empty; + } + break; + case WHS_overflow_sensor: + if (WHS_info.WHS_sensors.waste_tank_empty_sensor) + { + + // 1.StopMacine + // 2. + + WHS_info.sttMachine = WHS_overflow; + } + else + { + WHS_info.sttMachine = WHS_full; + } + break; + default: //error state + break; + } + WHS_info.event = WHS_no_event;; + } + return ret; +} + + + +uint32_t start_WHS_machin() +{ + switch( WHS_info.sttMachine ) + { + case WHS_empty: // last OnOffPBstate was OFF + AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); // + break; + case WHS_filling : // last OnOffPBstate was COUNTPB + AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); // + AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); // + break; + case WHS_emptying: // last OnOffPBstate was SHORTPB + AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankEmptyCallBackFunction, 0,0,0 ); // + AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); // + break; + case WHS_full: + AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); // + AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankOverflowCallBackFunction, 0,0,0 ); // + break; + case WHS_overflow: + AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankFullCallBackFunction, 0,0,0 ); // + AddControlCallback( EmptyWasteTankCBFunction, eOneMinute, WasteTankOverflowCallBackFunction, 0,0,0 ); // + break; + default: // WHS_sttError + break; + } + return OK; +} + +*/ + +//U8 WasteCartridgeCBFunction() +//{ +// bool ret = notOK; +// switch (WHS_info.event) +// { +// /*case WHS_waste1_presence_sensor : +// if (WHS_info.WHS_sensors.waste_cartridge1_precense_sensor ) // waste cartridge 1 is inserted . +// { +// SetCartridgeLED(waste_cartridge1, led_on); +// RdWasteCartridgeParam(waste_cartridge1); +// if ( CartridgeAuthentication(waste_cartridge1)) // to define authentication +// { +// //WHS_info.cartridge_1.autheticate = PASSED; //='0' +// //???WHS_info.WHS_valve = waste_cartridge1; // or we should do it only before pumping???? +// //???SetValveDirection(); // or we should do it only before pumping???? +// } +// else +// { +// //WHS_info.cartridge_1.autheticate = FAILED; //='1' +// SetCartridgeLED(waste_cartridge1, led_off); +// } +// } +// else // waste cartridge 1 take out +// { +// WHS_info.cartridge_1.autheticate = FAILED; +// //???if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping???? +// //???{ +// //???WHS_info.WHS_valve = waste_cartridge; +// //???SetValveDirection(); +// //???} +// //???else +// //???{ +// //??? +// //???} +// //??? RdWasteCartridgeParam(waste_cartridge2); +// //???WHS_info.WHS_valve = waste_cartridge1; +// } +// +// break; +// case WHS_waste2_presence_sensor : +// if (WHS_info.WHS_sensors.waste_cartridge2_precense_sensor ) // waste cartridge is inserted . +// { +// SetCartridgeLED(waste_cartridge2, led_on); +// RdWasteCartridgeParam(waste_cartridge2); +// if ( CartridgeAuthentication(waste_cartridge2)) // to define authentication +// { +// //WHS_info.cartridge_2.autheticate = PASSED; //='0' +// //???WHS_info.WHS_valve = waste_cartridge2; // or we should do it only before pumping???? +// //???SetValveDirection(); // or we should do it only before pumping???? +// } +// else +// { +// //WHS_info.cartridge_2.autheticate = FAILED; //='1' +// SetCartridgeLED(waste_cartridge2, led_off); +// } +// } +// else // waste cartridge 2 take out +// { +// WHS_info.cartridge_2.autheticate = FAILED; +// +// if (WHS_info.cartridge_2.autheticate == PASSED) // or we should do it only before pumping???? +// { +// WHS_info.WHS_valve = waste_cartridge; +// SetValveDirection(); +// } +// else +// { +// +// } +// RdWasteCartridgeParam(waste_cartridge2); +// WHS_info.WHS_valve = waste_cartridge1; +// +// } +// break;*/ +// default: +// break; +// } +// +// WHS_info.event = WHS_no_event; +// +// return ret; +//} + + +//IDS_Dispenser_Build_Pressure_Callback + + +/*------------------------------------------------------------------------------------------------*/ + + + + |