preparation for persistant alarms, handle temperature spike, handle voltage hystersis

6 files changed, 117 insertions, 41 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 881a02f8e..88ef35236 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -1078,14 +1078,14 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value)
         if (AlarmItem[Alarm_i].EventType == AlarmId)
         {
             if (0) // PERSISTENT ALARM
+  			//if ((AlarmItem[Alarm_i].EventType == EVENT_TYPE__UNINTENDED_RESET)) // PERSISTENT ALARM simulate
             {
-                PersistentEventsResponse.n_events++;
                 if (PersistentEventsResponse.events == NULL)
-                    PersistentEventsResponse.events = (Event **)my_malloc(sizeof(Event*)*PersistentEventsResponse.n_events);
+                    PersistentEventsResponse.events = (Event **)my_malloc(sizeof(Event*)*(PersistentEventsResponse.n_events+1));
                 else
                 {
-                    re_events = (Event **)my_malloc(sizeof(Event*)*PersistentEventsResponse.n_events);
-                    for (Event_i = 0;Event_i < (PersistentEventsResponse.n_events-1);Event_i++)
+                    re_events = (Event **)my_malloc(sizeof(Event*)*(PersistentEventsResponse.n_events+1));
+                    for (Event_i = 0;Event_i < (PersistentEventsResponse.n_events);Event_i++)
                     {
                         re_events[Event_i] = PersistentEventsResponse.events[Event_i];
                     }
@@ -1100,8 +1100,9 @@ void AlarmHandlingInternalSetAlarm(uint32_t AlarmId, bool value)
                     AlarmState[Alarm_i].EventPtr->type = AlarmItem[Alarm_i].EventType;
                     AlarmState[Alarm_i].EventPtr->message = NULL;//AlarmItem[Alarm_i].EventName;
                 }
-                AlarmState[Alarm_i].Status = true;
+                //AlarmState[Alarm_i].Status = true;
                 PersistentEventsResponse.events[PersistentEventsResponse.n_events] = AlarmState[Alarm_i].EventPtr;
+                PersistentEventsResponse.n_events++;
                 ReportWithPackageFilter(AlarmFilter,"Persistent Alarm ", __FILE__,PersistentEventsResponse.n_events,AlarmItem[Alarm_i].EventType, RpMessage, value, Alarm_i);
             }
             else
@@ -1751,6 +1752,7 @@ int LargeMessagesAH = 0;
 void SendEventNotifications(void)
 {
     MessageContainer responseContainer;
+    int total_events_number = 0;
     //StartEventsNotificationResponse EventsResponse = START_EVENTS_NOTIFICATION_RESPONSE__INIT;
     int i,e=0;
 
@@ -1782,9 +1784,13 @@ void SendEventNotifications(void)
         }
     }
 
-    if (EventsResponse.n_events)
+    total_events_number = PersistentEventsResponse.n_events + EventsResponse.n_events;
+    if (PersistentEventsResponse.n_events)
+        ReportWithPackageFilter(AlarmFilter,"PersistentEventsResponse found", __FILE__,PersistentEventsResponse.n_events,EventsResponse.n_events, RpMessage, total_events_number, 0);
+
+    if (total_events_number)
     {
-        EventsResponse.events = (Event **)my_malloc(sizeof(Event*)*EventsResponse.n_events);
+        EventsResponse.events = (Event **)my_malloc(sizeof(Event*)*total_events_number);
         if(EventsResponse.events)
         {
             for (i = 0;i<NumOfSystemAlarms;i++)
@@ -1808,6 +1814,16 @@ void SendEventNotifications(void)
                 ReportWithPackageFilter(AlarmFilter,"Error in alarm numbers - small ", __FILE__,__LINE__,EventsResponse.n_events, RpFatalError, e, 0);
                 EventsResponse.n_events = e;
             }
+            for (i = 0;i<PersistentEventsResponse.n_events;i++)
+            {
+                EventsResponse.events[e]=PersistentEventsResponse.events[i];
+                e++;
+            }
+            if (e!=total_events_number)
+            {
+                ReportWithPackageFilter(AlarmFilter,"Error in alarm numbers  ", __FILE__,total_events_number,EventsResponse.n_events, RpFatalError, e, 0);
+            }
+            EventsResponse.n_events = e;
         }
         else
         {
@@ -1841,6 +1857,15 @@ void SendEventNotifications(void)
         AlarmHandlingStop();
     if (EventsResponse.events)
         my_free(EventsResponse.events);
+    if (PersistentEventsResponse.n_events)
+    {
+        for (i = 0;i<PersistentEventsResponse.n_events;i++)
+            my_free(PersistentEventsResponse.events[i]);
+        my_free(PersistentEventsResponse.events);
+        PersistentEventsResponse.events = NULL;
+        PersistentEventsResponse.n_events = 0;
+    }
+
     //if (responseContainer.data.data)
     //    my_free(responseContainer.data.data);
 }
