MERGE

1 files changed, 105 insertions, 61 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index 8fe9e5c2e..fd4d2b39b 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -22,6 +22,7 @@
 #include "../AlarmHandling/AlarmHandling.h"
 #include "../control/control.h"
 #include "../control/pidalgo.h"
+#include "../control/MillisecTask.h"
 
 #include <ti/sysbios/knl/Task.h>
 #include <driverlib/timer.h>
@@ -205,8 +206,8 @@ uint32_t LoadHeaterSetPoint(HeaterType HeaterType)
 void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
 {
     int HeaterId = HeaterType;
-    double temp = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
-    //double temp = HeaterPreviousRead[HeaterId];//TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
+    double temp = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
+    //double temp = HeaterPreviousRead[HeaterId];//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
 
     HeaterState->has_heatertype = true;
     HeaterState->heatertype = HeaterType;
@@ -214,7 +215,7 @@ void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
     HeaterState->setpoint = HeaterCmd[HeaterId].targettemperatue/100;
     //    HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse;
     HeaterState->has_currentvalue = true;
-    HeaterState->currentvalue = temp/100;//TemperatureSensorRead(HeaterId2PT100Id[HeaterId])/100;
+    HeaterState->currentvalue = temp/100;//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId])/100;
     HeaterState->has_isactive = true;
     HeaterState->isactive = GetHeaterState(HeaterId);
     HeaterState->has_isrampingup = true;
@@ -399,7 +400,7 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
         }
         else
         {
-            HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//
+            HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId);//
             LOG_ERROR(HeaterId,"ReRead Heater Temp");
         }*/
         PrepareHeater(HeaterId,Temperature);  //prepare the heaters control info
@@ -430,12 +431,12 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
 {
     if (ControlIdtoHeaterId [HeaterId] == 0xFF)
     {
-        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
-        //HeaterPreviousRead[HeaterId] = TemperatureSensorRead(DryerInternalPT100Id);
-        HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//
+        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
+        //HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(DryerInternalPT100Id);
+        HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//
         //Report("PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);//TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
-        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = GetFilteredHeaterRead(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);// = TemperatureSensorRead(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
+        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);//MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
+        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);// = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
     }
     //turn all alarms off
         AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false);
@@ -443,7 +444,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
         AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);
 
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
-        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
     Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
     Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
@@ -451,9 +452,9 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
     HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
     HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
     if (MainDryerHeaterMaxTempControl == 0xFF)
-        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
+        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
     if (SecondDryerHeaterMaxTempControl == 0xFF)
-        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
+        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
     //InitialHeating = true;
     HeaterReady[HeaterId] = false;
     if (BlowerCfg.enabled == true)
