/************************************************************************************************************************
 * Heaters_print.c
 **************************************************************************************************************************/

////////////////////////////////State machine operation////////////////////////////////////
//the state machine operation is used to operate in runtime correct profile flow execution
//by recieved esign flow of the user from the UI
///////////////////////////////////////////////////////////////////////////////////////////
#include "include.h"
#include <DataDef.h>
#include <math.h>
#include "heaters.h"
#include "Heaters_ex.h"

#include "PMR/Hardware/HardwarePidControlType.pb-c.h"
#include "PMR/Hardware/HardwarePidControl.pb-c.h"
#include "PMR/Hardware/HardwareBlower.pb-c.h"
#include "PMR/Diagnostics/SetHeaterStateRequest.pb-c.h"
#include "PMR/Diagnostics/SetHeaterStateResponse.pb-c.h"
#include "PMR/Diagnostics/HeaterType.pb-c.h"
#include "PMR/Diagnostics/HeaterState.pb-c.h"
#include "PMR/common/MessageContainer.pb-c.h"
#include "PMR/Diagnostics/EventType.pb-c.h"

#include "../AlarmHandling/AlarmHandling.h"
#include "../control/control.h"
#include "../control/pidalgo.h"
#include "../control/MillisecTask.h"
#include "../Ids/Ids_ex.h"
#include "../General/process.h"

#include <ti/sysbios/knl/Task.h>
#include <driverlib/timer.h>
#include <inc/hw_ints.h>
#include <inc/hw_memmap.h>

#include "Drivers/Heater/Heater.h"
#include "Drivers/Heater/TemperatureSensor.h"
#include "Drivers/I2C_Communication/DAC/blower.h"
#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
#include "drivers/I2C_Communication/Head_Card/ADC/Head_ADC.h"
#include "Drivers/I2C_Communication/I2C.h"
#include <Drivers/I2C_Communication/I2C_Task.h>
#include <Drivers/I2C_Communication/WHS_Card/D_Max5805_ADC_Blower/WHS_Blower.h>

#include "StateMachines/Printing/PrintingSTM.h"
#include "StateMachines/Initialization/PowerIdle.h"
#include "StateMachines/Initialization/PowerOffSequence.h"
#include "StateMachines/Initialization/InitSequence.h"


/******************** Data Structures  ********************************************/
#define OVERHEAT_COUNT_LIMIT 3
#define UNDERHEAT_COUNT_LIMIT 3
#define MIN_ALLOWED_PWM 0
#define MAX_ALLOWED_PWM 255
#define ARC_ALARM_LIMIT 3

 int Overheat_Count_Limit = OVERHEAT_COUNT_LIMIT;
 int Underheat_Count_Limit = UNDERHEAT_COUNT_LIMIT;
 int  AcHeatersLoweroperationLimit = 995;
 int  AcHeatersUpperoperationLimit = 1005;
 int  DcHeatersLoweroperationLimit = 978;
 int  DcHeatersUpperoperationLimit = 1002;

typedef enum
{
    HeatersControl,
}HeatersControlMessages;

typedef struct HeatersControlMessage{
    uint16_t messageId;
    uint16_t msglen;
    uint32_t tick;
    uint8_t messageData[20];
}HeatersControlMessageStruc;
typedef struct
{
    bool                m_isEnabled;
    float            m_SetParam;
    float            m_mesuredParam;
    float               m_preError;
    float               m_integral;
    float               m_calculatedError;
    bool                m_isReady;
    PID_Config_Params   m_params;
}HeaterControlConfig_t;
HeaterControlConfig_t  HeaterPIDConfig[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
//PID_Config_Params   temp_params;

/******************** GLOBAL PARAMETERS  ********************************************/
HeaterCommand          HeaterCmd[HEATER_TYPE_MAX_HEATERS];
uint32_t    ControlIdtoHeaterId [HEATER_TYPE_MAX_HEATERS] =    {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
uint32_t    ControlIdtoMaxHeaterId [HEATER_TYPE_MAX_HEATERS] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
uint32_t    OverHeatCounter [HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
uint32_t    BlowerOverHeatCounter[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
uint32_t    BlowersControlIdtoMaxHeaterId [HEATER_TYPE_MAX_HEATERS] =  {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
uint32_t    UnderHeatCounter [HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
uint32_t    MainDryerHeaterMaxTempControl = 0xFF;
uint32_t    SecondDryerHeaterMaxTempControl = 0xFF;
uint32_t    DisasterControlId = 0xFF;

#define DRYER_AIR_PT100  TEMP_SENSE_ANALOG_DRYER_TEMP1
#define DRYER_MAIN_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP2
#define DRYER_SECONDARY_PT100 TEMP_SENSE_ANALOG_DRYER_TEMP3

bool UseSecondaryDrierHeater = true;

uint32_t HeaterId2PT100Id[HEATER_TYPE_MAX_HEATERS] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,HEAD_PT100_ZONE_1_0X80_0, HEAD_PT100_ZONE_2_0X80_1, HEAD_PT100_ZONE_3_0X82_0,
                                                      HEAD_PT100_ZONE_4_0X82_1, HEAD_PT100_ZONE_5_0X84_0, HEAD_PT100_ZONE_6_0X84_1,HEAD_PT100_MIXER_0X8E_0, HEAD_PT100_ZONE_7_0X86_0, HEAD_PT100_ZONE_8_0X86_1,
                                                      HEAD_PT100_ZONE_9_0X88_0, HEAD_PT100_ZONE_10_0X88_1, HEAD_PT100_ZONE_11_0X8A_0, HEAD_PT100_ZONE_12_0X8A_1,HEAD_PT100_AIR_HEATER_2_0X8C_1,HEAD_PT100_AIR_HEATER_1_0X8C_0 };
HEATERS_CURRENT HeaterId2CurrentId[HEATER_TYPE_MAX_HEATERS] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEAD_CURRENT_ZONE_1, HEAD_CURRENT_ZONE_2,
                                                               HEAD_CURRENT_ZONE_3, HEAD_CURRENT_ZONE_4, HEAD_CURRENT_ZONE_5, HEAD_CURRENT_ZONE_6, HEAD_CURRENT_MIXER, HEAD_CURRENT_ZONE_7,
                                                               HEAD_CURRENT_ZONE_8, HEAD_CURRENT_ZONE_9, HEAD_CURRENT_ZONE_10, HEAD_CURRENT_ZONE_11, HEAD_CURRENT_ZONE_12,HEAD_CURRENT_HTIN_1,HEAD_CURRENT_HTOT_1};
void initializeArrays(void)
{
    int i;
    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
    {
        HeaterId2PT100Id[i] = 0xFF;
        HeaterId2CurrentId[i] = NUM_OF_CURRENT_HEATERS;
    }
    if (Head_Type == HEAD_TYPE_FLAT)
    {
        HeaterId2PT100Id[HEATER_TYPE__DryerAirHeater] =       DRYER_AIR_PT100;
        HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater] =      DRYER_MAIN_PT100;
        HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater] = DRYER_SECONDARY_PT100;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone1] =          HEAD_PT100_ZONE_1_0X80_0;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone2] =          HEAD_PT100_ZONE_2_0X80_1;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone3] =          HEAD_PT100_ZONE_3_0X82_0;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone4] =          HEAD_PT100_ZONE_4_0X82_1;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone5] =          HEAD_PT100_ZONE_5_0X84_0;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone6] =          HEAD_PT100_ZONE_6_0X84_1;
        HeaterId2PT100Id[HEATER_TYPE__MixerHeater] =          HEAD_PT100_MIXER_0X8E_0;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone7] =          HEAD_PT100_ZONE_7_0X86_0;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone8] =          HEAD_PT100_ZONE_8_0X86_1;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone9] =          HEAD_PT100_ZONE_9_0X88_0;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone10] =         HEAD_PT100_ZONE_10_0X88_1;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone11] =         HEAD_PT100_ZONE_11_0X8A_0;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone12] =         HEAD_PT100_ZONE_12_0X8A_1;
        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater1] =     HEAD_PT100_AIR_HEATER_2_0X8C_1;
        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     HEAD_PT100_AIR_HEATER_1_0X8C_0 ;

        HeaterId2CurrentId[HEATER_TYPE__DryerAirHeater] =       NUM_OF_CURRENT_HEATERS;
        HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater] =      HEATER_DRYER_CURRENT_1;
        HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater] = HEATER_DRYER_CURRENT_2;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone1] =          HEAD_CURRENT_ZONE_1;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone2] =          HEAD_CURRENT_ZONE_2;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone3] =          HEAD_CURRENT_ZONE_3;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone4] =          HEAD_CURRENT_ZONE_4;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone5] =          HEAD_CURRENT_ZONE_5;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone6] =          HEAD_CURRENT_ZONE_6;
        HeaterId2CurrentId[HEATER_TYPE__MixerHeater] =          HEAD_CURRENT_MIXER;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone7] =          HEAD_CURRENT_ZONE_7;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone8] =          HEAD_CURRENT_ZONE_8;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone9] =          HEAD_CURRENT_ZONE_9;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone10] =         HEAD_CURRENT_ZONE_10;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone11] =         HEAD_CURRENT_ZONE_11;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone12] =         HEAD_CURRENT_ZONE_12;
        HeaterId2CurrentId[HEATER_TYPE__HeadCoverHeater1] =     HEAD_CURRENT_HTIN_1;
        HeaterId2CurrentId[HEATER_TYPE__HeadCoverHeater2] =     HEAD_CURRENT_HTOT_1;

    }
    else if (Head_Type == HEAD_TYPE_FLAT_WITHOUT_CARD)
    {
        HeaterId2PT100Id[HEATER_TYPE__DryerAirHeater] =       DRYER_AIR_PT100;
        HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater] =      DRYER_MAIN_PT100;
        HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater] = DRYER_SECONDARY_PT100;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone1] =          TEMP_SENSE_ANALOG_DYEINGH_TEMP1;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone2] =          TEMP_SENSE_ANALOG_DYEINGH_TEMP2;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone3] =          TEMP_SENSE_ANALOG_DYEINGH_TEMP3;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone4] =          TEMP_SENSE_ANALOG_DYEINGH_TEMP4;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone5] =          TEMP_SENSE_ANALOG_DYEINGH_TEMP5;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone6] =          HEAD6_PT100;
        HeaterId2PT100Id[HEATER_TYPE__MixerHeater] =          MIXER_PT100;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone7] =          0xFF;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone8] =          0xFF;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone9] =          0xFF;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone10] =         0xFF;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone11] =         0xFF;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone12] =         0xFF;
        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater1] =     0xFF;
        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     0xFF;

        HeaterId2CurrentId[HEATER_TYPE__DryerAirHeater] =       NUM_OF_CURRENT_HEATERS;
        HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater] =      HEATER_DRYER_CURRENT_1;
        HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater] = HEATER_DRYER_CURRENT_2;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone1] =          HEATER_HEAD_CURRENT_ZONE_1;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone2] =          HEATER_HEAD_CURRENT_ZONE_2;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone3] =          HEATER_HEAD_CURRENT_ZONE_3;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone4] =          HEATER_HEAD_CURRENT_ZONE_4;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone5] =          HEATER_HEAD_CURRENT_ZONE_5_6;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone6] =          HEATER_HEAD_CURRENT_ZONE_5_6;
        HeaterId2CurrentId[HEATER_TYPE__MixerHeater] =          HEATER_MIXCHIP_CURRENT;
    }
    else if (Head_Type == HEAD_TYPE_ARC)
    {
        HeaterId2PT100Id[HEATER_TYPE__DryerAirHeater] =       DRYER_AIR_PT100;
        HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater] =      DRYER_MAIN_PT100;
        HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater] = DRYER_SECONDARY_PT100;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone1] =          HEAD_PT100_ZONE_1_0X80_0;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone2] =          HEAD_PT100_ZONE_2_0X80_1;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone3] =          HEAD_PT100_ZONE_3_0X82_0;
        //HeaterId2PT100Id[HEATER_TYPE__HeaterZone4] =          HEAD_PT100_ZONE_4_0X82_1;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone5] =          HEAD_PT100_ZONE_5_0X84_0;
        //HeaterId2PT100Id[HEATER_TYPE__HeaterZone6] =          HEAD_PT100_ZONE_6_0X84_1;*/
        HeaterId2PT100Id[HEATER_TYPE__MixerHeater] =          HEAD_PT100_MIXER_0X8E_0;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone7] =          HEAD_PT100_ZONE_7_0X86_0;
        /*HeaterId2PT100Id[HEATER_TYPE__HeaterZone8] =          HEAD_PT100_ZONE_8_0X86_1;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone9] =          HEAD_PT100_ZONE_9_0X88_0;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone10] =         HEAD_PT100_ZONE_10_0X88_1;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone11] =         HEAD_PT100_ZONE_11_0X8A_0;
        HeaterId2PT100Id[HEATER_TYPE__HeaterZone12] =         HEAD_PT100_ZONE_12_0X8A_1;
        */
