arc alarms fix. some spike handling

4 files changed, 88 insertions, 48 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index 1057ddbc3..97640ccdb 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -540,7 +540,8 @@ int MillisecCalculateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId)
     TemperatureSum[SensorId]-=TemperatureMax[SensorId];
     TemperatureSum[SensorId]-=TemperatureMin[SensorId];
     calc = TemperatureSum[SensorId] / (TemperatureCount[SensorId]-2);
-
+    if (abs(TemperatureMax[SensorId]-TemperatureMin[SensorId])>2000)
+        Report("Millisec Temp spike",__FILE__,SensorId,(int)TemperatureMax[SensorId],RpWarning,(int) TemperatureMin[SensorId],0);
     TemperatureSum[SensorId] = 0;
     TemperatureCount[SensorId] = 0;
     TemperatureMin[SensorId] = 30000;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
index 5134e97aa..946958a08 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_Blowers.c
@@ -212,108 +212,148 @@ uint32_t HeadBlowersOffGet()
     ReportWithPackageFilter(HeatersFilter,"HeadBlowersOffGet",__FILE__,__LINE__,HeadBlowersEnable,RpError, 0,0);
     return HeadBlowersEnable;
 }
+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;
+void setArcHeadAlarms(uint32_t AlarmId, bool value)
+{
+    AlarmHandlingSetAlarm(AlarmId, value);
+    if (value == true)
+    {
+        switch(AlarmId)
+        {
+            /*case EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count9,RpError, 0,0);
+                break;*/
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count3,RpError, HeadBlowersGetRPM(HEAD_FAN_RIGHT),0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count4,RpError, HeadBlowersGetRPM(HEAD_FAN_LEFT),0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count5,RpError, PressureSensorGetPressure(HEAD_FAN_RIGHT),0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count7,RpError, PressureSensorGetPressure(HEAD_FAN_LEFT),0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count6,RpError, PressureSensorGetPressure(HEAD_FAN_RIGHT),0);
+                break;
+            case EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW:
+                ReportWithPackageFilter(HeatersFilter,"ArcHeadAlarms on",__FILE__,AlarmId,count8,RpError, PressureSensorGetPressure(HEAD_FAN_LEFT),0);
+                break;
+        }
+    }
+}
 
 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) {
         if (++count9 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, true);
         count9 = (count9 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count9);
     } else {
         if (--count9 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_ARC_LID_IS_OPEN, false);
+            setArcHeadAlarms(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) {
         if (++count10 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, true);
         count10 = (count10 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count10);
     } else {
         if (--count10 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_TUNNEL_LID_IS_OPEN, false);
         count10 = (count10 < 0)?(0):(count10);
     }
 
     if (Head_Fan_Tach[0] == 0x1FFE) {
         if (++count1 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, true);
         count1 = (count1 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count1);
     } else {
         if (--count1 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_STOPPED, false);
         count1 = (count1 < 0)?(0):(count1);
     }
     if (Head_Fan_Tach[1] == 0x1FFE) {
         if (++count2 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, true);
         count2 = (count2 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count2);
     } else {
         if (--count2 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_STOPPED, false);
         count2 = (count2 < 0)?(0):(count2);
     }
 
     if (HeadBlowersGetRPM(HEAD_FAN_RIGHT) < 2000) {
         if (++count3 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, true);
         count3 = (count3 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count3);
     } else {
         if (--count3 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FAN_RPM_TOO_LOW, false);
         count3 = (count3 < 0)?(0):(count3);
     }
     if (HeadBlowersGetRPM(HEAD_FAN_LEFT) < 2000) {
         if (++count4 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, true);
         count4 = (count4 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count4);
     } else {
         if (--count4 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FAN_RPM_TOO_LOW, false);
         count4 = (count4 < 0)?(0):(count4);
     }
 
     currentFlow = PressureSensorGetPressure(HEAD_FAN_RIGHT);
     if (currentFlow > 5.0) {
         if (++count5 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, true);
         count5 = (count5 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count5);
     } else {
         if (--count5 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_HIGH, false);
         count5 = (count5 < 0)?(0):(count5);
     }
     if (currentFlow < 1.0) {
         if (++count6 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, true);
         count6 = (count6 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count6);
     } else {
         if (--count6 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_1_FLOW_TOO_LOW, false);
         count6 = (count6 < 0)?(0):(count6);
     }
 
     currentFlow = PressureSensorGetPressure(HEAD_FAN_LEFT);
     if (currentFlow > 5.0) {
         if (++count7 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, true);
         count7 = (count7 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count7);
     } else {
         if (--count7 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_HIGH, false);
         count7 = (count7 < 0)?(0):(count7);
     }
     if (currentFlow < 1.0) {
         if (++count8 == ARC_ALARM_LIMIT)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, true);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, true);
         count8 = (count8 > ARC_ALARM_LIMIT)?(ARC_ALARM_LIMIT):(count8);
     } else {
         if (--count8 == 0)
-            AlarmHandlingSetAlarm(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, false);
+            setArcHeadAlarms(EVENT_TYPE__DYEING_HEAD_BLOWER_2_FLOW_TOO_LOW, false);
         count8 = (count8 < 0)?(0):(count8);
     }
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 84013add6..def9c5530 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -1053,7 +1053,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
-        ReportWithPackageFilter(HeatersFilter,"Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        ReportWithPackageFilter(HeatersFilter,"Temperature Spike AC",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
 #ifdef IGNORE_SPIKE
         HeaterPreviousRead[index] = readValue;
 #else
@@ -1345,18 +1345,18 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
             DeActivateHeater(HEATER_TYPE__DryerMainHeater);
             HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
             HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
-            if (HeaterSpikeRead[index] == 0)
-            {
-                HeaterSpikeRead[index] = readValue;
-            }
-            else
-            {
-                ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
-                HeaterPreviousRead[index] = HeaterSpikeRead[index];
-                HeaterSpikeRead[index] = 0;
-            }
-
         }
