path: root/Software/Embedded_SW/Embedded/Modules/Heaters/Heaters_print.c

/************************************************************************************************************************
 * 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 "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/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 <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 "StateMachines/Printing/PrintingSTM.h"


/******************** Data Structures  ********************************************/
#define OVERHEAT_COUNT_LIMIT 3
#define UNDERHEAT_COUNT_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[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0,0,0};
//PID_Config_Params   temp_params;

/******************** GLOBAL PARAMETERS  ********************************************/
HeaterCommand          HeaterCmd[MAX_HEATERS_NUM];
uint32_t    ControlIdtoHeaterId [MAX_HEATERS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
uint32_t    ControlIdtoMaxHeaterId [MAX_HEATERS_NUM] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
uint32_t    OverHeatCounter [MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0};
uint32_t    UnderHeatCounter [MAX_HEATERS_NUM] = {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
#define MINIMUM_HEATER_READ 9.0
#define MAXIMUM_HEATER_READ 283

//old uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,TEMP_SENSE_AN_ENCLOSURETEMP3};
uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,HEAD6_PT100,MIXER_PT100};
HEATERS_CURRENT HeaterId2CurrentId[MAX_HEATERS_NUM] = {NUM_OF_CURRENT_HEATERS,HEATER_DRYER_CURRENT_1,HEATER_DRYER_CURRENT_2,HEATER_HEAD_CURRENT_ZONE_1,HEATER_HEAD_CURRENT_ZONE_2,HEATER_HEAD_CURRENT_ZONE_3,HEATER_HEAD_CURRENT_ZONE_4,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_HEAD_CURRENT_ZONE_5_6,HEATER_MIXCHIP_CURRENT};
uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
bool HeatersRestart = false;

bool HeaterMaxTempFlag[MAX_HEATERS_NUM] = {false,false,false,false,false,false,false,false,false,false};
bool HeaterMinTempFlag[MAX_HEATERS_NUM] = {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[MAX_HEATERS_NUM] = {0};

bool TimerActivated = false;
char ACheatstr[100];

Mailbox_Handle          HeatersControlMsgQ = NULL;
//bool InitialHeating = true;
//bool DCInitialHeating[MAX_HEATERS_NUM] = {true};
bool    HeaterReady[MAX_HEATERS_NUM] = {true};
bool    HeaterAtTemp[MAX_HEATERS_NUM] = {true};
uint32_t HeaterPreviousRead[MAX_HEATERS_NUM] = {0,0,0,0,0,0,0,0,0,0}; //A/C Heaters Cycle time in milliseconds - one for all heaters
EventType HeaterEventType[MAX_HEATERS_NUM] = {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};
EventType HeaterUnderEventType[MAX_HEATERS_NUM] = {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};

EventType HeaterUnderEventType_B[MAX_HEATERS_NUM] = {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};

int HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {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 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 < MAX_HEATERS_NUM; 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_ENCLOSURETEMP1,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};
uint32_t HeatersTestInternalAlarmsCBFunction(uint32_t IfIndex, uint32_t readValue)
{
    int index=MAX_HEATERS_NUM;

    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)||(270.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)
        {
            if(InternalOverHeatCounter[index]++ >=Overheat_Count_Limit)
            {
                InternalOverHeatCounter[index] = Overheat_Count_Limit;

                    InternalAlarmActive[index] = true;
                    ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature, turned off",__FILE__,index,readValue,RpWarning,  0,0);
                    AlarmHandlingSetAlarm(EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE, true);
            }
        }
    }
    else
    {
        if (InternalAlarmActive[index] == true)
        {
            if(InternalOverHeatCounter[index]-- <= 0)
            {
                InternalOverHeatCounter[index] = 0;

                InternalAlarmActive[index] = true;
                ReportWithPackageFilter(HeatersFilter,"Internal Over the max temperature, turned off",__FILE__,index,readValue,RpWarning,  0,0);
                AlarmHandlingSetAlarm(EVENT_TYPE__MACHINE_INTERNAL_OVERTEMPERATURE, 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 >= MAX_HEATERS_NUM)
    {
        ReportWithPackageFilter(HeatersFilter,"Wrong Heater Id",__FILE__,__LINE__,HeaterType,RpError, 0,0);
        return 0;
    }
    return HeaterCmd[HeaterType].targettemperatue;
}
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 == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
    {
        HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].outputproportionalpowerlimit;
        //HeaterState->isrampingup = InitialHeating;
    }
    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
    {
        HeaterState->setpoint = HeaterControl[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].outputproportionalpowerlimit;
        //HeaterState->isrampingup = InitialHeating;
    }
    return;
}
uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
{
    int status = OK;
    ReportWithPackageFilter(HeatersFilter,"HeatersSingleHeaterEnd ", __FILE__,__LINE__,HeaterId, RpMessage, 0, 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;
            }
            HeaterRecalculateHeaterParams(HeaterId, 0);
            DeActivateHeater(HeaterId);
            HeaterPIDConfig[HeaterId].m_SetParam = 0;
            HeaterReady[HeaterId] = true;
            HeaterAtTemp[HeaterId] = true;
            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(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
            if (MainDryerHeaterMaxTempControl)
            {
                status |=RemoveControlCallback(MainDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
                MainDryerHeaterMaxTempControl=0xFF;
            }
            if (SecondDryerHeaterMaxTempControl)
            {
                status |=RemoveControlCallback(SecondDryerHeaterMaxTempControl ,HeaterMaxTempCBFunction);
                SecondDryerHeaterMaxTempControl=0xFF;
            }
            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
            HeaterPIDConfig[HeaterId].m_SetParam = 0;
            HeaterReady[HeaterId] = true;
            HeaterAtTemp[HeaterId] = true;
        }

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

}


uint32_t HeatersEnd(void)
{
    HardwarePidControlType i;
    uint32_t status = OK;
    HeatersControlStop();
    for (i=0;i<MAX_HEATERS_NUM;i++)
    {
        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[MAX_HEATERS_NUM] = {false,false,false,false,false,false,false,false,false,false};
uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
{
    //uint32_t status = NOT_SUPPORTED;
    //MessageContainer responseContainer;
    if (HeaterControl[HeaterId].configured == false)
    {
        ReportWithPackageFilter(HeatersFilter,"HeaterControl not configured",__FILE__,__LINE__,HeaterId,RpError, 0,0);
        return ERROR;
    }
//    Turn_the_Blower_On();

    if (HeaterId< MAX_HEATERS_NUM)
    {
        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;
    }
#ifdef DEMO_TEMPERATURE
    if (OnOff == false)
        HeaterTestActive[HeaterId] = false;
#endif
    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,ControlIdtoHeaterId [HeaterId],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[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);//MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);// = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);
        if((HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain])||
           (HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]<=MINIMUM_HEATER_READ*100)||(MAXIMUM_HEATER_READ*100<=HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]))
        {
            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,RpError, HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
            ReportWithPackageFilter(HeatersFilter,"PT100 not working properly",__FILE__,__LINE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,RpError, HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
            if (ControlIdtoMaxHeaterId [HeaterId] != 0xFF)
            {
                RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
                ControlIdtoMaxHeaterId [HeaterId] = 0xFF;
            }
            if (ControlIdtoHeaterId [HeaterId] != 0xFF)
            {
                RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
                ControlIdtoHeaterId [HeaterId] = 0xFF;
            }
            DeActivateHeater(HeaterId);
            HeaterCmd[HeaterId].targettemperatue = 0;
#warning PT100 error is misidentified as overheat in alarms
            AlarmHandlingSetAlarm(HeaterEventType[HeaterId], 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[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] =  MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);//MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
        HeaterPreviousRead[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]  = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);// = MillisecGetTemperatures(HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);

    }
    //turn all alarms off
        AlarmHandlingSetAlarm(HeaterUnderEventType[HeaterId], false);
        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[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
    Enable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);

    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
    if (MainDryerHeaterMaxTempControl == 0xFF)
        MainDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
    if (SecondDryerHeaterMaxTempControl == 0xFF)
        SecondDryerHeaterMaxTempControl = AddControlCallback("HeatersMax", HeaterMaxTempCBFunction, eOneSecond,MillisecGetTemperatures,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
    //InitialHeating = true;
    HeaterReady[HeaterId] = false;
    HeaterAtTemp[HeaterId] = false;
    if (BlowerCfg.enabled == true)
    {
        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__,__LINE__,HeaterId,RpError, 0,0);
        if (ControlIdtoMaxHeaterId [HeaterId] != 0xFF)
        {
            RemoveControlCallback(ControlIdtoMaxHeaterId [HeaterId], DcHeaterMaxTempCBFunction);
            ControlIdtoMaxHeaterId [HeaterId] = 0xFF;
        }
        if (ControlIdtoHeaterId [HeaterId] != 0xFF)
        {
            RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
            ControlIdtoHeaterId [HeaterId] = 0xFF;
        }
        DeActivateHeater(HeaterId);
        AlarmHandlingSetAlarm(HeaterEventType[HeaterId], 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);

    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);

    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 >= MAX_HEATERS_NUM)
    {
        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,Frequency,RpWarning,HeaterPIDConfig[HeaterId].m_params.dt, 0);
        if (PrepareDCHeater(HeaterId,Frequency,SetTemperatue)!=OK)
            return ERROR;
    }
    else if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
    {
        PrepareACHeater(HeaterId,Frequency,SetTemperatue);
    }
    return OK;
}
bool HeaterCheckReady(void)
{
    int i;
    for (i=0;i<MAX_HEATERS_NUM;i++)
    {
        if (HeaterAtTemp[i] == false)
        {
            return false; //not all configured heaters are ready
        }
    }
    return true;
}
void HeaterPrepareReady(void)
{
    int i;
    if (GetHeatersPrepareWaiting() == false)
    {
        return;
    }
    for (i=0;i<MAX_HEATERS_NUM;i++)
    {
        if (HeaterAtTemp[i] == false)
        {
            return; //not all configured heaters are ready
        }
    }
    PrepareReady(Module_Heaters,ModuleDone);
    IDSPrepareStart();
}
/*
 * HeaterControlCBFunction
 * called by: Communication from host
 * initialized all global data
 */
