Chktemp.c

Go to the documentation of this file.

#include <windows.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "mgui.h"
#include "DAS_Spatram.h"
#include "dcl.h"
#include "dxl.h"

int D_readtemp(void);

adtester ADTESTER;
//cpl CPL;          //Control Panel
//lis LIS;          //LIS
//paramini PARAM;   //Param.ini 
//marc MARC;        // Marconi struct
//omu OMU;      //OMU temperature structure
das DAS;
omuthr OMUTHR;

//Gains for actual temp near to target temp (5 > delta temp > 0=°C)
#define P_GAIN 0.9
#define D_GAIN 0.9
#define I_GAIN 0.5

//Gains for actual temp far from target temp ( 15 > delta temp >= 5°C)
//#define P_GAIN 1.9
//#define D_GAIN 1.9
//#define I_GAIN 1.5

//Gains for actual temp very far from target temp (delta temp >= 15°C)
//#define P_GAIN_F 3.9
//#define D_GAIN_F 3.9
//#define I_GAIN_F 4.5

//#define P_GAIN 3.9
//#define D_GAIN 3.9
//#define I_GAIN 4.5



#define I_COUNT_MAX   2            //-- # of intervals before increasing I
#define I_COUNT_DEC   4            //-- # times longer to wait b4 decrementing
#define I_VALUE_MAX   40           //-- Max Integral Value - Limits overshoot



#define CONTROLED_BAND 15          //-- Temperature band around Target that
                                   //   is controlled (2 units per degree!!)

#define MAX_TEMP    (50 * 2)       //-- Max Temperature of 50 Degrees


unsigned char Intergral = 0;
unsigned char I_Counter;
unsigned int FirstTimeP = 0;



//****************************************************************
//                    Calculate POWER
//****************************************************************




//mod  = 1 --> Aumenta Power
//mod  = 0 --> Diminuisce Power

int PID_Calc(int mod, int pow)
{
    
//  int temp;
    const double pgain = 30;//1.9;
    const double dgain =0;// 0.1;
    float igain = 0;//3;//1.5;
    double fac_dgain=0;
    double fac_pgain=0;
    float kp = 50;
    float kd = 5;//0.3;
    double ki = 0.005;
    double epsilon = 0.01, i_inst;
    float dt = LISTEMP_TASK_TIME/1000;


    static float pre_error = 0;
    static float old_error = 0;
    static float integral;// = 0;
    float error, delta;
    float derivative;
    float output;
    float PID_P, PID_D;
    static float PID_I;
    //integral =0;
    char buff[64];

    //dt = 0.5; //(float)(OMUTHR.CoolCnt*500);

    delta = (float)(OMUTHR.CoolTT - OMUTHR.CoolAT);
    sprintf(buff, "%.2lf", delta/10);
    //error = (float)atof(buff);
    error = delta/10;
    
//integral = 0;
//output = 0;
    if ((fabs(error)> 0.5))
    {
        integral = integral + (error * dt);
        if (fabs(integral) > 100)
            integral = 0;
    }
/*  else
        integral=0;
*/
    derivative = (error - pre_error) / dt;

//  output = 1100 * error+ 0.005*integral;//+ 150*derivative;

    output = OMUTHR.PID_kp * error+ OMUTHR.PID_ki*integral + OMUTHR.PID_kd*derivative;

    //output = OMUTHR.PID_kp/1000 * error - OMUTHR.PID_ki * integral + OMUTHR.PID_kd * derivative;
    
    //sprintf(buff, "%.2lf %.2lf %.2lf %.2lf", output, 1000*error, 0.5*integral, 500*derivative);
    //sprintf(buff, "%.2lf %.2lf %.2lf", output, 1000*error, 1400*derivative);
//  sprintf(buff, "%.2lf %.2lf %.2lf %.2lf", output, OMUTHR.PID_kp*error,OMUTHR.PID_ki*integral, OMUTHR.PID_kd*derivative);
//  Status(buff);

    
    if (output > 0)
    {
        pow = (int)output;
    }   
    if  (output < 0 )
    {
        pow = (int) -output;
    }
    
    pre_error = error;

    return (pow);
    
    //DTA Algorithm
    PID_P = error;
    if (OMUTHR.PID_ki>0)
    {
        i_inst = error * OMUTHR.PID_ki;
        PID_I += (float)i_inst;
        //if (PID_I > 1000) PID_I = 1000;
        //if (PID_I < -1000) PID_I = -1000;
        if (PID_I >= 100) PID_I = 100;
        if (PID_I <= -100) PID_I = -100;
    }
    else
        PID_I = 0;

    if(OMUTHR.PID_kd > 0)
    {
        PID_D = (OMUTHR.PID_kd * ((error - pre_error)*2));
        pre_error = error;
    }
    else
        PID_D = 0;


    output = OMUTHR.PID_kp *(PID_P + PID_I - PID_D);
    

    sprintf(buff, "%.2lf %.2lf %.2lf %.2lf", output, PID_P, PID_I, PID_D);
    Status(buff);

    if (output > 0)
    {
        
        pow = (int)output;
    
    }   
    if  (output < 0 )
    {
        
    
        pow = (int) -output;
    }
    
    pre_error = error;
    
    return (pow);


    /*********************************/
    //DTA Algorithm
    /*********************************/
/*  PID_P = error;
    if (ki>0)
    {
        i_inst = error * ki;
        PID_I += i_inst;
        if (PID_I > 10) PID_I = 10;
        if (PID_I < -10) PID_I = -10;
    }
    else
        PID_I = 0;

    if(kd > 0)
    {
        PID_D = kd * ((error - old_error));
        old_error = error;
    }
    else
        PID_D = 0;

    output = kp*(PID_P + PID_I - PID_D);

    
    
    pow = (int) output;


    
//}
    return pow;
*/
/******************************************/

/*

        fac_dgain = fabs( (float)(OMUTHR.CoolTT - OMUTHR.CoolTmp));
        fac_pgain = (OMUTHR.CoolTT / OMUTHR.CoolTmp);
    
    if (mod)
    {
        if(I_Counter++ > I_COUNT_MAX)
        {
            I_Counter=0;        //-- Counter slows the response of I
            Intergral++;        //-- Only Increase Integral if less than target
            if(Intergral > I_VALUE_MAX) Intergral=I_VALUE_MAX;
        }
        //pow = pow+((OMU.CoolTT / OMU.CoolTmp) * (float) P_GAIN) + (Intergral * (float) I_GAIN) + (((float)fabs(OMU.CoolTT - OMU.CoolTmp)) * (float) D_GAIN) ;
        pow = pow + (int)(fac_pgain *  pgain) + ((float)Intergral * igain)+(fac_dgain * dgain) ;
    }
    else
    {
        if(I_Counter++ > (I_COUNT_MAX*I_COUNT_DEC))  //-- Slower decrease of value
        {
            I_Counter=0;        //-- Counter slows the response of I
            if(Intergral !=0)Intergral--;
        }
        //temp= ((OMUTHR.CoolTT / OMUTHR.CoolTmp) * (float) P_GAIN) + (Intergral * (float) I_GAIN) + (((float)fabs(OMUTHR.CoolTT - OMUTHR.CoolTmp)) * (float) D_GAIN) ;
        temp = (int)(fac_pgain * pgain) + (Intergral * igain) + (fac_dgain * dgain);
        pow = pow - temp;

    }

    return (pow);
*/
}