diff --git a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
index 90c18caa0..b03494496 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/GeneralHardware.c
@@ -57,6 +57,7 @@
 #include <Modules/Waste/newWHS_init.h>
 #include <Drivers/I2C_Communication/I2C_Task.h>
 #include "drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.h"
+#include "Modules/heaters/heaters_ex.h"
 
 uint32_t EmbeddedParametersInit(void);
 uint32_t EmbeddedParametersWrite(void * buffer, uint16_t size);
@@ -239,8 +240,8 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
             EmbeddedParameters->has_startheatingoninitsequence = true;
             EmbeddedParameters->startheatingoninitsequence = true; //set to true shlomo 14/5/2019
 
-            EmbeddedParameters->n_generalparameters = 12;
-            EmbeddedParameters->generalparameters = malloc (sizeof(double)*13);
+            EmbeddedParameters->n_generalparameters = 13;
+            EmbeddedParameters->generalparameters = malloc (sizeof(double)*14);
             if (EmbeddedParameters->generalparameters)
             {
                 EmbeddedParameters->generalparameters[0] = 1.0; //CheckHardLimitAlarms
@@ -255,6 +256,7 @@ void LoadConfigurationParameters(ConfigurationParameters *Params)
                 EmbeddedParameters->generalparameters[9] = 30; //   sublimation
                 EmbeddedParameters->generalparameters[10] = 0.07; //    AllowedRangeForHeadBlowerDeviation;
                 EmbeddedParameters->generalparameters[11] = 0.2; //                AllowedRangeForWasteBlowerDeviation = WasteLimit;
+                EmbeddedParameters->generalparameters[12] = 4; //  Voltage hysteresis (bug #2970)
             }
 
             EmbeddedParameters->has_currentalarmlowlimit = true;
@@ -407,6 +409,10 @@ uint32_t EmbeddedParametersInit(void)
     {
         setWastePrepareValues(EmbeddedParameters->generalparameters[10],EmbeddedParameters->generalparameters[11]);
     }
+    if (EmbeddedParameters->n_generalparameters >= 13)
+    {
+        Set_Voltage_Hysteresis (EmbeddedParameters->generalparameters[12]);
+    }
     PowerIdleSetParameters(EmbeddedParameters->switchtoidletimeinseconds,EmbeddedParameters->idledriertemperature,EmbeddedParameters->idleheadtemperature,EmbeddedParameters->idlemixertemperature);
 
     return Fresult;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
index e85694c48..2c675606b 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_ex.h
@@ -29,6 +29,7 @@ bool HeaterCheckReady(void);
 bool isHeaterReady(uint8_t HeaterId);
 
 bool HeaterGetOverTemperatureState(uint8_t HeaterId);
+void Set_Voltage_Hysteresis (double Hysteresis);
 
 void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState);
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 56b46c98c..e702d7072 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -1046,9 +1046,17 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
     }
     //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]);
 
