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 "PMR/Hardware/HardwarePidControlType.pb-c.h"
#include "PMR/Hardware/HardwarePidControl.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 "../control/control.h"
#include "../control/pidalgo.h"
#include <driverlib/timer.h>
#include <DataDef.h>
#include <inc/hw_ints.h>
#include <inc/hw_memmap.h>

#include "heaters.h"
#include "Drivers/Heater/Heater.h"
#include "Heaters_ex.h"
#include "Drivers/Heater/TemperatureSensor.h"
#include "Drivers/I2C_Communication/DAC/blower.h"
#include "StateMachines/Printing/PrintingSTM.h"


/******************** Data Structures  ********************************************/
typedef enum
{
    HeatersControl,
}HeatersControlMessages;

typedef struct HeatersControlMessage{
    uint16_t messageId;
    uint16_t msglen;
    uint32_t tick;
    uint8_t messageData[20];
}HeatersControlMessageStruc;

/******************** 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    MainDryerHeaterMaxTempControl = 0xFF;
uint32_t    SecondDryerHeaterMaxTempControl = 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

uint32_t HeaterId2PT100Id[MAX_HEATERS_NUM] = {DRYER_AIR_PT100,DRYER_MAIN_PT100,DRYER_SECONDARY_PT100,TEMP_SENSE_ANALOG_DYEINGH_TEMP1,TEMP_SENSE_ANALOG_DYEINGH_TEMP2,TEMP_SENSE_ANALOG_DYEINGH_TEMP3,TEMP_SENSE_ANALOG_DYEINGH_TEMP4,TEMP_SENSE_ANALOG_DYEINGH_TEMP5,TEMP_SENSE_ANALOG_MIXCHIP_TEMP,TEMP_SENSE_AN_ENCLOSURETEMP3};
uint32_t    DryerInternalPT100Id = DRYER_AIR_PT100;
bool HeatersRestart = false;

bool HeaterMaxTempFlag[MAX_HEATERS_NUM] = {false,false,false,false,false,false,false,false,false,false};

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;

Mailbox_Handle          HeatersControlMsgQ = NULL;
bool InitialHeating = true;
bool DCInitialHeating[MAX_HEATERS_NUM] = {true};
bool    HeaterReady[MAX_HEATERS_NUM] = {true};

/******************** FUNCTIONS  ********************************************/
uint32_t HeaterMaxTempCBFunction(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 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;
    }
    HeatersRestart = false;


    return;
}
void HeatersControlStop(void)
{
    if (HeatersRestart == true)
    {
        Report("HeatersControlStop ", __FILE__,__LINE__,0, RpMessage, 0, 0);
        TimerActivated = false;
        HeatersRestart = false;
    }
}
//#warning there is a need to separate the AC and DC heaters preparation!
void HeatersControlStart(void)
{
    if (HeatersRestart == false)
    {
        Report("HeatersControlStart ", __FILE__,__LINE__,0, RpMessage, 0, 0);
        HeatersRestart = true;
        HeatersStartControlTimer();
    }
}
void LoadHeaterState(HeaterType HeaterType,HeaterState *HeaterState)
{
    HardwarePidControlType HeaterTypeToControlId[HEATER_TYPE__HeaterZone6] = {HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ1,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ2,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ3,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ4,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ5,HARDWARE_PID_CONTROL_TYPE__HeadHeaterZ6};
    int HeaterId = HeaterTypeToControlId[HeaterType];

    HeaterState->has_heatertype = true;
    HeaterState->heatertype = HeaterType;
    HeaterState->has_setpoint = true;
    HeaterState->setpoint = HeaterCmd[HeaterId].targettemperatue/100;
    HeaterState->has_currentvalue = true;
    HeaterState->currentvalue = TemperatureSensorRead(HeaterId2PT100Id[HeaterId])/100;
    HeaterState->has_isactive = true;
    HeaterState->isactive = GetHeaterState(HeaterId);
    HeaterState->has_isrampingup = true;
    HeaterState->isrampingup = DCInitialHeating[HeaterId];
    HeaterState->has_isinsetpoint = true;
    HeaterState->isinsetpoint = HeaterReady[HeaterId];

    return;
}
uint32_t HeatersSingleHeaterEnd(HardwarePidControlType HeaterId)
{
    int status = OK;
        if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
        {
            if (ControlIdtoHeaterId [HeaterId]!=0xFF)
            {
                status |= RemoveControlCallback(ControlIdtoHeaterId [HeaterId], DCHeaterControlCBFunction);
                ControlIdtoHeaterId [HeaterId]=0xFF;
                HeaterRecalculateHeaterParams(HeaterId, 0);
            }
            DeActivateHeater(HeaterId);
            HeaterReady[HeaterId] = true;
        }
        else if (HeaterId < MAX_AC_HEATERS) //AC Heaters
        {
            if (ControlIdtoHeaterId [HeaterId]!=0xFF)
            {
                status |=RemoveControlCallback(ControlIdtoHeaterId [HeaterId] ,HeaterControlCBFunction);
                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, 0);
                HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
                ControlIdtoHeaterId [HeaterId]=0xFF;
            }
            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);
            HeaterReady[HeaterId] = true;
        }

    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);
    Report("HeatersStartControlTimer ", __FILE__,__LINE__,0, RpMessage, 0, 0);
    return;
}
/**************************************************************************************
 * HeaterCommandRequestMessage
 * called by: Communication from host
 * initialized all global data
 *************************************************************************************/