float Calculate(float TARGET,float CURRENT, float POWER)
{
// float POWER;


// if(TARGET <= CURRENT)
    if( (CURRENT - TARGET) >= 0.2 )
    {
        if(CURRENT < (TARGET - CONTROLED_BAND))
        {
            POWER=90;
            Intergral=0;
        }
        else
        {
            if(CURRENT != TARGET)
            {
                if(I_Counter++ > I_COUNT_MAX)
                {
                    I_Counter=0;        //-- Counter slows the response of I
                    Intergral++;        //-- Only Increase Integral if less than target
                    if(Intergral > I_VALUE_MAX) Intergral=I_VALUE_MAX;
                }
            }
            if(FLAG.OMU_TempReached)
            //-- P.I.D     Proportional                Integral                 Derivative
                POWER = ((TARGET / CURRENT) * ((float) P_GAIN/4)) + (Intergral * (float) I_GAIN/4) + (((float)fabs(TARGET - CURRENT)) * ((float) D_GAIN/4)) ;
            else
                POWER = ((TARGET / CURRENT) * (float) P_GAIN) + (Intergral * (float) I_GAIN) + (((float)fabs(TARGET - CURRENT)) * (float) D_GAIN) ;
        }
    }
    else
    {

        //if(TARGET > CURRENT)
         if( (CURRENT - TARGET) <= -0.2 )
            POWER=POWER - (float) 0.1;
        else
            POWER = POWER;
        if(I_Counter++ > (I_COUNT_MAX*I_COUNT_DEC))  //-- Slower decrease of value
        {
            I_Counter=0;        //-- Counter slows the response of I
            if(Intergral !=0)Intergral--;
        }
    }

    if(POWER > 90) POWER = 90;

    if(POWER <= 0) POWER = 0;
    
    if(CURRENT > MAX_TEMP) POWER=0;
    
    return(POWER);
}


/*
  switch Peltier Rele' 
  param: int mod: 0 -> Peltier Heat; 1 -> Peltier Cold

*/
void OMU_ChooseDir(int mod)
{

    
    switch (mod)
    {
        case 0 :
            if(DAS.Paramini.EqType == SPATRAM2 )
            {
                
                Peltier(0);
                PeltFlg = 1; //Raffredda per SPATRAM2
                FANPeltier(1);
                FANFlg = 1;     
                MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[0], "SYS\\pltcool.bmp");
                MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[1], "SYS\\pltoff.bmp");

            }
            else
            {
                Peltier(0);
                PeltFlg = 0; //Scalda
                FANPeltier(0);
                FANFlg = 0;     
                MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[0], "SYS\\pltoff.bmp");
                MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[1], "SYS\\pltheat.bmp");
            }
            break;
        case 1:
            if(DAS.Paramini.EqType == SPATRAM2 )
            {
                Peltier(1);
                PeltFlg = 0; //Scalda per SPATRAM2
                FANPeltier(0);
                FANFlg = 0; 
                MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[0], "SYS\\pltcool.bmp");
                MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[1], "SYS\\pltoff.bmp");

            }
            else
            {
                Peltier(1);
                PeltFlg = 1; //Raffredda
                FANPeltier(1);
                FANFlg = 1; 
                MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[0], "SYS\\pltcool.bmp");
                MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[1], "SYS\\pltoff.bmp");
            }
            break;
    }
/*
    if(DAS.Paramini.EqType == SPATRAM2)
    {
        mod =! mod;
    }


    Peltier(mod);
    PeltFlg = mod; //Scalda (0) per SPATRAMPLUS, NG1,2,3, TropoGAS, LIS o Raffredda(1) per SPATRAM2
    FANPeltier(mod);
    FANFlg = mod;       

    if(DAS.Paramini.EqType == SPATRAM2 & mod == 0)
    {
        MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[0], "SYS\\pltcool.bmp");
        MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[1], "SYS\\pltoff.bmp");

    }
    else if(DAS.Paramini.EqType == SPATRAM2 & mod == 1)
    {
        MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[0], "SYS\\pltoff.bmp");
        MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[1], "SYS\\pltheat.bmp");
    }
    else
    {
        if (mod==0)
        {
            MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[0], "SYS\\pltoff.bmp");
            MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[1], "SYS\\pltheat.bmp");
        }
        if (mod==1)
        {
            MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[0], "SYS\\pltcool.bmp");
            MPixmapSetImageFile(DAS.Gui.ContrPanel.ledpelt[1], "SYS\\pltoff.bmp");
        }

    }

*/

}