+    if (readValue == 0)
+    {
+        ReportWithPackageFilter(HeatersFilter,"Read value 0 ignored",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        return 0xFFFFFFFF;
+    }
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
         ReportWithPackageFilter(HeatersFilter,"Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+#ifdef IGNORE_SPIKE
+        HeaterPreviousRead[index] = readValue;
+#else
         if (HeaterSpikeRead[index] == 0)
         {
             HeaterSpikeRead[index] = readValue;
@@ -1059,12 +1067,13 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
             HeaterPreviousRead[index] = HeaterSpikeRead[index];
             HeaterSpikeRead[index] = 0;
         }
-        HeaterMaxTempFlag[index] = true;
+        //HeaterMaxTempFlag[index] = true;
         DeActivateHeater(HEATER_TYPE__DryerMainHeater);
         HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
         DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
         HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
         return ERROR;
+#endif
     }
     HeaterPreviousRead[index] = readValue;
     if (index == HEATER_TYPE__DryerMainHeater)
@@ -1309,9 +1318,18 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         //ReportWithPackageFilter(HeatersFilter, "unconfigured",__FILE__,__LINE__,0,RpError, 0,0);
         return ERROR;
     }
+    if (readValue == 0)
+    {
+        ReportWithPackageFilter(HeatersFilter,"Read value 0 ignored",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        return 0xFFFFFFFF;
+    }
+
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
         ReportWithPackageFilter(HeatersFilter,"AC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+#ifdef IGNORE_SPIKE
+        HeaterPreviousRead[index] = readValue;
+#else
         if (readValue > HeaterCmd[index].targettemperatue)
         {
             /*if (HeaterSpikeRead[index] == 0)
@@ -1340,6 +1358,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 
         }
         return ERROR;
+#endif
     }
     if (HeaterDisasterCounter[index] >= DISASTER_COUNTER_LIMIT)
     {
@@ -1549,9 +1568,18 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         ReportWithPackageFilter(HeatersFilter, "unconfigured",__FILE__,__LINE__,index,RpError, 0,0);
         return ERROR;
     }
+    if (readValue == 0)
+    {
+        ReportWithPackageFilter(HeatersFilter,"Read value 0 ignored",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        return 0xFFFFFFFF;
+    }
+
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
         ReportWithPackageFilter(HeatersFilter,"DC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+#ifdef IGNORE_SPIKE
+        HeaterPreviousRead[index] = readValue;
+#else
         //if (readValue > HeaterCmd[index].targettemperatue)
         {
             DeActivateHeater(index);
@@ -1567,6 +1595,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
                 HeaterSpikeRead[index] = 0;
             }
         }
+#endif
     }
     HeaterPreviousRead[index] = readValue;
     if (HeaterDisasterCounter[index] >= DISASTER_COUNTER_LIMIT)
@@ -1809,8 +1838,16 @@ double TotalCurrentLimit(double VAC)
     }
 
 }
-uint8_t Histeresis = 0;
-
+#define VOLTAGE_HYSTERESIS  4
+uint8_t Hysteresis  = 0, Voltage_Hysteresis  = VOLTAGE_HYSTERESIS;
+void Set_Voltage_Hysteresis (double Hysteresis)
+{
+    if ((Hysteresis>1)&&(Hysteresis<99))
+    {
+        Voltage_Hysteresis = Hysteresis;
+        REPORT_MSG(Hysteresis , "Setting voltage hysteresis ");
+    }
+}
 uint32_t DrierHeaterVoltageSetup(void)
 {
     double DrierAcVoltage = 0.0;
@@ -1818,22 +1855,22 @@ uint32_t DrierHeaterVoltageSetup(void)
     bool tempDrier2 = UseSecondaryDrierHeater;
     double Z1Current = 0,Z2AssumedCurrent = 0,LimitCurrent = 0;
 
-    if ((Histeresis>0)&&(Histeresis<4))
+    if ((Hysteresis >0)&&(Hysteresis <4))
     {
-        Histeresis++;
-        REPORT_MSG(Histeresis, "AC handling Histeresis");
+        Hysteresis ++;
+        REPORT_MSG(Hysteresis , "AC handling Hysteresis ");
         return OK;
     }
-    Histeresis = 0;
+    Hysteresis  = 0;
 #ifndef VAC_TEST
     if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD) //rapid/pp machines
 #endif
     {
         DrierAcVoltage = ReadVAC();
-        if (DrierAcVoltage<=180)
+        if ((DrierAcVoltage>120)&&(DrierAcVoltage<=180))
         {
-            //AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
-            //ReportWithPackageFilter(HeatersFilter,"Power too low!!!!!", __FILE__,__LINE__,DrierAcVoltage, RpMessage, 0, 0);
+            AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
+            ReportWithPackageFilter(HeatersFilter,"Power too low!!!!!", __FILE__,__LINE__,DrierAcVoltage, RpMessage, 0, 0);
         }
         else if (DrierAcVoltage>264)
         {
@@ -1844,11 +1881,11 @@ uint32_t DrierHeaterVoltageSetup(void)
             HeatersEnd();
             //PowerOffPowerOff();
         }
-        else if (DrierAcVoltage<205)
+        else if (DrierAcVoltage<(205-(Voltage_Hysteresis /2)))
         {
             UseSecondaryDrierHeater = true;
         }
-        else if (DrierAcVoltage>224)
+        else if (DrierAcVoltage>(224+(Voltage_Hysteresis /2)))
         {
             UseSecondaryDrierHeater = false;
         }
@@ -1876,7 +1913,7 @@ uint32_t DrierHeaterVoltageSetup(void)
 #endif
     if (tempDrier2 != UseSecondaryDrierHeater)
     {
-        Histeresis = 1;
+        Hysteresis  = 1;
         usnprintf(str, 100, "Changing Dryer 2 from %d to %d  VAC %d D1 Current %d D2 assumed current %d limit %d" ,tempDrier2,UseSecondaryDrierHeater
                         ,(int)DrierAcVoltage,(int)(Z1Current*100),(int)(Z2AssumedCurrent*100),(int)(abs(LimitCurrent)*100));
         ReportWithPackageFilter(HeatersFilter,str, __FILE__,__LINE__,DrierAcVoltage, RpMessage, UseSecondaryDrierHeater, 0);
diff --git a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
index 987257645..051df3b05 100644
--- a/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
+++ b/Software/Embedded_SW/Embedded/Modules/Stubs_Handler/Progress.c
@@ -9,9 +9,6 @@
 #include "Communication/Connection.h"
 
 #include "Drivers/USB_Communication/USBCDCD.h"
-#include "StateMachines/Initialization/PowerOffSequence.h"
-#include "StateMachines/Initialization/PowerIdle.h"
-
 #include "drivers/Flash_Memory/FATFS/ff.h"
 #include "drivers/Flash_Memory/FATFS/Control_File_System.h"
 #include "drivers/Flash_ram/FlashProgram.h"
@@ -20,20 +17,12 @@
 #include "drivers/ADC_Sampling/adc.h"
 #include "drivers/Flash_ram/MCU_E2Prom.h"
 #include "Drivers/SSI_Comm/Dancer/Dancer.h"
-
 #include "Drivers/I2C_Communication/Head_Card/PT100/Head_PT100_ADC.h"
 #include "Drivers/I2C_Communication/Head_Card/Fan/fan_click.h"
 #include "Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h"
 #include "drivers/Motors/Motor.h"
 #include "drivers/Valves/Valve.h"
 #include "drivers/FPGA/FPGA_SPI_Comm.h"
-#include "Modules/IFS/ifs.h"
-#include "Modules/IDS/ids_ex.h"
-#include "Modules/IDS/ids.h"
-#include "Modules/Control/MillisecTask.h"
-#include "modules/thread/thread_ex.h"
-#include "modules/heaters/heaters_ex.h"
-#include "modules/waste/waste_ex.h"
 #include <Drivers/I2C_Communication/I2C.h>
 #include <Drivers/I2C_Communication/Head_Card/I2C_Head_Mux.h>
 #include "Drivers/I2C_Communication/Head_Card/IO_Ports/Head_IO.h"
@@ -45,16 +34,24 @@
 #include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>
 #include <Drivers/I2C_Communication/WHS_Card/D_MAX11614_ADC/WHS_MAX11614_A2D.h>
 #include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
-
-
 #include "Drivers/I2C_Communication/Dispenser_Card/EEPROM/Dispenser_EEPROM.h"
-
 #include "drivers/Uart_Comm/WHS_Controller_Comm/WHS_UART/WHS_Uart.h"
 #include <Drivers/I2C_Communication/WHS_Card/IO_Extender_Ports_TCA9555/WHS_IO.h>
-
 #include "drivers/Heater/TemperatureSensor.h"
 #include "Drivers/I2C_Communication/Head_Card/PT100/ADS122X04.h"
 
+#include "Modules/IFS/ifs.h"
+#include "Modules/IDS/ids_ex.h"
+#include "Modules/IDS/ids.h"
+#include "Modules/Control/MillisecTask.h"
+#include "modules/thread/thread_ex.h"
+#include "modules/heaters/heaters_ex.h"
+#include "modules/waste/waste_ex.h"
+#include "AlarmHandling/AlarmHandling.h"
+
+#include "StateMachines/Initialization/PowerOffSequence.h"
+#include "StateMachines/Initialization/PowerIdle.h"
+
 extern HeadBoardTempSensConfigStruc  HeadTempSensConfig[MAX_HEAD_CARD_TEMP_SENS_ID];
 extern float NumberOfRotationPerPassage;  // how many rotations per spool passage
 extern void HeaterSafetyTestSetLimits(int limit);
@@ -1227,6 +1224,15 @@ void Stub_ProgressRequest(MessageContainer* requestContainer)
         response.has_progress = true;
     }
     else
+    if(request->amount == 0xB22)  //Set loading arm cycles
+    {
+        REPORT_MSG(request->delay,"Send persistent alarm");
+        AlarmHandlingSetAlarm (EVENT_TYPE__UNINTENDED_RESET,ON);  //handle alarm detection and operation
+
+        response.progress = (double)MotorSetMaxSpeed(HARDWARE_MOTOR_TYPE__MOTO_SCREW,request->delay);
+        response.has_progress = true;
+    }
+    else
     if(request->amount == 0xC3)  //suspend I2C task
     {
         if (request->delay == 0)
diff --git a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
index 7a8265cbb..155d84fdb 100644
--- a/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
+++ b/Software/Embedded_SW/Embedded/StateMachines/Printing/JobSTM.c
@@ -1042,10 +1042,6 @@ void SendCleaningJobProgress(double ProcessedLength, int SegmentId, bool done, c
     double totlen = ProcessedLength;
     if (ProcessedLength>job_length)
         totlen = job_length;
-    if (Message)
-    {
-        response.status = Message;
-    }
     response.has_progress = true;
     response.progress = totlen;
     response.has_total = true;
@@ -1060,6 +1056,11 @@ void SendCleaningJobProgress(double ProcessedLength, int SegmentId, bool done, c
         {
             responseContainer.has_error = true;
             responseContainer.error = JobError_to_ErrorCode[JobEndReason];
+            responseContainer.errormessage = Message;
+            if (Message)  //moved - bug #3867
+            {
+                response.status = Message;
+            }
         }
         if (JobAbortedByUser == true)
         {