uint32_t  HeaterCommandRequestMessage(int HeaterId, bool OnOff, int Temperature)
{
    //uint32_t status = NOT_SUPPORTED;
    //MessageContainer responseContainer;
    if (HeaterControl[HeaterId].configured == false)
    {
        LOG_ERROR (HeaterId,"HeaterControl not configured");
        return ERROR;
    }
//    Turn_the_Blower_On();

    if (HeaterId< MAX_HEATERS_NUM)
    {
        if (HeaterControl[HeaterId].id != HeaterId) // heater configuration missing
        {
            LOG_ERROR (HeaterId, "Heater is not yet configured");
            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
    {
        //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
    {
        if (HeaterPIDConfig[HeaterId].m_SetParam < HeaterCmd[HeaterId].targettemperatue)  //#bug 221
        {
            PrepareHeater(HeaterId,Temperature);  //prepare the heaters control info
        }
        HeaterPIDConfig[HeaterId].m_SetParam = HeaterCmd[HeaterId].targettemperatue;
        // 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);
    }
    /*else //heater off, and the heater is not ready yet
    {
        //turn off the heater
         HeatersSingleHeaterEnd(HeaterId);
         //stop the control
         HeaterPIDConfig[HeaterId].m_SetParam  = 0;
    }*/

    return OK;
}
/*
 * PrepareHeater
 * called by: Communication from host
 * initialized all global data
 */
uint32_t PrepareHeater(int HeaterId, uint32_t SetTemperatue)
{
    if(HeaterId >= MAX_HEATERS_NUM)
    {
        LOG_ERROR (HeaterId,"HeaterId too high");
        return ERROR;
    }

    if (SetTemperatue > MAX_HEATERS_TEMPERATURE)
    {
        LOG_ERROR (SetTemperatue,"Control Temperature too high");
        return ERROR;
    }

    //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.dt = 0.01;
    HeaterPIDConfig[HeaterId].m_params.epsilon = 10;
    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
    if (HeaterId >= MAX_AC_HEATERS) //DC Heaters
    {
        ControlIdtoHeaterId [HeaterId] = AddControlCallback( DCHeaterControlCBFunction, /*eOneSecond*/eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
        DCInitialHeating[HeaterId] = true;
        HeaterReady[HeaterId] = false;
    }
    else if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
    {
#ifdef DEMO_TEMPERATURE
        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, eHundredMillisecond,DemoTemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature,0);
        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,DemoTemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain,0);
        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,DemoTemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary,0);
#else
        ControlIdtoHeaterId [HeaterId] = AddControlCallback( HeaterControlCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),DryerInternalPT100Id,0);
        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain],0);
        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),HeaterId2PT100Id[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary],0);