/*
  Assign power to peltier
  param: int pow: Power (for Heating or cooling) to be assigned to the peltier

*/
void OMU_AssignPow(int pow)
{

    char buff[80];
    float PowerOn, PowerOff;

    AMS_PWM(AMS2, 0, 0);
    
    if(pow>LIM_PELTPOW)
        pow = LIM_PELTPOW;
    if(pow<0)
        pow = 0;

    PowerOn = (LISTEMP_TASK_TIME * (float)((double) pow / MAX_PELTPOW) );// * OMUTHR.CoolCnt;
    PowerOff = LISTEMP_TASK_TIME * OMUTHR.CoolCnt - PowerOn;
    if (PowerOn == 0)
    {
            PowerOn += 1;
            PowerOff -= 1;
    }
    if (PowerOff == 0)
    {
            PowerOff += 1;
            PowerOn -= 1;
    }

        AMS_PWM(AMS2, (int)PowerOn, (int)PowerOff); //scalda
    //Label della percentuale
    if(PeltFlg) // = 1 Raffredda
        sprintf(buff,"-%.1lf%%",(double) (PowerOn/LISTEMP_TASK_TIME*100));
    else //Riscalda
        sprintf(buff,"+%.1lf%%",(double) (PowerOn/LISTEMP_TASK_TIME*100));

    MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[7], buff);


}

/*
  switch Peltier Rele' and assign power to peltier
  param:
  int mod: 0 -> Peltier Heat; 1 -> Peltier Cold
  int pow: Power (for Heating or colding) to be assigned to the peltier

*/
void OMU_DoPeltPow(int mod, int pow)
{

    int c = mod;
    int p = pow;
    static int olddir = 1;

//  if(FlgSM_Stop)
//  {

        

        if(DAS.Paramini.EqType == SPATRAM2)
        {
            c =! c;
            olddir=0;
        }

        
/*  if(c == olddir)
        {
            OMU_ChooseDir(c);
            olddir = c;
        }
        else
        {
*/      
            AMS_PWM_OFF(AMS2);
            AMS_PWM_Zero(0);
            olddir = c;
            OMU_ChooseDir(c);

//      }

        //olddir = c;

        OMU_AssignPow(p);

//  }



}
int OMU_ColdOnly(void)
{

                
    // Esegue questo blocco se la target temp e minore di quella letta
    if(OMUTHR.CoolTT < OMUTHR.CoolTmp)
    {
        // Incrementa il power solo se la temperatura letta e' >= della precedente
        if(OMUTHR.CoolTmp >= OMUTHR.CoolPT)
        {
            if(OMUTHR.PCPower < LIM_PELTPOW)
            {
                
                if(OMUTHR.PID_On) //PID Algorithm
                {
                    OMUTHR.PCPower = PID_Calc(1, OMUTHR.PCPower);
                }
                else //Progressive algorithm
                {
                    OMUTHR.PCPower++;
                }
                OMU_DoPeltPow(1, OMUTHR.PCPower);
            }
        }
    }
    // Esegue questo blocco se la target temp e maggiore di quella letta
    if(OMUTHR.CoolTT > OMUTHR.CoolTmp)
    {
        // Decrementa il power solo se la temperatura letta e' <= della precedente
        if(OMUTHR.CoolTmp <= OMUTHR.CoolPT)
        {
            if(OMUTHR.PCPower > 0)
            {
                
                if(OMUTHR.PID_On) //PID Algorithm
                {
                    OMUTHR.PCPower = PID_Calc(0, OMUTHR.PCPower);
                }
                else //Progressive algorithm
                {
                    OMUTHR.PCPower--;
                }
                OMU_DoPeltPow(1, OMUTHR.PCPower);
            }
        }
    }
    return 0;
}

int OMU_HeatOnly(void)
{

                
    // Esegue questo blocco se la target temp e maggiore di quella letta
    if(OMUTHR.CoolTT > OMUTHR.CoolTmp)
    {
        // Incrementa il power solo se la temperatura letta e' <= della precedente
        if(OMUTHR.CoolTmp <= OMUTHR.CoolPT)
        {
            if(OMUTHR.PCPower < LIM_PELTPOW)
            {
                OMUTHR.PHPower++;
                OMU_DoPeltPow(0, OMUTHR.PHPower);

            }
        }
    }
    // Esegue questo blocco se la target temp e minore di quella letta
    if(OMUTHR.CoolTT < OMUTHR.CoolTmp)
    {
        // Decrementa il power solo se la temperatura letta e' >= della precedente
        if(OMUTHR.CoolTmp >= OMUTHR.CoolPT)
        {
            if(OMUTHR.PHPower > 0)
            {
                OMUTHR.PHPower--;
                OMU_DoPeltPow(0, OMUTHR.PHPower);

            }
        }
    }
    return 0;
}