bool HeaterGetOverTemperatureState(uint8_t HeaterId)
{
    if (HeaterId > MAX_HEATERS_NUM) return false;
    return HeaterMaxTempFlag[HeaterId];
}
uint32_t MainPT100Read = 0,SecondaryPT100Read = 0;
#ifndef max
    #define max(a,b) ((a) > (b) ? (a) : (b))
#endif
#ifndef min
    #define min(a,b) ((a) < (b) ? (a) : (b))
#endif
uint32_t HeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
{
    int index=MAX_HEATERS_NUM;
    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 != HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)&&(index != HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)) //AC Heaters
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return 0xFFFFFFFF;
    }
    //int32_t readValue = MillisecGetTemperatures(HeaterId2PT100Id[index]);

    if (abs(readValue - HeaterPreviousRead[index])>2000)
    {
        ReportWithPackageFilter(HeatersFilter,"Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
        HeaterMaxTempFlag[index] = true;
        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
        return ERROR;
    }
    HeaterPreviousRead[index] = readValue;
    if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
    {
        MainPT100Read = readValue;
    }
    if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
    {
        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(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
        HeaterMaxTempFlag[index] = true;
        //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
        //HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true;
        //HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
        return OK;
    }
    if (MaxreadValue <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue)) //was MinreadValue
    {
        if (HeaterControl[index].sensorminvalue > 0)
        {
            if (HeaterMaxTempFlag[index] == true)
            {
               /* ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
                if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature]==false)
                {
                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                }*/
                //ReportWithPackageFilter(HeatersFilter, "Heater Cooled Off max temperature, turned on",__FILE__,__LINE__,(MinreadValue/100),RpError, 0,0);
            }
            HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
            HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = false;
        }
        return OK;
    }
    return ERROR;
}
uint32_t DcHeaterMaxTempCBFunction(uint32_t IfIndex, uint32_t readValue)
{
    int index=MAX_HEATERS_NUM;
    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)
    {
        ReportWithPackageFilter(HeatersFilter,"Heater over the max temperature",__FILE__,OverHeatCounter[index],index,RpWarning,HeaterControl[index].sensormaxvalue,  0);
        if(OverHeatCounter[index]++ >=Overheat_Count_Limit)
        {
            OverHeatCounter[index] = Overheat_Count_Limit;
            //?????HeaterReady[index] = false;
            if (JobIsActive()&&(HeaterReady[index]==true))
            {
                JobEndReason = JOB_TEMPERATURE_ALARM;
                SendJobProgress(0.0,0,false, "Temperature Error");
                AbortJob("Over Temperature Error");
                //SegmentReady(Module_Heaters,ModuleFail);
                ReportWithPackageFilter(HeatersFilter, "Temperature Error",__FILE__,__LINE__,index,RpError, 0,0);
                return OK;
            }
        }
        DeActivateHeater(index);
        HeaterRecalculateHeaterParams(index, 0);
        HeaterMaxTempFlag[index] = true;
        //ReportWithPackageFilter(HeatersFilter,(MinreadValue/100), "Heater Over the max temperature, turned off");
        ReportWithPackageFilter(HeatersFilter,"DC Heater Over the max temperature, turned off",__FILE__,index,HeaterPreviousRead[index],RpWarning,  HeaterReady[index],0);
        if (getIdleState() == false)
            AlarmHandlingSetAlarm(HeaterEventType[index], true);
        return OK;
    }
    else if ((HeaterPreviousRead[index]) < (HeaterControl[index].sensorminvalue))
    {
        if (HeaterReady[index]==true)
        {
            ReportWithPackageFilter(HeatersFilter,"Heater under the min temperature",__FILE__,UnderHeatCounter[index],index,RpWarning,HeaterControl[index].sensorminvalue,  0);
            ReportWithPackageFilter(HeatersFilter,"Heater under the min temperature",__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))
            {
                JobEndReason = JOB_TEMPERATURE_ALARM;
                SendJobProgress(0.0,0,false, "Temperature Error");
                AbortJob("Under Temperature Error");
                ReportWithPackageFilter(HeatersFilter, "Temperature Error",__FILE__,__LINE__,index,RpError, 0,0);
                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=MAX_HEATERS_NUM;
    //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 != HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
    {
        ReportWithPackageFilter(HeatersFilter, "Wrong  Interface ",__FILE__,__LINE__,IfIndex,RpError, 0,0);
        return ERROR;
    }
    if (HeaterCmd[index].targettemperatue == 0)
    {
        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
        //Heaters OFF until coming into the proportional band
        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
        //ReportWithPackageFilter(HeatersFilter, "unconfigured",__FILE__,__LINE__,0,RpError, 0,0);
        return ERROR;
    }
    if (abs(readValue - HeaterPreviousRead[index])>2000)
    {
        ReportWithPackageFilter(HeatersFilter,"AC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
        if (readValue > HeaterCmd[index].targettemperatue)
        {
            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
        }
        return ERROR;
    }
    if (HeaterDisasterCounter[index] >= DISASTER_COUNTER_LIMIT)
    {
        ReportWithPackageFilter(HeatersFilter,"AC Temperature disaster",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
        return ERROR;
    }
    HeaterPreviousRead[index] = readValue;

    if (readValue>(HeaterCmd[index].targettemperatue+800))
    {
        ReportWithPackageFilter(HeatersFilter, "AC OverHeating in progress",__FILE__,readValue,HeaterReady[index],RpError, HeaterAtTemp[index],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(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                    DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
                    //Heaters OFF until coming into the proportional band
                    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
                    HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
                    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))
        {
            //ReportWithPackageFilter(HeatersFilter,"AC Activating",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
            if ((HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)&&(HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false))
            {
                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,100);
                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,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(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 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__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 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);
            }
            HeaterReady[index] = true;
            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain]);
            Disable_Reading_Heaters_Current(HeaterId2CurrentId[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary]);

        }
        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__,__LINE__,readValue,RpWarning,(HeaterCmd[index].targettemperatue), 0);
                HeaterAtTemp[index] = true;
                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(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 100);
                //REPORT_MSG (readValue,"AC HEATER Over temperature");
            }
            else if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
            {
                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 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
            {
                if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0)
                {
                    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);
                }
                else
                {
                    HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(HeaterPIDConfig[index].m_SetParam , HeaterPIDConfig[index].m_mesuredParam,
                                                          &HeaterPIDConfig[index].m_params,   &HeaterPIDConfig[index].m_preError, &HeaterPIDConfig[index].m_integral);
                }
            //}
