Merge branch 'master' of https://twinetfs.visualstudio.com/Tango/_git/Tango

5 files changed, 122 insertions, 84 deletions

diff --git a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
index 72276772c..1ca1e5f84 100644
--- a/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
+++ b/Software/Embedded_SW/Embedded/Modules/Diagnostics/Diagnostics.c
@@ -228,10 +228,16 @@ void Diagnostic100msecCollection(void)
     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(TEMP_SENSE_ANALOG_MIXCHIP_TEMP));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP1));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP2));
-    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2, TemperatureSensorRead(TEMP_SENSE_ANALOG_DRYER_TEMP3));
-/*
+#ifndef DEMO_TEMPERATURE
+    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));
+#else
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, DemoTemperature[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature]*100);
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, DemoTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]*100);
+    DiagnosticLoadTemperature(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, DemoTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]*100);
+#endif
+    /*
     mixertemperature[DiagnosticsIndex] = TemperatureSensorRead(TEMP_SENSE_AN_ENCLOSURETEMP3)/100;
     headzone1temperature[DiagnosticsIndex] = TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP1)/100;
     headzone2temperature[DiagnosticsIndex] = TemperatureSensorRead(TEMP_SENSE_ANALOG_DYEINGH_TEMP2)/100;
@@ -354,9 +360,9 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.headzone4temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4];
     DiagnosticsMonitor.headzone5temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5];
     DiagnosticsMonitor.headzone6temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6];
-    DiagnosticsMonitor.dryerzone1temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w];
-    DiagnosticsMonitor.dryerzone2temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1];
-    DiagnosticsMonitor.dryerzone3temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2];
+    DiagnosticsMonitor.dryerzone1temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature];
+    DiagnosticsMonitor.dryerzone2temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain];
+    DiagnosticsMonitor.dryerzone3temperature = HeaterTemperature[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary];
 
     DiagnosticsMonitor.n_mixertemperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__MixerHeater];
     DiagnosticsMonitor.n_headzone1temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1];
@@ -365,9 +371,9 @@ void SendDiagnostics(void)
     DiagnosticsMonitor.n_headzone4temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4];
     DiagnosticsMonitor.n_headzone5temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5];
     DiagnosticsMonitor.n_headzone6temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6];
-    DiagnosticsMonitor.n_dryerzone1temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w];
-    DiagnosticsMonitor.n_dryerzone2temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1];
-    DiagnosticsMonitor.n_dryerzone3temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2];
+    DiagnosticsMonitor.n_dryerzone1temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature];
+    DiagnosticsMonitor.n_dryerzone2temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain];
+    DiagnosticsMonitor.n_dryerzone3temperature = HeaterCounterIndex[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary];
     DiagnosticsMonitor.n_blowervoltage = 1;
     DiagnosticsMonitor.blowervoltage = &voltage;
     memset(HeaterCounterIndex,0,sizeof(HeaterCounterIndex));
diff --git a/Software/Embedded_SW/Embedded/Modules/General/process.c b/Software/Embedded_SW/Embedded/Modules/General/process.c
index e254c9ff1..fda955b98 100644
--- a/Software/Embedded_SW/Embedded/Modules/General/process.c
+++ b/Software/Embedded_SW/Embedded/Modules/General/process.c
@@ -93,28 +93,29 @@ uint32_t HandleProcessParameters(ProcessParameters* ProcessParams)
                 ProcessParams->headzone6temp);
     if (ProcessParams->dryerzone1temp)
         status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w, true,
+                HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, true,
                 ProcessParams->dryerzone1temp);
     else
         status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w, false,
+                HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature, false,
                 ProcessParams->dryerzone1temp);
-    if (ProcessParams->dryerzone2temp)
+/*    if (ProcessParams->dryerzone2temp)
         status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1, true,
+                HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, true,
                 ProcessParams->dryerzone2temp);
     else
         status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1, false,
+                HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, false,
                 ProcessParams->dryerzone2temp);
     if (ProcessParams->dryerzone3temp)
         status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2, true,
+                HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, true,
                 ProcessParams->dryerzone3temp);
     else
         status |= HeaterCommandRequestMessage(
-                HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2, false,
+                HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, false,
                 ProcessParams->dryerzone3temp);
+                */
     dyeingspeed = ProcessParams->dyeingspeed;
     dryerbufferlength = ProcessParams->dryerbufferlength;
     mininkuptake = ProcessParams->mininkuptake;
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
index 280389b09..3b357ce11 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters.h
@@ -5,7 +5,7 @@
 #include "PMR/Hardware/HardwarePidControlType.pb-c.h"
 #include "heaters_ex.h"
 /******************** DEFINITIONS  ********************************************/