@@ -478,7 +479,7 @@ void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
 int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
 {
     if (ControlIdtoHeaterId [HeaterId] == 0xFF)
-    ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+    ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
     //HeaterPIDConfig[HeaterId].m_params.dt *=10;
     //DCInitialHeating[HeaterId] = true;
     HeaterReady[HeaterId] = false;
@@ -491,7 +492,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
 
     Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
 
-    HeaterPreviousRead[HeaterId] = GetFilteredHeaterRead(HeaterId);//TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
+    HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
     if((abs(HeaterPreviousRead[HeaterId]-MINIMUM_HEATER_READ)<1)||(abs(MAXIMUM_HEATER_READ-HeaterPreviousRead[HeaterId])<10))
     {
         LOG_ERROR (HeaterId,"PT100 not working properly");
@@ -499,7 +500,7 @@ int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
     }
     //Report("PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
     if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
-        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback( DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
 
     return OK;
 }
@@ -538,12 +539,17 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
     HeaterPIDConfig[HeaterId].m_preError = 0;
     HeaterPIDConfig[HeaterId].m_SetParam = SetTemperatue*100;//need to update SetParams on presegment stage
 
-    temp = SetTemperatue*(100+HeaterControl[HeaterId].outputproportionalband);
-    temp = SetTemperatue*110.0;
+    int band = 5;
+    if (HeaterControl[HeaterId].outputproportionalband)
+    {
+        band = HeaterControl[HeaterId].outputproportionalband;
+    }
+    temp = SetTemperatue*(100+band);
+    //temp = SetTemperatue*110.0;
     HeaterControl[HeaterId].sensormaxvalue = (int)temp;
 
-    temp = SetTemperatue*(100-HeaterControl[HeaterId].outputproportionalband);
-    temp = SetTemperatue*90.0;
+    temp = SetTemperatue*(100-band);
+    //temp = SetTemperatue*90.0;
     HeaterControl[HeaterId].sensorminvalue = (int)temp;
 
     if (HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier)
@@ -606,13 +612,11 @@ uint32_t MainPT100Read = 0,SecondaryPT100Read = 0;
 #ifndef min
     #define min(a,b) ((a) < (b) ? (a) : (b))
 #endif
-uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
+uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=MAX_HEATERS_NUM;
-    int32_t MaxreadValue = max (MainPT100Read,SecondaryPT100Read);
-    int32_t MinreadValue = min (MainPT100Read,SecondaryPT100Read);
-    /*char str[100];
-    uint8_t len = 0;*/
+    int32_t MaxreadValue;
+    int32_t MinreadValue;
     if (IfIndex>>8 != IfTypeHeaters)
     {
         LOG_ERROR (IfIndex, "Wrong  Interface type");
@@ -624,11 +628,15 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
         LOG_ERROR (IfIndex, "Wrong  Interface ");
         return 0xFFFFFFFF;
     }
-    int32_t readValue = TemperatureSensorRead(HeaterId2PT100Id[index]);
+    //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]);
 
     if (abs(readValue - HeaterPreviousRead[index])>2000)
     {
         Report("Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
         return ERROR;
     }
     HeaterPreviousRead[index] = readValue;
@@ -640,19 +648,24 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
     {
         SecondaryPT100Read = readValue;
     }
+    MaxreadValue = max (MainPT100Read,SecondaryPT100Read);
+    MinreadValue = min (MainPT100Read,SecondaryPT100Read);
+
     if ((MaxreadValue) >= HeaterControl[index].sensormaxvalue)
     {
         if (HeaterMaxTempFlag[index] == false)
         {
-     //       LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
+            LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
         }
         DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
         HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = true;
+        //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
         DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
         HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true;
+        //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
         return OK;
     }
-    if ((MinreadValue) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue))
+    if ((MaxreadValue) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
     {
         if (HeaterControl[index].sensorminvalue > 0)
         {
@@ -663,7 +676,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
                 {
                     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;
@@ -672,7 +685,7 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
     }
     return ERROR;
 }
-uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
+uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
 {
     int index=MAX_HEATERS_NUM;
     if (IfIndex>>8 != IfTypeHeaters)
@@ -681,7 +694,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
-    int32_t readValue = TemperatureSensorRead(HeaterId2PT100Id[index]);
+    //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]);
     if (HeaterControl[index].sensormaxvalue == 0)
         return OK;
     if ((HeaterPreviousRead[index]) >= HeaterControl[index].sensormaxvalue)
@@ -689,6 +702,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
         if(OverHeatCounter[index]++ >=Overheat_Count_Limit)
         {
             OverHeatCounter[index] = Overheat_Count_Limit;
+            HeaterReady[index] = false;
             if (JobIsActive()&&(HeaterReady[index]==true))
             {
                 JobEndReason = JOB_TEMPERATURE_ALARM;
@@ -711,6 +725,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
         if(UnderHeatCounter[index]++ >=Underheat_Count_Limit)
         {
             UnderHeatCounter[index] = Underheat_Count_Limit;
+            HeaterReady[index] = false;
             if (JobIsActive()&&(HeaterReady[index]==true))
             {
                 JobEndReason = JOB_TEMPERATURE_ALARM;
@@ -719,7 +734,7 @@ uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t eadValue)
                 LOG_ERROR(index, "Temperature Error");
                 return OK;
             }
-            HeaterMinTempFlag[index] = true;
+            //HeaterMinTempFlag[index] = true;
 //            Report("Heater under the min temperature",__FILE__,__LINE__,index,RpWarning,HeaterPreviousRead[index],  HeaterControl[index].sensormaxvalue);
             if (HeaterReady[index]==false)
                 AlarmHandlingSetAlarm(HeaterUnderEventType[index], true);
@@ -763,17 +778,21 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
     if (IfIndex>>8 != IfTypeHeaters)
     {
         LOG_ERROR (IfIndex, "Wrong  Interface type");
-        return 0xFFFFFFFF;
+        return ERROR;
     }
     index = IfIndex&0xFF;
     if (index != HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
     {
         LOG_ERROR (IfIndex, "Wrong  Interface ");
-        return 0xFFFFFFFF;
+        return ERROR;
     }
     if (HeaterCmd[index].targettemperatue == 0)
     {
-        DeActivateHeater(index);
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        //Heaters OFF until coming into the proportional band
+        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
+        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
         //LOG_ERROR (0, "unconfigured");
         return ERROR;
     }
@@ -782,7 +801,8 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         Report("AC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
         if (readValue > HeaterCmd[index].targettemperatue)
         {
-            DeActivateHeater(index);
+            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
             HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
             HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
         }
@@ -1031,7 +1051,7 @@ void EightMilliSecondHeatersInterrupt(UArg arg0)
     return ;
 }
 
-
+int HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {28000,28000,28000,17000,17000,17000,17000,17000,17000,11000};
 uint32_t HeatersControlLoop(uint32_t tick)
 {
     //char str[100];
@@ -1041,45 +1061,69 @@ uint32_t HeatersControlLoop(uint32_t tick)
                     ,SliceCounter,TimeSliceAllocation[SliceCounter],HeatersRestart,NumberOFSlicesInUse);
     Report(str, __FILE__,__LINE__,0, RpMessage, SliceCounter, TimeSliceAllocation[SliceCounter]);
 */
-    static bool first = true;
+    /*static bool first = true;
     if (first == true)
     {
         first = false;
+    }*/
+    if ((MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain])>HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain])|
+            (MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary])>HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]))
+    {
+        Report("AC Disaster Temperature ",__FILE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]),RpWarning,HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary], 0);
+        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
     }