int OMU_HC(void)
{
// PID_Calc
//mod  = 1 --> Aumenta Power
//mod  = 0 --> Diminuisce Power





    int  TLimit = 0;//limite di soglia della temp (decimi di grado)
    /*-------------------------------------------------------------*/
    
    
    
    if((OMUTHR.CoolTmp - OMUTHR.CoolTT) > TLimit )
    {
        OMUTHR.PCPower = PID_Calc(1, OMUTHR.PCPower);
        if(OMUTHR.PCPower >= LIM_PELTPOW)
            OMUTHR.PCPower = LIM_PELTPOW;
        OMU_DoPeltPow(1, OMUTHR.PCPower);
        OMUTHR.PHPower =0;
    }
    else if((OMUTHR.CoolTmp - OMUTHR.CoolTT) < -TLimit )

    {
        OMUTHR.PHPower = PID_Calc(0, OMUTHR.PHPower);
        if(OMUTHR.PHPower >= LIM_PELTPOW)
            OMUTHR.PHPower = LIM_PELTPOW;
        OMU_DoPeltPow(0, OMUTHR.PHPower);
        OMUTHR.PCPower =0;
    }
        
    
    
/*  
    //Raffredda
    // Esegue questo blocco se la target temp e minore di quella letta + Tlimit
    if((OMUTHR.CoolTmp - OMUTHR.CoolTT) > TLimit )
    {
        // Incrementa il power x COLD solo se la temperatura letta e' >= della precedente
//      if( (  ((OMUTHR.CoolPT - OMUTHR.CoolTT) > 0) & ((OMUTHR.CoolPT - OMUTHR.CoolTmp) >= 0)  )
//          |
//          (  ((OMUTHR.CoolPT - OMUTHR.CoolTT) > 0) & ((OMUTHR.CoolPT - OMUTHR.CoolTmp) <  0)  )   )
        if(   ((OMUTHR.CoolTmp - OMUTHR.CoolPT) > 0 ))
        {

            if(OMUTHR.PCPower < LIM_PELTPOW)
            {
                if(OMUTHR.PID_On) //PID Algorithm
                    OMUTHR.PCPower = PID_Calc(1, OMUTHR.PCPower);
                else //Progressive algorithm
                    OMUTHR.PCPower++;
            }
        }
        else if(   ((OMUTHR.CoolTmp - OMUTHR.CoolPT) == 0 )) //if the temperature is the same as the previous check, apply only the power
        {
        
        }
        else
        {
            if(OMUTHR.PCPower > 0)
            {
                if(OMUTHR.PID_On) //PID Algorithm
                    OMUTHR.PCPower = PID_Calc(0, OMUTHR.PCPower);
                else //Progressive algorithm
                    OMUTHR.PCPower--;
            }
            
        }

        OMUTHR.PCPower = PID_Calc(1, OMUTHR.PCPower);
        if(OMUTHR.PCPower >= LIM_PELTPOW)
            OMUTHR.PCPower = LIM_PELTPOW;

        OMU_DoPeltPow(1, OMUTHR.PCPower);
    }

    /*-------------------------------------------------------------*/
/*
    // Esegue questo blocco se la target temp e maggiore di quella letta
    if((OMUTHR.CoolTmp - OMUTHR.CoolTT) < -TLimit)
    {
        // Incrementa il power X HEAT solo se la temperatura letta e' <= della precedente
    //      if(OMUTHR.CoolTmp <= OMUTHR.CoolPT)
        if( ( ((OMUTHR.CoolPT - OMUTHR.CoolTT) < 0) & ((OMUTHR.CoolPT - OMUTHR.CoolTmp) <= 0)  )
            |
            ( ((OMUTHR.CoolPT - OMUTHR.CoolTT) < 0) & ((OMUTHR.CoolPT - OMUTHR.CoolTmp) >  0)  )  )

        {
            if(OMUTHR.PHPower <= LIM_PELTPOW)
            {
                if(OMUTHR.PID_On) //PID Algorithm
                    OMUTHR.PHPower = PID_Calc(1, OMUTHR.PHPower);
                else //Progressive algorithm
                    OMUTHR.PHPower++;
            }
        }
        else
        {
            if(OMUTHR.PHPower >= 0)
            {
                if(OMUTHR.PID_On) //PID Algorithm
                    OMUTHR.PHPower = PID_Calc(0, OMUTHR.PHPower);
                else //Progressive algorithm
                    OMUTHR.PHPower--;
            }
        }
        OMU_DoPeltPow(0, OMUTHR.PHPower);
    }
    
    // Esegue questo blocco se la temperatura letta e' tra i limiti
    if((OMUTHR.CoolTmp - OMUTHR.CoolTT) <= TLimit && (OMUTHR.CoolTmp - OMUTHR.CoolTT) >= -TLimit)
    {
        if((OMUTHR.CoolTmp - OMUTHR.CoolTT) > 0) //temp letta maggiore di temp target
        {
            if((OMUTHR.CoolPT - OMUTHR.CoolTmp) >= 0) //caso 1
            {
                if(OMUTHR.PCPower > 0)
                {
                    if(OMUTHR.PID_On) //PID Algorithm
                        OMUTHR.PCPower = PID_Calc(0, OMUTHR.PCPower); // 0 = Diminuisce, 1 = Aumenta Power
                    else //Progressive algorithm
                        OMUTHR.PCPower--;
                }   
            }
            if((OMUTHR.CoolPT - OMUTHR.CoolTmp) < 0) //caso 4
            {
                if(OMUTHR.PCPower <= LIM_PELTPOW)
                {
                    if(OMUTHR.PID_On) //PID Algorithm
                        OMUTHR.PCPower = PID_Calc(1, OMUTHR.PCPower);
                    else //Progressive algorithm
                        OMUTHR.PCPower++;
                }
            }

            OMU_DoPeltPow(1, OMUTHR.PCPower); // 1 = Raffredda
        }
        if((OMUTHR.CoolTmp - OMUTHR.CoolTT) < 0) //temp letta minore di temp target
        {
            if((OMUTHR.CoolPT - OMUTHR.CoolTmp) >= 0) //caso 3
            {
                if(OMUTHR.PHPower <= LIM_PELTPOW)
                {
                    if(OMUTHR.PID_On) //PID Algorithm
                        OMUTHR.PHPower = PID_Calc(1, OMUTHR.PHPower); // 0 = Diminuisce, 1 = Aumenta Power
                    else //Progressive algorithm
                        OMUTHR.PHPower++;
                }   
            }
            if((OMUTHR.CoolPT - OMUTHR.CoolTmp) < 0) //caso 4
            {
                if(OMUTHR.PHPower > 0)
                {
                    if(OMUTHR.PID_On) //PID Algorithm
                        OMUTHR.PHPower = PID_Calc(0, OMUTHR.PHPower);
                    else //Progressive algorithm
                        OMUTHR.PHPower--;
                }
            }

            OMU_DoPeltPow(0, OMUTHR.PHPower); // 0 = Riscalda
        }

    }
        
*/

    return 0;

}