-#define MAX_AC_HEATERS HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2+1
+#define MAX_AC_HEATERS HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary+1
 #define MAX_TIMESLICES 200
 #define MAX_HEATERS_TEMPERATURE 300
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
index 8e16e2c01..f1b9247d3 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_init.c
@@ -232,10 +232,13 @@ uint32_t HeaterConfigRequestMessage(HardwarePidControl* request)
         HeaterControl[HeaterId].derivativetime = request->derivativetime;
         HeaterControl[HeaterId].sensorcorrectionadjustment = request->sensorcorrectionadjustment;
         //sensorminvalue,sensormaxvalue are used for the dryer heater as internal heater control
-        if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w)
+        if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature)
+        //if ((HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)||(HeaterId != HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary))
         {
-            HeaterControl[HeaterId].sensormaxvalue = request->sensormaxvalue;
-            HeaterControl[HeaterId].sensorminvalue = request->sensorminvalue;
+            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].sensormaxvalue = request->sensormaxvalue;
+            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].sensorminvalue = request->sensorminvalue;
+            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].sensormaxvalue = request->sensormaxvalue;
+            HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].sensorminvalue = request->sensorminvalue;
         }
         //HeaterControl[HeaterId].sensortypeandsetpointlimits = request->sensortypeandsetpointlimits;
         HeaterControl[HeaterId].setpointramprateorsoftstartramp = request->setpointramprateorsoftstartramp;
@@ -256,13 +259,13 @@ uint32_t HeaterConfigRequestMessage(HardwarePidControl* request)
             AcHeaterConfigured[HeaterId] = true;
 
         //check if all A/C heaters are defined. if they are - validate the configuration
-        if (((HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w)||(HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1))
-                &&HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w].configured
-                &&HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1].configured
+        if (((HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)||(HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary))
+                &&HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].configured
+                &&HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].configured
                 /*&&HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2].id*/)
         {
-            if (HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w].outputproportionalpowerlimit
-                    + HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1].outputproportionalpowerlimit
+            if (HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit
+                    + HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit
                     /*+ HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2].outputproportionalpowerlimit*/> 100)
                 ValidationError += 2;
             if (ValidationError)
@@ -310,8 +313,8 @@ uint32_t HeaterConfigSetSharedHeatersParams(uint32_t outputproportionalcycletime
    }
 
    // all numbers are rounded down. better to have carefully calculated numbers
