add arc alarms hysteresis counters

1 files changed, 65 insertions, 22 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index c46d62ade..38379d094 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -55,6 +55,7 @@
 #define UNDERHEAT_COUNT_LIMIT 3
 #define MIN_ALLOWED_PWM 0
 #define MAX_ALLOWED_PWM 255
+#define ARC_ALARM_LIMIT 3
 
  int Overheat_Count_Limit = OVERHEAT_COUNT_LIMIT;
  int Underheat_Count_Limit = UNDERHEAT_COUNT_LIMIT;
@@ -2200,12 +2201,12 @@ uint32_t HeadBlowerPidFunc(double setParam,double measuredParam, int blowerId)
     HeadBlowersCloseLoopTime[blowerId] = HeadBlowerControl[blowerId].m_params.dt;
 
     if (calculatedPwm < MIN_ALLOWED_PWM) {
-        ReportWithPackageFilter(HeatersFilter,"calculatedPwm < MIN_ALLOWED_PWM",__FILE__,__LINE__,calculatedPwm,RpError, MIN_ALLOWED_PWM,0);
+        //ReportWithPackageFilter(HeatersFilter,"calculatedPwm < MIN_ALLOWED_PWM",__FILE__,__LINE__,calculatedPwm,RpError, MIN_ALLOWED_PWM,0);
         HeadBlowerControl[blowerId].m_integral = 0;
         calculatedPwm = MIN_ALLOWED_PWM;
     }
     if (calculatedPwm > MAX_ALLOWED_PWM) {
-        ReportWithPackageFilter(HeatersFilter,"calculatedPwm > MAX_ALLOWED_PWM",__FILE__,__LINE__,calculatedPwm,RpError, MAX_ALLOWED_PWM,0);
+        //ReportWithPackageFilter(HeatersFilter,"calculatedPwm > MAX_ALLOWED_PWM",__FILE__,__LINE__,calculatedPwm,RpError, MAX_ALLOWED_PWM,0);
         HeadBlowerControl[blowerId].m_integral = 0;
         calculatedPwm = MAX_ALLOWED_PWM;
     }
@@ -2243,63 +2244,105 @@ uint32_t HeadBlowersOffGet()
 void ArcHeadAlarms(void)
 {
     double currentFlow = 0.0;
+    static int8_t count1 = 0, count2 = 0, count3 = 0, count4 = 0, count5 = 0;
+    static int8_t count6 = 0, count7 = 0, count8 = 0, count9 = 0, count10 = 0;
 
     if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_ARC) != LIMIT) {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, true);
+        if (++count9 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, true);
+        count9 = (count9 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count9);
     } else {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, false);
+        if (--count9 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, false);
+        count9 = (count9 < 0)?(0):(count9);
     }
 
     if (FPGA_Read_limit_Switches(I2C_HEADCARD_COVER_LS_TUNNEL_ARC) != LIMIT) {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, true);
+        if (++count10 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, true);
+        count10 = (count10 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count10);
     } else {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, false);
+        if (--count10 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, false);
+        count10 = (count10 < 0)?(0):(count10);
     }
 
     if (Head_Fan_Tach[0] == 0x1FFE) {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, true);
+        if (++count1 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, true);
+        count1 = (count1 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count1);
     } else {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, false);
+        if (--count1 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, false);
+        count1 = (count1 < 0)?(0):(count1);
     }
     if (Head_Fan_Tach[1] == 0x1FFE) {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, true);
+        if (++count2 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, true);
+        count2 = (count2 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count2);
     } else {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, false);
+        if (--count2 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, false);
+        count2 = (count2 < 0)?(0):(count2);
     }
 
     if (HeadBlowersGetRPM(0) < 2000) {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, true);
+        if (++count3 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, true);
+        count3 = (count3 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count3);
     } else {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, false);
+        if (--count3 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, false);
+        count3 = (count3 < 0)?(0):(count3);
     }
     if (HeadBlowersGetRPM(1) < 2000) {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, true);
+        if (++count4 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, true);
+        count4 = (count4 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count4);
     } else {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, false);
+        if (--count4 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, false);
+        count4 = (count4 < 0)?(0):(count4);
     }
 
     currentFlow = PressureSensorGetPressure(HEAD_PT100_ZONE_5_0X84_0);
     if (currentFlow > 5.0) {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, true);
+        if (++count5 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, true);
+        count5 = (count5 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count5);
     } else {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, false);
+        if (--count5 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, false);
+        count5 = (count5 < 0)?(0):(count5);
     }
     if (currentFlow < 1.0) {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, true);
+        if (++count6 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, true);
+        count6 = (count6 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count6);
     } else {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, false);
+        if (--count6 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, false);
+        count6 = (count6 < 0)?(0):(count6);
     }
 
     currentFlow = PressureSensorGetPressure(HEAD_PT100_ZONE_7_0X86_0);
     if (currentFlow > 5.0) {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, true);
+        if (++count7 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, true);
+        count7 = (count7 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count7);
     } else {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, false);
+        if (--count7 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, false);
+        count7 = (count7 < 0)?(0):(count7);
     }
     if (currentFlow < 1.0) {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, true);
+        if (++count8 == ARC_ALARM_LIMIT)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, true);
+        count8 = (count8 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count8);
     } else {
-        AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, false);
+        if (--count8 == 0)
+            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, false);
+        count8 = (count8 < 0)?(0):(count8);
     }
 }