int OMU_TemperatureHandle(void)
{
    int     c;
    


    OMUTHR.CoolCnt--;
    if(OMUTHR.CoolCnt == 0)
    {
        // Calcola il numero di interventi in funzione del salto
        //   termico che deve effettuare
        // DANBO ADDENDA
        // Ricorda che nella funzione chiamante bisogna mettere un blocco del tipo:
        //***************************
        // if(OMUTHR.CoolCnt == 1)
        //      OMU_TemperatureHandle();
        // else
        //      OMUTHR.CoolCnt--;
        //***************************
        // In questo modo se Coolcnt = 1, si esegue la routine, in caso contrario si
        // decrementa il contatore fino a quando e' 1 (quindi si ritarda l'applicazione
        // di eventuali modifiche di un certo intervallo di tempo 
        // (Es. coolCnt = 4, delay di 2 secondi - 0.500ms x 4 = 2 sec)
        // (Es. coolCnt = 5, delay di 2.5 secondi - 0.500ms x 5 = 2.5 sec)
        

        OMUTHR.CoolCnt = (int) fabs(OMUTHR.CoolTT - OMUTHR.CoolAT);
        if(OMUTHR.CoolCnt >= 40) //4°
            OMUTHR.CoolCnt = 1;//20; //1; // 0.5 s
        else
        {
            if(OMUTHR.CoolCnt >= 20) //2°
                OMUTHR.CoolCnt = 1;//10;//2; // 1 s
            else
            {
                if(OMUTHR.CoolCnt >= 10) //1°
                    OMUTHR.CoolCnt = 1;//3;//3; // 1.5 s
                else
                {
                    if (DAS.DOption.refertemp == 0) // Internal Peltier
                    {
                        if(OMUTHR.CoolCnt >= 2) //0.5°
                            OMUTHR.CoolCnt = 2; //4;    // 2 s
                        else
                            OMUTHR.CoolCnt = 1; //5;    // 2.5 s
                    }
                    if (DAS.DOption.refertemp == 1) // OPTIC
                    {
                        if(OMUTHR.CoolCnt >= 5) //0.5°
                            OMUTHR.CoolCnt = 20;    // 10 s
                        else
                            OMUTHR.CoolCnt = 40;    // 20 s
                    }
                    if (DAS.DOption.refertemp == 2) // Grating
                    {
                        if(OMUTHR.CoolCnt >= 5) //0.5°
                            OMUTHR.CoolCnt = 1;//4;//10;    // 10 s
                        else
                            OMUTHR.CoolCnt = 1;//2;//20;    // 40 s
                    }

                }
            }
        }
        // Flush dei decimali oltre il decimo di grado
        c = (int) (OMUTHR.CoolAT * 10);
        OMUTHR.CoolTmp = (float) c;
        OMUTHR.CoolTmp /= 10;
    
        switch(OMUTHR.TRType)
        {
            case TRTCOOL :
                    OMU_ColdOnly();
                break;
            case TRTHEAT:
                    OMU_HeatOnly();
                break;
            case TRTBOTH:
                    OMU_HC();
                    //D_PID();
                break;
        }
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        if(OMUTHR.CoolTT == OMUTHR.CoolTmp)
        {
            OMUTHR.ReachTemp = 1;
            OMUTHR.CoolSts = 3;
        }
        else
        {
            OMUTHR.ReachTemp = 0;
            OMUTHR.CoolSts = 2;
        }
        OMUTHR.CoolPT = OMUTHR.CoolTmp;
    }

    return 0;
}


void Task_LIS_Temp(TIMEOUT_ID id, void *data)

{
    static float power;
    double DeltaT;
    extern int FirstTime;
    extern int DeltaTPrec;
    extern int Incr_Read_Temp;
    char Label[30];
    int DeltaTMax = 300;
    int DeltaTMin = 0;
    int stopplt = 0;
    char str[64];

    extern char PrgFile[_MAX_PATH];// Nome della tabella da eseguire

    /**********************************************************************/
    /**********   for OMU Thermoregulation     ****************************/
    //Target temperature
    OMUTHR.CoolTT = (float)DAS.Paramini.TPelt * 10; 

    // Read Temperatures
    D_readtemp();
    
    //Actual temperature (Reference)
    switch (DAS.DOption.refertemp)
    {
        case 0:
            if(DAS.Paramini.EqType == LIS_)
                OMUTHR.CoolAT = (OMUTHR.Temperature[9] + OMUTHR.Temperature[13]) * 10 / 2; //Average internal Peltier
            else
                OMUTHR.CoolAT = (OMUTHR.Temperature[12] + OMUTHR.Temperature[14]) * 10 / 2; //Average internal Peltier
            break;
        case 1:
            if(DAS.Paramini.EqType == LIS_)
                OMUTHR.CoolAT  = OMUTHR.Temperature[11] * 10; //Optic LIS
            else
                OMUTHR.CoolAT  = OMUTHR.Temperature[15] * 10; //Optic
                break;
        case 2:
                OMUTHR.CoolAT  = OMUTHR.Temperature[10] * 10; //Grating
                break;
    }   


    DeltaT = OMUTHR.CoolAT - OMUTHR.CoolTT;

    if(FirstTimeP == 0)
    {
        FirstTimeP = 1;
        //OMUTHR.PCPower = 550;
        OMUTHR.PHPower = OMUTHR.PCPower;// / 3;
    }


    //Security control
    //Ccontrollo sulle temperature esterne
    //Se una o l'altra temperatura ext sono maggiori di 55 gradi
    // bisogna spegnere le peltier!!!!!!
    if(DAS.Paramini.EqType == LIS_)
    {
        if( (OMUTHR.Temperature[8] > 55) | (OMUTHR.Temperature[12] > 55)  ) 
            stopplt = 1; 
    }
    else
    {
        if( (OMUTHR.Temperature[11] > 55) | (OMUTHR.Temperature[13] > 55)  )    
            stopplt = 1; 
    }

    if(stopplt)
    {
        if(FlgSM_Stop)
        {
            OMU_ChooseDir(1);
            OMU_AssignPow(0); //Peltier OFF
        }
    }
    else
    {
        //OMU Thermo Regulation 
        if(OMUTHR.CoolCnt == 1)
            OMU_TemperatureHandle();
        else
            OMUTHR.CoolCnt--;
    }
    //Label deltaT  
    sprintf(Label,"%.02lf", DeltaT/10);
    MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[6], Label);
    /**********************************************************************/    
