diff options
| author | Shlomo Hecht <shlomo@twine-s.com> | 2019-01-02 08:47:29 +0200 |
|---|---|---|
| committer | Shlomo Hecht <shlomo@twine-s.com> | 2019-01-02 08:47:29 +0200 |
| commit | 520e878bf98efcec9c75abcfe483175ff72620a2 (patch) | |
| tree | 62a7221e3c22187821f6a5e399eca0f7bd31168a /Software/Embedded_SW/Embedded/Modules | |
| parent | 30574fe4a6e1bb4f60a43e9000acaf919811689a (diff) | |
| parent | 25f5e6ddef7ef2fa0a747305847eeb4ceee5a2c9 (diff) | |
| download | Tango-520e878bf98efcec9c75abcfe483175ff72620a2.tar.gz Tango-520e878bf98efcec9c75abcfe483175ff72620a2.zip | |
Merge branch 'master' of https://twinetfs.visualstudio.com/Tango/_git/Tango
Diffstat (limited to 'Software/Embedded_SW/Embedded/Modules')
21 files changed, 716 insertions, 381 deletions
diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c index b7b018cdb..8d5955636 100644 --- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c +++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c @@ -89,140 +89,113 @@ typedef struct uint16_t Frequency; //1/10/100/1000 AlarmSource AlarmSource; uint16_t DeviceId; - uint32_t AlarmValue; + uint8_t ModuleDeviceId; + uint16_t AlarmValue; bool AlarmDirection; DebugLogCategory Severity; uint16_t Predecessor; uint8_t DebounceValue; - int8_t DebounceCounter; - bool Status; EventType EventType; - Event *EventPtr; char *EventName; }AlarmHandlingItem; -AlarmHandlingItem AlarmItem[MAX_SYSTEM_ALARMS]={ -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser1Empty,NULL,"Dispenser1Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser2Empty,NULL,"Dispenser2Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser3Empty,NULL,"Dispenser3Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser4Empty,NULL,"Dispenser4Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser5Empty,NULL,"Dispenser5Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser6Empty,NULL,"Dispenser6Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser7Empty,NULL,"Dispenser7Empty"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__Dispenser8Empty,NULL,"Dispenser8Empty"}, -/*{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_1,false,true,DEBUG_LOG_CATEGORY__Warning,0,0,0,false,EVENT_TYPE__Dispenser1LowLevel,NULL,"Dispenser1LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_2,false,true,DEBUG_LOG_CATEGORY__Warning,1,0,0,false,EVENT_TYPE__Dispenser2LowLevel,NULL,"Dispenser2LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_3,false,true,DEBUG_LOG_CATEGORY__Warning,2,0,0,false,EVENT_TYPE__Dispenser3LowLevel,NULL,"Dispenser3LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_4,false,true,DEBUG_LOG_CATEGORY__Warning,3,0,0,false,EVENT_TYPE__Dispenser4LowLevel,NULL,"Dispenser4LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_5,false,true,DEBUG_LOG_CATEGORY__Warning,4,0,0,false,EVENT_TYPE__Dispenser5LowLevel,NULL,"Dispenser5LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_6,false,true,DEBUG_LOG_CATEGORY__Warning,5,0,0,false,EVENT_TYPE__Dispenser6LowLevel,NULL,"Dispenser6LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_7,false,true,DEBUG_LOG_CATEGORY__Warning,6,0,0,false,EVENT_TYPE__Dispenser7LowLevel,NULL,"Dispenser7LowLevel"}, -{eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmLow_8,false,true,DEBUG_LOG_CATEGORY__Warning,7,0,0,false,EVENT_TYPE__Dispenser8LowLevel,NULL,"Dispenser8LowLevel"},*/ -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"Mixer Over Temperature"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"GeneralInternal Over Temperature"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,80,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"GeneralInternal Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead1OverTemperature,NULL,"DyeingHead1 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead2OverTemperature,NULL,"DyeingHead2 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead3OverTemperature,NULL,"DyeingHead3 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead4OverTemperature,NULL,"DyeingHead4 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead5OverTemperature,NULL,"DyeingHead5 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead6OverTemperature,NULL,"DyeingHead6 Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer Over Temperature"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,300,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer Over Temperature"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__GeneralInternalOverTemperature,NULL,"Mixer PT100 Not Working"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,250,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalPT100 Not Working,NULL,"GeneralInternalPT100 Not Working"}, -//{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,80,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,0,false,EVENT_TYPE__GeneralInternalPT100 Not Working,NULL,"GeneralInternalPT100 Not Working"}, -/*{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead1OverTemperature,NULL,"DyeingHead 1 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead2OverTemperature,NULL,"DyeingHead 2 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead3OverTemperature,NULL,"DyeingHead 3 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead4OverTemperature,NULL,"DyeingHead 4 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead5OverTemperature,NULL,"DyeingHead 5 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DyeingHead6OverTemperature,NULL,"DyeingHead 6 PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer PT100 Not Working"}, -{eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer PT100 Not Working"}, -{eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,0,false,EVENT_TYPE__DryerOverTemperature,NULL,"Dryer PT100 Not Working"},*/ -{eOneSecond,PressureAlarm,0,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser1Pressure,NULL,"Dispenser1Pressure"}, -{eOneSecond,PressureAlarm,1,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser2Pressure,NULL,"Dispenser2Pressure"}, -{eOneSecond,PressureAlarm,2,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser3Pressure,NULL,"Dispenser3Pressure"}, -{eOneSecond,PressureAlarm,3,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser4Pressure,NULL,"Dispenser4Pressure"}, -{eOneSecond,PressureAlarm,4,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser5Pressure,NULL,"Dispenser5Pressure"}, -{eOneSecond,PressureAlarm,5,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser6Pressure,NULL,"Dispenser6Pressure"}, -{eOneSecond,PressureAlarm,6,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser7Pressure,NULL,"Dispenser7Pressure"}, -{eOneSecond,PressureAlarm,7,6,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,0,false,EVENT_TYPE__Dispenser8Pressure,NULL,"Dispenser8Pressure"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerOverCurrent,NULL,"MotorDryerOverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederOverCurrent,NULL,"MotorFeederOverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewOverCurrent,NULL,"MotorScrewOverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderOverCurrent,NULL,"MotorWinderOverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerOverCurrent,NULL,"MotorPoolerOverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1OverCurrent,NULL,"MotorDispenser1OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2OverCurrent,NULL,"MotorDispenser2OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3OverCurrent,NULL,"MotorDispenser3OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4OverCurrent,NULL,"MotorDispenser4OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5OverCurrent,NULL,"MotorDispenser5OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6OverCurrent,NULL,"MotorDispenser6OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7OverCurrent,NULL,"MotorDispenser7OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8OverCurrent,NULL,"MotorDispenser8OverCurrent"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerOverTemperature,NULL,"MotorDryerOverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederOverTemperature,NULL,"MotorFeederOverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewOverTemperature,NULL,"MotorScrewOverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderOverTemperature,NULL,"MotorWinderOverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerOverTemperature,NULL,"MotorPoolerOverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1OverTemperature,NULL,"MotorDispenser1OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2OverTemperature,NULL,"MotorDispenser2OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3OverTemperature,NULL,"MotorDispenser3OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4OverTemperature,NULL,"MotorDispenser4OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5OverTemperature,NULL,"MotorDispenser5OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6OverTemperature,NULL,"MotorDispenser6OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7OverTemperature,NULL,"MotorDispenser7OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8OverTemperature,NULL,"MotorDispenser8OverTemperature"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerUnderVoltage,NULL,"MotorDryerUnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederUnderVoltage,NULL,"MotorFeederUnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewUnderVoltage,NULL,"MotorScrewUnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderUnderVoltage,NULL,"MotorWinderUnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerUnderVoltage,NULL,"MotorPoolerUnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1UnderVoltage,NULL,"MotorDispenser1UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2UnderVoltage,NULL,"MotorDispenser2UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3UnderVoltage,NULL,"MotorDispenser3UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4UnderVoltage,NULL,"MotorDispenser4UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5UnderVoltage,NULL,"MotorDispenser5UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6UnderVoltage,NULL,"MotorDispenser6UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7UnderVoltage,NULL,"MotorDispenser7UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8UnderVoltage,NULL,"MotorDispenser8UnderVoltage"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDryerStall,NULL,"MotorDryerStall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorFeederStall,NULL,"MotorFeederStall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorScrewStall,NULL,"MotorScrewStall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorWinderStall,NULL,"MotorWinderStall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorPoolerStall,NULL,"MotorPoolerStall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser1Stall,NULL,"MotorDispenser1Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser2Stall,NULL,"MotorDispenser2Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser3Stall,NULL,"MotorDispenser3Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser4Stall,NULL,"MotorDispenser4Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser5Stall,NULL,"MotorDispenser5Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser6Stall,NULL,"MotorDispenser6Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser7Stall,NULL,"MotorDispenser7Stall"}, -{eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,0,false,EVENT_TYPE__MotorDispenser8Stall,NULL,"MotorDispenser8Stall"}, -{eOneSecond,DoNotPollAlarm,0,0,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,0,false,EVENT_TYPE__ThreadBreak,NULL,"Thread Break"}, -{eOneSecond,DoNotPollAlarm,0,0,false,DEBUG_LOG_CATEGORY__Warning,0xFF,0,0,false,EVENT_TYPE__ThreadTensionControlFailure,NULL,"Thread Tension Control Failure"}, -}; -char TestMessage[5]="Test"; -/* - typedef struct +typedef struct { - uint16_t Frequency; //1/10/100/1000 - AlarmSource AlarmSource; - uint16_t DeviceId; - uint32_t AlarmValue; - bool AlarmDirection; - DebugLogCategory Severity; - uint16_t Predecessor; - uint8_t DebounceValue; int8_t DebounceCounter; bool Status; - EventType EventType; Event *EventPtr; - char *EventName; -}AlarmHandlingItem; - */ +}AlarmStatusItem; +AlarmStatusItem AlarmState[MAX_SYSTEM_ALARMS]; + +const AlarmHandlingItem AlarmItem[MAX_SYSTEM_ALARMS]={ + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_1,0,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser1Empty,"Dispenser1Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_2,1,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser2Empty,"Dispenser2Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_3,2,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser3Empty,"Dispenser3Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_4,3,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser4Empty,"Dispenser4Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_5,4,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser5Empty,"Dispenser5Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_6,5,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser6Empty,"Dispenser6Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_7,6,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser7Empty,"Dispenser7Empty"}, + {eHundredMillisecond,LimitSwitchAlarm,LimitSwitchAlarmEmpty_8,7,false,true,DEBUG_LOG_CATEGORY__Error,0xFF,0,EVENT_TYPE__Dispenser8Empty,"Dispenser8Empty"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__GeneralInternalOverTemperature,"Mixer Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead1OverTemperature,"DyeingHead1 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead2OverTemperature,"DyeingHead2 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead3OverTemperature,"DyeingHead3 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead4OverTemperature,"DyeingHead4 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead5OverTemperature,"DyeingHead5 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead6OverTemperature,"DyeingHead6 Over Temperature"}, + {eHundredMillisecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,270,true,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DryerOverTemperature,"Dryer Over Temperature"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP3, HARDWARE_PID_CONTROL_TYPE__MixerHeater ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__GeneralInternalOverTemperature,"Mixer PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead1OverTemperature,"DyeingHead 1 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead2OverTemperature,"DyeingHead 2 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead3OverTemperature,"DyeingHead 3 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead4OverTemperature,"DyeingHead 4 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead5OverTemperature,"DyeingHead 5 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_MIXCHIP_TEMP, HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6 ,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DyeingHead6OverTemperature,"DyeingHead 6 PT100 Not Working"}, + {eOneSecond,TemperatureAlarm,TEMP_SENSE_ANALOG_DRYER_TEMP1, HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,9,false,DEBUG_LOG_CATEGORY__Error,0xFF,10,EVENT_TYPE__DryerOverTemperature,"Dryer PT100 Not Working"}, + {eOneSecond,PressureAlarm,0,0,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser1Pressure,"Dispenser1Pressure"}, + {eOneSecond,PressureAlarm,1,1,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser2Pressure,"Dispenser2Pressure"}, + {eOneSecond,PressureAlarm,2,2,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser3Pressure,"Dispenser3Pressure"}, + {eOneSecond,PressureAlarm,3,3,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser4Pressure,"Dispenser4Pressure"}, + {eOneSecond,PressureAlarm,4,4,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser5Pressure,"Dispenser5Pressure"}, + {eOneSecond,PressureAlarm,5,5,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser6Pressure,"Dispenser6Pressure"}, + {eOneSecond,PressureAlarm,6,6,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser7Pressure,"Dispenser7Pressure"}, + {eOneSecond,PressureAlarm,7,7,5,true,DEBUG_LOG_CATEGORY__Error,0xFF,5,EVENT_TYPE__Dispenser8Pressure,"Dispenser8Pressure"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerOverCurrent,"MotorDryerOverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederOverCurrent,"MotorFeederOverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewOverCurrent,"MotorScrewOverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderOverCurrent,"MotorWinderOverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerOverCurrent,"MotorPoolerOverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1OverCurrent,"MotorDispenser1OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2OverCurrent,"MotorDispenser2OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3OverCurrent,"MotorDispenser3OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4OverCurrent,"MotorDispenser4OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5OverCurrent,"MotorDispenser5OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6OverCurrent,"MotorDispenser6OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7OverCurrent,"MotorDispenser7OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_OCD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8OverCurrent,"MotorDispenser8OverCurrent"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerOverTemperature,"MotorDryerOverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederOverTemperature,"MotorFeederOverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewOverTemperature,"MotorScrewOverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderOverTemperature,"MotorWinderOverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerOverTemperature,"MotorPoolerOverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1OverTemperature,"MotorDispenser1OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2OverTemperature,"MotorDispenser2OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3OverTemperature,"MotorDispenser3OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4OverTemperature,"MotorDispenser4OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5OverTemperature,"MotorDispenser5OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6OverTemperature,"MotorDispenser6OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7OverTemperature,"MotorDispenser7OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_TH_SD,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8OverTemperature,"MotorDispenser8OverTemperature"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerUnderVoltage,"MotorDryerUnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederUnderVoltage,"MotorFeederUnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewUnderVoltage,"MotorScrewUnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderUnderVoltage,"MotorWinderUnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerUnderVoltage,"MotorPoolerUnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1UnderVoltage,"MotorDispenser1UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2UnderVoltage,"MotorDispenser2UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3UnderVoltage,"MotorDispenser3UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4UnderVoltage,"MotorDispenser4UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5UnderVoltage,"MotorDispenser5UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6UnderVoltage,"MotorDispenser6UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7UnderVoltage,"MotorDispenser7UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_UVLO,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8UnderVoltage,"MotorDispenser8UnderVoltage"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING,x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDryerStall,"MotorDryerStall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorFeederStall,"MotorFeederStall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_SCREW, HARDWARE_MOTOR_TYPE__MOTO_SCREW, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorScrewStall,"MotorScrewStall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_WINDER, HARDWARE_MOTOR_TYPE__MOTO_WINDER, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorWinderStall,"MotorWinderStall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorPoolerStall,"MotorPoolerStall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser1Stall,"MotorDispenser1Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser2Stall,"MotorDispenser2Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_3, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser3Stall,"MotorDispenser3Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_4, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser4Stall,"MotorDispenser4Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_5, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser5Stall,"MotorDispenser5Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_6, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser6Stall,"MotorDispenser6Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_7, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser7Stall,"MotorDispenser7Stall"}, + {eOneMinute,MotorAlarm,HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_8, x_STATUS_STEP_LOSS_A,false,DEBUG_LOG_CATEGORY__Error,0xFF,2,EVENT_TYPE__MotorDispenser8Stall,"MotorDispenser8Stall"}, + {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__ThreadBreak,"Thread Break"}, + {eOneSecond,DoNotPollAlarm,0,0,0,0,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__ThreadTensionControlFailure,"Thread Tension Control Failure"} +}; +char TestMessage[5]="Test"; +bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false}; bool EventsNotificationRequestAccepted = false; //read dispensers limit switches. 25 - send warning. up - stop job and send alarm //Cone missing @@ -242,6 +215,13 @@ void AlarmHandlingInit(void) AlarmHandlingMsgQ = Mailbox_create(sizeof(AlarmHandlingMessageStruc), 20, NULL,&eb); + int Alarm_i; + for (Alarm_i = 0;Alarm_i < MAX_SYSTEM_ALARMS;Alarm_i++) + { + AlarmState[Alarm_i].Status = false; + AlarmState[Alarm_i].DebounceCounter = 0; + AlarmState[Alarm_i].EventPtr = NULL; + } return; } JobEndReasonEnum getEndReason(uint32_t AlarmId) @@ -264,14 +244,46 @@ JobEndReasonEnum getEndReason(uint32_t AlarmId) } uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Severity) { - switch (Severity) + //DebugLogCategory reprocessedSeverity = Severity; + //ProcessParameters ProcessParameterZero; + switch (AlarmItem[AlarmId].AlarmSource) + { + case TemperatureAlarm: + //need to discover the heater Id and shut it down + HeaterCommandRequestMessage(AlarmItem[AlarmId].ModuleDeviceId, HEATER_OFF, 0); + break; + case LimitSwitchAlarm: + IDS_StopDispenser (AlarmItem[AlarmId].ModuleDeviceId); + break; + case PressureAlarm: + IDS_StopDispenser (AlarmItem[AlarmId].ModuleDeviceId); + break; + case CurrentAlarm: + break; + case MotorAlarm: + MotorStop(AlarmItem[AlarmId].ModuleDeviceId,Hard_Hiz); + break; + default: + break; + } + /*switch (reprocessedSeverity)*/ + switch (Severity) { case DEBUG_LOG_CATEGORY__Warning: - //raise flag fr next job break; case DEBUG_LOG_CATEGORY__Critical: watchdogCriticalAlarm = true; +/* + //stop all dispensers + for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++) + { + MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz); + } + //stop all heating + memset (ProcessParameterZero,0,sizeof(ProcessParameterZero)); + HandleProcessParameters(ProcessParameterZero); + */ //intentional fall through case DEBUG_LOG_CATEGORY__Error: if (JobIsActive()) @@ -280,7 +292,42 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever AbortJob(AlarmItem[AlarmId].EventName); Report(AlarmItem[AlarmId].EventName, __FILE__,__LINE__,AlarmId, RpMessage, DEBUG_LOG_CATEGORY__Error, 0); } -//Stop Job + /*switch (AlarmItem[AlarmId].AlarmSource) + { + case TemperatureAlarm: + //need to discover the heater Id and shut it down + // HeaterCommandRequestMessage( HARDWARE_PID_CONTROL_TYPE__MixerHeater, false, + // ProcessParams->mixertemp); + break; + case LimitSwitchAlarm: + if ((AlarmItem[AlarmId].EventType>=EVENT_TYPE__Dispenser1Empty)&&(AlarmItem[AlarmId].EventType<=EVENT_TYPE__Dispenser8Empty)) + { + Disp_i = AlarmItem[AlarmId].EventType- EVENT_TYPE__Dispenser1Empty; + MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz); + if (JobIsActive()) + { + if (DispenserInUse[Disp_i] == false) + AlarmItem[AlarmId].Severity = DEBUG_LOG_CATEGORY__Info; + } + } + break; + case PressureAlarm: + Disp_i = AlarmItem[AlarmId].EventType- EVENT_TYPE__Dispenser1Pressure; + MotorStop(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+Disp_i,Hard_Hiz); + if (JobIsActive()) + { + if (DispenserInUse[Disp_i] == false) + AlarmItem[AlarmId].Severity = DEBUG_LOG_CATEGORY__Info; + } + break; + case CurrentAlarm: + break; + case MotorAlarm: + break; + default: + break; + }*/ + break; case DEBUG_LOG_CATEGORY__Debug: case DEBUG_LOG_CATEGORY__Info: @@ -294,13 +341,16 @@ uint32_t AlarmHandlingConsequentActions(uint32_t AlarmId, DebugLogCategory Sever JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) { JobTicket* JobTicket = CurrentJob; - bool DispenserInUse[MAX_SYSTEM_DISPENSERS] = {false,false,false,false,false,false,false,false}; EventType HeaterEventType[MAX_HEATERS_NUM] = {EVENT_TYPE__DryerOverTemperature,EVENT_TYPE__DryerOverTemperature,EVENT_TYPE__DryerOverTemperature,EVENT_TYPE__DyeingHead1OverTemperature,EVENT_TYPE__DyeingHead2OverTemperature, EVENT_TYPE__DyeingHead3OverTemperature,EVENT_TYPE__DyeingHead4OverTemperature,EVENT_TYPE__DyeingHead5OverTemperature,EVENT_TYPE__DyeingHead6OverTemperature, EVENT_TYPE__GeneralInternalOverTemperature}; int Segment_i,Brush_i,Dispenser_i,DispenserId,Alarm_i,Heater_i,AlarmId=0; HeaterState HeaterState; + for (Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++) + { + DispenserInUse[Dispenser_i] = false; + } JobEndReasonEnum status = JOB_OK; if (JobTicket->n_segments == 0) return OK; @@ -322,38 +372,44 @@ JobEndReasonEnum AlarmHandlingPrepareJob(void *CurrentJob) }//if dispensers }//for brush }//for segments - for (Dispenser_i=0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++) + if (Configured[Module_IDS]) { - if (DispenserInUse[Dispenser_i] == true) + for (Dispenser_i=0;Dispenser_i<MAX_SYSTEM_DISPENSERS;Dispenser_i++) { - for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++) + if (DispenserInUse[Dispenser_i] == true) { - if (AlarmItem[Alarm_i].EventType == (EVENT_TYPE__Dispenser1Empty+Dispenser_i)) + for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++) { - if (AlarmItem[Alarm_i].Status == true) + if (AlarmItem[Alarm_i].EventType == (EVENT_TYPE__Dispenser1Empty+Dispenser_i)) { - status = ERROR; - AlarmId = Alarm_i; - break; + if (AlarmState[Alarm_i].Status == true) + { + status = ERROR; + AlarmId = Alarm_i; + break; + } } } } } } - for (Heater_i = 0;Heater_i<MAX_HEATERS_NUM;Heater_i++) + if (Configured[Module_Heaters]) { - LoadHeaterState((HeaterType)Heater_i,&HeaterState); - if (HeaterState.setpoint)//temperature is set - heater active + for (Heater_i = 0;Heater_i<MAX_HEATERS_NUM;Heater_i++) { - for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++) + LoadHeaterState((HeaterType)Heater_i,&HeaterState); + if (HeaterState.setpoint)//temperature is set - heater active { - if (AlarmItem[Alarm_i].EventType == HeaterEventType[Heater_i]) + for (Alarm_i = 0;Alarm_i<MAX_SYSTEM_ALARMS;Alarm_i++) { - if (AlarmItem[Alarm_i].Status == true) + if (AlarmItem[Alarm_i].EventType == HeaterEventType[Heater_i]) { - status = ERROR; - AlarmId = Alarm_i; - break; + if (AlarmState[Alarm_i].Status == true) + { + status = ERROR; + AlarmId = Alarm_i; + break; + } } } } @@ -408,24 +464,27 @@ void AlarmHandlingSetAlarm(uint32_t AlarmId, bool value) { if (AlarmItem[Alarm_i].EventType == AlarmId) { - AlarmItem[Alarm_i].Status = value; - if (value == true) + if (AlarmState[Alarm_i].Status != value) { - AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); - // report the alarm! - AlarmItem[Alarm_i].EventPtr = my_malloc (sizeof(Event)); - if (AlarmItem[Alarm_i].EventPtr) + AlarmState[Alarm_i].Status = value; + if (value == true) { - event__init(AlarmItem[Alarm_i].EventPtr); - AlarmItem[Alarm_i].EventPtr->has_type = true; - AlarmItem[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; - AlarmItem[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; + // no need to call consequent actionsAlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); + // report the alarm! + AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); + if (AlarmState[Alarm_i].EventPtr) + { + event__init(AlarmState[Alarm_i].EventPtr); + AlarmState[Alarm_i].EventPtr->has_type = true; + AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; + AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; + } + } + else + { + if (AlarmState[Alarm_i].EventPtr) + my_free(AlarmState[Alarm_i].EventPtr); } - } - else - { - if (AlarmItem[Alarm_i].EventPtr) - my_free(AlarmItem[Alarm_i].EventPtr); } break; } @@ -439,8 +498,8 @@ uint32_t AlarmHandlingEmptyCBFunction(uint32_t IfIndex, uint32_t ReadValue) uint32_t AlarmHandlingStart(void) { - if (EventsNotificationRequestAccepted == false) - return ERROR; + //if (EventsNotificationRequestAccepted == false) + // return ERROR; if ( AlarmHandlingActive == false) { AlarmHandlingActive = true; @@ -542,7 +601,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick) } break; case DoNotPollAlarm: - Status = AlarmItem[Alarm_i].Status; + Status = AlarmState[Alarm_i].Status; break; default: break; @@ -551,64 +610,64 @@ uint32_t AlarmHandlingLoop(uint32_t tick) { if (Status == true) //increase counter { - AlarmItem[Alarm_i].DebounceCounter++; - if (AlarmItem[Alarm_i].Status == false) // alarm is not set yet + AlarmState[Alarm_i].DebounceCounter++; + if (AlarmState[Alarm_i].Status == false) // alarm is not set yet { - if (AlarmItem[Alarm_i].DebounceCounter < AlarmItem[Alarm_i].DebounceValue) //had not reached the debounce value + if (AlarmState[Alarm_i].DebounceCounter < AlarmItem[Alarm_i].DebounceValue) //had not reached the debounce value { Status = false; //do not set the alarm } //else alarm will be set } else // alarm is already set { - AlarmItem[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue; // do not go over the debounce value + AlarmState[Alarm_i].DebounceCounter = AlarmItem[Alarm_i].DebounceValue; // do not go over the debounce value } } else //status == false - decrease counter { - AlarmItem[Alarm_i].DebounceCounter--; - if (AlarmItem[Alarm_i].Status == true) // alarm is set + AlarmState[Alarm_i].DebounceCounter--; + if (AlarmState[Alarm_i].Status == true) // alarm is set { - if (AlarmItem[Alarm_i].DebounceCounter > 0) // had not reached zero yet + if (AlarmState[Alarm_i].DebounceCounter > 0) // had not reached zero yet { Status = true; // do not reset the alarm yet } // else reset the alarm } else // if the alarm is off { - AlarmItem[Alarm_i].DebounceCounter = 0; //do not go below 0 + AlarmState[Alarm_i].DebounceCounter = 0; //do not go below 0 } } } if (AlarmItem[Alarm_i].Predecessor!=0xFF) { - if (AlarmItem[AlarmItem[Alarm_i].Predecessor].Status == true) //higher hierarchy alarm is on + if (AlarmState[AlarmItem[Alarm_i].Predecessor].Status == true) //higher hierarchy alarm is on Status = false; } - if (Status != AlarmItem[Alarm_i].Status) //change in alarm Status + if (Status != AlarmState[Alarm_i].Status) //change in alarm Status { if (Status == true) // alarm on { - AlarmItem[Alarm_i].Status = true; + AlarmState[Alarm_i].Status = true; AlarmHandlingConsequentActions(Alarm_i, AlarmItem[Alarm_i].Severity); // report the alarm! - AlarmItem[Alarm_i].EventPtr = my_malloc (sizeof(Event)); - if (AlarmItem[Alarm_i].EventPtr) + AlarmState[Alarm_i].EventPtr = my_malloc (sizeof(Event)); + if (AlarmState[Alarm_i].EventPtr) { - event__init(AlarmItem[Alarm_i].EventPtr); - AlarmItem[Alarm_i].EventPtr->has_type = true; - AlarmItem[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; - AlarmItem[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; + event__init(AlarmState[Alarm_i].EventPtr); + AlarmState[Alarm_i].EventPtr->has_type = true; + AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType; + AlarmState[Alarm_i].EventPtr->message = AlarmItem[Alarm_i].EventName; } Report("Alarm ON ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i); } else // alarm off { - AlarmItem[Alarm_i].Status = false; + AlarmState[Alarm_i].Status = false; AlarmHandlingConsequentActions(Alarm_i, DEBUG_LOG_CATEGORY__Info); // report the alarm! - if (AlarmItem[Alarm_i].EventPtr) - my_free(AlarmItem[Alarm_i].EventPtr); + if (AlarmState[Alarm_i].EventPtr) + my_free(AlarmState[Alarm_i].EventPtr); Report("Alarm OFF ", __FILE__,__LINE__,AlarmItem[Alarm_i].EventType, RpMessage, 0, Alarm_i); } } @@ -625,7 +684,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick) //Motor Status //machine cover open - if (tick%eOneSecond == 0) + if ((tick%eOneSecond == 0)&&(EventsNotificationRequestAccepted==true)) SendEventNotifications(); return OK; } @@ -682,7 +741,7 @@ void SendEventNotifications(void) for (i = 0;i<MAX_SYSTEM_ALARMS;i++) { - if (AlarmItem[i].Status == true) + if (AlarmState[i].Status == true) { response.n_events++; } @@ -692,9 +751,9 @@ void SendEventNotifications(void) { for (i = 0;i<MAX_SYSTEM_ALARMS;i++) { - if (AlarmItem[i].Status == true) + if (AlarmState[i].Status == true) { - response.events[e]=AlarmItem[i].EventPtr; + response.events[e]=AlarmState[i].EventPtr; e++; } } @@ -709,7 +768,8 @@ void SendEventNotifications(void) if (SendChars(container_buffer, container_size) == false) //comm tx mailbox full { - AlarmHandlingToken[0] = 0; + //AlarmHandlingToken[0] = 0; + my_free(container_buffer); } } if (response.events) @@ -729,9 +789,9 @@ uint32_t ResolveEventRequestFunc(MessageContainer* requestContainer) { if (AlarmItem[Alarm_i].EventType == request->type) { - AlarmItem[Alarm_i].Status = false; - if (AlarmItem[Alarm_i].EventPtr) - my_free(AlarmItem[Alarm_i].EventPtr); + AlarmState[Alarm_i].Status = false; + if (AlarmState[Alarm_i].EventPtr) + my_free(AlarmState[Alarm_i].EventPtr); status = OK; break; } @@ -754,7 +814,7 @@ uint32_t StartEventsNotificationRequestFunc(MessageContainer* requestContainer) // ReportInitParams InitParams; //ControlStart(); EventsNotificationRequestAccepted = true; - AlarmHandlingStart(); + //AlarmHandlingStart(); StartEventsNotificationRequest* request = start_events_notification_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data); ustrncpy (AlarmHandlingToken, requestContainer->token,36); diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c index 68bd680a8..64b6ac4e0 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c @@ -90,6 +90,7 @@ MillisecMotorDataStruc SpeedSetPending[NUM_OF_MOTORS] = {0}; MillisecMotorDataStruc PT100Data[MAX_TEMPERATURE_SENSOR_ID] = {0}; /******************** GLOBAL PARAMETERS ********************************************/ Mailbox_Handle MillisecMsgQ = NULL; +Mailbox_Handle TenMillisecMsgQ = NULL; Mailbox_Handle MotorsMsgQ[NUM_OF_MOTORS] = {NULL}; bool MillisecRestart; static GateMutex_Handle gateMillisecDB; @@ -114,6 +115,7 @@ void MillisecInit(void) Error_init(&eb); MillisecMsgQ = Mailbox_create(sizeof(MillisecMessageStruc), 2, NULL,&eb); + TenMillisecMsgQ = Mailbox_create(sizeof(MillisecMessageStruc), 2, NULL,&eb); for (i=0;i<NUM_OF_MOTORS;i++) { MotorsMsgQ[i] = Mailbox_create(sizeof(MillisecMotorDataStruc), 5, NULL,&eb); @@ -158,6 +160,7 @@ void MillisecStart(void) void OneMilliSecondMillisecInterrupt(UArg arg0) { MillisecMessageStruc Message; + uint32_t Tenmsec_millisecondCounter = 0; ROM_IntMasterDisable(); ROM_TimerIntClear(Millisec_timerBase, TIMER_TIMA_TIMEOUT); // Clear the timer interrupt if (MillisecRestart == true) @@ -170,13 +173,26 @@ void OneMilliSecondMillisecInterrupt(UArg arg0) ROM_IntMasterEnable(); return; } + if (msec_millisecondCounter%10 == 0) + { + Tenmsec_millisecondCounter = msec_millisecondCounter; + } //send message to the Millisec task Message.messageId = OneMillisec; - Message.tick = msec_millisecondCounter++;; + Message.tick = msec_millisecondCounter++; Message.msglen = sizeof(MillisecMessageStruc); if (MillisecMsgQ != NULL) Mailbox_post(MillisecMsgQ , &Message, BIOS_NO_WAIT); + if (Tenmsec_millisecondCounter) + { + Message.messageId = OneMillisec; + Message.tick = Tenmsec_millisecondCounter; + Message.msglen = sizeof(MillisecMessageStruc); + if (TenMillisecMsgQ != NULL) + Mailbox_post(TenMillisecMsgQ , &Message, BIOS_NO_WAIT); + } + // // Enable all interrupts. // @@ -341,17 +357,16 @@ int32_t MillisecReadFromMotor(TimerMotors_t MotorId, unsigned long Data, int Len else return false; } -//TEMPERATURE_SENSOR_ID_ENUM Sensor_Read = 0; uint32_t MillisecLoop(uint32_t tick) { - uint8_t Motor_i,Disp_i; + uint8_t Motor_i; TEMPERATURE_SENSOR_ID_ENUM Sensor_i; unsigned int MotorInfo = 0; 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,Tick98,OneMinute_Tick; +/* bool Ten_msTick, Hundred_msTick, Onesecond_Tick,O900Millisecond_Tick,Tick98,OneMinute_Tick; Ten_msTick = (tick%eTenMillisecond == 0) ?true:false; Hundred_msTick = (tick%eHundredMillisecond == 0) ?true:false; O900Millisecond_Tick = (tick%eOneSecond == 900) ?true:false; @@ -360,7 +375,7 @@ uint32_t MillisecLoop(uint32_t tick) Tick98 = (tick%eHundredMillisecond == 99) ?true:false; //gather Motor data from FPGA //ROM_IntMasterDisable(); - +*/ #ifndef EVALUATION_BOARD FPGA_GetBusy(); //load the busy motor information to all motors FPGA_Read_limit_Switches_Registers(); @@ -473,6 +488,26 @@ uint32_t MillisecLoop(uint32_t tick) Dancer_Data[FEEDER_DANCER] = Read_Dancer_Position(FEEDER_DANCER); Dancer_Data[POOLER_DANCER] = Read_Dancer_Position(POOLER_DANCER); Dancer_Data[WINDER_DANCER] = Read_Dancer_Position(WINDER_DANCER); + return OK; +} +uint32_t MillisecLowLoop(uint32_t tick) +{ + uint8_t Disp_i; + 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,Tick98,OneMinute_Tick; + Ten_msTick = (tick%eTenMillisecond == 0) ?true:false; + Hundred_msTick = (tick%eHundredMillisecond == 0) ?true:false; + O900Millisecond_Tick = (tick%eOneSecond == 900) ?true:false; + Onesecond_Tick = (tick%eOneSecond == 0) ?true:false; + OneMinute_Tick = (tick%eOneMinute == 0) ?true:false; + //gather Motor data from FPGA + //ROM_IntMasterDisable(); + if (Ten_msTick) { //Speed_Data = Calculate_Speed_Sensor_Velocity(); @@ -501,7 +536,7 @@ uint32_t MillisecLoop(uint32_t tick) for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++) { CalculateDispenserPressure(Disp_i); - Read_MidTank_Pressure_Sensor(Disp_i); + //Read_MidTank_Pressure_Sensor(Disp_i); } FPGA_GetAllDispensersValveBusyOCD(); DrawerFansStatus = Read_Fans_Tacho(); @@ -509,10 +544,10 @@ uint32_t MillisecLoop(uint32_t tick) } if (OneMinute_Tick) { - for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++) - { - Read_MidTank_Pressure_Sensor(Disp_i); - } +// for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++) +// { +// Read_MidTank_Pressure_Sensor(Disp_i); +// } /* for (Motor_i = 0;Motor_i < NUM_OF_MOTORS;Motor_i++) { if (Motor_i == HARDWARE_MOTOR_TYPE__MOTO_SCREW) @@ -553,6 +588,33 @@ void MillisecTask(UArg arg0, UArg arg1) } } } +/****************************************************************************** + * ======== messageTsk ======== + * Task for this function is created statically. See the project's .cfg file. + * this message task is created statically in system initialization, + ******************************************************************************/ +void MillisecLowTask(UArg arg0, UArg arg1) +{ + MillisecMessageStruc Message; + //char str[60]; + //uint16_t length; + //Clock_setTimeout(HostKAClock, 1000); + //Clock_start(HostKAClock); + //MillisecInit(); + //Millisecond_Task_Handle = Task_self(); + while(1) + { + Mailbox_pend(TenMillisecMsgQ , &Message, BIOS_WAIT_FOREVER); + switch (Message.messageId) + { + case OneMillisec: + MillisecLowLoop(Message.tick); + break; + default: + break; + } + } +} /*uint32_t getMotorStatusData(int MotorId) diff --git a/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c b/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c index 72774461a..f9aee7929 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/PIDAlgo.c @@ -52,8 +52,6 @@ float AdvancedPIDAlgorithmCalculation(float _setPoint,float _mesuredParam , PID_ } derivative = (error - *_pre_error)/params->dt; - float IntegralErrorMultiplier; - float ProportionalErrorMultiplier; output = params->Kp*error/params->ProportionalErrorMultiplier + params->Ki**_integral/params->IntegralErrorMultiplier + params->Kd*derivative; diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.c b/Software/Embedded_SW/Embedded/Modules/Control/control.c index 2110029e4..001cafeb3 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.c +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.c @@ -65,10 +65,11 @@ typedef struct uint32_t PartId; // the identity of the inspected/controlled part in the Devices enum. bool ControlActive; uint32_t Parameter1; - uint32_t IfIndex; + uint16_t IfIndex; + uint32_t StartTick; DataReadCBFunction ControlDataReadPtr; ControlCBFunction ControlCallbackPtr; - CTRL_TIMING_ENUM ControlTiming; + uint16_t ControlTiming; }ControlDeviceStruc; typedef enum @@ -87,6 +88,7 @@ int ControlPhaseDelay = 300; //the control task enters only after data gathering //this parameters defines how many microseconds in the delay. it is used only on starting the control loop on the first time /******************** GLOBAL PARAMETERS ********************************************/ Mailbox_Handle ControlMsgQ = NULL; +Mailbox_Handle TenControlMsgQ = NULL; bool ControlRestart; static GateMutex_Handle gateControlDB; Task_Handle Control_Task_Handle; @@ -114,7 +116,8 @@ void ControlInit(void) Error_Block eb; //Mailbox_Params_init(&ControlMsgQ); - ControlMsgQ = Mailbox_create(sizeof(ControlMessageStruc), 20, NULL,NULL); + ControlMsgQ = Mailbox_create(sizeof(ControlMessageStruc), 1, NULL,NULL); + TenControlMsgQ = Mailbox_create(sizeof(ControlMessageStruc), 1, NULL,NULL); ControlRestart = false; @@ -195,7 +198,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, uint32_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ) +uint32_t AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ) { assert(Callback); assert(DriverfPtr); @@ -220,6 +223,7 @@ uint32_t AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlF ControlArray[deviceId].ControlDataReadPtr = DriverfPtr; ControlArray[deviceId].Parameter1 = Parameter1; ControlArray[deviceId].IfIndex = IfIndex; + ControlArray[deviceId].StartTick = millisecondCounter; GateMutex_leave(gateControlDB, key); //LOG_ERROR(deviceId, "Add Callback"); @@ -258,6 +262,8 @@ uint32_t millisecondCounter = 0; void OneMilliSecondControlInterrupt(UArg arg0) { ControlMessageStruc Message; + uint32_t TenmillisecondCounter = 0; + ROM_IntMasterDisable(); ROM_TimerIntClear(Control_timerBase, TIMER_TIMA_TIMEOUT); // Clear the timer interrupt @@ -272,6 +278,10 @@ void OneMilliSecondControlInterrupt(UArg arg0) //ROM_TimerDisable(Control_timerBase, TIMER_A); return; } + if (millisecondCounter%10 == 0) + { + TenmillisecondCounter = millisecondCounter; + } //send message to the control task Message.messageId = OneMillisec; @@ -279,6 +289,12 @@ void OneMilliSecondControlInterrupt(UArg arg0) Message.msglen = sizeof(ControlMessageStruc); if (ControlMsgQ != NULL) Mailbox_post(ControlMsgQ , &Message, BIOS_NO_WAIT); + //if (TenmillisecondCounter) + { + //Message.tick = TenmillisecondCounter; + if (TenControlMsgQ != NULL) + Mailbox_post(TenControlMsgQ , &Message, BIOS_NO_WAIT); + } if (millisecondCounter == 1000000000) millisecondCounter = 0; // @@ -294,7 +310,7 @@ uint32_t ControlLoop(uint32_t tick) //test dancers and speed encoders //check all callback units (state machine waiting for completion of a change) uint32_t Device_i; - bool Ten_msTick, Hundred_msTick, Onesecond_Tick,Tick98,Tick998; + /*bool Ten_msTick, Hundred_msTick, Onesecond_Tick,Tick98,Tick998; Ten_msTick = (tick%eTenMillisecond == 0) ?true:false; Hundred_msTick = (tick%eHundredMillisecond == 0) ?true:false; // Hundred_msTick = (tick%200 == 0) ?true:false; @@ -302,7 +318,7 @@ uint32_t ControlLoop(uint32_t tick) Tick98 = (tick%eHundredMillisecond == 98) ?true:false; // Tick98 = (tick%200 == 199) ?true:false; Tick998 = (tick%eOneSecond == 996) ?true:false; - +*/ //ROM_IntMasterDisable(); for (Device_i = 0; Device_i < MAX_TANGO_CONTROL_DEVICES;Device_i++) { @@ -323,6 +339,58 @@ uint32_t ControlLoop(uint32_t tick) else LOG_ERROR (Device_i, "Invalid callback ptr"); break; + default: + break; + } //switch + } //if control active + } //for + //ROM_IntMasterEnable(); + + return OK; +} +uint32_t ControlLowLoop(uint32_t tick) +{ + //call all modules control functions + //test dancers and speed encoders + //check all callback units (state machine waiting for completion of a change) + uint32_t Device_i; + bool Ten_msTick, Hundred_msTick, Onesecond_Tick,Tick98,Tick998; + Ten_msTick = (tick%eTenMillisecond == 0) ?true:false; + Hundred_msTick = (tick%eHundredMillisecond == 0) ?true:false; + Onesecond_Tick = (tick%eOneSecond == 0) ?true:false; + Tick98 = (tick%eHundredMillisecond == 98) ?true:false; + Tick998 = (tick%eOneSecond == 996) ?true:false; + + //ROM_IntMasterDisable(); + for (Device_i = 0; Device_i < MAX_TANGO_CONTROL_DEVICES;Device_i++) + { + if (ControlArray[Device_i].ControlActive) + { + if (tick == ControlArray[Device_i].StartTick) + continue; + if (((tick - ControlArray[Device_i].StartTick)%ControlArray[Device_i].ControlTiming)==0) // run the control on exact intervals + { + ControlBacklog[backlogindex]=Device_i; + if ( ++backlogindex >= 999) + backlogindex = 0; + + if(ControlArray[Device_i].ControlDataReadPtr) + ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1); + else + LOG_ERROR (Device_i, "Invalid callback ptr"); + if(ControlArray[Device_i].ControlCallbackPtr) + ControlArray[Device_i].ControlCallbackPtr(ControlArray[Device_i].IfIndex, ControlDatalog[Device_i]); + else + LOG_ERROR (Device_i, "Invalid callback ptr"); + } + /* + ControlBacklog[backlogindex]=Device_i; + if ( ++backlogindex >= 999) + backlogindex = 0; + switch (ControlArray[Device_i].ControlTiming) + { + case eOneMillisecond: + break; case eTenMillisecond: if (Ten_msTick) { @@ -374,9 +442,21 @@ uint32_t ControlLoop(uint32_t tick) memset (&ControlArray[Device_i],0,sizeof(ControlDeviceStruc) ); break; default: - LOG_ERROR (ControlArray[Device_i].ControlTiming, "Invalid control timing value"); + //LOG_ERROR(tick, "Default Timing checked"); + if (tick%ControlArray[Device_i].ControlTiming == 0) + { + Report("Default Timing checked",__FILE__,__LINE__,tick,RpWarning,ControlArray[Device_i].ControlTiming,0); + if(ControlArray[Device_i].ControlDataReadPtr) + ControlDatalog[Device_i] = ControlArray[Device_i].ControlDataReadPtr( ControlArray[Device_i].Parameter1); + else + LOG_ERROR (Device_i, "Invalid callback ptr"); + if(ControlArray[Device_i].ControlCallbackPtr) + ControlArray[Device_i].ControlCallbackPtr(ControlArray[Device_i].IfIndex, ControlDatalog[Device_i]); + else + LOG_ERROR (Device_i, "Invalid callback ptr"); + } break; - } //switch + } //switch*/ } //if control active } //for //ROM_IntMasterEnable(); @@ -410,3 +490,30 @@ void controlTask(UArg arg0, UArg arg1) } } } +/****************************************************************************** + * ======== messageTsk ======== + * Task for this function is created statically. See the project's .cfg file. + * this message task is created statically in system initialization, + ******************************************************************************/ +void controlLowTask(UArg arg0, UArg arg1) +{ + ControlMessageStruc Message; + //char str[60]; + //uint16_t length; + //Clock_setTimeout(HostKAClock, 1000); + //Clock_start(HostKAClock); + Control_Task_Handle = Task_self(); + + while(1) + { + Mailbox_pend(TenControlMsgQ , &Message, BIOS_WAIT_FOREVER); + switch (Message.messageId) + { + case OneMillisec: + ControlLowLoop(Message.tick); + break; + default: + break; + } + } +} diff --git a/Software/Embedded_SW/Embedded/Modules/Control/control.h b/Software/Embedded_SW/Embedded/Modules/Control/control.h index 0aba4b4ba..b3e574d2a 100644 --- a/Software/Embedded_SW/Embedded/Modules/Control/control.h +++ b/Software/Embedded_SW/Embedded/Modules/Control/control.h @@ -37,10 +37,11 @@ typedef enum void ControlInit(void); void ControlStop(void); void ControlStart(void); -uint32_t AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint32_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ); +uint32_t AddControlCallback( ControlCBFunction Callback, CTRL_TIMING_ENUM CtrlFrequency, DataReadCBFunction DriverfPtr, uint16_t IfIndex, uint32_t Parameter1, uint32_t Parameter2 ); int RemoveControlCallback(uint32_t deviceId, ControlCBFunction Callback ); uint32_t TemplateDataReadCBFunction (uint32_t deviceId, uint32_t Parameter1); extern Task_Handle Control_Task_Handle; +extern uint32_t millisecondCounter; #endif diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c index 20fce7cf6..2a0d88c7f 100644 --- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c +++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c @@ -57,8 +57,8 @@ uint32_t Diagnostics_TenMiliControlTrigger(uint32_t IfIndex, uint32_t ReadValue) DiagnosticsMonitors DiagnosticsMonitor = DIAGNOSTICS_MONITORS__INIT; -#define DIAGNOSTICS_LIMIT 5 -#define DIAGNOSTICS_DANCER_LIMIT 50 +#define DIAGNOSTICS_LIMIT 3 +#define DIAGNOSTICS_DANCER_LIMIT 30 int DiagnosticsIndex = 0; int DiagnosticCollectionLimit = 2; //number of data samples to collect before sending to the host //int DiagnosticLimit = eHundredMillisecond; //frequency of data collection @@ -90,7 +90,7 @@ double dryerzone3temperature[DIAGNOSTICS_LIMIT]; double dispensermotorfrequency[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT]; double dispenserspressure[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT]; -double MidTankpressure[MAX_SYSTEM_DISPENSERS][DIAGNOSTICS_LIMIT]; +double MidTankpressure[MAX_SYSTEM_DISPENSERS][1]; DoubleArray DispenserFreq[MAX_SYSTEM_DISPENSERS]; DoubleArray DiagnosticsDispenserPressure[MAX_SYSTEM_DISPENSERS]; @@ -198,7 +198,6 @@ void DiagnosticLoadMotor(int MotorId, int frequency) } void DiagnosticsLoadDigitalValues(void) { - int i; DigitalOutputState[0].interfaceio = INTERFACE_IOS__GPO_DRYER_SSR3_CTRL; DigitalOutputState[0].value = GetHeaterState(0); @@ -367,7 +366,7 @@ void Diagnostic100msecCollection(void) { dispensermotorfrequency[i][DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1+i); dispenserspressure[i][DiagnosticsIndex] = GetDispenserPressure(i); //Read_MidTank_Pressure_Sensor - MidTankpressure[i][DiagnosticsIndex] = Get_MidTank_Pressure_Sensor(i); + MidTankpressure[i][0] = Get_MidTank_Pressure_Sensor(i); } /* dispenser1motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1); dispenser2motorfrequency[DiagnosticsIndex] = MotorGetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_2); @@ -554,6 +553,23 @@ void SendDiagnostics(void) DiagnosticsMonitor.n_dispenser8pressure = DiagnosticsIndex; DiagnosticsMonitor.dispenser8pressure = dispenserspressure[7]; + + DiagnosticsMonitor.n_midtank1level = 1; + DiagnosticsMonitor.midtank1level = MidTankpressure[0]; + DiagnosticsMonitor.n_midtank2level = 1; + DiagnosticsMonitor.midtank2level = MidTankpressure[1]; + DiagnosticsMonitor.n_midtank3level = 1; + DiagnosticsMonitor.midtank3level = MidTankpressure[2]; + DiagnosticsMonitor.n_midtank4level = 1; + DiagnosticsMonitor.midtank4level = MidTankpressure[3]; + DiagnosticsMonitor.n_midtank5level = 1; + DiagnosticsMonitor.midtank5level = MidTankpressure[4]; + DiagnosticsMonitor.n_midtank6level = 1; + DiagnosticsMonitor.midtank6level = MidTankpressure[5]; + DiagnosticsMonitor.n_midtank7level = 1; + DiagnosticsMonitor.midtank7level = MidTankpressure[6]; + DiagnosticsMonitor.n_midtank8level = 1; + DiagnosticsMonitor.midtank8level = MidTankpressure[7]; response.monitors = &DiagnosticsMonitor; //response.digitalpins = DigitalPinArray; response.n_componentsstates = 0; @@ -584,6 +600,7 @@ void SendDiagnostics(void) if (SendChars(diagnosticscontainer_buffer, container_size) == false) //comm tx mailbox full { DiagnosticsStop(); + my_free(diagnosticscontainer_buffer); } /*else { @@ -607,6 +624,11 @@ void SendDiagnostics(void) } my_free(diagnosticsresponseContainer.data.data); } + else + { + LOG_ERROR(Task_self(),"my_malloc failed"); + DiagnosticsStop(); + } DiagnosticsReset(); } uint32_t DiagnosticsControlId = 0xff; diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c index 4ad9af903..f2618e65f 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c +++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c @@ -131,7 +131,6 @@ uint32_t HWConfiguration(UploadHardwareConfigurationRequest* UploadRequest) uint32_t HWConfigurationFunc(MessageContainer* requestContainer) { uint32_t status = 0; - int Motor_i, Dancer_i, Dispenser_i,PID_i; MessageContainer responseContainer; UploadHardwareConfigurationResponse response = UPLOAD_HARDWARE_CONFIGURATION_RESPONSE__INIT; diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c index 96248ab8b..a918f6574 100644 --- a/Software/Embedded_SW/Embedded/Modules/General/process.c +++ b/Software/Embedded_SW/Embedded/Modules/General/process.c @@ -15,6 +15,10 @@ #include "PMR/Printing/UploadProcessParametersResponse.pb-c.h" #include "PMR/Hardware/HardwarePidControlType.pb-c.h" #include "PMR/common/MessageContainer.pb-c.h" +#include "drivers/Valves/Valve.h" +#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h" +#include "modules/ids/ids_ex.h" + double dyeingspeed = 0; double dryerbufferlength = 0; @@ -33,6 +37,8 @@ ProcessParameters ProcessParametersKeep; uint32_t HandleProcessParameters(ProcessParameters* ProcessParams) { uint32_t status = 0; + int Disp_i; + if (ProcessParams->dryerzone1temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER; if (ProcessParams->dryerzone2temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER; if (ProcessParams->dryerzone3temp > MAX_ALLOWED_TEMPERATURE) status = ERROR_CODE__INVALID_PARAMETER; @@ -139,6 +145,12 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams) headairflow = ProcessParams->headairflow; dryerairflow = ProcessParams->dryerairflow; + for (Disp_i = 0;Disp_i < MAX_SYSTEM_DISPENSERS;Disp_i++) + { + Valve_Set(IDS_Id_to_AirValve[Disp_i], Atm_MidTank_ON ); //Atm_MidTank_OFF/ON + Read_MidTank_Pressure_Sensor(Disp_i); + Valve_Set(IDS_Id_to_AirValve[Disp_i], Atm_MidTank_OFF ); //Atm_MidTank_OFF/ON + } return status;//status; } diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h index 975635342..601f5ce31 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h @@ -26,9 +26,9 @@ typedef struct HeaterPIDControlConfigstruc float outputproportionalband; //int32_t sensorcorrectionadjustment; //int32_t sensortypeandsetpointlimits; - //int32_t setpointramprateorsoftstartramp; + int32_t setpointramprateorsoftstartramp; //int32_t setpointcontroloutputrate; - //int32_t outputonoffhysteresisvalues; + int32_t outputonoffhysteresisvalue; //int32_t processvariablesamplingrate; //int32_t pvinputfilterfactormode; int32_t sensormaxvalue; @@ -54,7 +54,6 @@ extern HeaterCommand HeaterCmd[MAX_HEATERS_NUM]; extern uint32_t Heater_timerBase; uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_outputproportionalpowerlimit); -void HeatingTestSendResonse(uint32_t status, bool last,bool heater1Active,bool heater2Active, int temperature1, int temperature2,int Heater1Percentage,int Heater2Percentage, char* Message); uint32_t HeaterRecalculateHeaterParams(uint32_t deviceId, uint32_t new_outputproportionalpowerlimit); uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h index e5c12f7b0..482d081b0 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h @@ -20,5 +20,7 @@ bool HeaterGetOverTemperatureState(uint8_t HeaterId); void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState); +uint32_t LoadHeaterSetPoint(HeaterType HeaterType); + uint32_t HeatersEnd(void); uint32_t Heaters_Init(void); diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c index 169ae463e..4de0d8894 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c @@ -137,6 +137,8 @@ uint32_t HeaterConfigRequestMessage(HardwarePidControl* request) HeaterControl[HeaterId].id = HeaterId; HeaterControl[HeaterId].outputproportionalpowerlimit = request->outputproportionalpowerlimit; HeaterControl[HeaterId].outputproportionalband = request->outputproportionalband; + HeaterControl[HeaterId].setpointramprateorsoftstartramp = request->setpointramprateorsoftstartramp; + HeaterControl[HeaterId].outputonoffhysteresisvalue = request->outputonoffhysteresisvalue; if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) { HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].sensormaxvalue = request->sensormaxvalue; diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c index e12ede228..a985c7570 100644 --- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c @@ -85,6 +85,7 @@ Mailbox_Handle HeatersControlMsgQ = NULL; bool InitialHeating = true; bool DCInitialHeating[MAX_HEATERS_NUM] = {true}; bool HeaterReady[MAX_HEATERS_NUM] = {true}; +uint32_t HeaterPreviousRead[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters /******************** FUNCTIONS ********************************************/ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue); @@ -93,6 +94,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue); uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue); void HeatersStartControlTimer (void); + //********************************************************************** //******************** CODE *******************************************/ //********************************************************************** @@ -113,6 +115,9 @@ void HeatersControlInit(void) { DCInitialHeating[i] = true; HeaterReady[i] = true; + HeaterCmd[i].targettemperatue = 0; + HeaterCmd[i].command = HEATER_OFF; + HeaterCmd[i].heaterid = i; } HeatersRestart = false; @@ -138,9 +143,22 @@ void HeatersControlStart(void) HeatersStartControlTimer(); } } +uint32_t LoadHeaterSetPoint(HeaterType HeaterType) +{ + if (HeaterType >= MAX_HEATERS_NUM) + { + LOG_ERROR(HeaterType,"Wrong Heater Id"); + return 0; + } + return HeaterCmd[HeaterType].targettemperatue; +} void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState) { int HeaterId = HeaterType; + //double temp = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]); + double temp = HeaterPreviousRead[HeaterId];//TemperatureSensorRead(HeaterId2PT100Id[HeaterId]); + + HeaterState->has_heatertype = true; HeaterState->heatertype = HeaterType; @@ -149,14 +167,18 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState) // if (HeaterType >= HEATER_TYPE__HeaterZone1) HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse; HeaterState->has_currentvalue = true; - HeaterState->currentvalue = TemperatureSensorRead(HeaterId2PT100Id[HeaterId])/100; + HeaterState->currentvalue = temp/100;//TemperatureSensorRead(HeaterId2PT100Id[HeaterId])/100; HeaterState->has_isactive = true; HeaterState->isactive = GetHeaterState(HeaterId); HeaterState->has_isrampingup = true; HeaterState->isrampingup = DCInitialHeating[HeaterId]; HeaterState->has_isinsetpoint = true; HeaterState->isinsetpoint = HeaterReady[HeaterId]; - + if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) + { + HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit; + HeaterState->isrampingup = InitialHeating; + } return; } uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId) @@ -314,6 +336,7 @@ uint32_t HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature) */ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) { + CTRL_TIMING_ENUM Frequency = eHundredMillisecond; if(HeaterId >= MAX_HEATERS_NUM) { LOG_ERROR (HeaterId,"HeaterId too high"); @@ -332,6 +355,8 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) HeaterPIDConfig[HeaterId].m_params.Kd = HeaterControl[HeaterId].kd; HeaterPIDConfig[HeaterId].m_params.Kp = HeaterControl[HeaterId].kp; HeaterPIDConfig[HeaterId].m_params.Ki = HeaterControl[HeaterId].ki; + HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier = HeaterControl[HeaterId].setpointramprateorsoftstartramp; + HeaterPIDConfig[HeaterId].m_params.ProportionalErrorMultiplier = HeaterControl[HeaterId].outputonoffhysteresisvalue; HeaterPIDConfig[HeaterId].m_params.dt = HeaterControl[HeaterId].dt; HeaterPIDConfig[HeaterId].m_params.epsilon = HeaterControl[HeaterId].epsilon; //0.1 degree HeaterPIDConfig[HeaterId].m_calculatedError = 0; @@ -341,20 +366,29 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue) HeaterPIDConfig[HeaterId].m_mesuredParam = 0; HeaterPIDConfig[HeaterId].m_preError = 0; HeaterPIDConfig[HeaterId].m_SetParam = SetTemperatue*100;//need to update SetParams on presegment stage + + if (HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier) + { + Frequency = eOneSecond*HeaterPIDConfig[HeaterId].m_params.dt; + } if (HeaterId >= MAX_AC_HEATERS) //DC Heaters { if (ControlIdtoHeaterId [HeaterId] == 0xFF) - ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); + ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0); HeaterPIDConfig[HeaterId].m_params.dt *=10; DCInitialHeating[HeaterId] = true; HeaterReady[HeaterId] = false; + HeaterPreviousRead[HeaterId] = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]); } else if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters { if (ControlIdtoHeaterId [HeaterId] == 0xFF) { - ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0); + ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond/*eHundredMillisecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0); HeaterPIDConfig[HeaterId].m_params.dt *=10; + HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id); + HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]); + HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]); } if (MainDryerHeaterMaxTempControl == 0xFF) MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0); @@ -437,6 +471,12 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) LOG_ERROR (IfIndex, "Wrong Interface "); return 0xFFFFFFFF; } + if (abs(readValue - HeaterPreviousRead[index])>2000) + { + Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index); + return ERROR; + } + HeaterPreviousRead[index] = readValue; if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain) { MainPT100Read = readValue; @@ -449,7 +489,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) { if (HeaterMaxTempFlag[index] == false) { - LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off"); + // LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off"); } DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain); HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = true; @@ -468,7 +508,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue) { ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); } - LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on"); + // LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on"); } HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false; HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = false; @@ -499,6 +539,13 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) //LOG_ERROR (0, "unconfigured"); return ERROR; } + if (abs(readValue - HeaterPreviousRead[index])>2000) + { + Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index); + return ERROR; + } + HeaterPreviousRead[index] = readValue; + // check if the read value is within the proportional band if (InitialHeating) { @@ -521,6 +568,14 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary); HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0); HeatersControlStart(); + //HeaterReady[index] = true; + //HeaterPrepareReady(); + } + } + if (HeaterReady[index]==false) + { + if ((readValue > (HeaterCmd[index].targettemperatue * 995/1000))&&(readValue < (HeaterCmd[index].targettemperatue * 1005/1000)))//read value within 0.5 percent from target + { HeaterReady[index] = true; HeaterPrepareReady(); if (BlowerCfg.enabled == true) @@ -550,13 +605,20 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) } else //PID active { - //check only for the proportional band limits - HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, - &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); - len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError); + if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0) + { + HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } + else + { + HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } +// len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError); // Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index, Counter[index]); // #warning PID is now only proportional (above) - Report(ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue, HeaterPIDConfig[index].m_calculatedError); +// Report(ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue, HeaterPIDConfig[index].m_calculatedError); HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, (int)(HeaterPIDConfig[index].m_calculatedError/100)); } } @@ -598,11 +660,12 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) //LOG_ERROR (index, "unconfigured"); return ERROR; } -/* - HeatingTestSendResonse(0, false,GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary), - Temperature[0],Temperature[1], - HeaterPIDConfig[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].m_calculatedError, HeaterPIDConfig[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].m_calculatedError,"Standard"); -*/ + if (abs(readValue - HeaterPreviousRead[index])>2000) + { + Report("Temperature Spike",__FILE__,__LINE__,HeaterPreviousRead[index],RpWarning,readValue, index); + return ERROR; + } + HeaterPreviousRead[index] = readValue; // check if the read value is within the proportional band if (DCInitialHeating[index]==true) { @@ -625,10 +688,19 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) { DCInitialHeating[index] = false; HeatersControlStart(); + //HeaterReady[index] = true; + //HeaterPrepareReady(); + } + } + if (HeaterReady[index]==false) + { + if ((readValue > (HeaterCmd[index].targettemperatue * 998/1000))&&(readValue < (HeaterCmd[index].targettemperatue * 1002/1000)))//read value within 0.5 percent from target + { HeaterReady[index] = true; HeaterPrepareReady(); } } + if(HeaterPIDConfig[index].m_isEnabled && (HeaterPIDConfig[index].m_SetParam != 0)) { if (HeaterControl[index].pidactive == false) @@ -647,8 +719,16 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) { //check only for the proportional band limits HeaterPIDConfig[index].m_mesuredParam = readValue; - HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0) + { + HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, + &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } + else + { + HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam, &HeaterPIDConfig[index].m_params, &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral); + } // error[index][Counter[index]] = HeaterPIDConfig[index].m_preError; // integral[index][Counter[index]] = HeaterPIDConfig[index].m_integral; // output[index][Counter[index]] = HeaterPIDConfig[index].m_calculatedError; @@ -658,8 +738,8 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue) // #warning PID is now only proportional (above) if (index == HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2) { - len = usnprintf(heatstr, 254, "PID id, Temp, Integral, Output { %d, %d ,%d, %d}",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError); - Report(heatstr,__FILE__,__LINE__,index,RpWarning,HeaterPIDConfig[index].m_calculatedError,0); + // len = usnprintf(heatstr, 254, "PID id, Temp, Integral, Output { %d, %d ,%d, %d}",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError); + // Report(heatstr,__FILE__,__LINE__,index,RpWarning,HeaterPIDConfig[index].m_calculatedError,0); } HeaterRecalculateHeaterParams(index, (int)(HeaterPIDConfig[index].m_calculatedError/100)); @@ -755,7 +835,7 @@ uint32_t HeatersControlLoop(uint32_t tick) } for ( DcHeaterId = HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1; DcHeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;DcHeaterId++) { - if (HeaterReady[DcHeaterId] == false) + if (DCInitialHeating[DcHeaterId] == true) continue; if (DCTimeSliceAllocation[DcHeaterId] > 0) //heater active { diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h index 7c25fed89..1e15cc1c2 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_ex.h @@ -43,6 +43,7 @@ uint32_t IDS_DispenserPidRequestMessage(HardwarePidControl* request); uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback); uint32_t IDS_StopHomeDispenser (uint32_t deviceID); uint32_t IDS_EmptyDispenser (uint32_t deviceID, uint32_t speed , callback_fptr callback); +uint32_t IDS_StopDispenser (uint8_t deviceID); uint32_t IDS_CheckDispenserLimitSwitch (LimitSwitchAlarms LS_Id); diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c index e4d4c7b9c..bf03b42de 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_maint.c @@ -104,6 +104,16 @@ uint32_t IDS_HomeDispenser (uint32_t deviceID, uint32_t speed , callback_fptr ca } return ERROR; } +uint32_t IDS_StopDispenser (uint8_t deviceID) +{ + uint32_t status = OK; + TimerMotors_t MotorId = HARDWARE_MOTOR_TYPE__MOTO_DISPENSER_1 + deviceID; + status |= MotorAbortMovetoLimitSwitch(MotorId); + Valve_Set(IDS_Id_to_AirValve[deviceID], Atm_MidTank_OFF); + status |= MotorSetMicroStep(deviceID, MotorsCfg[deviceID].microstep); + status |= MotorStop(deviceID, Hard_Hiz); + return status; +} uint32_t IDS_StopHomeDispenser (uint32_t deviceID) { diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c index 62a534a1c..346ee0246 100644 --- a/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c +++ b/Software/Embedded_SW/Embedded/Modules/IDS/IDS_print.c @@ -40,6 +40,8 @@ HardwarePidControlType ThreadDispenserIdToControlId[MAX_SYSTEM_DISPENSERS] = { bool DispenserReady[MAX_SYSTEM_DISPENSERS] = {true}; 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); /******************** GLOBAL PARAMETERS ********************************************/ DispenserControlConfig_t DispenserControlConfig[MAX_SYSTEM_DISPENSERS]; uint32_t ControlIdtoDispenserId [MAX_SYSTEM_DISPENSERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF}; @@ -187,8 +189,9 @@ bool IDS_isDispenserUsedNextSegment(void *JobDetails,int DispenserId, int Segmen { TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; MotorStop(HW_Motor_Id,Hard_Hiz); - REPORT_MSG(deviceID,"Dispenser PreSegment called"); + //REPORT_MSG(deviceID,"Dispenser PreSegment called"); IDS_Valve_PresegmentReady( deviceID, ReadValue); + return OK; } //******************************************************************************************************************** uint32_t IDS_Valve_PresegmentReady(uint32_t deviceID, uint32_t ReadValue) @@ -251,7 +254,7 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) //prepare the SW structures DispenserId = JobTicket->segments[SegmentId]->brushstops[JobBrushStopId]->dispensers[Dispenser_i]->index; DispenserPreSegmentReady[DispenserId] = false; - REPORT_MSG(DispenserId,"Dispenser PreSegment Start"); + //REPORT_MSG(DispenserId,"Dispenser PreSegment Start"); } for (Dispenser_i = 0;Dispenser_i < n_dispensers;Dispenser_i++) { @@ -376,9 +379,10 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) { TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; MotorStop(HW_Motor_Id,Hard_Hiz); - REPORT_MSG(deviceID,"Dispenser DTS called"); + //REPORT_MSG(deviceID,"Dispenser DTS called"); IDS_Valve_DistanceToSpoolReady( deviceID, ReadValue); - } + return OK; +} //******************************************************************************************************************** uint32_t IDS_Valve_DistanceToSpoolReady(uint32_t deviceID, uint32_t ReadValue) @@ -419,8 +423,9 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) uint32_t IDS_Valve_EndValveReady(uint32_t deviceID, uint32_t ReadValue) { TimerMotors_t HW_Motor_Id = DispenserIdToMotorId[deviceID]; - REPORT_MSG(deviceID,"Dispenser End called"); + //REPORT_MSG(deviceID,"Dispenser End called"); MotorStop(HW_Motor_Id,Hard_Hiz); + return OK; } //******************************************************************************************************************** uint32_t IDSEndState(void *JobDetails) @@ -428,10 +433,10 @@ uint32_t IDSPreSegmentState(void *JobDetails, int SegmentId) int Dispenser_i; IDS_Active = false; Valve_Set(VALVE_MIXCHIP_WASTECH, Mixer_Waste); + REPORT_MSG(0,"Dispenser End Start"); for ( Dispenser_i = 0;Dispenser_i < MAX_SYSTEM_DISPENSERS;Dispenser_i++) { //MotorStop(DispenserIdToMotorId[Dispenser_i],Hard_Hiz); - REPORT_MSG(Dispenser_i,"Dispenser End Start"); Control3WayValvesWithCallback (Dispenser_i, MidTank_Dispenser, IDS_Valve_EndValveReady); //direction: MidTank_Dispenser or Dispenser_Mixer } diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/MixerHandler.c b/Software/Embedded_SW/Embedded/Modules/IDS/MixerHandler.c deleted file mode 100644 index ce423ab72..000000000 --- a/Software/Embedded_SW/Embedded/Modules/IDS/MixerHandler.c +++ /dev/null @@ -1,37 +0,0 @@ -/* - * MixerHandle.c - * - * Created on: 26 áôáø× 2018 - * Author: shlomo - */ - -#ifndef MODULES_IDS_MIXERHANDLER_C_ -#define MODULES_IDS_MIXERHANDLER_C_ -#include "include.h" -#include "MixerHandler.h" -typedef enum -{ - MixerStateNone, - MixerStateHead, - MixerStateWaste -}MIXER_STATE_ENUM; - -MIXER_STATE_ENUM MixerState = MixerStateNone; - -uint32_t MixerHandlerSwitchToWaste(void) -{ - return OK; - -} -uint32_t MixerHandlerSwitchToHead(void) -{ - return OK; -} -uint32_t MixerHandlerGetState(void) -{ - return MixerState; -} - - - -#endif /* MODULES_IDS_MIXERHANDLER_C_ */ diff --git a/Software/Embedded_SW/Embedded/Modules/IDS/MixerHandler.h b/Software/Embedded_SW/Embedded/Modules/IDS/MixerHandler.h deleted file mode 100644 index 51093e1b7..000000000 --- a/Software/Embedded_SW/Embedded/Modules/IDS/MixerHandler.h +++ /dev/null @@ -1,17 +0,0 @@ -/* - * MixerHandle.h - * - * Created on: 26 áôáø× 2018 - * Author: shlomo - */ - -#ifndef MODULES_IDS_MIXERHANDLER_H_ -#define MODULES_IDS_MIXERHANDLER_H_ - -extern uint32_t MixerHandlerSwitchToWaste(void); -extern uint32_t MixerHandlerSwitchToHead(void); -extern uint32_t MixerHandlerGetState(void); - - - -#endif /* MODULES_IDS_MIXERHANDLER_H_ */ diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c index 2009943b0..fed1311bd 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_Winder.c @@ -124,7 +124,7 @@ uint32_t Winder_PrepareStage2(uint32_t deviceID, uint32_t ReadValue) //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,InternalWinderCfg.segmentoffsetpulses); //REPORT_MSG(numOfSteps, "Winder_PrepareStage2"); - REPORT_MSG(MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency, "Winder_PrepareStage2"); + REPORT_MSG(millisecondCounter/*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].maxfrequency*/, "Winder_PrepareStage2"); status |= MotorMoveWithCallback(HARDWARE_MOTOR_TYPE__MOTO_SCREW, (1-MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].directionthreadwize),numOfSteps, Winder_ScrewAtOffsetCallback); //set motor location 0 here @@ -141,7 +141,7 @@ uint32_t Winder_ScrewAtOffsetCallback(uint32_t deviceID, uint32_t BusyFlag) ScrewSpeed = 0; ScrewControlId = 0xFF; ScrewNumberOfSteps = 0; - REPORT_MSG(BusyFlag, "Winder_ScrewAtOffsetCallback"); + REPORT_MSG(millisecondCounter, "Winder_ScrewAtOffsetCallback"); MotorStop (HARDWARE_MOTOR_TYPE__MOTO_SCREW,Soft_Hiz); //per L6470 errata between mov and run commands PrepareReady(Module_Winder, ModuleDone); return OK; @@ -174,15 +174,21 @@ InternalWinderCfg.segmentoffsetpulses numOfSteps = InternalWinderCfg.startoffsetpulses*MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_SCREW].microstep; */ +char ScrewStr[100]; +//char TempScrewStr[100]; +double WinderReferenceSpeed=0; +int32_t TotalWinderSpeed=0; uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) { - uint32_t Steps,i,winderspeed=0; - double temp; - uint32_t WinderReferenceSpeed = OriginalMotorSpd_2PPS[WINDER_MOTOR]; - float screw_horizontal_speed = 0; - float RotationsPerSecond; + uint32_t Steps; + double temp,tempScrewSpeed; + double screw_horizontal_speed = 0; + double RotationsPerSecond; + int32_t Averagewinderspeed = 0; + TotalWinderSpeed-=WinderMotorSpeed[WinderMotorSpeedCounter]; WinderMotorSpeed[WinderMotorSpeedCounter] = CurrentControlledSpeed[WINDER_MOTOR]; + TotalWinderSpeed+=WinderMotorSpeed[WinderMotorSpeedCounter]; if (WinderMotorSpeedCounter++>=MAX_WINDER_SPEED_CALCULATION) { WinderMotorSpeedCounter=0; @@ -214,31 +220,41 @@ uint32_t Screw100msecDirectionChange(uint32_t deviceID, uint32_t BusyFlag) } if (WinderMotorSpeedRollOver) { - for (i=0;i<MAX_WINDER_SPEED_CALCULATION;i++) + /*for (i=0;i<MAX_WINDER_SPEED_CALCULATION;i++) { - winderspeed+=WinderMotorSpeed[i]; - } - winderspeed/=MAX_WINDER_SPEED_CALCULATION; - //LOG_ERROR(winderspeed, "WinderSpeedUpdated"); - Report("WinderSpeedUpdated",__FILE__,__LINE__,winderspeed,RpWarning,ScrewNumberOfSteps,0); + TotalWinderSpeed+=WinderMotorSpeed[i]; + }*/ + Averagewinderspeed = TotalWinderSpeed/MAX_WINDER_SPEED_CALCULATION; + //REPORT_MSG(winderspeed, "WinderSpeedUpdated"); + Report("WinderSpeedUpdated",__FILE__,__LINE__,TotalWinderSpeed,RpWarning,Averagewinderspeed,0); - WinderReferenceSpeed = winderspeed; + WinderReferenceSpeed = Averagewinderspeed; } screw_horizontal_speed = ScrewNumberOfSteps / InternalWinderCfg.NumberOfRotationPerPassage; - RotationsPerSecond = WinderReferenceSpeed / MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround; - ScrewSpeed = screw_horizontal_speed*RotationsPerSecond; + RotationsPerSecond = WinderReferenceSpeed / (double)MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround; + tempScrewSpeed = screw_horizontal_speed*RotationsPerSecond; + //ROM_IntMasterDisable(); CurrentControlledSpeed[SCREW_MOTOR] = ScrewSpeed; temp = SYS_CLK_FREQ; temp *= ScrewNumberOfSteps; - temp /= ScrewSpeed; - if (ScrewRunningTime != temp) + temp /= tempScrewSpeed; + if ((ScrewRunningTime != temp)||(ScrewSpeed != tempScrewSpeed)) { - //LOG_ERROR(temp , "new winder speed"); - Report("new winder speed",__FILE__,__LINE__,temp,RpWarning,ScrewSpeed,0); + ScrewSpeed = tempScrewSpeed; + ScrewRunningTime = temp;//(SYS_CLK_FREQ*Steps)/ScrewSpeed; + //ROM_IntMasterEnable(); + //usnprintf(TempScrewStr, 100, "Winder: Horizon,Rotation, PPR, RPP{ %d, %d ,%d, %d} ",(int)screw_horizontal_speed,(int)RotationsPerSecond,(int)InternalWinderCfg.NumberOfRotationPerPassage,(int)MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_WINDER].pulseperround); + usnprintf(ScrewStr, 100, "Winder: Steps,Speed, Time, WinderSpeed{ %d, %d ,%d, %d} ",(int)ScrewNumberOfSteps,(int)ScrewSpeed,(int)temp,(int)WinderReferenceSpeed); + // Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index, Counter[index]); + // #warning PID is now only proportional (above) + //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); } - ScrewRunningTime = temp;//(SYS_CLK_FREQ*Steps)/ScrewSpeed; /********************************************************************************/ + //ROM_IntMasterEnable(); return OK; } @@ -251,9 +267,8 @@ uint32_t WinderPresegmentReady(uint32_t deviceID, uint32_t ReadValue) uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId) { //JobTicket* JobTicket = JobDetails; - float screw_horizontal_speed = 0; - float RotationsPerSecond; - char Message[80]; + double screw_horizontal_speed = 0; + double RotationsPerSecond; double temp = 0; if (dyeingspeed == 0) { @@ -277,13 +292,14 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId) ScrewSpeed = screw_horizontal_speed*RotationsPerSecond; //MotorSetMaxSpeed (HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed); - usnprintf(Message, 80, "SCREW speed Rot/sec %d horizon %d pulses %d",(int)RotationsPerSecond,(int)screw_horizontal_speed,(int)ScrewSpeed); - //LOG_ERROR(segmentfirst_speed,Message); - //Report(Message,__FILE__,__LINE__,Dispenser_i,RpWarning,segmentfirst_speed,0); - SendJobProgress(0.0,0,false, Message); + usnprintf(ScrewStr, 100, "SCREW speed Rot/sec %d horizon %d pulses %d",(int)RotationsPerSecond,(int)screw_horizontal_speed,(int)ScrewSpeed); + //REPORT_MSG(segmentfirst_speed,ScrewStr); + Report(ScrewStr,__FILE__,__LINE__,RotationsPerSecond,RpWarning,ScrewSpeed,0); + SendJobProgress(0.0,0,false, ScrewStr); CurrentControlledSpeed[SCREW_MOTOR] = ScrewSpeed; OriginalMotorSpd_2PPS[SCREW_MOTOR] = ScrewSpeed; + WinderReferenceSpeed = OriginalMotorSpd_2PPS[WINDER_MOTOR]; //screw_horizontal_speed = InternalWinderCfg.milimetersperrotation // * 2. determine optimal micro-step setting // * 3. calculate cart travel length from winding parameters @@ -294,11 +310,12 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId) temp *= InternalWinderCfg.segmentoffsetpulses; temp /= ScrewSpeed; ScrewRunningTime = temp;//(SYS_CLK_FREQ*InternalWinderCfg.segmentoffsetpulses)/ScrewSpeed; - LOG_ERROR(ScrewNumberOfSteps,"Winder pre segment - ScrewNumberOfSteps"); - LOG_ERROR(ScrewRunningTime,"Winder pre segment - ScrewRunningTime"); + REPORT_MSG(ScrewNumberOfSteps,"Winder pre segment - ScrewNumberOfSteps"); + REPORT_MSG(ScrewRunningTime,"Winder pre segment - ScrewRunningTime"); // MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection); //ScrewDirection = 1-ScrewDirection; - LOG_ERROR(ScrewSpeed,"Winder pre segment - ScrewSpeed"); + REPORT_MSG(SegmentId,"Winder pre segment - SegmentId"); + REPORT_MSG(ScrewSpeed,"Winder pre segment - ScrewSpeed"); //MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed); ScrewsStartControlTimer (); ScrewControlId = AddControlCallback(Screw100msecDirectionChange, eHundredMillisecond,TemplateDataReadCBFunction,0,0,0); @@ -306,6 +323,7 @@ uint32_t Winder_Presegment(void *JobDetails, uint32_t SegmentId) CalculationDirectionChangeCounter = 1; memset (WinderMotorSpeed,0,sizeof(WinderMotorSpeed) ); WinderMotorSpeedCounter=0; + TotalWinderSpeed = 0; WinderMotorSpeedRollOver=false; } PreSegmentReady(Module_Winder,ModuleDone); @@ -382,12 +400,10 @@ void ScrewTimerInterrupt(int ARG0) { ROM_TimerIntClear(Screw_timerBase, TIMER_TIMA_TIMEOUT); // Clear the timer interrupt ROM_IntMasterDisable(); - //ScrewDirectionChange(0,NOTBUSY); if (SCREW_TimerActivated == true) { MotorSetDirection (HARDWARE_MOTOR_TYPE__MOTO_SCREW, ScrewCurrentDirection); -// ScrewCurrentDirection = 1-ScrewCurrentDirection; MotorSetSpeedDirect(HARDWARE_MOTOR_TYPE__MOTO_SCREW,ScrewSpeed); ROM_TimerLoadSet(Screw_timerBase, TIMER_A,(int)ScrewRunningTime); ScrewDirectionChangeCounter++; @@ -396,11 +412,11 @@ void ScrewTimerInterrupt(int ARG0) { TimerDisable(Screw_timerBase, TIMER_A); } + ROM_IntMasterEnable(); //Report("ScrewTimerInterrupt dir, duration, speed", __FILE__,ScrewCurrentDirection,ScrewRunningTime, RpMessage, ScrewSpeed, 0); // // Enable all interrupts. // - ROM_IntMasterEnable(); return ; } diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h index c5e3edc85..34be77177 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_ex.h @@ -29,7 +29,7 @@ uint32_t ThreadConfigBreakSensor(void *request); uint32_t ThreadGetMotorSpeed(threadMotorsEnum MotorId); double ThreadGetMotorCalculatedError(int DancerId); uint32_t ThreadPrepareState(void *JobDetails); -uint32_t ThreadPreSegmentState(void *JobDetails); +uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId); uint32_t ThreadSegmentState(void *JobDetails, int SegmentId); uint32_t ThreadDistanceToSpoolState(void); uint32_t ThreadEndState(void *JobDetails); diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c index 41daa4002..f641737ee 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_init.c @@ -21,8 +21,10 @@ double NormalizedErrorCoEfficient[MAX_THREAD_MOTORS_NUM] = {0}; int DancerStopActivityLimit[MAX_THREAD_MOTORS_NUM] = {0}; HardwareDancer DancersCfg[MAX_SYSTEM_DANCERS] = {0}; +#define BREAK_SENSOR_LIMIT 10 + bool BreakSensorenabled; -int32_t BreakSensordebouncetimemilli; +int32_t BreakSensordebouncetimemilli = BREAK_SENSOR_LIMIT; HardwarePidControlType ThreadMotorIdToControlId[MAX_THREAD_MOTORS_NUM] = {HARDWARE_PID_CONTROL_TYPE__MotorFeeder,HARDWARE_PID_CONTROL_TYPE__MotorDryer,HARDWARE_PID_CONTROL_TYPE__MotorPooler,HARDWARE_PID_CONTROL_TYPE__MotorWinder,0}; @@ -116,7 +118,10 @@ uint32_t ThreadConfigBreakSensor(void *request) if (SensorCfg) { BreakSensorenabled = SensorCfg->enabled; - BreakSensordebouncetimemilli = SensorCfg->debouncetimemilli; + if (SensorCfg->debouncetimemilli) + { + BreakSensordebouncetimemilli = SensorCfg->debouncetimemilli; + } return OK; } return ERROR; diff --git a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c index 76c0fbfd8..94858cae2 100644 --- a/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c +++ b/Software/Embedded_SW/Embedded/Modules/Thread/Thread_print.c @@ -355,6 +355,8 @@ void testDancersControl() bool dancerinvalid = false; int MotorFailedSample[MAX_THREAD_MOTORS_NUM] = {0,0,0,0,0}; char Message[60]; +uint16_t BreakSensorCounter = 0; +uint16_t BreakSensorLatchCounter = 0; uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) { //#define MAX_CONTROL_SAMPLES 6 @@ -425,16 +427,29 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) { if (ReadBreakSensor()==ERROR) { - //consider applying the debouce parameters later - //BreakSensordebouncetimemilli - JobEndReason = JOB_THREAD_BREAK; - ThreadControlActive = false; - SendJobProgress(0.0,0,false, "ReadBreakSensor Error"); - SegmentReady(Module_Thread,ModuleFail); - AlarmHandlingSetAlarm(EVENT_TYPE__ThreadBreak,true); - //EndState(CurrentJob,"ReadBreakSensor Error" ); - LOG_ERROR(index, "ReadBreakSensor Error"); - return OK; + BreakSensorCounter++; + BreakSensorLatchCounter++; + if (BreakSensorCounter>=BreakSensordebouncetimemilli) + { + //consider applying the debouce parameters later + //BreakSensordebouncetimemilli + JobEndReason = JOB_THREAD_BREAK; + ThreadControlActive = false; + SendJobProgress(0.0,0,false, "ReadBreakSensor Error"); + SegmentReady(Module_Thread,ModuleFail); + AlarmHandlingSetAlarm(EVENT_TYPE__ThreadBreak,true); + //EndState(CurrentJob,"ReadBreakSensor Error" ); + LOG_ERROR(index, "ReadBreakSensor Error"); + return OK; + } //passed limit + }//ReadBreakSensor()==ERROR + else //reset counter - we are looking for consequent calls + { + if (BreakSensorCounter) + { + LOG_ERROR(BreakSensorCounter, "ReadBreakSensor Spike"); + } + BreakSensorCounter = 0; } } } @@ -447,7 +462,7 @@ uint32_t ThreadControlCBFunction(uint32_t IfIndex, uint32_t ReadValue) usnprintf(Message, 60, "Dancer %d limit %d value %d Zero %d",DancerId,DancerStopActivityLimit[index],avreageSampleValue,DancersCfg[DancerId].zeropoint); //JobAbortedByUser = true; ThreadControlActive = false; - MotorGetStatusFromFPGA(ThreadMotorIdToMotorId[index]); + //MotorGetStatusFromFPGA(ThreadMotorIdToMotorId[index]); JobEndReason = JOB_WINDER_DANCER_FAIL+DancerId; SendJobProgress(0.0,0,false, Message); //EndState(CurrentJob,Message ); @@ -525,7 +540,7 @@ uint32_t ThreadInitialTestStub(HardwareMotor * request) //MotorsConfigMessage(request); ThreadPrepareState(request); - ThreadPreSegmentState(request); + ThreadPreSegmentState(request,0); return OK; } bool InitialProcess = false; @@ -659,7 +674,7 @@ void SetOriginMotorSpeed(float process_speed) } //******************************************************************************************************************** -uint32_t ThreadPreSegmentState(void *JobDetails) +uint32_t ThreadPreSegmentState(void *JobDetails, uint32_t SegmentId) { //set the speed only before the first segment, speed is constant across all job segments and intersegments JobTicket* JobTicket = JobDetails; @@ -670,33 +685,26 @@ uint32_t ThreadPreSegmentState(void *JobDetails) LOG_ERROR (dyeingspeed," job speed zero"); return ERROR; } - LOG_ERROR (dyeingspeed," ThreadPreSegmentState"); - - SetOriginMotorSpeed(process_speed); - ThreadControlActive = true; - PrepareState = false; - // set the new speed in the dryer motor to the speed of the new segment - MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING, OriginalMotorSpd_2PPS[DRYER_MOTOR]); - //only for testing - when control works, these motors will take their speed from the dryer - //MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_LDRIVING, OriginalMotorSpd_2PPS[POOLER_MOTOR]); - //only for testing - when control works, these motors will take their speed from the dryer - //MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_RDRIVING, OriginalMotorSpd_2PPS[FEEDER_MOTOR]); - -//#warning rocker disabled - if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].maxfrequency > 0) + REPORT_MSG (dyeingspeed," ThreadPreSegmentState"); + if (SegmentId == 0) // do all this only in the beginning of the job. do not touch after that (assuming spool does not change mid job) { - MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize); - MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 1); - } - if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].maxfrequency > 0) - { - MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize); - MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 1); - } -// #warning rocker disabled - -// MotorMovetoLimitSwitch (HARDWARE_MOTOR_TYPE__MOTO_RDRIVING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RDRIVING].directionthreadwize, 0, GPI_LS_RLOADMOTOR_UP, EndState); //TODO + SetOriginMotorSpeed(process_speed); + ThreadControlActive = true; + PrepareState = false; + // set the new speed in the dryer motor to the speed of the new segment + MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_DRYER_DRIVING, OriginalMotorSpd_2PPS[DRYER_MOTOR]); + if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].maxfrequency > 0) + { + MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_RLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_RLOADING].directionthreadwize); + MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_RLOADING, 1); + } + if (MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].maxfrequency > 0) + { + MotorSetDirection((TimerMotors_t)HARDWARE_MOTOR_TYPE__MOTO_LLOADING,MotorsCfg[HARDWARE_MOTOR_TYPE__MOTO_LLOADING].directionthreadwize); + MotorSetSpeed(HARDWARE_MOTOR_TYPE__MOTO_LLOADING, 1); + } + } // activate control fr all motors //set speed for both rocker motors //wait for all motors to get to the required speed (set the target speed for the control to check) @@ -718,17 +726,17 @@ uint32_t ThreadPreSegmentState(void *JobDetails) int REPSegmentId = 0; void ThreadInterSegmentEnded(void) { - LOG_ERROR (REPSegmentId,"ThreadInterSegmentEnded"); + REPORT_MSG (REPSegmentId,"ThreadInterSegmentEnded"); PreSegmentReady(Module_Thread,ModuleDone); } void ThreadSegmentEnded(void) { - LOG_ERROR (REPSegmentId," ThreadSegmentState"); + REPORT_MSG (REPSegmentId," ThreadSegmentState"); SegmentReady(Module_Thread,ModuleDone); } void ThreadDistanceToSpoolEnded(void) { - LOG_ERROR (REPSegmentId," ThreadDistanceToSpoolEnded"); + REPORT_MSG (REPSegmentId," ThreadDistanceToSpoolEnded"); DistanceToSpoolReady(Module_Thread,ModuleDone); } double seglength = 0.0; @@ -739,7 +747,7 @@ uint32_t ThreadSegmentState(void *JobDetails, int SegmentId) REPSegmentId = SegmentId; seglength = JobTicket->segments[SegmentId]->length; CurrentSegmentId = SegmentId; - LOG_ERROR (seglength," ThreadSegmentState"); + REPORT_MSG (seglength," ThreadSegmentState"); ThreadUpdateProcessLength (seglength,(void *)ThreadSegmentEnded); return OK; } @@ -748,7 +756,7 @@ uint32_t ThreadSegmentState(void *JobDetails, int SegmentId) uint32_t ThreadDistanceToSpoolState(void ) { seglength = dryerbufferlength; - LOG_ERROR (seglength,"ThreadDistanceToSpoolState"); + REPORT_MSG (seglength,"ThreadDistanceToSpoolState"); ThreadUpdateProcessLength (seglength,(void *)ThreadDistanceToSpoolEnded); return OK; } |