#ifdef USE_TUNNEL_PT100
        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater1] =     HEAD_PT100_ZONE_11_0X8A_0; //HEAD_PT100_AIR_HEATER_2_0X8C_1;
        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     HEAD_PT100_ZONE_12_0X8A_1; //HEAD_PT100_AIR_HEATER_1_0X8C_0;
#else
        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater1] =     HEAD_PT100_AIR_HEATER_2_0X8C_1;  //notice HEAD_PT100_AIR_HEATER_2_0X8C_1 refer to HeadCoverHeater1
        HeaterId2PT100Id[HEATER_TYPE__HeadCoverHeater2] =     HEAD_PT100_AIR_HEATER_1_0X8C_0;  //notice HEAD_PT100_AIR_HEATER_1_0X8C_0 refer to HeadCoverHeater2
#endif
        HeaterId2CurrentId[HEATER_TYPE__DryerAirHeater] =       NUM_OF_CURRENT_HEATERS;
        HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater] =      HEATER_DRYER_CURRENT_1;
        HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater] = HEATER_DRYER_CURRENT_2;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone1] =          HEAD_CURRENT_ZONE_1;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone2] =          HEAD_CURRENT_ZONE_2;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone3] =          HEAD_CURRENT_ZONE_3;
        //HeaterId2CurrentId[HEATER_TYPE__HeaterZone4] =          HEAD_CURRENT_ZONE_4;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone5] =          HEAD_CURRENT_ZONE_5;
        //HeaterId2CurrentId[HEATER_TYPE__HeaterZone6] =          HEAD_CURRENT_ZONE_6;
        HeaterId2CurrentId[HEATER_TYPE__MixerHeater] =          HEAD_CURRENT_MIXER;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone7] =          HEAD_CURRENT_ZONE_7;
        /*HeaterId2CurrentId[HEATER_TYPE__HeaterZone8] =          HEAD_CURRENT_ZONE_8;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone9] =          HEAD_CURRENT_ZONE_9;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone10] =         HEAD_CURRENT_ZONE_10;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone11] =         HEAD_CURRENT_ZONE_11;
        HeaterId2CurrentId[HEATER_TYPE__HeaterZone12] =         HEAD_CURRENT_ZONE_12;
        */
        HeaterId2CurrentId[HEATER_TYPE__HeadCoverHeater1] =     HEAD_CURRENT_HTIN_1;
        HeaterId2CurrentId[HEATER_TYPE__HeadCoverHeater2] =     HEAD_CURRENT_HTOT_1;
    }
}
uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
bool HeatersRestart = false;

bool HeaterMaxTempFlag[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false};
bool BlowerHeaterMaxTempFlag[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false};
bool HeaterMinTempFlag[HEATER_TYPE_MAX_HEATERS] = {true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true};

uint32_t OutputProportionalSingleStep = 0;  //A/C Heaters step size from one decision point to another - in cpu clocks. 120000 = 1 millisecod
uint32_t  Heater_timerBase = TIMER2_BASE;   //Timer handle
uint32_t OutputProportionalCycleTime = 0; //A/C Heaters Cycle time in milliseconds - one for all heaters
char     TimeSliceAllocation[MAX_TIMESLICES] = {0xFF};
int     DCTimeSliceAllocation[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

bool TimerActivated = false;
char ACheatstr[100];

Mailbox_Handle  HeatersControlMsgQ = NULL;
//bool InitialHeating = true;
//bool DCInitialHeating[HEATER_TYPE_MAX_HEATERS] = {true};
bool    HeaterReady[HEATER_TYPE_MAX_HEATERS] = {true};
bool    HeaterAtTemp[HEATER_TYPE_MAX_HEATERS] = {true};
uint32_t HeaterPreviousRead[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters
uint32_t HeaterSpikeRead[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters
EventType HeaterEventType[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_2_OVERTEMPERATURE,EVENT_TYPE__DRYER_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_2_OVERTEMPERATURE,
                                         EVENT_TYPE__DYEING_HEAD_ZONE_3_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_4_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_5_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_6_OVERTEMPERATURE,
                                              EVENT_TYPE__MIXER_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_7_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_8_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_9_OVERTEMPERATURE,
                                              EVENT_TYPE__DYEING_HEAD_ZONE_10_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_11_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_ZONE_12_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_BLOWER_1_OVERTEMPERATURE,EVENT_TYPE__DYEING_HEAD_BLOWER_2_OVERTEMPERATURE};
EventType HeaterUnderEventType[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_A,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_A,
                                              EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_A,
                                              EVENT_TYPE__MIXER_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_7_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_8_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_9_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_10_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_ZONE_11_UNDERTEMPERATURE_A,
                                              EVENT_TYPE__DYEING_HEAD_ZONE_12_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_BLOWER_1_UNDERTEMPERATURE_A,EVENT_TYPE__DYEING_HEAD_BLOWER_2_UNDERTEMPERATURE_A};

EventType HeaterUnderEventType_B[HEATER_TYPE_MAX_HEATERS] = {EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_2_UNDERTEMPERATURE_B,EVENT_TYPE__DRYER_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_2_UNDERTEMPERATURE_B,
                                              EVENT_TYPE__DYEING_HEAD_ZONE_3_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_4_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_5_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_6_UNDERTEMPERATURE_B,
                                              EVENT_TYPE__MIXER_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_7_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_8_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_9_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_10_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_ZONE_11_UNDERTEMPERATURE_B,
                                              EVENT_TYPE__DYEING_HEAD_ZONE_12_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_BLOWER_1_UNDERTEMPERATURE_B,EVENT_TYPE__DYEING_HEAD_BLOWER_2_UNDERTEMPERATURE_B};

int HeaterDisasterCounter[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
#define DISASTER_COUNTER_LIMIT 10

/******************** FUNCTIONS  ********************************************/
uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue);
uint32_t HeaterBlowerMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue);
uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue);
uint32_t HeaterControlCBFunction(uint32_t deviceID, uint32_t readValue);
uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue);
uint32_t HeatersDisasterControl(uint32_t x,uint32_t y);

uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue);
void HeatersStartControlTimer (void);

//**********************************************************************
//******************** CODE  *******************************************/
//**********************************************************************

void HeatersControlInit(void)
{
    int i;
    HeatersControlMsgQ = Mailbox_create(sizeof(HeatersControlMessageStruc), 20, NULL,NULL);

    HeaterConfigSetSharedHeatersParams(1000,120000*12);

    ROM_TimerConfigure(Heater_timerBase, TIMER_CFG_PERIODIC);   // 32 bits Timer
    ROM_TimerEnable(Heater_timerBase, TIMER_A);
    ROM_IntEnable(INT_TIMER2A);
    ROM_TimerIntEnable(Heater_timerBase, TIMER_TIMA_TIMEOUT);

    for (i = 0; i < HEATER_TYPE_MAX_HEATERS; i++)
    {
        //DCInitialHeating[i] = true;
        HeaterReady[i] = true;
        HeaterAtTemp[i] = true;
        HeaterCmd[i].targettemperatue = 0;
        HeaterCmd[i].command = HEATER_OFF;
        HeaterCmd[i].heaterid = i;
    }
    HeatersRestart = false;


    return;
}

/*void Heaters_SetOverHeatTimeOutValues(uint32_t OverHeatTimeout, uint32_t UnderHeatTimeout)
{
    Overheat_Count_Limit = OverHeatTimeout;
    Underheat_Count_Limit = UnderHeatTimeout;
}*/
void  Heaters_SetOperationLimits(int acheatersloweroperationlimit, int acheatersupperoperationlimit, int dcheatersloweroperationlimit, int dcheatersupperoperationlimit)
{
    AcHeatersLoweroperationLimit =  acheatersloweroperationlimit;
    AcHeatersUpperoperationLimit =  acheatersupperoperationlimit;
    DcHeatersLoweroperationLimit =  dcheatersloweroperationlimit;
    DcHeatersUpperoperationLimit =  dcheatersupperoperationlimit;
}

void HeatersControlStop(void)
{
    if (HeatersRestart == true)
    {
        ReportWithPackageFilter(HeatersFilter,"HeatersControlStop ", __FILE__,__LINE__,0, RpMessage, 0, 0);
        TimerActivated = false;
        HeatersRestart = false;
    }
}

//{eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP1,  0,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
//{eOneSecond,ALARM_SOURCE_TYPE__TemperatureAlarm,TEMP_SENSE_AN_ENCLOSURETEMP2,  1,40,true,DEBUG_LOG_CATEGORY__Warning,0xFF,0,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE      },
typedef enum{
    INTERNAL_ENCLOSURE_TEMP,
    INTERNAL_CABINET_TEMP,
    INTERNAL_MAIN_CARD_TEMP,
    MAX_INTERNAL_ALARMS
}InternalTemperatureTestPointsEnum;
int InternalAlarmCounter[MAX_INTERNAL_ALARMS] = {0,0,0};
uint32_t InternalId2PT100Id[MAX_INTERNAL_ALARMS] = {TEMP_SENSE_AN_ENCLOSURETEMP1,TEMP_SENSE_AN_ENCLOSURETEMP2,0xFF};
int32_t    InternalOverHeatCounter [MAX_INTERNAL_ALARMS] = {0,0,0};
bool    InternalAlarmActive[MAX_INTERNAL_ALARMS] = {false,false,false};
uint32_t ControlIdtoInternalId[MAX_INTERNAL_ALARMS] = {0xFF,0xFF,0xFF};
EventType InternalTempEventType[MAX_INTERNAL_ALARMS] = {EVENT_TYPE__ELECTRICAL_CABINET_OVERTEMPERATURE,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE,EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE_2};

uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValue)
{
    int index=HEATER_TYPE_MAX_HEATERS;

    if (IfIndex>>8 != IfTypeHeaters)
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return 0xFFFFFFFF;
    }
    index = IfIndex&0xFF;
    if (index >= MAX_INTERNAL_ALARMS) //Enclosure pt100
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return 0xFFFFFFFF;
    }

    readValue = MillisecGetTemperatures(InternalId2PT100Id[index]);
    if((MINIMUM_HEATER_READ*100>=readValue)||(200.00*100 < readValue))
    {
        //ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HeaterId,RpError, 0,0);
        return ERROR;
    }

    // no test for spikes yet!
    if (readValue > 4000)//40.0 c
    {
        if (InternalAlarmActive[index] == false)
        {
            ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature",__FILE__,index,readValue,RpWarning,  InternalOverHeatCounter[index],0);
            if(InternalOverHeatCounter[index]++ >=Overheat_Count_Limit*10)
            {
                InternalOverHeatCounter[index] = Overheat_Count_Limit;

                    InternalAlarmActive[index] = true;
                    AlarmHandlingSetAlarm(InternalTempEventType[index], true);
                    if (JobIsActive())
                    {
                        ReportWithPackageFilter(HeatersFilter, "Internal Temperature Error - abort job!",__FILE__,__LINE__,index,RpError, 0,0);
                        JobEndReason = JOB_TEMPERATURE_ALARM;
                        usnprintf(AlarmReasonStr, 100, "Internal Temperature %d Error %d",index,readValue);
                        SendJobProgress(0.0,0,false, "Internal Temperature Error");
                        AbortJob("Internal Over Temperature Error");
                        //SegmentReady(Module_Heaters,ModuleFail);
                        HeatersEnd();
                        return OK;
                    }
            }
        }
    }
    else
    {
        if (InternalAlarmActive[index] == true)
        {
            ReportWithPackageFilter(HeatersFilter,"Internal Under the max temperature",__FILE__,index,readValue,RpWarning,  InternalOverHeatCounter[index],0);
            if(InternalOverHeatCounter[index]-- <= 0)
            {
                InternalOverHeatCounter[index] = 0;

                InternalAlarmActive[index] = false;
                ReportWithPackageFilter(HeatersFilter,"Internal Under the max temperature, alarm turned off",__FILE__,index,readValue,RpWarning,  0,0);
                AlarmHandlingSetAlarm(InternalTempEventType[index], false);
            }

        }
    }
    return OK;
}


//#warning there is a need to separate the AC and DC heaters preparation!
void HeatersControlStart(void)
{
    int i;
    if (HeatersRestart == false)
    {
        ReportWithPackageFilter(HeatersFilter,"HeatersControlStart ", __FILE__,__LINE__,0, RpMessage, 0, 0);
        HeatersRestart = true;
        HeatersStartControlTimer();
        for (i = 0; i< (MAX_INTERNAL_ALARMS-1);i++)
        {
            if (ControlIdtoInternalId [i] == 0xFF)
            {
                ControlIdtoInternalId [i] = AddControlCallback("Internal Heaters", HeatersTestInternalAlarmsCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+i),0,0);
            }
        }
    }

}
uint32_t LoadHeaterSetPoint(HeaterType HeaterType)
{
    if (HeaterType >= HEATER_TYPE_MAX_HEATERS)
    {
        ReportWithPackageFilter(HeatersFilter,"Wrong Heater Id",__FILE__,__LINE__,HeaterType,RpError, 0,0);
        return 0;
    }
    return HeaterCmd[HeaterType].targettemperatue;
}
bool specialHeaterState = false;
void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
{
    int HeaterId = HeaterType;
    double temp = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
    //double temp = HeaterPreviousRead[HeaterId];//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);

    HeaterState->has_heatertype = true;
    HeaterState->heatertype = HeaterType;
    HeaterState->has_setpoint = true;
    HeaterState->setpoint = HeaterCmd[HeaterId].targettemperatue/100;
    //HeaterState->setpoint = DCTimeSliceAllocation[HeaterId]*100/NumberOFSlicesInUse;
    HeaterState->has_currentvalue = true;
    HeaterState->currentvalue = temp/100;//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId])/100;
    HeaterState->has_isactive = true;
    HeaterState->isactive = GetHeaterState(HeaterId);
    HeaterState->has_isrampingup = true;
    HeaterState->isrampingup = 1-HeaterAtTemp[HeaterId];
    HeaterState->has_isinsetpoint = true;
    HeaterState->isinsetpoint = HeaterReady[HeaterId];
    if (HeaterId == HEATER_TYPE__DryerMainHeater)
    {
        HeaterState->setpoint = HeaterControl[HEATER_TYPE__DryerMainHeater].outputproportionalpowerlimit;
        //HeaterState->isrampingup = InitialHeating;
        if (specialHeaterState == true)
        {
            HeaterState->setpoint = HeaterPIDConfig[HEATER_TYPE__DryerAirHeater].m_integral/10000;
        }
    }
    if (HeaterId == HEATER_TYPE__DryerSecondaryHeater)
    {
        HeaterState->setpoint = HeaterControl[HEATER_TYPE__DryerSecondaryHeater].outputproportionalpowerlimit;
        //HeaterState->isrampingup = InitialHeating;
        if (specialHeaterState == true)
        {
            HeaterState->setpoint = HeaterPIDConfig[HEATER_TYPE__DryerAirHeater].m_calculatedError/100;
        }
    }
    return;
}
uint32_t HeatersSingleHeaterEnd(int HeaterId)
{
    int status = OK;
    assert(HeaterId < HEATER_TYPE_MAX_HEATERS);
    //HEATER_TYPE_ENUM HeaterId = HeaterPidtoHeaterId(HeaterPID_Id);
    ReportWithPackageFilter(HeatersFilter,"HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, HeaterPIDConfig[HeaterId].m_SetParam, 0);
        if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
        {
            if (ControlIdtoHeaterId [HeaterId]!=0xFF)
            {
                status |= RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
                ControlIdtoHeaterId [HeaterId]=0xFF;
            }
            if (ControlIdtoMaxHeaterId [HeaterId]!=0xFF)
            {
                status |= RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
                ControlIdtoMaxHeaterId [HeaterId]=0xFF;
            }
#ifdef USE_TUNNEL_PT100
            if (BlowersControlIdtoMaxHeaterId [HeaterId]!=0xFF)
            {
                status |= RemoveControlCallback(BlowersControlIdtoMaxHeaterId [HeaterId], HeaterBlowerMaxTempCBFunction);
                BlowersControlIdtoMaxHeaterId [HeaterId]=0xFF;
            }
#endif
            HeaterRecalculateHeaterParams(HeaterId, 0);
            DeActivateHeater(HeaterId);
            HeaterPIDConfig[HeaterId].m_SetParam = 0;
            HeaterCmd[HeaterId].targettemperatue = 0;
            HeaterReady[HeaterId] = true;
            HeaterAtTemp[HeaterId] = true;
            if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
                Disable_Reading_Heaters_ADC(HeaterId2CurrentId[HeaterId]);
            else
                Disable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
        }
        else if (HeaterId < MAX_AC_HEATERS) //AC Heaters
        {
            if (ControlIdtoHeaterId [HeaterId]!=0xFF)
            {
                status |=RemoveControlCallback(ControlIdtoHeaterId [HeaterId] ,HeaterControlCBFunction);
                ControlIdtoHeaterId [HeaterId]=0xFF;
            }
            if (ControlIdtoMaxHeaterId [HeaterId]!=0xFF)
            {
                status |= RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
                ControlIdtoMaxHeaterId [HeaterId]=0xFF;
            }
            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
            if (MainDryerHeaterMaxTempControl)
            {
                status |=RemoveControlCallback(MainDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
                MainDryerHeaterMaxTempControl=0xFF;
            }
            if (SecondDryerHeaterMaxTempControl)
            {
                status |=RemoveControlCallback(SecondDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
                SecondDryerHeaterMaxTempControl=0xFF;
            }
            DeActivateHeater(HEATER_TYPE__DryerMainHeater);
            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
            HeaterPIDConfig[HeaterId].m_SetParam = 0;
            HeaterCmd[HeaterId].targettemperatue = 0;
            HeaterReady[HeaterId] = true;
            HeaterAtTemp[HeaterId] = true;
        }

    AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false);
    AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false);
    AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);
    return status;

}
//this function returns preparation ratio for the most cool heater (current temperature/ target temerature)
double HeatersPrepareProgress(void)
{
    HardwarePidControlType i;
    double MaxDifference = 1.00,temp = 0;
    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
    {
        if(HeaterCmd[i].targettemperatue)
        {
            if (MillisecGetTemperatures(HeaterId2PT100Id[i])>=HeaterCmd[i].targettemperatue)
                continue;
            temp = (double)(MillisecGetTemperatures(HeaterId2PT100Id[i]))/(double)(HeaterCmd[i].targettemperatue);
            if (temp<MaxDifference)
                MaxDifference = temp;
        }
    }
    //Report("HeatersPrepareProgress" ,__FILE__,__LINE__,(int)(MaxDifference*100),RpWarning,0,0);

    return MaxDifference;

}


uint32_t HeatersEnd(void)
{
    HardwarePidControlType i;
    uint32_t status = OK;
    HeatersControlStop();
    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
    {
        if(HeaterIdtoHeaterpid[i]!=HEATER_TYPE_MAX_HEATERS)
            status = HeatersSingleHeaterEnd(i);
    }
    return status;

}


void HeatersStartControlTimer (void)
{
    if (TimerActivated == true)
        return;
    TimerActivated = true;
    ROM_TimerConfigure(Heater_timerBase, TIMER_CFG_PERIODIC);   // 32 bits Timer
    ROM_TimerLoadSet(Heater_timerBase, TIMER_A,OutputProportionalSingleStep /*twelve millisecond???*/);
    ROM_TimerEnable(Heater_timerBase, TIMER_A);
    ROM_IntEnable(INT_TIMER2A);
    ROM_TimerIntEnable(Heater_timerBase, TIMER_TIMA_TIMEOUT);
    ReportWithPackageFilter(HeatersFilter,"HeatersStartControlTimer ", __FILE__,__LINE__,0, RpMessage, 0, 0);
    return;
}
/***************************************************************************************************
int GetFilteredHeaterRead(int HeaterId)
{
#define MAX_FILTER 12
    int i,maxread = -999999,minread = 999999,sum=0;
    int FilteredRead[MAX_FILTER];
    for (i = 0; i < MAX_FILTER;i++)
    {
        FilteredRead[i] = TemperatureSensorRead(HeaterId2PT100Id[HeaterId]);
        Task_sleep(1);
    }
    for (i = 0; i < MAX_FILTER;i++)
    {
        if (FilteredRead[i]<minread)
            minread = FilteredRead[i];
        if (FilteredRead[i]>maxread)
            maxread = FilteredRead[i];
        sum+=FilteredRead[i];
    }
    sum -= minread;
    sum -= maxread;
    ReportWithPackageFilter(HeatersFilter,"GetFilteredHeaterRead ", __FILE__,HeaterId,sum, minread, maxread, 0);
    return (sum/(MAX_FILTER-2));
}
**************************************************************************************
 * HeaterCommandRequestMessage
 * called by: Communication from host
 * initialized all global data
 *************************************************************************************/