/************************************************************************************/
// Procedura per scegliere la temperatura di esercizio del CCD a diversi SZA
// se si sta eseguendo una tabella di misure.

    if((PrgFile[0] != 0) | (Master == 1))           // Se si esegue una tabella
    {
        if(FLAG.settempvar) //Se il flag per la temperatura variabiele è attivo
        {
            if( (S_zenetr >= 80) & (S_zenetr <= 95))    
            {
                if(FLAG.settemp8095)
                {
                    // Imposta la temperatura di esercizio CCDTemp
                    DC_SetTemp( -15.0, CELSIUS, 0);
                    // Imposta la potenza del cooler del CCD
                    DC_SetPower((double)35.0, 0); 
                    sprintf(str, "%.1lf", -15.00);
                    MObjectSetText(DAS.Gui.ContrPanel.lbl_Par[0], str);
                    sprintf(str,"%.1lf%%",35.00);
                    MObjectSetText(DAS.Gui.ContrPanel.lbl_Par[1], str);
                    FLAG.settemp8095 = 0;
                    FLAG.settemp7080 = 1;
                    FLAG.settemp070 = 1;
                }
            }
            else if( (S_zenetr >= 70) & (S_zenetr < 80))
            {
                if(FLAG.settemp7080)
                {
                    // Imposta la temperatura di esercizio CCDTemp
                    DC_SetTemp( -5.0, CELSIUS, 0);
                    // Imposta la potenza del cooler del CCD
                    DC_SetPower((double)35.0, 0); 
                    sprintf(str, "%.1lf", -5.00);
                    MObjectSetText(DAS.Gui.ContrPanel.lbl_Par[0], str);
                    sprintf(str,"%.1lf%%",35.00);
                    MObjectSetText(DAS.Gui.ContrPanel.lbl_Par[1], str);
                    FLAG.settemp8095 = 1;
                    FLAG.settemp7080 = 0;
                    FLAG.settemp070 = 1;
                }
            }
            else if( ((S_zenetr >= 0) & (S_zenetr < 70)) | (S_zenetr > 95))
            {
                if(FLAG.settemp070)
                {
                    // Imposta la temperatura di esercizio CCDTemp
                    DC_SetTemp( 5.0, CELSIUS, 0);
                    // Imposta la potenza del cooler del CCD
                    DC_SetPower(DAS.Paramini.CoolPw/10, 0); 
                    sprintf(str, "%.1lf", 5.00);
                    MObjectSetText(DAS.Gui.ContrPanel.lbl_Par[0], str);
                    sprintf(str,"%.1lf%%",DAS.Paramini.CoolPw/10.00);
                    MObjectSetText(DAS.Gui.ContrPanel.lbl_Par[1], str);
                    FLAG.settemp8095 = 1;
                    FLAG.settemp7080 = 1;
                    FLAG.settemp070 = 0;
                }
            }

        }
    }

    /******************************************************/
            //Fan ECU

    if (OMUTHR.Temperature[8] >= 22)
        FANECU(1);
    else
        FANECU(0);



/************************************************************************************/

    if((FLAG.ADPC104 == 0) | (FLAG.ADTempTest == 0))
//      if(!FLAG.AMS_H) 
            MAddTimeout(LISTEMP_TASK_TIME, Task_LIS_Temp, data);  // rilancia il task

        DeltaTPrec = (int) DeltaT;

}

/********************************************************************/
void Task_AMSH(TIMEOUT_ID id, void *data)
{

    int d,er;



    // Read input  
    d = AMS_chkbitsts(AMS1, 3);
    FLAG.AMS_H = 1;
    if (d==0)
    {
        
        er = AMS_TrackOff(AMS1, 1, 0);
        FLAG.AMS_H = 0;
    }

    if(FLAG.AMS_H)
        MAddTimeout(AMSH_TASK_TIME, Task_AMSH, data);  // rilancia il task
}