//            len = usnprintf(ACheatstr, 254, "ACD Id, Temp , Integral, Output{ %d, %d ,%d, %d} ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError);
            //        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[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == true)
            {
                ReportWithPackageFilter(HeatersFilter,"Restarting same temperature Heater Temp",__FILE__,HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,HeaterPIDConfig[index].m_calculatedError,RpWarning,readValue,  0);
                HeaterRestarted[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
            }
            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, (int)(HeaterPIDConfig[index].m_calculatedError/100));
        }
    }


 return OK;
}
/*
 * DCHeaterControlCBFunction
 * called by: Communication from host
 * initialized all global data
 */
//float error[HARDWARE_PID_CONTROL_TYPE__MixerHeater][100];
//float integral[HARDWARE_PID_CONTROL_TYPE__MixerHeater][100];
//float output[HARDWARE_PID_CONTROL_TYPE__MixerHeater][100];
//int Counter[HARDWARE_PID_CONTROL_TYPE__MixerHeater] = {0,0,0,0,0,0,0};
//char logmsg[HARDWARE_PID_CONTROL_TYPE__MixerHeater][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=MAX_HEATERS_NUM;
    //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 (abs(readValue - HeaterPreviousRead[index])>2000)
    {
        ReportWithPackageFilter(HeatersFilter,"DC Temperature Spike",__FILE__,index,HeaterPreviousRead[index],RpWarning,readValue, index);
        //if (readValue > HeaterCmd[index].targettemperatue)
        {
            DeActivateHeater(index);
            HeaterRecalculateHeaterParams(index, 0);
        }
    }
    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+500))
    {
        ReportWithPackageFilter(HeatersFilter, "DC OverHeating in progress",__FILE__,readValue,HeaterReady[index],RpError, HeaterAtTemp[index],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
                    ReportWithPackageFilter(HeatersFilter,"HEATER Over temperature ", __FILE__,__LINE__,index, RpMessage, readValue, 0);
                    return OK;
                }
        if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
                {
                    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);
            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;
            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
            {
                if (HeaterPIDConfig[index].m_params.IntegralErrorMultiplier == 0)
                {
                    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);
                }
                else
                {
                    HeaterPIDConfig[index].m_calculatedError = AdvancedPIDAlgorithmCalculation(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,"Restarting same temperature Heater Temp",__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[HARDWARE_PID_CONTROL_TYPE__MixerHeater+1] = {28000,28000,28000,17000,17000,17000,17000,17000,17000,11000};
//int HeaterDisasterTemp[HARDWARE_PID_CONTROL_TYPE__MixerHeater+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 = HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature; HeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;HeaterId++)
    {
        temperature = MillisecGetTemperatures(HeaterId2PT100Id[HeaterId]);
        if (temperature>=HeaterDisasterTemp[HeaterId])
        {
            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;
}
uint32_t HeatersControlLoop(uint32_t tick)
{
    //char str[100];
    //uint8_t len = 0;
    int DcHeaterId;
    bool AcHeaterDisaster = false;

    /*len = usnprintf(str, 100, "\r\n 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[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] >= DISASTER_COUNTER_LIMIT)
    {
        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
        AcHeaterDisaster = true;
    }
    if (HeaterDisasterCounter[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] >= DISASTER_COUNTER_LIMIT)
    {
        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
        DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
        AcHeaterDisaster = true;
    }


    if (AcHeaterDisaster == false)
    {
        if (HeaterReady[HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature] == true)
        {
            if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
            {
                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] == false)
                {
                    //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain should be active
                    //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
                    //DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                }
                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)
                {
#warning trial use both heaters in drier
                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
                    //DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                }
            }
            /*else if (TimeSliceAllocation[SliceCounter] == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
            {
                if (HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] == false)
                {
                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
                    //If HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary should be active
                    //Activate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
                    ActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                }
            }*/
            else
            {
                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain
                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
                    //DeActivate HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary
                    DeActivateHeater (HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
            }
        }
    }
    for ( DcHeaterId = HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1; DcHeaterId<= HARDWARE_PID_CONTROL_TYPE__MixerHeater;DcHeaterId++)
    {
        if (HeaterDisasterCounter[DcHeaterId] >= DISASTER_COUNTER_LIMIT)
        {
            DeActivateHeater (DcHeaterId);
            continue;
        }
        if (HeaterReady[DcHeaterId] == false)
            continue;
        if (DCTimeSliceAllocation[DcHeaterId] > 0) //heater active
        {
            if (SliceCounter == 0)
            {
                if (HeaterMaxTempFlag[DcHeaterId] == false)
                {
                    ActivateHeater (DcHeaterId);
                }
            }
            else if (SliceCounter >= 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;
        }
    }
}