+        if (HeaterSpikeRead[index] == 0)
+        {
+            HeaterSpikeRead[index] = readValue;
+        }
+        else
+        {
+            ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
+            HeaterPreviousRead[index] = HeaterSpikeRead[index];
+            HeaterSpikeRead[index] = 0;
+        }
+
         return ERROR;
 #endif
     }
@@ -1580,20 +1580,20 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 #ifdef IGNORE_SPIKE
         HeaterPreviousRead[index] = readValue;
 #else
-        //if (readValue > HeaterCmd[index].targettemperatue)
+        if (readValue > HeaterCmd[index].targettemperatue)
         {
             DeActivateHeater(index);
             HeaterRecalculateHeaterParams(index, 0);
-            if (HeaterSpikeRead[index] == 0)
-            {
-                HeaterSpikeRead[index] = readValue;
-            }
-            else
-            {
-                ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
-                HeaterPreviousRead[index] = HeaterSpikeRead[index];
-                HeaterSpikeRead[index] = 0;
-            }
+        }
+        if (HeaterSpikeRead[index] == 0)
+        {
+            HeaterSpikeRead[index] = readValue;
+        }
+        else
+        {
+            ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
+            HeaterPreviousRead[index] = HeaterSpikeRead[index];
+            HeaterSpikeRead[index] = 0;
         }
 #endif
     }
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
index 3a0c94e27..b5ebdee17 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Initialization/PowerOffSequence.c
@@ -275,9 +275,8 @@ uint32_t PowerOffHeatersOff(void)
     if (HandleProcessParameters(&ProcessParametersClear,false)!= OK)
     {
         LOG_ERROR (PowerOffMachineState, "Turn Off Heaters  failed");
-        //return ERROR;
     }
-
+    HeadBlowersOff(1);
     PowerOffMachineState++;
 
     return OK;