bool HeaterRestarted[HEATER_TYPE_MAX_HEATERS] = {false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false};

void SetHeaterStateRequestFunc(MessageContainer* requestContainer)
{

    uint32_t status = PASSED;
    MessageContainer responseContainer;

    SetHeaterStateRequest* request = set_heater_state_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    SetHeaterStateResponse response = SET_HEATER_STATE_RESPONSE__INIT;

    if (request->has_heatertype)
    {
        if ((request->has_isactive)&&(request->has_setpoint))
            status = HeaterCommandRequestMessage(request->heatertype,true,request->setpoint);
        else
            status = HeaterCommandRequestMessage(request->heatertype,false,request->setpoint);
    }

    responseContainer = createContainer(MESSAGE_TYPE__SetHeaterStateResponse, requestContainer->token, true, &response, &set_heater_state_response__pack, &set_heater_state_response__get_packed_size);
    if (status)
    {
        responseContainer.has_error = true;
        responseContainer.error = (ErrorCode)status;
    }
    //-------------------------------------------------------------------------------------------
    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    free(responseContainer.data.data);
    SendChars((char*)container_buffer, container_size);

    set_heater_state_request__free_unpacked(request,NULL);

}
uint32_t  HeaterCommandRequestMessage(int HeaterNum, bool OnOff, int Temperature)
{
    //uint32_t status = NOT_SUPPORTED;
    //MessageContainer responseContainer;
    int HeaterId = getHeaterId(HeaterNum);

    if (HeaterControl[HeaterId].configured == false)
    {
        ReportWithPackageFilter(HeatersFilter,"HeaterControl not configured",__FILE__,__LINE__,HeaterId,RpError, 0,0);
        return ERROR;
    }
//    Turn_the_Blower_On();

    if (HeaterId< HEATER_TYPE_MAX_HEATERS)
    {
        if (HeaterControl[HeaterId].id != HeaterId) // heater configuration missing
        {
            ReportWithPackageFilter(HeatersFilter, "Heater is not yet configured",__FILE__,__LINE__,HeaterId,RpError, 0,0);
            return ERROR;
        }
        HeaterCmd[HeaterId].heaterid = HeaterId;
        HeaterCmd[HeaterId].command = OnOff;
        HeaterCmd[HeaterId].targettemperatue = Temperature*100;
    }
    bool HeaterState;
    if ( ControlIdtoHeaterId [HeaterId] == 0xFF)
    {
        HeaterState = false;
    }
    else
    {
        HeaterState = HeaterReady[HeaterId];//GetHeaterState(HeaterId);
    }

    if ((HeaterState == HEATER_OFF)&& (OnOff == HEATER_ON)) //start heating
    {
        ReportWithPackageFilter(HeatersFilter,"HeaterCommandRequest OFF-> ON",__FILE__,HeaterId,Temperature*100,RpWarning,HeaterState,  0);
        //set the heater control parameters
        //set the target operation temperature
        //start the control
        PrepareHeater(HeaterId,Temperature);  //prepare the heaters control info
        //set the power balance handler (if not set yet)
        // if the heater is off (?) start it.
        //ActivateHeater(HeaterId);
        //set the heater operation mode to fast heating - depended on the current temperature
        // timers are prepared but not started yet!!! only when the system is hot.

    }
    else if ((HeaterState == HEATER_ON)&& (OnOff == HEATER_ON)) //set temperature
    {
        ReportWithPackageFilter(HeatersFilter,"HeaterCommandRequest ON-> ON",__FILE__,HeaterId,Temperature*100,RpWarning,HeaterState,  0);
        //HeaterPIDConfig[HeaterId].m_SetParam = HeaterCmd[HeaterId].targettemperatue;
        if (abs(HeaterPIDConfig[HeaterId].m_SetParam - HeaterCmd[HeaterId].targettemperatue)>0.5)  //#bug 221
        {
            PrepareHeater(HeaterId,Temperature);  //prepare the heaters control info
        }
        else
        {
            //HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId);//
            ReportWithPackageFilter(HeatersFilter,"Restarting same temperature Heater Temp",__FILE__,HeaterId,HeaterPIDConfig[HeaterId].m_calculatedError,RpWarning,HeaterPreviousRead[HeaterId],  0);
            HeaterRestarted[HeaterId] = true;
        }
        //PrepareHeater(HeaterId,Temperature);  //prepare the heaters control info
        // if the heater is not on return (?).
        //set the target operation temperature
        //set the heater operation mode to fast heating - depended on the current temperature
    }
    else if (OnOff == HEATER_OFF)//((HeaterState == HEATER_ON)&& (OnOff == HEATER_OFF)) //stop heating
    {
        //stop the control
        HeaterPIDConfig[HeaterId].m_SetParam  = 0;
       //turn off the heater
        HeatersSingleHeaterEnd(HeaterId);
    }

    //usnprintf(ACheatstr, 254, "HeaterCommandRequestMessage(Id %d,OnOff %d,Temperature %d)",HeaterId,  OnOff,  Temperature);
    //ReportWithPackageFilter(HeatersFilter,"HeaterCommandRequestMessage",__FILE__,Temperature,HeaterId,RpWarning,HeaterState,  0);
    //ReportWithPackageFilter(HeatersFilter,"HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, 0, 0);

    return OK;
}
/*
 * PrepareHeater
 * called by: Communication from host
 * initialized all global data
 */
void PrepareACHeater(int HeaterId,uint32_t Frequency, uint32_t SetTemperatue)
{
    if (ControlIdtoHeaterId [HeaterId] == 0xFF)
    {
        ControlIdtoHeaterId [HeaterId] = AddControlCallback("HeatersControl", HeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
        //HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(DryerInternalPT100Id);
        HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//
        //ReportWithPackageFilter(HeatersFilter,"PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
        HeaterPreviousRead[HEATER_TYPE__DryerMainHeater] =  MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);//MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);
        HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]  = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);// = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);
        if((HeaterPreviousRead[HEATER_TYPE__DryerMainHeater]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HEATER_TYPE__DryerMainHeater])||
           (HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]))
        {
            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HEATER_TYPE__DryerMainHeater,RpError, HeaterPreviousRead[HEATER_TYPE__DryerMainHeater],0);
            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HEATER_TYPE__DryerSecondaryHeater,RpError, HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater],0);
            if (ControlIdtoMaxHeaterId [HeaterId] != 0xFF)
            {
                RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
                ControlIdtoMaxHeaterId [HeaterId] = 0xFF;
            }
#ifdef USE_TUNNEL_PT100
            if (BlowersControlIdtoMaxHeaterId [HeaterId]!=0xFF)
            {
                RemoveControlCallback(BlowersControlIdtoMaxHeaterId [HeaterId], HeaterBlowerMaxTempCBFunction);
                BlowersControlIdtoMaxHeaterId [HeaterId] = 0xFF;
            }
#endif
            if (ControlIdtoHeaterId [HeaterId] != 0xFF)
            {
                RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
                ControlIdtoHeaterId [HeaterId] = 0xFF;
            }
            DeActivateHeater(HeaterId);
            HeaterCmd[HeaterId].targettemperatue = 0;
            AlarmHandlingSetAlarm(EVENT_TYPE__TEMPERATURE_MEASUREMENT_ERROR, true);

            return;
        }

    }
    else
    {
        ReportWithPackageFilter(HeatersFilter,"PrepareACHeater control still running",__FILE__,HeaterId,ControlIdtoHeaterId [HeaterId],RpError, HeaterCmd[HeaterId].targettemperatue,0);
        HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//
        //ReportWithPackageFilter(HeatersFilter,"PrepareHeater AC Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
        HeaterPreviousRead[HEATER_TYPE__DryerMainHeater] =  MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);//MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater]);
        HeaterPreviousRead[HEATER_TYPE__DryerSecondaryHeater]  = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);// = MillisecGetTemperatures(HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater]);

    }
    //turn all alarms off
        AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false);
        AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false);
        AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);

    if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback("HeatersMax", DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);

    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
    if (UseSecondaryDrierHeater == true)
        Enable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);

    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, 0);
    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
    if (MainDryerHeaterMaxTempControl == 0xFF)
        MainDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HEATER_TYPE__DryerMainHeater),HeaterId2PT100Id[HEATER_TYPE__DryerMainHeater],0);
    if (SecondDryerHeaterMaxTempControl == 0xFF)
        SecondDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HEATER_TYPE__DryerSecondaryHeater),HeaterId2PT100Id[HEATER_TYPE__DryerSecondaryHeater],0);
    //InitialHeating = true;
    HeaterReady[HeaterId] = false;
    HeaterAtTemp[HeaterId] = false;
    if (BlowerCfg.enabled == true)
    {
        if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
        {
            WHS_Set_SetPoint_Q_value(headairflow);
        }
        else
        {
            Turn_the_Blower_On();//Turn on with the Default_Voltage
            if (BlowerCfg.heatingvoltage)
                Control_Voltage_To_Blower(BlowerCfg.heatingvoltage);
            else
                Control_Voltage_To_Blower(BlowerCfg.voltage-500);
        }
    }
    if (SetTemperatue)
    {
        Control_Dryer_Fan(START,75);//use START or STOP,  0 - 100%
        ReportWithPackageFilter(HeatersFilter,"Control_Dryer_Fan",__FILE__,__LINE__,START,RpError, 75,0);
    }
}
/*
 * PrepareHeater
 * called by: Communication from host
 * initialized all global data
 */
int PrepareDCHeater(int HeaterId, uint32_t Frequency, uint32_t SetTemperatue)
{
    if (DisasterControlId == 0xFF)
        DisasterControlId = AddControlCallback("Heaters Disaster", HeatersDisasterControl, eOneSecond,TemplateDataReadCBFunction,0,0, 0);

    HeaterPreviousRead[HeaterId] = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);//MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
    if((HeaterPreviousRead[HeaterId]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HeaterId]))
    {
        ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,HeaterId,HeaterPreviousRead[HeaterId],RpError, 0,0);
        if (ControlIdtoMaxHeaterId [HeaterId] != 0xFF)
        {
            RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
            ControlIdtoMaxHeaterId [HeaterId] = 0xFF;
        }
#ifdef USE_TUNNEL_PT100
        if (BlowersControlIdtoMaxHeaterId [HeaterId]!=0xFF)
        {
            RemoveControlCallback(BlowersControlIdtoMaxHeaterId [HeaterId], HeaterBlowerMaxTempCBFunction);
            BlowersControlIdtoMaxHeaterId [HeaterId]=0xFF;
        }