#endif
        InitialHeating = true;
        HeaterReady[HeaterId] = false;
    }
/*    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain) //Dryer Heaters
    {
        MainDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
    }
    if (HeaterId == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary) //Dryer Heaters
    {
        SecondDryerHeaterMaxTempControl = AddControlCallback( HeaterMaxTempCBFunction, eHundredMillisecond,TemperatureSensorRead,(IfTypeHeaters*0x100+HeaterId),HeaterId2PT100Id[HeaterId],0);
    }
*/

    return OK;
}
bool HeaterCheckReady(void)
{
    int i;
    for (i=0;i<MAX_HEATERS_NUM;i++)
    {
        if (HeaterReady[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 (HeaterReady[i] == false)
        {
            return; //not all configured heaters are ready
        }
    }
    PrepareReady(Module_Heaters,ModuleDone);
}
/*
 * 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;
    uint32_t MaxreadValue = max (MainPT100Read,SecondaryPT100Read);
    uint32_t MinreadValue = min (MainPT100Read,SecondaryPT100Read);
    /*char str[100];
    uint8_t len = 0;*/
    if (IfIndex>>8 != IfTypeHeaters)
    {
        LOG_ERROR (IfIndex, "Wrong  Interface type");
        return 0xFFFFFFFF;
    }
    index = IfIndex&0xFF;
    if ((index != HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)&&(index != HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)) //AC Heaters
    {
        LOG_ERROR (IfIndex, "Wrong  Interface ");
        return 0xFFFFFFFF;
    }
    if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain)
    {
        MainPT100Read = readValue;
    }
    if (index == HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary)
    {
        SecondaryPT100Read = readValue;
    }
    if ((MaxreadValue/100) >= HeaterControl[index].sensormaxvalue)
    {
        if (HeaterMaxTempFlag[index] == false)
        {
            LOG_ERROR (MaxreadValue/100, "Heater Over the max temperature, turned off");
        }
        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
        HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = true;
        DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
        HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = true;
        return OK;
    }
    if ((MinreadValue/100) <= (HeaterControl[index].sensormaxvalue-HeaterControl[index].sensorminvalue))
    {
        if (HeaterControl[index].sensorminvalue > 0)
        {
            if (HeaterMaxTempFlag[index] == true)
            {
                ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
                if (InitialHeating)
                {
                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                }
                LOG_ERROR ((MinreadValue/100), "Heater Cooled Off max temperature, turned on");
            }
            HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain] = false;
            HeaterMaxTempFlag[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary] = false;
        }
        return OK;
    }
    return ERROR;
}
uint32_t HeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
{
    int index=MAX_HEATERS_NUM;
    double temperror = 0.0, correction = 0.0;
    /*char str[100];
    uint8_t len = 0;*/
    if (IfIndex>>8 != IfTypeHeaters)
    {
        LOG_ERROR (IfIndex, "Wrong  Interface type");
        return 0xFFFFFFFF;
    }
    index = IfIndex&0xFF;
    if (index != HARDWARE_PID_CONTROL_TYPE__DryerAirTemperature) //AC Heaters
    {
        LOG_ERROR (IfIndex, "Wrong  Interface ");
        return 0xFFFFFFFF;
    }
    if (HeaterCmd[index].targettemperatue == 0)
    {
        DeActivateHeater(index);
        //LOG_ERROR (0, "unconfigured");
        return ERROR;
    }
    // check if the read value is within the proportional band
    if (InitialHeating)
    {
        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
                    return OK;
                }
        if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
                {
                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
                    ActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain);
                    return OK;
                }

        {
            InitialHeating = false;
            DeActivateHeater(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary);
            HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary, 0);
            HeatersControlStart();
            HeaterReady[index] = true;
            HeaterPrepareReady();
        }
    }
    if(HeaterPIDConfig[index].m_isEnabled && (HeaterPIDConfig[index].m_SetParam != 0))
    {
        HeaterPIDConfig[index].m_mesuredParam = readValue;
//check only for the proportional band limits
        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);
        //correction = HeaterPIDConfig[index].m_calculatedError;
        HeaterRecalculateSharedHeatersParams(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain, (int)(HeaterPIDConfig[index].m_calculatedError));
    }


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