void Task_CCD_Temp(TIMEOUT_ID id, void *data)
{
    char ActTemp[16], buf[16];
    char buff[128];
    int er = 0;
    double CCD_Pwr;
    unsigned long   et;
    static unsigned long starttime;
    double tout,x;
    SYSTEM_POWER_STATUS status;

    //Read the CCD Temperature
    DC_GetTemp(ActTemp, CELSIUS, 0);
    
    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    /******************************************************************************************/
    /* These few line of code are necessary because for the period 00:00:00-01:00:00
        sometimes the DC_GetTemp procedure returns an empty string, so the code check if
        the second character of the returned string is not 0 (normally it has to be + or -)
        and in this case assign the temperature to the DAS.Marconi.CCDTemp variable, otherwhise 
        it mantain the previous value
    */
    /******************************************************************************************/
    if (ActTemp[1] != 0)
    {
        DAS.Marconi.CCDTemp = (float) atof(ActTemp);
        sprintf(buf, "%0.1lf", DAS.Marconi.CCDTemp);
        MObjectSetText(DAS.Gui.ContrPanel.Albl_CS[0], buf);
    }
    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

    /*  If the temperature is  -273.15 the  USB connection is lost and the camera have to be reinitializied */
    if (DAS.Marconi.CCDTemp < -250)
    {
        if(FLAG.exec)
        {
            FLAG.exec = 0;
            FLAG.REINITCCD = 0;
            starttime = GetTickCount()-1000;

            Status("Camera Re-Init in 60 sec");

            if(DAS.Flag.DeltaSZA == 1)
            {
                DAS.Flag.ExeDSZA = 0; //Stop PRG Execution 

    //          SZADelta.LastMSZA = S_zenetr;   
    //          D_FixSZA();
            }
        
        }
        
        if(FLAG.exec == 0 &&  FLAG.REINITCCD == 0)
        {
            et = GetTickCount();
            x = labs(et - starttime)/1000.0;
            if(x <60)
            {
            
                tout = 60.0 - x;
                sprintf (buff,"Camera Init in %.1lf sec", tout);
                Status(buff);
            }
            else
                FLAG.REINITCCD = 1;

        }


        if(FlgSM_Stop && FLAG.REINITCCD)
        {
            er = DB_InitCamera(1);
            
            FLAG.exec = 1;
            FLAG.REINITCCD = 0;
            Status("Ready");
            // If a SZAPRG or a *.PRG file is in execution with the DeltaSZA Mode activated
            // the next SZA has to be recalculated
        
        
            if(DAS.Flag.DeltaSZA == 1)
            {
                DAS.Flag.ExeDSZA = 1; //PRG Execution 

                SZADelta.LastMSZA = S_zenetr; 
                D_FixSZA();
    
            }


        }


        
    }


    /******************************************************************************************/

    if( DAS.Marconi.CCDTemp <= DAS.Paramini.ITemp)
    //if( fabs(DAS.Marconi.CCDTemp - DAS.Paramini.ITemp) <= 1.00)
    {
        OMUTHR.ReachTemp = 1;
//      Status("CCD Temp Reached");

    }
//  else
//  {
//      OMUTHR.ReachTemp = 0;

//  }

    er = DC_CoolerStatus(0);

    switch (er)
    {
    case 0:
//      Status("Cooler Not Activated");
        break;
//    case 1:
//      Status("Cooler Active without temp. control");
//      break;
    case 1:
//      Status("Cooler Active, waiting for equilibrium");
        break;
    case 2:
//      Status("Equilibrium Reached");
//      LIS.ReachTemp = 1;
        break;
    case 3:
//      Status("Equilibrium Reached");
    //  OMUTHR.ReachTemp = 1;
        break;

    case 4:
//      Status("ShutDown in Progress");
        break;
    case 5:
//      Status("ShutDown Done");
        break;

    }

    CCD_Pwr = DC_GetPower(0);  
    sprintf(buf, "%.1lf%%", CCD_Pwr);   
    MObjectSetText(DAS.Gui.ContrPanel.Albl_CS[1], buf);

/*******************************************************************************************/
    // These lines of code are related to the possibility of a UPS linked to the 
    // instrument:
    // 1) The UPS is a serial one (recognized by the Operating System) therefore DAS 
    // uses the windows API to be adviced about the battery utilization
    // 2) The UPS utilize a open collector/open emitter technology, so DAS knows about the 
    // utilization of the battery with the inputs port of the mainboard I/O

    // 1)
    //Check the Supply status
    GetSystemPowerStatus( &status );

    switch (status.ACLineStatus)
        {
            case 1: // Power On Line
                if(DAS.Flag.UPS_Battery == 1)
                    DAS.Flag.UPS_Battery = 2;
                else
                    DAS.Flag.UPS_Battery = 0;
            break;
            case 0: //Battery on line
                DAS.Flag.UPS_Battery = 1;
            break;
        }

    // 2) 
    //Check the Supply status
/*  er = NOVA_In(DAS.Nova.type, DAS.Nova.DigIn);
    er = ChkDigIO(DAS.Nova.DigIn, 0);
    if(er==1)
        DAS.Flag.UPS_Battery = 1;
    if (er == 0 & DAS.Flag.UPS_Battery == 1)
        DAS.Flag.UPS_Battery = 2;
*/



    // Common
    if (DAS.Flag.UPS_Battery == 1) // UPS battery ON
    {
        //Shutdown CCD sensor
        DC_SetTemp(25.0, CELSIUS, 0);

        //Switch off the Peltier

    }
    else if (DAS.Flag.UPS_Battery == 2)
    {
        DAS.Flag.UPS_Battery = 0;
        // Set CCD Temperature
        DC_SetTemp(DAS.Paramini.ITemp, CELSIUS, 0);
        // Set CCD Cooler Power
        DC_SetPower((double) ((double)DAS.Paramini.CoolPw / 10),0);

        //Switch on the Peltier

        
    }
/*******************************************************************************************/
    
    MAddTimeout(CCDTEMP_TASK_TIME, Task_CCD_Temp, data);  // rilancia il task

        


}