-   Heater1000Slices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
-   Heater200aSlices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater1000Slices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater200aSlices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
 
    if ((Heater1000Slices + Heater200aSlices +2)>NumberOFSlicesInUse)
    {
@@ -321,8 +324,8 @@ uint32_t HeaterConfigSetSharedHeatersParams(uint32_t outputproportionalcycletime
 
    //mark the time slices  for heaters operation as empty / Heater1000 / Heater 200
    memset (TimeSliceAllocation,0xFF,sizeof(TimeSliceAllocation));
-   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w;
-   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1;
+   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain;
+   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary;
 
    return OK;
 
@@ -346,8 +349,8 @@ uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_ou
 
    // all numbers are rounded down. better to have carefully calculated numbers
    HeaterControl[deviceId].outputproportionalpowerlimit = new_outputproportionalpowerlimit;
-   Heater1000Slices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
-   Heater200aSlices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater1000Slices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
+   Heater200aSlices = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit * NumberOFSlicesInUse / 100;
 
 //#warning temporary disable time slice control as we are working with one heater in run time
 /*   if ((Heater1000Slices + Heater200aSlices +2)>NumberOFSlicesInUse)
@@ -358,8 +361,8 @@ uint32_t HeaterRecalculateSharedHeatersParams(uint32_t deviceId, uint32_t new_ou
 */
    //mark the time slices  for heaters operation as empty / Heater1000 / Heater 200
    memset (TimeSliceAllocation,0xFF,sizeof(TimeSliceAllocation));
-   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w;
-   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1;
+   for (Slice_i = 0; Slice_i < Heater1000Slices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain;
+   for (Slice_i = Heater1000Slices+1; Slice_i <= Heater1000Slices+Heater200aSlices;Slice_i++ ) TimeSliceAllocation[Slice_i] = HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary;
 
    return OK;
 
diff --git a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
index c873be015..01a08125a 100644
--- a/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
+++ b/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c
@@ -14,7 +14,6 @@
 
 #include "../control/control.h"
 #include "../control/pidalgo.h"
-#include "include.h"
 #include <driverlib/timer.h>
 #include <DataDef.h>
 #include <inc/hw_ints.h>
@@ -44,10 +43,15 @@ typedef struct HeatersControlMessage{
 /******************** GLOBAL PARAMETERS  ********************************************/
 HeaterCommand          HeaterCmd[MAX_HEATERS_NUM];
 uint32_t    ControlIdtoHeaterId [MAX_HEATERS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
-uint32_t    DryerHeaterMaxTempControl = 0xFF;
+uint32_t    MainDryerHeaterMaxTempControl = 0xFF;
+uint32_t    SecondDryerHeaterMaxTempControl = 0xFF;
+
+#define DRYER_AIR_PT100  TEMP_SENSE_ANALOG_DRYER_TEMP3
+#define DRYER_MAIN_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP1
+#define DRYER_SECONDARY_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP2
 
-uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {TEMP_SENSE_ANALOG_DRYER_TEMP1,TEMP_SENSE_ANALOG_DRYER_TEMP1,TEMP_SENSE_ANALOG_DRYER_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,TEMP_SENSE_AN_ENCLOSURETEMP3};
-uint32_t    DryerInternalPT100Id = TEMP_SENSE_ANALOG_DRYER_TEMP2;
+uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,TEMP_SENSE_AN_ENCLOSURETEMP3};
+uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
 bool HeatersRestart = false;
 
 bool HeaterMaxTempFlag[MAX_HEATERS_NUM] = {false,false,false,false,false,false,false,false,false,false};
@@ -114,29 +118,36 @@ void HeatersControlStart(void)
 uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
 {
     int status = OK;
-        if (HeaterId > HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2) //DC Heaters
+        if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
         {
             if (ControlIdtoHeaterId [HeaterId]!=0xFF)
             {
                 status |= RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
                 ControlIdtoHeaterId [HeaterId]=0xFF;
             }
+            DeActivateHeater(HeaterId);
         }
-        else if (HeaterId < HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2) //AC Heaters
+        else if (HeaterId < MAX_AC_HEATERS) //AC Heaters
         {
             if (ControlIdtoHeaterId [HeaterId]!=0xFF)
             {
                 status |=RemoveControlCallback(ControlIdtoHeaterId [HeaterId] ,HeaterControlCBFunction);
                 ControlIdtoHeaterId [HeaterId]=0xFF;
             }
-        }
-        if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w) //DC Heaters
-            if (DryerHeaterMaxTempControl)
+            if (MainDryerHeaterMaxTempControl)
+            {
+                status |=RemoveControlCallback(MainDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
+                MainDryerHeaterMaxTempControl=0xFF;
+            }
+            if (SecondDryerHeaterMaxTempControl)
             {
-                status |=RemoveControlCallback(DryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
-                DryerHeaterMaxTempControl=0xFF;
+                status |=RemoveControlCallback(SecondDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
+                SecondDryerHeaterMaxTempControl=0xFF;
             }
-        DeActivateHeater(HeaterId);
+            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
+            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+        }
+
     return status;
 
 }
@@ -183,6 +194,7 @@ uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
         LOG_ERROR (HeaterId,"HeaterControl not configured");
         return ERROR;
     }
+//    Turn_the_Blower_On();
 
     if (HeaterId< MAX_HEATERS_NUM)
     {
@@ -266,20 +278,35 @@ uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
     HeaterPIDConfig[HeaterId].m_mesuredParam = 0;
     HeaterPIDConfig[HeaterId].m_preError = 0;
     HeaterPIDConfig[HeaterId].m_SetParam = SetTemperatue*100;//need to update SetParams on presegment stage
-    if (HeaterId > HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2) //DC Heaters
+    if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
     {
         ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
         DCInitialHeating[HeaterId] = true;
+        HeaterReady[HeaterId] = false;
     }
-    else if (HeaterId < HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2) //AC Heaters
+    else if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
     {
-        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+#ifdef DEMO_TEMPERATURE
+        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, eHundredMillisecond,DemoTemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,0);
+        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,DemoTemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
+        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,DemoTemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
+#else
+        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
+        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
+        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
+#endif
         InitialHeating = true;
+        HeaterReady[HeaterId] = false;
     }
-    HeaterReady[HeaterId] = false;
-    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w) //Dryer Heaters
-        DryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
-
+/*    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain) //Dryer Heaters
+    {
+        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+    }
+    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary) //Dryer Heaters
+    {
+        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
+    }
+*/
 
     return OK;
 }
@@ -332,14 +359,14 @@ uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
-    if (index != HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w) //AC Heaters
+    if ((index != HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)&&(index != HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)) //AC Heaters
     {
         LOG_ERROR (IfIndex, "Wrong  Interface ");
         return 0xFFFFFFFF;
     }
     if ((readValue/100) >= HeaterControl[index].sensormaxvalue)
     {
-        if (HeaterMaxTempFlag == false)
+        if (HeaterMaxTempFlag[index] == false)
         {
             LOG_ERROR (readValue, "Heater Over the max temperature, turned off");
         }
@@ -374,7 +401,7 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
-    if (index >= HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2) //AC Heaters
+    if (index != HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
     {
         LOG_ERROR (IfIndex, "Wrong  Interface ");
         return 0xFFFFFFFF;
@@ -390,17 +417,22 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
                 {
                     HeaterControlFlag[index] = false;
-                    DeActivateHeater(index);
+                    DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
                     //Heaters OFF until coming into the proportional band
                     return OK;
                 }
         if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
                 {
+                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
                     return OK;
                 }
         else
         {
             InitialHeating = false;
+            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
+            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
             HeatersControlStart();
             HeaterReady[index] = true;
             HeaterPrepareReady();
@@ -411,12 +443,12 @@ uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         HeaterPIDConfig[index].m_mesuredParam = readValue;
         if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) //below proportional band
         {
-            HeaterRecalculateSharedHeatersParams(index, 100);
+            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 100);
             REPORT_MSG (readValue,"AC HEATER Over temperature");
         }
         else if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
         {
-            HeaterRecalculateSharedHeatersParams(index, 0);
+            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
             REPORT_MSG (readValue,"AC HEATER Under temperature");
         }
 //check only for the proportional band limits
@@ -448,7 +480,7 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         return 0xFFFFFFFF;
     }
     index = IfIndex&0xFF;
-    if (index <= HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2) //AC Heaters
+    if (index < MAX_AC_HEATERS) //AC Heaters
     {
         LOG_ERROR (IfIndex, "Wrong  Interface ");
         return 0xFFFFFFFF;
@@ -459,9 +491,9 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
         return ERROR;
     }
 /*
-    HeatingTestSendResonse(0, false,GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w),GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1),
+    HeatingTestSendResonse(0, false,GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),
                            Temperature[0],Temperature[1],
-                           HeaterPIDConfig[HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w].m_calculatedError, HeaterPIDConfig[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1].m_calculatedError,"Standard");
+                           HeaterPIDConfig[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].m_calculatedError, HeaterPIDConfig[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].m_calculatedError,"Standard");
 */
     // check if the read value is within the proportional band
     if (DCInitialHeating[index]==true)
@@ -517,7 +549,6 @@ uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
 int  SliceCounter = 0;
 void EightMilliSecondHeatersInterrupt(UArg arg0)
 {
-
     ROM_TimerIntClear(Heater_timerBase, TIMER_TIMA_TIMEOUT);  // Clear the timer interrupt
 
     ROM_IntMasterDisable();
@@ -563,37 +594,34 @@ uint32_t HeatersControlLoop(uint32_t tick)
     }
     if (InitialHeating == false)
     {
-        if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w)
+        if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
         {
-            if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w] == false)
+            if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)
             {
-                //If HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w should be active
-                //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w
-                ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w);
-                //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1);
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2);
+                //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__DryerHeater200w1)
+        else if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
         {
-            if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1] == false)
+            if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)
             {
-                //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w);
-                //If HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1 should be active
-                //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1
-                ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1);
-                ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2);
+                //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__DryerHeater1000w
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeater1000w);
-                //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeater200w1);
-                DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeater200w2);
+                //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++)