#endif
        if (ControlIdtoHeaterId [HeaterId] != 0xFF)
        {
            RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
            ControlIdtoHeaterId [HeaterId] = 0xFF;
        }
        DeActivateHeater(HeaterId);
        AlarmHandlingSetAlarm(EVENT_TYPE__TEMPERATURE_MEASUREMENT_ERROR, true);
        HeaterCmd[HeaterId].targettemperatue = 0;

        return ERROR;
    }
    if (ControlIdtoHeaterId [HeaterId] == 0xFF)
        ControlIdtoHeaterId [HeaterId] = AddControlCallback("DCHeatersControl", DCHeaterControlCBFunction, Frequency/*eOneSecond*/,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
    //HeaterPIDConfig[HeaterId].m_params.dt *=10;
    //DCInitialHeating[HeaterId] = true;
    HeaterReady[HeaterId] = false;
    HeaterAtTemp[HeaterId] = false;
    HeaterRecalculateHeaterParams(HeaterId, 0);

    //turn all alarms off
    AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false);
    AlarmHandlingSetAlarm(HeaterUnderEventType_B[HeaterId], false);
    AlarmHandlingSetAlarm(HeaterEventType[HeaterId], false);

    if (HeaterPreviousRead[HeaterId] < HeaterCmd[HeaterId].targettemperatue )
    {
        if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
            Enable_Reading_Heaters_ADC(HeaterId2CurrentId[HeaterId]);
        else
            Enable_Reading_Heaters_Current(HeaterId2CurrentId[HeaterId]);
    }

    //ReportWithPackageFilter(HeatersFilter,"PrepareHeater Read", __FILE__,HeaterId, SetTemperatue, RpWarning,HeaterPreviousRead[HeaterId], 0);
    if (ControlIdtoMaxHeaterId [HeaterId] == 0xFF)
        ControlIdtoMaxHeaterId [HeaterId] = AddControlCallback("DcHeatersMax", DcHeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
#ifdef USE_TUNNEL_PT100
    if ((HeaterId == HEATER_TYPE__HeadCoverHeater1)||(HeaterId == HEATER_TYPE__HeadCoverHeater2)) //tunnel Heaters
    {
        if (BlowersControlIdtoMaxHeaterId [HeaterId] == 0xFF)
            BlowersControlIdtoMaxHeaterId [HeaterId] = AddControlCallback("DcHeatersMax", HeaterBlowerMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
    }
#endif
    return OK;
}
/*
 * PrepareHeater
 * called by: Communication from host
 * initialized all global data
 */
uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
{
    double temp ;
    CTRL_TIMING_ENUM Frequency = eOneSecond;
    if(HeaterId >= HEATER_TYPE_MAX_HEATERS)
    {
        ReportWithPackageFilter(HeatersFilter,"HeaterId too high",__FILE__,__LINE__,HeaterId,RpError, 0,0);
        return ERROR;
    }

    //ReportWithPackageFilter(HeatersFilter,"PrepareHeater ", __FILE__,__LINE__,HeaterId, SetTemperatue, 0, 0);

    //start thread control for all motors
    HeaterPIDConfig[HeaterId].m_params.MAX = HeaterControl[HeaterId].outputproportionalpowerlimit*100;
    HeaterPIDConfig[HeaterId].m_params.MIN = 0.0;
    HeaterPIDConfig[HeaterId].m_params.Kd = HeaterControl[HeaterId].kd;
    HeaterPIDConfig[HeaterId].m_params.Kp = HeaterControl[HeaterId].kp;
    HeaterPIDConfig[HeaterId].m_params.Ki = HeaterControl[HeaterId].ki;
    HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier = HeaterControl[HeaterId].IntegralErrorMultiplier;
    HeaterPIDConfig[HeaterId].m_params.ProportionalErrorMultiplier = HeaterControl[HeaterId].ProportionalErrorMultiplier;
    HeaterPIDConfig[HeaterId].m_params.dt = HeaterControl[HeaterId].dt;
    HeaterPIDConfig[HeaterId].m_params.epsilon = HeaterControl[HeaterId].epsilon; //0.1 degree
    HeaterPIDConfig[HeaterId].m_calculatedError = 0;
    HeaterPIDConfig[HeaterId].m_integral = 0;
    HeaterPIDConfig[HeaterId].m_isEnabled = true;
    HeaterPIDConfig[HeaterId].m_isReady = true;
    HeaterPIDConfig[HeaterId].m_mesuredParam = 0;
    HeaterPIDConfig[HeaterId].m_preError = 0;
    HeaterPIDConfig[HeaterId].m_SetParam = SetTemperatue*100;//need to update SetParams on presegment stage

    int band = 10;
    if (HeaterControl[HeaterId].outputproportionalband)
    {
        band = HeaterControl[HeaterId].outputproportionalband+2; //sometimes after PID is started the temp is falling a little bit. we want to avoid an alarm
    }
    temp = SetTemperatue*(100+band);
    //temp = SetTemperatue*110.0;
    HeaterControl[HeaterId].sensormaxvalue = (int)temp;

    temp = SetTemperatue*(100-band);
    //temp = SetTemperatue*90.0;
    HeaterControl[HeaterId].sensorminvalue = (int)temp;
    //ReportWithPackageFilter(HeatersFilter,"Temperature limits",__FILE__,HeaterId,HeaterControl[HeaterId].sensormaxvalue,RpWarning,HeaterControl[HeaterId].sensorminvalue, 0);

    if (HeaterPIDConfig[HeaterId].m_params.IntegralErrorMultiplier)
    {
        Frequency = eOneSecond*HeaterPIDConfig[HeaterId].m_params.dt;
    }
    if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
    {
        ReportWithPackageFilter(HeatersFilter,"call PrepareDCHeater",__FILE__,HeaterId,SetTemperatue,RpWarning,HeaterPreviousRead[HeaterId], 0);
        if (PrepareDCHeater(HeaterId,Frequency,SetTemperatue)!=OK)
            return ERROR;
    }
    else if (HeaterId == HEATER_TYPE__DryerAirHeater) //AC Heaters
    {
        ReportWithPackageFilter(HeatersFilter,"call PrepareACHeater",__FILE__,HeaterId,SetTemperatue,RpWarning,HeaterPreviousRead[HeaterId], 0);
        PrepareACHeater(HeaterId,Frequency,SetTemperatue);
    }
    return OK;
}
bool isHeaterReady(uint8_t HeaterId)
{
    if (HeaterId<HEATER_TYPE_MAX_HEATERS)
        return HeaterReady[HeaterId];
    else
        return false;
}
bool HeaterCheckReady(void)
{
    int i;
    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
    {
        if (HeaterAtTemp[i] == false)
        {
            return false; //not all configured heaters are ready
        }
    }
    return true;
}
int HeaterPrepareFailureCheckCounter = 0;
uint32_t HeaterPrepareFailureCheckTemperatures[HEATER_TYPE_MAX_HEATERS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters

void HeaterPrepareFailureCheck(void)
{
    int i;
    int band = 200;
    if (GetHeatersPrepareWaiting() == false)
    {
        HeaterPrepareFailureCheckCounter = 0;
        return;
    }
    if (HeaterPrepareFailureCheckCounter%60 == 0)
        ReportWithPackageFilter(HeatersFilter,"HeaterPrepareFailureCheck",__FILE__,HeaterPrepareFailureCheckCounter,GetHeatersPrepareWaiting(),RpWarning,HeaterCheckReady(), 0);
    if ((HeaterPrepareFailureCheckCounter>=300)&&(HeaterPrepareFailureCheckCounter%60 == 0))
    {
        for (i = 0; i<HEATER_TYPE_MAX_HEATERS; i++)
        {
            if(HeaterReady[i] == false)
            {
                if ((i == HEATER_TYPE__DryerAirHeater)||(i == HEATER_TYPE__HeadCoverHeater1)||(i == HEATER_TYPE__HeadCoverHeater2))
                    band = 50;
                else
                    band = 200;
                if (abs (HeaterPrepareFailureCheckTemperatures[i] - HeaterPreviousRead[i])<band) // no temperature move in the last 5 minutes
                {
                    ReportWithPackageFilter(HeatersFilter,"HeaterPrepareFailureCheck",__FILE__,i,HeaterPrepareFailureCheckTemperatures[i],RpWarning,HeaterPreviousRead[i], 0);
                    JobEndReason = JOB_TEMPERATURE_ALARM;
                    usnprintf(AlarmReasonStr, 100, "Temperature not getting into work zone!!!");
                    PrepareReady(Module_Heaters,ModuleFail);
                    return;
                }
            }
            HeaterPrepareFailureCheckTemperatures[i] = HeaterPreviousRead[i];
        }
        //test temp progress
    }
    HeaterPrepareFailureCheckCounter++;
}
void HeaterPrepareReady(void)
{
    int i;
    if (GetHeatersPrepareWaiting() == false)
    {
        return;
    }
    for (i=0;i<HEATER_TYPE_MAX_HEATERS;i++)
    {
        if (HeaterAtTemp[i] == false)
        {
            return; //not all configured heaters are ready
        }
    }
    PrepareReady(Module_Heaters,ModuleDone);
    IDSPrepareStart();
    HeadBlowersV0Init();
}
/*
 * HeaterControlCBFunction
 * called by: Communication from host
 * initialized all global data
 */
bool HeaterGetOverTemperatureState(uint8_t HeaterId)
{
    if (HeaterId > HEATER_TYPE_MAX_HEATERS) return false;
    return HeaterMaxTempFlag[HeaterId];
}
uint32_t MainPT100Read = 0,SecondaryPT100Read = 0;
uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
{
    int index=HEATER_TYPE_MAX_HEATERS;
    int32_t MaxreadValue;

    if (IfIndex>>8 != IfTypeHeaters)
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return 0xFFFFFFFF;
    }
    index = IfIndex&0xFF;
    if ((index != HEATER_TYPE__DryerMainHeater)&&(index != HEATER_TYPE__DryerSecondaryHeater)) //AC Heaters
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return 0xFFFFFFFF;
    }
    //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 AC",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
#ifdef IGNORE_SPIKE
        HeaterPreviousRead[index] = readValue;
#else
        if (HeaterSpikeRead[index] == 0)
        {
            HeaterSpikeRead[index] = readValue;
        }
        else
        {
            ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
            HeaterPreviousRead[index] = HeaterSpikeRead[index];
            HeaterSpikeRead[index] = 0;
        }
        //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)
    {
        MainPT100Read = readValue;
    }
    if (index == HEATER_TYPE__DryerSecondaryHeater)
    {
        SecondaryPT100Read = readValue;
    }
    MaxreadValue = max (MainPT100Read,SecondaryPT100Read);


    if (MaxreadValue >= HeaterControl[index].sensormaxvalue)
    {
        if (HeaterMaxTempFlag[index] == false)
        {
            //LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
            ReportWithPackageFilter(HeatersFilter," AC Heater Over the max temperature, turned off",__FILE__,index,HeaterReady[index],RpWarning,HeaterControl[index].sensormaxvalue, 0);
        }
        DeActivateHeater(HEATER_TYPE__DryerMainHeater);
        HeaterMaxTempFlag[index] = true;
        //HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
        DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
        //HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] = true;
        //HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
        return OK;
    }
    if (MaxreadValue <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
    {
        if (HeaterControl[index].sensorminvalue > 0)
        {
            if (HeaterMaxTempFlag[index] == true)
            {
               /* ActivateHeater(HEATER_TYPE__DryerMainHeater);
                if (HeaterReady[HEATER_TYPE__DryerAirHeater]==false)
                {
                    ActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
                }*/
                //ReportWithPackageFilter(HeatersFilter, "Heater Cooled Off max temperature, turned on",__FILE__,__LINE__,(MinreadValue/100),RpError, 0,0);
            }
            HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] = false;
            HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] = false;
        }
        return OK;
    }
    return ERROR;
}