-    if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature] == true)
+    else
     {
-        if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
+        if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature] == true)
         {
-            if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)
+            if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
             {
-                //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain should be active
-                //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)
+                {
+                    //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain should be active
+                    //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
+                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
+                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                }
             }
-        }
-        else if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
-        {
-            if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)
+            else if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
             {
-                //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary should be active
-                //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)
+                {
+                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
+                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+                    //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary should be active
+                    //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
+                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                }
+            }
+            else
+            {
+                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
+                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
+                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
             }
-        }
-        else
-        {
-                //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
-                //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
         }
     }
     for ( DcHeaterId = HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1; DcHeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;DcHeaterId++)
     {
+        if (MillisecGetTemperatures(HeaterId2PT100Id[DcHeaterId])>HeaterDisasterTemp[DcHeaterId])
+        {
+	        if (HeaterCmd[DcHeaterId].targettemperatue)
+	            Report("DC Disaster Temperature ",__FILE__,DcHeaterId,MillisecGetTemperatures(HeaterId2PT100Id[DcHeaterId]),RpWarning,HeaterDisasterTemp[DcHeaterId], DcHeaterId);
+            DeActivateHeater (DcHeaterId);
+            continue;
+        }
+        if (   MillisecGetTemperatures(HeaterId2PT100Id[DcHeaterId]<MINIMUM_HEATER_READ))
+        {
+            if (HeaterCmd[DcHeaterId].targettemperatue)
+                Report("DC negative Temperature ",__FILE__,DcHeaterId,MillisecGetTemperatures(HeaterId2PT100Id[DcHeaterId]),RpWarning,HeaterDisasterTemp[DcHeaterId], DcHeaterId);
+            DeActivateHeater (DcHeaterId);
+            continue;
+        }
         if (HeaterReady[DcHeaterId] == false)
             continue;
         if (DCTimeSliceAllocation[DcHeaterId] > 0) //heater active