MERGE

5 files changed, 163 insertions, 74 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
index 81c4a230b..c19dea78f 100644
--- a/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
+++ b/Software/Embedded_SW/Embedded/Modules/AlarmHandling/AlarmHandling.c
@@ -735,7 +735,7 @@ uint32_t AlarmHandlingLoop(uint32_t tick)
             switch (AlarmItem[Alarm_i].AlarmSource)
             {
             /*case ALARM_SOURCE_TYPE__TemperatureAlarm:
-                ivalue = TemperatureSensorRead((TEMPERATURE_SENSOR_ID_ENUM)AlarmItem[Alarm_i].DeviceId);
+                ivalue = MillisecGetTemperatures((TEMPERATURE_SENSOR_ID_ENUM)AlarmItem[Alarm_i].DeviceId);
                 if (AlarmItem[Alarm_i].AlarmDirection == true)
                 {
                     if (ivalue/100 >= AlarmItem[Alarm_i].AlarmValue)
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
index d34ac9ff9..193769265 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.c
@@ -445,6 +445,37 @@ uint32_t MillisecLoop(uint32_t tick)
 #endif
     return OK;
 }
+int TemperatureSum[MAX_TEMPERATURE_SENSOR_ID];
+int TemperatureMin[MAX_TEMPERATURE_SENSOR_ID];
+int TemperatureMax[MAX_TEMPERATURE_SENSOR_ID];
+int TemperatureCount[MAX_TEMPERATURE_SENSOR_ID];
+int TemperatureCalc[MAX_TEMPERATURE_SENSOR_ID];
+void MillisecUpdateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId,int temperature)
+{
+   //if(TemperatureCount[SensorId]++>=10)
+   //    TemperatureCount[SensorId] = 0;
+    TemperatureCount[SensorId]++;
+    if (TemperatureMax[SensorId]<temperature) TemperatureMax[SensorId]=temperature;
+    if (TemperatureMin[SensorId]>temperature) TemperatureMin[SensorId]=temperature;
+    TemperatureSum[SensorId]+=temperature;
+}
+int MillisecCalculateTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId)
+{
+    int calc = 0;
+    TemperatureSum[SensorId]-=TemperatureMax[SensorId];
+    TemperatureSum[SensorId]-=TemperatureMin[SensorId];
+    calc = TemperatureSum[SensorId] / (TemperatureCount[SensorId]-2);
+
+    TemperatureSum[SensorId] = 0;
+    TemperatureCount[SensorId] = 0;
+    TemperatureMin[SensorId] = 30000;
+    TemperatureMax[SensorId] = -30000;
+    return calc;
+}
+int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId)
+{
+    return TemperatureCalc[SensorId];
+}
 uint32_t MillisecLowLoop(uint32_t tick)
 {
     uint8_t Motor_i,Disp_i,Heater_i,temp;
@@ -454,9 +485,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
     //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,OneMinute_Tick;
+    bool Ten_msTick, Hundred_msTick , m90msecTick, Onesecond_Tick,O900Millisecond_Tick,OneMinute_Tick;
     Ten_msTick      =   (tick%eTenMillisecond == 0)      ?true:false;
     Hundred_msTick  =   (tick%eHundredMillisecond == 0)  ?true:false;
+    m90msecTick  =   (tick%eHundredMillisecond == 90)  ?true:false;
     O900Millisecond_Tick  =   (tick%eOneSecond == 900)           ?true:false;
     Onesecond_Tick  =   (tick%eOneSecond == 0)           ?true:false;
     OneMinute_Tick  =   (tick%eOneMinute == 0)           ?true:false;
@@ -471,13 +503,20 @@ uint32_t MillisecLowLoop(uint32_t tick)
         if(Machine_Idle_Mode == true)
             Machine_Idle_Breathing_Led();
     }
+    if (m90msecTick)
+    {
+        for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++)
+        {
+            MillisecReadFromTempSensor(Sensor_i, NULL);
+        }
+    }
     if (Hundred_msTick)
     {
         Speed_Data = Calculate_Speed_Sensor_Velocity();
         Read_Buttons_Reg();
         for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++)
         {
-            MillisecReadFromTempSensor(Sensor_i, NULL);
+            MillisecUpdateTemperatures (Sensor_i,TemperatureSensorRead(Sensor_i));
         }
         if (GeneralHwReady == true)
         {
@@ -517,6 +556,10 @@ uint32_t MillisecLowLoop(uint32_t tick)
             Read_Heaters_Current(Heater_i);
         }
         Gas_PPM = Calculate_Gas_Power_Consumption();
+        for (Sensor_i = 0;Sensor_i < MAX_TEMPERATURE_SENSOR_ID;Sensor_i++)
+        {
+            TemperatureCalc[Sensor_i] =  MillisecCalculateTemperatures ( Sensor_i);
+        }
     }
     if (OneMinute_Tick)
     {
diff --git a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
index 064302685..be82d9e98 100644
--- a/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
+++ b/Software/Embedded_SW/Embedded/Modules/Control/MillisecTask.h
@@ -33,6 +33,8 @@ float getSensorSpeedData(void);
 uint32_t getDrawerFansStatus(void);
 uint32_t getSystemFansStatus(void);
 uint8_t getGasReading(void);
+int MillisecGetTemperatures (TEMPERATURE_SENSOR_ID_ENUM SensorId);
+
 
 void MillisecInit(void);
 void MillisecStop(void);
diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index c936d842c..a5f36d6a1 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -331,17 +331,17 @@ void Diagnostic100msecCollection(void)
         DiagnosticLoadMotor(WINDER_MOTOR, ThreadGetMotorSpeed (WINDER_MOTOR));
         DiagnosticLoadMotor(SCREW_MOTOR, ThreadGetMotorSpeed (SCREW_MOTOR));
     }
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, TemperatureSensorRead( MIXER_PT100));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, TemperatureSensorRead(HEAD6_PT100));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__MixerHeater, MillisecGetTemperatures( MIXER_PT100));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP1));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP2));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP3));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP4));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DYEINGH_TEMP5));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6, MillisecGetTemperatures(HEAD6_PT100));
 
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP1));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP2));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP3));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP1));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP2));
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, MillisecGetTemperatures(TEMP_SENSE_ANALOG_DRYER_TEMP3));
     for (i=0;i<MAX_SYSTEM_DISPENSERS;i++)
     {
         dispensermotorfrequency[i][DiagnosticsIndex] = IdsGetMotorSpeed(i);
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