uint32_t DCHeaterControlCBFunction(uint32_t IfIndex, uint32_t readValue)
{
    int index=MAX_HEATERS_NUM;
    int len;
    /*char str[100];
    uint8_t len = 0;*/
    if (IfIndex>>8 != IfTypeHeaters)
    {
        LOG_ERROR (IfIndex, "Wrong  Interface type");
        return 0xFFFFFFFF;
    }
    index = IfIndex&0xFF;
    if (index < MAX_AC_HEATERS) //AC Heaters
    {
        LOG_ERROR (IfIndex, "Wrong  Interface ");
        return 0xFFFFFFFF;
    }
    if (HeaterCmd[index].targettemperatue == 0)
    {
        DeActivateHeater(index);
        //LOG_ERROR (index, "unconfigured");
        return ERROR;
    }
/*
    HeatingTestSendResonse(0, false,GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain),GetHeaterState(HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary),
                           Temperature[0],Temperature[1],
                           HeaterPIDConfig[HARDWARE_PID_CONTROL_TYPE__DryerHeaterMain].m_calculatedError, HeaterPIDConfig[HARDWARE_PID_CONTROL_TYPE__DryerHeaterSecondary].m_calculatedError,"Standard");
*/
    // check if the read value is within the proportional band
    if (DCInitialHeating[index]==true)
    {
        //int temp = ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100);
        if (readValue > ((HeaterCmd[index].targettemperatue * (100+HeaterControl[index].outputproportionalband))/100))
                {
                    DeActivateHeater(index);
                    //Heaters OFF until coming into the proportional band
                    //Report("DC HEATER Over temperature ", __FILE__,__LINE__,index, RpMessage, readValue, 0);
                    return OK;
                }
        if (readValue < ((HeaterCmd[index].targettemperatue * (100-HeaterControl[index].outputproportionalband))/100))
                {
                    ActivateHeater(index);
                    //Heaters OFF until coming into the proportional band
                    //Report("DC HEATER Under temperature ", __FILE__,__LINE__,index, RpMessage, readValue, 0);
                    return OK;
                }

        {
            DCInitialHeating[index] = false;
            HeatersControlStart();
            HeaterReady[index] = true;
            HeaterPrepareReady();
        }
    }
    if(HeaterPIDConfig[index].m_isEnabled && (HeaterPIDConfig[index].m_SetParam != 0))
    {
        /*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);
        }*/

//check only for the proportional band limits
        HeaterPIDConfig[index].m_mesuredParam = readValue;
        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;
//        len = usnprintf(logmsg[index], 254, "PID%d: Temp %d Integral %d Output %d ",index,(int)HeaterPIDConfig[index].m_mesuredParam ,(int)HeaterPIDConfig[index].m_integral,(int)HeaterPIDConfig[index].m_calculatedError);
//        Report(logmsg[index],__FILE__,__LINE__,index,RpWarning,index,  Counter[index]);

        //#warning PID is now only proportional (above)
        HeaterRecalculateHeaterParams(index, (int)(HeaterPIDConfig[index].m_calculatedError));
    }


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


uint32_t HeatersControlLoop(uint32_t tick)
{
    //char str[100];
    //uint8_t len = 0;
    int DcHeaterId;
    /*len = usnprintf(str, 100, "\r\n EightMilliSecondHeatersInterrupt SliceCounter %d Owner %d H1000 %d  H2000 %d"
                    ,SliceCounter,TimeSliceAllocation[SliceCounter],HeatersRestart,NumberOFSlicesInUse);
    Report(str, __FILE__,__LINE__,0, RpMessage, SliceCounter, TimeSliceAllocation[SliceCounter]);
*/
    static bool first = true;
    if (first == true)
    {
        first = false;
    }
    if (InitialHeating == false)
    {
        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);
            }
        }
        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 (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;
    //char str[60];
    //uint16_t length;
    //Clock_setTimeout(HostKAClock, 1000);
    //Clock_start(HostKAClock);
    HeatersControlInit();

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