int D_readtemp(void)
{

    extern int Incr_Read_Temp;
    int i;
    char buf[24];
    double t, TRef, DeltaT;
    double temp;
    int NumSamples, x, KUP = 4096;
    float AVGTemp;

    // TEMPERATURES READING
    if(FLAG.ADPC104 == 0)
    {
        D_rt();

        for (i=0; i<16; i++)
        {
            if(FLAG.ADTempTest == 0)
            {
//              temp = Tmp[i][AD_SAMPLING/2];
                temp = OMUTHR.ADVolt[i];
//              Tmp[i][AD_SAMPLING/2] = (66.66666666666666666 * (temp) - 273.16);
                OMUTHR.ADVolt[i] = (66.66666666666666666 * (temp) - 273.16);
                
                //Shift of the Temperature Buffer
                for(x= KUP-1;x>0;x--)
                {
                    OMUTHR.Temptemp[i*KUP+x]= OMUTHR.Temptemp[i*KUP+x-1];
                }
                // Put the last retrieved temperature in the first place of the register
                //LIS.Temptemp[i*KUP]= Tmp[i][AD_SAMPLING/2];
                OMUTHR.Temptemp[i*KUP]= (float) OMUTHR.ADVolt[i];
                
                AVGTemp = 0;
                NumSamples = 1;

                //Calc the average temperature considering 
                //(if the register is full)only the firsts 
                //KUP/8 (4096/8=512) values (about 7 Minutes of sampling)
                //KUP/16 (4096/16=256) values (about 3.5 Minutes of sampling)
                for(x=0;x<KUP/64;x++)
                {
                    if(OMUTHR.Temptemp[i*KUP+x] != 0)
                    {
                        AVGTemp += OMUTHR.Temptemp[i*KUP+x];
                        NumSamples++;
                    }
                    

                }
                AVGTemp =AVGTemp / (NumSamples-1);


                //sprintf(str, "Channel %d", i);
                //sprintf(buf, "%.1f", (float)Tmp[i][AD_SAMPLING/2]);
                sprintf(buf, "%.1f", (float)AVGTemp);
                
                

                //LIS.LisT[i] =  (float) Tmp[i][AD_SAMPLING/2];
                OMUTHR.Temperature[i] =  (float) AVGTemp;

                if(DAS.Paramini.EqType == LIS_)
                {
                    switch(i)
                    {
                        case 0:
                            break;
                        case 1:
                            break;
                        case 2:
                            break;
                        case 3:
                            break;
                        case 4:
                            break;
                        case 5:
                            break;
                        case 6:
                            break;
                        case 7:
                            break;
                        case 8:
                            //Temp Out DX
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[1], buf);
                            break;
                        case 9:
                            //Temp Int DX
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[3], buf);
                            break;
                        case 10:
                            //Temp GRATING
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[5], buf);
                            break;
                        case 11:
                            //Temp Optic
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[0], buf);
                            break;
                        case 12:
                            //Temp Out SX
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[2], buf);
                            break;
                        case 13:
                            //Temp Int SX
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[4], buf);
                            break;

                        case 14:

                            break;

                        case 15:
                            //Temp ELET
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[6], buf);
                            break;
                    }


                }

                else if (DAS.Paramini.EqType == GASCODNG4 || DAS.Paramini.EqType == SPATRAM3) 
                {
                    switch(i)
                    {
                        case 0:
                            break;
                        case 1:
                            break;
                        case 2:
                            break;
                        case 3:
                            break;
                        case 4:
                            break;
                        case 5:
                            break;
                        case 6:
                            break;
                        case 7:
                            break;
                        case 8:
                            //Temp ELET
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[6], buf);
                            break;
                        case 9:
                            //Temp MIGE
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[7], buf);

                            break;
                        case 10:
                            //Temp GRATING
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[2], buf);
                            break;
                        case 11:
                            //Temp Out DX
                            sprintf(buf, "%s", "NA");
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[1], buf);
                            break;
                        case 12:
                            //Temp Int DX
                            sprintf(buf, "%s", "NA");
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[3], buf);
                            break;
                        case 13:
                            //Temp Out SX
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[5], buf);
                            break;
                        case 14:
                            //Temp Int SX
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[4], buf);
                            break;
                        case 15:
                            //Temp Optic
                            sprintf(buf, "%s", "NA");
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[0], buf);
                            break;
                    }

                }
                else
                {
                    switch(i)
                    {
                        case 0:
                            break;
                        case 1:
                            break;
                        case 2:
                            break;
                        case 3:
                            break;
                        case 4:
                            break;
                        case 5:
                            break;
                        case 6:
                            break;
                        case 7:
                            break;
                        case 8:
                            //Temp ELET
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[6], buf);
                            break;
                        case 9:
                            //Temp MIGE
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[7], buf);

                            break;
                        case 10:
                            //Temp GRATING
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[5], buf);
                            break;
                        case 11:
                            //Temp Out DX
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[1], buf);
                            break;
                        case 12:
                            //Temp Int DX
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[3], buf);
                            break;
                        case 13:
                            //Temp Out SX
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[2], buf);
                            break;
                        case 14:
                            //Temp Int SX
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[4], buf);
                            break;
                        case 15:
                            //Temp Optic
                            MObjectSetText(DAS.Gui.ContrPanel.Albl_LT[0], buf);
                            break;
                    }
                }
            }

        
            
            if(FLAG.ADTempTest == 1)
            {
                
                if(ADTESTER.OutputMode) //Temperature in gradi celsius
                {
                    temp = OMUTHR.ADVolt[i];
                    OMUTHR.ADVolt[i] = (66.66666666666666666 * (temp) - 273.16);            
                    sprintf(buf, "%.1f", OMUTHR.ADVolt[i]);
                    MObjectSetText(ADTESTER.lblADvalue[i], buf);
                }
                else
                {
                    sprintf(buf, "%.3f", OMUTHR.ADVolt[i]);// Temperature in Volts              
                    MObjectSetText(ADTESTER.lblADvalue[i], buf);
                }
                
            }

        }
        for(i=0;i<16;i++)
            OMUTHR.ADVolt[i] = 0;

        //Temperatura di Riferimento
        TRef = DAS.Paramini.TPelt * 10;
        //Target temperature
        switch (DAS.DOption.refertemp)
        {
            case 0:
                t = (OMUTHR.Temperature[12] + OMUTHR.Temperature[14]) *10 / 2; //Average internal Peltier
                break;
            case 1:
                t = OMUTHR.Temperature[15]*10; //Optic
                break;
            case 2:
                t = OMUTHR.Temperature[10] * 10; //Grating
                break;
        }
        
        DeltaT = t - TRef;
        
        //Label deltaT  
        sprintf(buf,"%.2lf", DeltaT/10);
        MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[6], buf);
    
    }

    
    
    return 0;   

}





void Task_REFRESH_Temp(TIMEOUT_ID id, void *data)
{

    D_readtemp();
//  if (DAS.DOption.aaopmode == 0)
//      AASunTrack();

    if(!FLAG.AMS_H)
        //MRefreshTimeout(&IDS.REFRTEMP, REFRESHTEMP_TASK_TIME, Task_REFRESH_Temp, NULL);

        MAddTimeout(REFRESHTEMP_TASK_TIME, Task_REFRESH_Temp, data);  // rilancia il task

}