uint32_t HeaterBlowerMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
{
    uint32_t BlowerPt100Read = 0;

    int index=HEATER_TYPE_MAX_HEATERS;

    if (IfIndex>>8 != IfTypeHeaters)
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return 0xFFFFFFFF;
    }
    if (Head_Type != HEAD_TYPE_ARC)
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  head type",__FILE__,__LINE__,Head_Type,RpError, 0,0);
        return 0xFFFFFFFF;
    }
    index = IfIndex&0xFF;
    if ((index != HEATER_TYPE__HeadCoverHeater1)&&(index != HEATER_TYPE__HeadCoverHeater2)) //AC Heaters
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, index,0);
        return 0xFFFFFFFF;
    }
    //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]);
    if (Head_Type == HEAD_TYPE_ARC) {
        if (index == HEATER_TYPE__HeadCoverHeater1) {
            BlowerPt100Read = MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_2_0X8C_1);
        }
        if (index == HEATER_TYPE__HeadCoverHeater2) {
            BlowerPt100Read = MillisecGetTemperatures(HEAD_PT100_AIR_HEATER_1_0X8C_0);
        }
    }

    if (BlowerPt100Read > 26000)
    {
        if (index == HEATER_TYPE__HeadCoverHeater1)
        {
            DeActivateHeater(HEATER_TYPE__HeadCoverHeater1);
            HeaterRecalculateHeaterParams(HEATER_TYPE__HeadCoverHeater1,0);
        }
        else
        {
            DeActivateHeater(HEATER_TYPE__HeadCoverHeater2);
            HeaterRecalculateHeaterParams(HEATER_TYPE__HeadCoverHeater2,0);
        }
        BlowerHeaterMaxTempFlag[index] = true;
    } else {
        if (BlowerPt100Read <= 25800)
        {
           BlowerHeaterMaxTempFlag[index] = false;
        }
    }
    return OK;
}

uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
{
    int index=HEATER_TYPE_MAX_HEATERS;
    if (IfIndex>>8 != IfTypeHeaters)
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return 0xFFFFFFFF;
    }
    index = IfIndex&0xFF;
    //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]);
    if (HeaterControl[index].sensormaxvalue == 0)
        return OK;
    if ((HeaterPreviousRead[index]) >= HeaterControl[index].sensormaxvalue)
    {
        if(OverHeatCounter[index]++ >=Overheat_Count_Limit)
        {
            OverHeatCounter[index] = Overheat_Count_Limit;
            //?????HeaterReady[index] = false;
            if (JobIsActive()&&(HeaterReady[index]==true))
            {
                ReportWithPackageFilter(HeatersFilter, "Temperature Error - abort job!",__FILE__,__LINE__,index,RpError, 0,0);
                JobEndReason = JOB_TEMPERATURE_ALARM;
                usnprintf(AlarmReasonStr, 100, "Temperature %d Error %d",index,readValue);
                SendJobProgress(0.0,0,false, "Temperature Error");
                AbortJob("Over Temperature Error");
                //SegmentReady(Module_Heaters,ModuleFail);
                return OK;
            }
            //if (getIdleState() == false)
                //not idle, not cooling to temp
            {
                if ((HeaterReady[index]==false)&&(HeaterPreviousRead[index]>HeaterCmd[index].targettemperatue))
                {
                    ReportWithPackageFilter(HeatersFilter,"DC Heater Over the max temperature, cooling off",__FILE__,index,HeaterPreviousRead[index],RpWarning,  HeaterCmd[index].targettemperatue,0);
                }
                else
                {
                    ReportWithPackageFilter(HeatersFilter,"DC Heater Over the max temperature, turned off",__FILE__,index,HeaterPreviousRead[index],RpWarning,  HeaterReady[index],0);
                    ReportWithPackageFilter(HeatersFilter,"Heater over the max temperature",__FILE__,index,OverHeatCounter[index],RpWarning,HeaterControl[index].sensormaxvalue,  0);
                    AlarmHandlingSetAlarm(HeaterEventType[index], true);
                }
            }
        }
        if (index == HEATER_TYPE__DryerAirHeater)
        {
            DeActivateHeater(HEATER_TYPE__DryerMainHeater);
            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
        }
        else
        {
            DeActivateHeater(index);
            HeaterRecalculateHeaterParams(index, 0);
        }
        HeaterMaxTempFlag[index] = true;
        //ReportWithPackageFilter(HeatersFilter,(MinreadValue/100), "Heater Over the max temperature, turned off");
        return OK;
    }
    else if ((HeaterPreviousRead[index]) < (HeaterControl[index].sensorminvalue))
    {
        if (HeaterReady[index]==true)
        {
            ReportWithPackageFilter(HeatersFilter,"Heater under the min temperature",__FILE__,index,UnderHeatCounter[index],RpWarning,HeaterControl[index].sensorminvalue,  0);
            ReportWithPackageFilter(HeatersFilter,"Heater under the min temperature more info",__FILE__,HeaterReady[index],GetHeaterState(index),RpWarning,HeaterPreviousRead[index],  0);
        }
        if(UnderHeatCounter[index]++ >=Underheat_Count_Limit)
        {
            UnderHeatCounter[index] = Underheat_Count_Limit;
            //???HeaterReady[index] = false;
            if (JobIsActive()&&(HeaterReady[index]==true))
            {
                ReportWithPackageFilter(HeatersFilter, "Temperature Error - abort job!",__FILE__,__LINE__,index,RpError, 0,0);
                JobEndReason = JOB_TEMPERATURE_ALARM;
                usnprintf(AlarmReasonStr, 100, "Temperature %d Error %d",index,readValue);
                SendJobProgress(0.0,0,false, "Temperature Error");
                AbortJob("Under Temperature Error");
                return OK;
            }
            //HeaterMinTempFlag[index] = true;
            if (HeaterReady[index]==false)
                AlarmHandlingSetAlarm(HeaterUnderEventType[index], true);
            else
                AlarmHandlingSetAlarm(HeaterUnderEventType_B[index], true);
            return OK;
        }
    }
    else //temperature within limits
    {
        if(UnderHeatCounter[index] )
        {
            UnderHeatCounter[index]--;
            if (UnderHeatCounter[index]==0)
            {
                if (HeaterReady[index]==false)
                    AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
                else
                    AlarmHandlingSetAlarm(HeaterUnderEventType_B[index], false);
            }
        }
        if(OverHeatCounter[index] )
        {
            if ((HeaterPreviousRead[index]) <= (HeaterControl[index].sensormaxvalue-2))
            {
                OverHeatCounter[index]--;
                if (OverHeatCounter[index]==0)
                {
                   AlarmHandlingSetAlarm(HeaterEventType[index], false);
                   HeaterMaxTempFlag[index] = false;
                }
            }
        }
    }
    return ERROR;
}

uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
{
    int index=HEATER_TYPE_MAX_HEATERS;
    //uint8_t len = 0;
    if (IfIndex>>8 != IfTypeHeaters)
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return ERROR;
    }
    index = IfIndex&0xFF;
    if (index != HEATER_TYPE__DryerAirHeater) //AC Heaters
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return ERROR;
    }
    if (HeaterCmd[index].targettemperatue == 0)
    {
        DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
        DeActivateHeater(HEATER_TYPE__DryerMainHeater);
        //Heaters OFF until coming into the proportional band
        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
        //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)
            {
                HeaterSpikeRead[index] = readValue;
            }
            else
            {
                HeaterPreviousRead[index] = HeaterSpikeRead[index];
                HeaterSpikeRead[index] = 0;
            }*/
            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
            DeActivateHeater(HEATER_TYPE__DryerMainHeater);
            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
        }
        if (HeaterSpikeRead[index] == 0)
        {
            HeaterSpikeRead[index] = readValue;
        }
        else
        {
            ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
            HeaterPreviousRead[index] = HeaterSpikeRead[index];
            HeaterSpikeRead[index] = 0;
        }

        return ERROR;
#endif
    }
    if (HeaterDisasterCounter[index] >= DISASTER_COUNTER_LIMIT)
    {
        ReportWithPackageFilter(HeatersFilter,"AC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
        DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
        DeActivateHeater(HEATER_TYPE__DryerMainHeater);
        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
        HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
        return ERROR;
    }
    HeaterPreviousRead[index] = readValue;
    //ReportWithPackageFilter(HeatersFilter, "AC Heating in progress",__FILE__,readValue,HeaterReady[index],RpError, HeaterAtTemp[index],0);

    if ((readValue>(HeaterCmd[index].targettemperatue+800))&&(getIdleState() == false))
    {
        ReportWithPackageFilter(HeatersFilter, "AC OverHeating in progress",__FILE__,readValue,GetHeaterState(HEATER_TYPE__DryerMainHeater),RpError, GetHeaterState(HEATER_TYPE__DryerSecondaryHeater),0);
        ReportWithPackageFilter(HeatersFilter, "AC OverHeating PID",__FILE__,(int)HeaterPIDConfig[index].m_calculatedError,(int)HeaterPIDConfig[index].m_SetParam,RpError, (int)HeaterPIDConfig[index].m_integral,0);
    }
    // check if the read value is within the proportional band
    if (HeaterReady[index]==false)
    {
        if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
                {
                    DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
                    DeActivateHeater(HEATER_TYPE__DryerMainHeater);
                    //Heaters OFF until coming into the proportional band
                    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,0);
                    HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,0);
                    ReportWithPackageFilter(HeatersFilter, "AC OverHeat - turned off",__FILE__,readValue,HeaterReady[index],RpError, HeaterAtTemp[index],0);
                    return OK;
                }
        if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
        //if (readValue < (/*HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000*/HeaterCmd[index].targettemperatue-800))
        {
            if ((HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)&&(HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] == false))
            {
                //ReportWithPackageFilter(HeatersFilter,"AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
                ActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
                ActivateHeater(HEATER_TYPE__DryerMainHeater);
                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater,100);
                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater,100);
            }
            return OK;
        }

/*        if ((readValue > (HeaterCmd[index].targettemperatue-300)/`*(HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000)*`/)&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
        {
//////////////////
            ReportWithPackageFilter(HeatersFilter,"AC Turn Off secondary",__FILE__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
            //InitialHeating = false;
            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
            HeatersControlStart();
////////////////////////

            AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
            if (BlowerCfg.enabled == true)
            {
                Turn_the_Blower_On();//Turn on with the Default_Voltage
                if (BlowerCfg.voltage)
                    //Gradual_Increase_Blower(BlowerCfg.heatingvoltage,BlowerCfg.voltage);
                    Control_Voltage_To_Blower(BlowerCfg.voltage);
            }
        }
        */
//        if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target

        if    (   (readValue >  (HeaterCmd[index].targettemperatue * ((100-HeaterControl[index].outputproportionalband)/100)))
              &&  (readValue < (HeaterCmd[index].targettemperatue *  ((100+HeaterControl[index].outputproportionalband)/100))))
        {
            //InitialHeating = false;
            ReportWithPackageFilter(HeatersFilter,"AC PID Activating",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
            DeActivateHeater(HEATER_TYPE__DryerSecondaryHeater);
            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerSecondaryHeater, 0);
            HeatersControlStart();
            AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
            /*if (BlowerCfg.enabled == true)
            {
                if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
                {
                    WHS_Set_SetPoint_Q_value(headairflow);
                }
                else
                {
                    Turn_the_Blower_On();//Turn on with the Default_Voltage
                    if (BlowerCfg.voltage)
                        Control_Voltage_To_Blower(BlowerCfg.voltage);
                }
            }*/
            HeaterReady[index] = true;
            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerMainHeater]);
            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);

        }
        return OK;
    }
    if (HeaterAtTemp[index] == false)
    {
        if ((readValue > (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
            {
                //InitialHeating = false;
                ReportWithPackageFilter(HeatersFilter,"AC Ready",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
                HeaterAtTemp[index] = true;
                HeaterPrepareReady();
            }
    }
    else
    {
        if ((readValue < (HeaterCmd[index].targettemperatue * AcHeatersLoweroperationLimit/1000))||(readValue > (HeaterCmd[index].targettemperatue * AcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
            {
                //InitialHeating = false;
                ReportWithPackageFilter(HeatersFilter,"AC returning to NOT Ready",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
                HeaterAtTemp[index] = false;
                HeaterPrepareReady();
            }
    }
    if(HeaterPIDConfig[index].m_isEnabled && (HeaterPIDConfig[index].m_SetParam != 0))
    {
        HeaterPIDConfig[index].m_mesuredParam = readValue;
        /*if (HeaterControl[index].pidactive == false)
        {
            if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) //below proportional band
            {
                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, 100);
                //REPORT_MSG (readValue,"AC HEATER Over temperature");
            }
            else if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
            {
                HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, 0);
                //REPORT_MSG (readValue,"AC HEATER Under temperature");
            }
        }
        else  //PID active
        {*/
            if ((readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100)))
            {
                //disable PID outside band
                HeaterPIDConfig[index].m_calculatedError = 0;
                HeaterPIDConfig[index].m_integral = 0;
            }
            else if ((readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)))
            {
                //disable PID outside band
                HeaterPIDConfig[index].m_calculatedError = 10000;
                HeaterPIDConfig[index].m_integral = 0;
            }
            else
            {
               HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
                                     &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
            //}
            if (ReportFilterTest(HeatersFilter))
            {
               int len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} H1 %d H2 %d ",index,
                               (int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError,
                               GetHeaterState(HEATER_TYPE__DryerMainHeater),GetHeaterState(HEATER_TYPE__DryerSecondaryHeater));
               //        ReportWithPackageFilter(HeatersFilter,logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);
               //        #warning PID is now only proportional (above)
                ReportWithPackageFilter(HeatersFilter,ACheatstr,__FILE__,__LINE__,index,RpWarning,readValue,  HeaterPIDConfig[index].m_calculatedError);
               //ReportWithPackageFilter(HeatersFilter,"AC PID",__FILE__,__LINE__,HeaterPIDConfig[index].m_calculatedError/100,RpWarning,readValue, index);
            }
            if (HeaterRestarted[HEATER_TYPE__DryerMainHeater] == true)
            {
                ReportWithPackageFilter(HeatersFilter,"Restarting same temperature Heater Temp",__FILE__,HEATER_TYPE__DryerMainHeater,HeaterPIDConfig[index].m_calculatedError,RpWarning,readValue,  0);
                HeaterRestarted[HEATER_TYPE__DryerMainHeater] = false;
            }
            HeaterRecalculateSharedHeatersParams(HEATER_TYPE__DryerMainHeater, (int)(HeaterPIDConfig[index].m_calculatedError/100));
        }
    }


 return OK;
}
/*
 * DCHeaterControlCBFunction
 * called by: Communication from host
 * initialized all global data
 */
//float error[HEATER_TYPE__HeadCoverHeater2][100];
//float integral[HEATER_TYPE__HeadCoverHeater2][100];
//float output[HEATER_TYPE__HeadCoverHeater2][100];
//int Counter[HEATER_TYPE__HeadCoverHeater2] = {0,0,0,0,0,0,0};
//char logmsg[HEATER_TYPE__HeadCoverHeater2][254];
char heatstr[100];
//float temp_calculatedError=0,temp_preError = 0, temp_integral = 0;

uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
{
    int index=HEATER_TYPE_MAX_HEATERS;
    //int len;
   //uint8_t len = 0;
    if (IfIndex>>8 != IfTypeHeaters)
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface type",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return 0xFFFFFFFF;
    }
    index = IfIndex&0xFF;
    if (index < MAX_AC_HEATERS) //AC Heaters
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return 0xFFFFFFFF;
    }
    if (HeaterCmd[index].targettemperatue == 0)
    {
        DeActivateHeater(index);
        HeaterRecalculateHeaterParams(index, 0);
        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);
            HeaterRecalculateHeaterParams(index, 0);
        }
        if (HeaterSpikeRead[index] == 0)
        {
            HeaterSpikeRead[index] = readValue;
        }
        else
        {
            ReportWithPackageFilter(HeatersFilter,"restoring read Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,HeaterSpikeRead[index], index);
            HeaterPreviousRead[index] = HeaterSpikeRead[index];
            HeaterSpikeRead[index] = 0;
        }
#endif
    }
    HeaterPreviousRead[index] = readValue;
    if (HeaterDisasterCounter[index] >= DISASTER_COUNTER_LIMIT)
    {
        ReportWithPackageFilter(HeatersFilter,"DC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
        DeActivateHeater (index);
        HeaterRecalculateHeaterParams(index, 0);
        return ERROR;
    }
    if ((readValue>(HeaterCmd[index].targettemperatue+300))&&(getIdleState() == false))
    {
        ReportWithPackageFilter(HeatersFilter, "DC OverHeating in progress",__FILE__,index,readValue,RpError, HeaterPIDConfig[index].m_calculatedError,0);
    }
    /*if (index == 4)
    {
        ReportWithPackageFilter(HeatersFilter, "DC Heating info head 2",__FILE__,GetControlLowDevice_i(),readValue,RpError, HeaterPIDConfig[index].m_calculatedError,0);
    }*/

    // check if the read value is within the proportional band
    if (HeaterReady[index]==false)
    {
        //int temp = ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100);
        if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
                {
                    DeActivateHeater(index);
                    HeaterRecalculateHeaterParams(index, 0);
                    //Heaters OFF until coming into the proportional band
                    if (getIdleState() == false)
                        ReportWithPackageFilter(HeatersFilter,"HEATER Over temperature ", __FILE__,index,HeaterCmd[index].targettemperatue, RpMessage, readValue, 0);
                    return OK;
                }
        if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
                {
                    if ((HeaterMaxTempFlag[index] == false) && (BlowerHeaterMaxTempFlag[index] == false))
                        ActivateHeater(index);
                    //HeaterRecalculateHeaterParams(index, 100);
                    //Heaters OFF until coming into the proportional band
                    //ReportWithPackageFilter(HeatersFilter,"DC HEATER Under temperature ", __FILE__,__LINE__,index, RpMessage, readValue, 0);
                    return OK;
                }

        //if ((readValue > (HeaterCmd[index].targettemperatue * DcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * DcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
        if    (   (readValue >  (HeaterCmd[index].targettemperatue * ((100-HeaterControl[index].outputproportionalband)/100)))
              &&  (readValue < (HeaterCmd[index].targettemperatue *  ((100+HeaterControl[index].outputproportionalband)/100))))
        {
            ReportWithPackageFilter(HeatersFilter,"DC PID Activating",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
            //DCInitialHeating[index] = false;
            HeatersControlStart();
            AlarmHandlingSetAlarm(HeaterUnderEventType[index], false);
            if(Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD)
                Disable_Reading_Heaters_ADC(HeaterId2CurrentId[index]);
            else
                Disable_Reading_Heaters_Current(HeaterId2CurrentId[index]);
            HeaterReady[index] = true;
        }
        return OK;
    }
    if (HeaterAtTemp[index] == false)
    {
        if ((readValue > (HeaterCmd[index].targettemperatue * DcHeatersLoweroperationLimit/1000))&&(readValue < (HeaterCmd[index].targettemperatue * DcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
        {
            ReportWithPackageFilter(HeatersFilter,"DC Ready",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
            HeaterAtTemp[index] = true;
            if (HeaterReady[index] == false)
            {
                HeaterReady[index] = true;
                ReportWithPackageFilter(HeatersFilter,"DC FastReady",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
            }
            HeaterPrepareReady();
        }
    }
    else
    {
        if ((readValue < (HeaterCmd[index].targettemperatue * DcHeatersLoweroperationLimit/1000))||(readValue > (HeaterCmd[index].targettemperatue * DcHeatersUpperoperationLimit/1000)))//read value within 0.5 percent from target
            {
                ReportWithPackageFilter(HeatersFilter,"DC AC returning to NOT Ready",__FILE__,index,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
                HeaterAtTemp[index] = false;
                HeaterPrepareReady();
            }
    }

    if(HeaterPIDConfig[index].m_isEnabled && (HeaterPIDConfig[index].m_SetParam != 0))
    {
        /*if (HeaterControl[index].pidactive == false)
        {
            if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)) //below proportional band
            {
                HeaterRecalculateHeaterParams(index, 100);
            }
            else if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
            {
                HeaterRecalculateHeaterParams(index, 0);
            }

        }
        else ///pid active
        {*/
            //check only for the proportional band limits
            HeaterPIDConfig[index].m_mesuredParam = readValue;
            if ((readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100)))
            {
                //disable PID outside band
                HeaterPIDConfig[index].m_calculatedError = 0;
                HeaterPIDConfig[index].m_integral = 0;
            }
            else if ((readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100)))
            {
                //disable PID outside band
                HeaterPIDConfig[index].m_calculatedError = 10000;
                HeaterPIDConfig[index].m_integral = 0;
            }
            else
            {
                HeaterPIDConfig[index].m_calculatedError = PIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
                                      &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);

            }
            //        error[index][Counter[index]]    = HeaterPIDConfig[index].m_preError;
            //        integral[index][Counter[index]] = HeaterPIDConfig[index].m_integral;
            //        output[index][Counter[index]]   = HeaterPIDConfig[index].m_calculatedError;
            //        if (Counter[index]++ >=100)
            //            Counter[index] = 0;
            //        ReportWithPackageFilter(HeatersFilter,logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);
            //        #warning PID is now only proportional (above)
            if (HeaterRestarted[index] == true)
            {
                ReportWithPackageFilter(HeatersFilter,"Restarted same temperature Heater ",__FILE__,index,HeaterPIDConfig[index].m_calculatedError,RpWarning,readValue,  0);
                HeaterRestarted[index] = false;
            }
            HeaterRecalculateHeaterParams(index, (int)(HeaterPIDConfig[index].m_calculatedError/100));

        //}

    }


 return OK;
}

/*
 * EightMilliSecondHeatersInterrupt - a timer based interrupt, that will handle the time sharing between the A/C heaters
 * There is a need to prevent the system from activating all A/C heaters at the same time, due to electrical current problems
 */
int  SliceCounter = 0;
void EightMilliSecondHeatersInterrupt(UArg arg0)
{
    ROM_TimerIntClear(Heater_timerBase, TIMER_TIMA_TIMEOUT);  // Clear the timer interrupt

    ROM_IntMasterDisable();
    HeatersControlMessageStruc Message;
    //bool retcode = false;

    //send message to the HeatersControl task
    Message.messageId = HeatersControl;
    Message.tick = UsersysTickGet();
    Message.msglen = sizeof(HeatersControlMessageStruc);
    if (HeatersControlMsgQ != NULL)
        /*retcode = */Mailbox_post(HeatersControlMsgQ , &Message, BIOS_NO_WAIT);

    if (HeatersRestart == true)
    {
        ROM_TimerLoadSet(Heater_timerBase, TIMER_A,OutputProportionalSingleStep);
    }
    else
    {
        TimerDisable(Heater_timerBase, TIMER_A);
    }
    //
    // Enable all interrupts.
    //
    ROM_IntMasterEnable();
    return ;
}

int HeaterDisasterTemp[HEATER_TYPE__HeadCoverHeater2+1] = {27000,27000,27000,17000,17000,17000,17000,17000,17000,11000,17000,17000,17000,17000,17000,27000,27000,27000};
//int HeaterDisasterTemp[HEATER_TYPE__HeadCoverHeater2+1] = {8100,8100,8200,8100,8100,8100,8100,8100,8100,8100};
uint32_t HeatersDisasterControl(uint32_t x,uint32_t y)
{
    int HeaterId,temperature;

    for ( HeaterId = HEATER_TYPE__DryerAirHeater; HeaterId<= HEATER_TYPE__HeadCoverHeater2;HeaterId++)
    {
        temperature = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
        if ((temperature>=HeaterDisasterTemp[HeaterId])&&(temperature<28300))
        {
            //ReportWithPackageFilter(HeatersFilter,"Disaster Temperature ",__FILE__,HeaterId,temperature,RpWarning,HeaterDisasterTemp[HeaterId], 0);
            if (HeaterDisasterCounter[HeaterId]++ >= DISASTER_COUNTER_LIMIT)
                HeaterDisasterCounter[HeaterId] = DISASTER_COUNTER_LIMIT;
        }
        else if (temperature<0)
        {
            if (HeaterDisasterCounter[HeaterId]++ <= 0)
                HeaterDisasterCounter[HeaterId] = 0;
        }
        else
        {
            if (HeaterDisasterCounter[HeaterId]-- <= 0)
                HeaterDisasterCounter[HeaterId] = 0;
        }

    }
    return OK;
}
void HeaterSafetyTestSetLimits(int limit)
{
    int i;
    HeaterControl[HEATER_TYPE__DryerMainHeater].sensormaxvalue = limit;
    HeaterControl[HEATER_TYPE__DryerSecondaryHeater].sensormaxvalue = limit;
    for(i = 0; i<=HEATER_TYPE__HeadCoverHeater2;i++)
    {
        HeaterDisasterTemp[i] = limit;
        RemoveControlCallback(ControlIdtoMaxHeaterId [i], DcHeaterMaxTempCBFunction);
    }
    RemoveControlCallback(DisasterControlId, HeatersDisasterControl);
    RemoveControlCallback(MainDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
    RemoveControlCallback(SecondDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
#ifdef USE_TUNNEL_PT100
    for(i = HEATER_TYPE__HeadCoverHeater1; i<=HEATER_TYPE__HeadCoverHeater2;i++)
    {
        HeaterDisasterTemp[i] = limit;
        RemoveControlCallback(BlowersControlIdtoMaxHeaterId [i], HeaterBlowerMaxTempCBFunction);
    }
#endif
    MaxAllowedTemperature = limit+1;
}

double TotalCurrentLimit(double VAC)
{
    if (VAC<=210)
    {
        return 5.8;
    }
    else if (VAC>222)
    {
        return 5.15;
    }
    else
    {
        return 5.5;
    }

}
#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;
    char str[100];
    bool tempDrier2 = UseSecondaryDrierHeater;
    double Z1Current = 0,Z2AssumedCurrent = 0,LimitCurrent = 0;

    if ((Hysteresis >0)&&(Hysteresis <4))
    {
        Hysteresis ++;
        REPORT_MSG(Hysteresis , "AC handling Hysteresis ");
        return OK;
    }
    Hysteresis  = 0;
#ifndef VAC_TEST
    if (Head_Type > HEAD_TYPE_FLAT_WITHOUT_CARD) //rapid/pp machines
#endif
    {
        DrierAcVoltage = ReadVAC();
        if ((DrierAcVoltage>120)&&(DrierAcVoltage<=180))
        {
            AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
            ReportWithPackageFilter(HeatersFilter,"Power too low!!!!!", __FILE__,__LINE__,DrierAcVoltage, RpMessage, 0, 0);
        }
        else if (DrierAcVoltage>264)
        {
            AlarmHandlingSetAlarm(EVENT_TYPE__POWER_UP_BIT_FAILURE, true);
            ReportWithPackageFilter(HeatersFilter,"Power too high!!!!!", __FILE__,__LINE__,DrierAcVoltage, RpMessage, 0, 0);
            ReportWithPackageFilter(HeatersFilter,"Power too high!!!!!", __FILE__,__LINE__,DrierAcVoltage, RpMessage, 0, 0);
            ReportWithPackageFilter(HeatersFilter,"Power too high!!!!!", __FILE__,__LINE__,DrierAcVoltage, RpMessage, 0, 0);
            HeatersEnd();
            //PowerOffPowerOff();
        }
        else if (DrierAcVoltage<(205-(Voltage_Hysteresis /2)))
        {
            UseSecondaryDrierHeater = true;
        }
        else if (DrierAcVoltage>(224+(Voltage_Hysteresis /2)))
        {
            UseSecondaryDrierHeater = false;
        }
        else
        {
            Z1Current = GetZone1RMSCurrent(DrierAcVoltage); //changed to assumed current as calculated on init
            Z2AssumedCurrent = GetZone2RMSCurrent(DrierAcVoltage);
            LimitCurrent = TotalCurrentLimit(DrierAcVoltage);
            //hysteresis: activate
            if ((Z2AssumedCurrent+Z1Current)>LimitCurrent)
            {
                UseSecondaryDrierHeater = false;
            }
            else
            {
                UseSecondaryDrierHeater = true;
            }
        }
    }
#ifndef VAC_TEST
    else
    {
        UseSecondaryDrierHeater = true;
    }
#endif
    if (tempDrier2 != UseSecondaryDrierHeater)
    {
        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);
        if (UseSecondaryDrierHeater == false)
        {
            DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HEATER_TYPE__DryerSecondaryHeater]);
        }

    }
    //UseSecondaryDrierHeater = true;
return OK;
}
uint32_t HeatersControlLoop(uint32_t tick)
{
    //char str[100];
    //uint8_t len = 0;
    int DcHeaterId;
    bool AcHeaterDisaster = false;

    /*len = usnprintf(str, 100, " EightMilliSecondHeatersInterrupt SliceCounter %d Owner %d H1000 %d  H2000 %d"
                    ,SliceCounter,TimeSliceAllocation[SliceCounter],HeatersRestart,NumberOFSlicesInUse);
    ReportWithPackageFilter(HeatersFilter,str, __FILE__,__LINE__,0, RpMessage, SliceCounter, TimeSliceAllocation[SliceCounter]);
*/
    if (HeaterDisasterCounter[HEATER_TYPE__DryerMainHeater] >= DISASTER_COUNTER_LIMIT)
    {
        DeActivateHeater (HEATER_TYPE__DryerMainHeater);
        DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
        AcHeaterDisaster = true;
    }
    if (HeaterDisasterCounter[HEATER_TYPE__DryerSecondaryHeater] >= DISASTER_COUNTER_LIMIT)
    {
        DeActivateHeater (HEATER_TYPE__DryerMainHeater);
        DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
        AcHeaterDisaster = true;
    }


    if (AcHeaterDisaster == false)
    {
        //if (HeaterReady[HEATER_TYPE__DryerAirHeater] == true)
        {
            if (TimeSliceAllocation[SliceCounter] == HEATER_TYPE__DryerMainHeater)
            {
                if (HeaterMaxTempFlag[HEATER_TYPE__DryerMainHeater] == false)
                {
                    //If HEATER_TYPE__DryerMainHeater should be active
                    //Activate HEATER_TYPE__DryerMainHeater
                    ActivateHeater (HEATER_TYPE__DryerMainHeater);
                    //DeActivate HEATER_TYPE__DryerSecondaryHeater
                    //DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                }
                if ((HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)&&(UseSecondaryDrierHeater == true))
                {
//#warning trial use both heaters in drier
                    ActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                    //DeActivate HEATER_TYPE__DryerSecondaryHeater
                    //DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                }
                else
                {
                    DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                }
            }
            /*else if (TimeSliceAllocation[SliceCounter] == HEATER_TYPE__DryerSecondaryHeater)
            {
                if (HeaterMaxTempFlag[HEATER_TYPE__DryerSecondaryHeater] == false)
                {
                    //DeActivate HEATER_TYPE__DryerMainHeater
                    DeActivateHeater (HEATER_TYPE__DryerMainHeater);
                    //If HEATER_TYPE__DryerSecondaryHeater should be active
                    //Activate HEATER_TYPE__DryerSecondaryHeater
                    ActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
                }
            }*/
            else
            {
                    //DeActivate HEATER_TYPE__DryerMainHeater
                    DeActivateHeater (HEATER_TYPE__DryerMainHeater);
                    //DeActivate HEATER_TYPE__DryerSecondaryHeater
                    DeActivateHeater (HEATER_TYPE__DryerSecondaryHeater);
            }
        }
    }
    for ( DcHeaterId = HEATER_TYPE__HeaterZone1; DcHeaterId<= HEATER_TYPE__HeadCoverHeater2;DcHeaterId++)
    {
        if (HeaterDisasterCounter[DcHeaterId] >= DISASTER_COUNTER_LIMIT)
        {
            DeActivateHeater (DcHeaterId);
            continue;
        }
        if (HeaterReady[DcHeaterId] == false)
            continue;
        if (DCTimeSliceAllocation[DcHeaterId] > 0) //heater active
        {
            if (SliceCounter == DcHeaterId)
            {
                if ((HeaterMaxTempFlag[DcHeaterId] == false) && (BlowerHeaterMaxTempFlag[DcHeaterId] == false))
                {
                    ActivateHeater (DcHeaterId);
                }
            }
            else if (SliceCounter-DcHeaterId >= DCTimeSliceAllocation[DcHeaterId]) //turn off
            {
                DeActivateHeater (DcHeaterId);
            }
        }
        else
        {
            DeActivateHeater (DcHeaterId); 
        }
    }
    //handle the time sharing module
    SliceCounter++;
    if (SliceCounter >= NumberOFSlicesInUse)
        SliceCounter = 0;

    return OK;
}
/******************************************************************************
 *  ======== messageTsk ========
 *  Task for this function is created statically. See the project's .cfg file.
 *  this message task is created statically in system initialization,
 ******************************************************************************/
void HeatersControlTask(UArg arg0, UArg arg1)
{
    HeatersControlMessageStruc Message;

    HeatersControlInit();

    while(1)
    {
        Mailbox_pend(HeatersControlMsgQ , &Message, BIOS_WAIT_FOREVER);
        switch (Message.messageId)
        {
            case HeatersControl:
                HeatersControlLoop(Message.tick);
                break;
            default:
                break;
        }
    }
}