RTC_Time.c

Go to the documentation of this file.

#include <fcntl.h>
#include <process.h>
#include <io.h>
#include <math.h>
#include <sys\stat.h>
#include <time.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/timeb.h>
#include <string.h>
#include <windows.h>
#include <stdlib.h>
#include <errno.h>
#include "mgui.h"
#include "DAS_Spatram.h"
#include "dcl.h"
#include "wsc.h"
#include "dxl.h"
#include "solpos.h"
#include "bil.h"
#include "dil.h"


DXL_par DXL;
flag FLAG; //flags structure
//cpl CPL;          //Control Panel
//lis LIS;          //LIS
stepm STEPM;        //Stepper Motors
dlog DLOG;
bil BIL;
dftp DFTP;
dsza SZADelta;

das DAS;

omuthr OMUTHR;

char ddmmyy[8];
char ddmmyyf[6];
extern int Incr_Read_Temp;
extern int ExeREM;


/* Trasforma la data da mm/gg/aa a gg/mm/aa  */
void FormatData(void)
{
    int     k, x, i;
    char datebuf[9];
    char dday[2], dmonth[2], dyear[2];


    _strdate(datebuf);
    k = 0;
    x = 0;
    for(i = 0; i < 9; i++)
    {
        if(i<2)
        {
            dmonth[i] = datebuf[i];
        }

        if(i > 2 && i < 5)
        {
            dday[k] = datebuf[i];
            k++;
        }
        if(i > 5 && i < 8)
        {
            dyear[x] = datebuf[i];
            x++;
        }
    }
    sprintf(ddmmyy,"%c%c/%c%c/%c%c", dday[0],dday[1],dmonth[0],dmonth[1],dyear[0],dyear[1]);
}

/* Trasforma la data da mm/gg/aa a ggmmaa per i nomi dei files  */
void FormatDataFile(void)
{
    int     k, x, i;
    char    datebuf[9];
    char    dday[2], dmonth[2], dyear[2];

    _strdate(datebuf);
    k = 0;
    x = 0;
    for(i = 0; i < 9; i++)
    {
        if(i<2)
        {
            dmonth[i] = datebuf[i];
        }

        if(i > 2 && i < 5)
        {
            dday[k] = datebuf[i];
            k++;
        }
        if(i > 5 && i < 8)
        {
            dyear[x] = datebuf[i];
            x++;
        }
    }

    sprintf(ddmmyyf,"%c%c%c%c%c%c", dday[0],dday[1],dmonth[0],dmonth[1],dyear[0],dyear[1]);


}

//Elabora la data per avere il file di log
void FileLog(char datebuf[9], char timebuf[9])
{

    _strdate(datebuf);
    _strtime(timebuf);
    FormatDataFile();
}

//Elabora la data per avere il file di Misure Giornaliero
void FileDat(void)
{
//  int     k, x, i;
//  char datebuf[9];
//  char dday[2], dmonth[2], dyear[2];
/*
    _strdate(datebuf);
    k = 0;
    x = 0;
    for(i = 0; i < 9; i++)
    {
        if(i<2)
        {
            dmonth[i] = datebuf[i];
        }

        if(i > 2 && i < 5)
        {
            dday[k] = datebuf[i];
            k++;
        }
        if(i > 5 && i < 8)
        {
            dyear[x] = datebuf[i];
            x++;
        }
    }
    sprintf(sd,"%c%c%c%c%c%c", dday[0],dday[1],dmonth[0],dmonth[1],dyear[0],dyear[1]);
    Status(filedati);
    return SaveDate
    */
}




//Scrive sul file giornaliero ("ddmmyy.log"), la data e
//l'ora di inizio del programma
void WriteInit(const char *sname, char *dateffn, char *timebuff)
{
    int     fc, er;
    char    tit1[256], datebuff[9];


    //for stepper motors log
    sprintf(DLOG.fsmlog,"%s\\SM_%s.log", BIL.DFILEM.LOGDIR, dateffn); 



    sprintf(DLOG.flog,"%s\\%s%s.log",BIL.DFILEM.LOGDIR, sname, dateffn);

    fc = _open(DLOG.flog, O_WRONLY | O_APPEND | O_TEXT  | O_CREAT, S_IWRITE);
    //test for errno
    //fc = _open(DLOG.flog, O_WRONLY | O_APPEND | O_TEXT  | O_CREAT| O_EXCL, S_IWRITE);
    
    
        if(fc < 0)
        {
            er = errno; 
        }return;
    
    sprintf(datebuff,"%c%c/%c%c/%c%c", dateffn[0],dateffn[1],dateffn[2],dateffn[3],dateffn[4],dateffn[5]);
    sprintf(tit1,"DAS Started on: %s, at: %s\n",datebuff,timebuff);
    write(fc, &tit1, strlen(tit1));
    // Write title for monitored values 
    sprintf(tit1,"Time      TCCD    PwCCD    PwPlt   T.Optic   T.IntSX   T.OutSX  T.IntDX   T.OutDX   T.Grat   SPARE   T.Elec   SPARE   SPARE   SPARE   SPARE   SPARE   SPARE   SPARE   SPARE \n");
    write(fc, &tit1, strlen(tit1));

    close(fc);
}

void WriteTitolo(void)
{
    int     fc;
    char    tit1[90];



        fc = open(DLOG.flog, O_WRONLY | O_APPEND | O_TEXT  | O_CREAT, S_IWRITE);
        if(fc < 0) return;
        sprintf(tit1,"Time      TCCD    PwCCD    PwPlt   T.Optic   T.IntSX   T.OutSX  T.IntDX   T.OutDX   T.Grat   SPARE   T.Elec   SPARE   SPARE   SPARE   SPARE   SPARE   SPARE   SPARE   SPARE \n");
        write(fc, &tit1, strlen(tit1));
        close(fc);
}


void MIGEAntiSunTrack(void)
{

    char str[16];
    float azi, elev;

    sprintf(str, "%.01lf", (90 + S_zenetr) );   
    elev = (float)atof(str); 

    sprintf(str, "%.01lf", S_azim);
    azi = (float)atof(str);

    SD_PosAADev(elev, azi);
    
}

void MIGESunTrack(void)
{

    char str[16];
    float azi, elev;

    sprintf(str, "%.01lf", (90 - S_zenetr));   
    elev = (float)atof(str); 

    sprintf(str, "%.01lf", S_azim);
    azi = (float)atof(str);

//  azi= MIGEActualZenAz(0);
//  elev= MIGEActualZenAz(1);

    SD_PosAADev(elev, azi);
    
    



}


void Task_LOG(TIMEOUT_ID id, void *data)
{
    int     fc;
    int     cont;
    char    str[80];
    char    tit1[256];
//    time_t ltime;
    struct tm today;
    struct time RTime;
    struct date RDate;
    
    GetDateTime(&RDate, &RTime, &today);
    /* Get UNIX-style time */
    //time( &ltime );
    /* Use time structure to build a customized time string. */
    //today = localtime( &ltime );
    /* Use strftime to build a customized time string. */
    strftime( DLOG.ndate, 7,"%y%m%d", &today );
    strftime( DLOG.ntime, 9,"%H:%M:%S", &today );

        // If the date is changed, the log filename changes...  
        if(strcmp(DLOG.ndate, DLOG.odate) != 0)
        {
            sprintf(DLOG.odate, "%s",DLOG.ndate);
            sprintf(DLOG.flog,"%s\\%s%s.log", BIL.DFILEM.LOGDIR, DAS.DGeo.s_name, DLOG.ndate);
            
            //for stepper motors log
            sprintf(DLOG.fsmlog,"%s\\SM_%s.log", BIL.DFILEM.LOGDIR, DLOG.ndate); 

            fc = open(DLOG.flog, O_WRONLY | O_APPEND | O_TEXT  | O_CREAT, S_IWRITE);
                if(fc < 0) return;
    
                // Write title for monitored values 
                sprintf(tit1,"Time      TCCD    PwCCD    PwPlt   T.Optic   T.IntSX   T.OutSX  T.IntDX   T.OutDX   T.Grat   SPARE   T.Elec   SPARE   SPARE   SPARE   SPARE   SPARE   SPARE   SPARE   SPARE \n");
                write(fc, tit1, strlen(tit1));
            close(fc);

            SZA_FindMin(); //...and the minimum daily SZA is calculate...

            ShutterOpening(1);// ...and write on the Shutter.ini the number of shuts 
            
        }

    fc = open(DLOG.flog, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
    if(fc > 0)
    {

        sprintf(str, "%s  ",DLOG.ntime); //Time
        write(fc, str, strlen(str));

        sprintf(str, "%5.1lf  ", DAS.Marconi.CCDTemp); // Temperature CCD
        //MObjectGetText(DAS.Gui.ContrPanel.Albl_CS[0], str);
        //strcat(str,"  ");
        write(fc, str, strlen(str));

        MObjectGetText(DAS.Gui.ContrPanel.Albl_CS[1], str); //Power CCD
        strcat(str,"  ");
        write(fc, str, strlen(str));

        MObjectGetText(DAS.Gui.ContrPanel.Albl_LS[7], str); //Power Peltier
        strcat(str,"  ");
        write(fc, str, strlen(str));



        for(cont = 15; cont >= 0; cont--)
        {
            
            sprintf(str, "%5.1lf  ", OMUTHR.Temperature[cont]);
            write(fc, str, strlen(str));
        }

        sprintf(str, "\n","");
        write(fc, str, strlen(str));

        //sprintf(str, "%5.1lf   %d  %2d:%02d:%02d\n\r",Temp, CoolPw, t.ti_hour, t.ti_min, t.ti_sec);
        //write(fc, str, strlen(str));

    }

    close(fc);



    

    if(!FLAG.AMS_H)
        MAddTimeout(LOG_TASK_TIME, Task_LOG, data);  // rilancia il task
}

int FTP_Back_UP(char *dirhome, char *dirdata)
{
    int er = 0, l;
    char COMANDO[_MAX_PATH];
    char buff[_MAX_PATH];
    
    char dailydir[6];
    FILE *fd;
    dailydir[0] = '\0';



    if(dirdata[0] != 0)
    {
        

        l = strlen(dirdata);
        sprintf(dailydir, "%s", dirdata + (l - 6));
        
        sprintf(buff, "%s\\Config\\%s", dirhome, "DataTransf.txt");
        fd = fopen(buff, "w");

        if(fd == NULL)
        {
            MMessageDialog("DAS information", "Problems in opening file", " Ok ", NULL);
            return 1;   
        }

        sprintf(buff, "%s\n", DFTP.ftpuser);
        fprintf(fd,buff);

        sprintf(buff, "%s\n", DFTP.ftppwd);
        fprintf(fd,buff);
    
        sprintf(buff, "%s\n", "bi");
        fprintf(fd,buff);
        
        buff[0] = '\0';
        sprintf(buff, "mkdir %s\n", dailydir);
        fprintf(fd,buff);

        buff[0] = '\0';
        sprintf(buff, "cd %s\n", dailydir);
        fprintf(fd,buff);
    
        if(DAS.DOption.savingmode)
        {
            sprintf(buff, "mput %s\\*.bif\n", dirdata);
            fprintf(fd,buff);
        }
        else
        {
            sprintf(buff, "mput %s\\*.dat\n", dirdata);
            fprintf(fd,buff);

        }

        buff[0] = '\0';
        sprintf(buff, "cd ..\n");
        fprintf(fd,buff);


        //Log file
        buff[0] = '\0';
        sprintf(buff, "%s\\Log\\%s%s.log\n", dirhome, BIL.SPH.location,dailydir);
        fprintf(fd,buff);
        


        sprintf(buff, "%s\n", "quit");
        fprintf(fd,buff);

        fclose(fd);


        COMANDO[0] = '\0';

        //Write Command file
        sprintf(buff, "%s\\Config\\%s", dirhome, "DataTransf.txt");
    
        sprintf(COMANDO, "ftp -i -s:%s %s",buff, DFTP.ftpserver);

//  er = WinExec(COMANDO, SW_HIDE);  // or SW_SHOW
        er = WinExec(COMANDO, SW_SHOW);  // or 

        FLAG.ftpstatus = 1;


    }
    return 0;

}

 void E_DeltaSZA(void)
{

    int a, b, c;

    ExeREM = 0;
    
    a = (int) (S_zenetr * 100); //Actual SZA
    b = (int) ((SZADelta.Dailyminsza+SZADelta.DeltaSZA) * 100); //Daily Min SZA + DeltaSZA
    c = (int) (SZADelta.MaxSZA * 100); //Max SZA
    PrgCnt = 0; 
    if(DAS.Flag.DeltaSZA == 1)
    {
        //if((int)(S_zenetr >= SZADelta.MinSZA) && (int)(S_zenetr <= SZADelta.MaxSZA))
        if((a >= b) && ( a <= c))
        {
            DAS.Flag.ExeDSZA = 0; //This STOP the measurements (via PRG file)
            Status("In E_DeltaSZA");
            delay(500);
        }
        else
            DAS.Flag.ExeDSZA = 1;
    }
    else
        DAS.Flag.ExeDSZA = 1;

    ExeREM = 1;
}

//Fix the Next SZA for measurements
// and set 
void D_FixSZA(void)
{

    
    double SZAInt;
    double SZATest;
    int k=0;
    double er;
    
    if((S_zenetr - SZADelta.LastMSZA) > 0) //   66.5-66 > 0 --> Afternoon period -->After local noon
    {

        SZAInt = floor(S_zenetr);
        k = 1;
        do
        {
            SZATest = SZAInt + ((double)k * SZADelta.DeltaSZA);
            SZADelta.NextSZA = SZATest;
            k++;
            er = SZATest - (S_zenetr + SZADelta.DeltaSZA);
        }while(er<0);
        SZADelta.NextSZA = SZADelta.NextSZA - SZADelta.DeltaSZA;
        DAS.Flag.ExeDSZA = -1;
        if(SZADelta.NextSZA <= SZADelta.Dailyminsza)
        {
            SZADelta.NextSZA = SZADelta.NextSZA + SZADelta.DeltaSZA;
            DAS.Flag.ExeDSZA = 1;
        }   
        if(SZADelta.NextSZA >= SZADelta.Dailymaxsza)
        {
            SZADelta.NextSZA = SZADelta.NextSZA - SZADelta.DeltaSZA;
            DAS.Flag.ExeDSZA = 1;
        }   


         
    }
    else if ((S_zenetr - SZADelta.LastMSZA) < 0)//66.2-66.5 < 0 --> Morning Period --> Before Local Noon 
    {
        SZAInt = ceil((double)S_zenetr); //62    62.45
        k = 1;
        do
        {
            SZATest = SZAInt - ((double)k * SZADelta.DeltaSZA); //62.1
            SZADelta.NextSZA = SZATest;
            k++;
            er = SZATest-(S_zenetr );
        
        }while(er > 0 );    
        DAS.Flag.ExeDSZA = -1;

        if(SZADelta.NextSZA <= SZADelta.Dailyminsza)
        {
            SZADelta.NextSZA = SZADelta.NextSZA + SZADelta.DeltaSZA;
            DAS.Flag.ExeDSZA = 1;
        }   
        if(SZADelta.NextSZA >= SZADelta.Dailymaxsza)
        {
            SZADelta.NextSZA = SZADelta.NextSZA - SZADelta.DeltaSZA;
            DAS.Flag.ExeDSZA = 1;
        }   

    }
}

void D_WaitSZA(void)
{
    char buff[256];
    int a, b, c;
    a= (int)(S_zenetr *100);
    b=(int)(SZADelta.NextSZA*100);
    
    c = abs(a-b);
    
    if(c == 0)
    {
        DAS.Flag.ExeDSZA = 1; //This RESUME the measurements (via PRG file)
    }
    else
    {
        if(FLAG.exec == 0)
        {
            Status("Execution Paused");
        }
        else
        {
            sprintf(buff, "Waiting for SZA = %.2f", SZADelta.NextSZA);
            Status(buff);
        }
    }
}


void D_AutoExecution(void)
{

    struct time RTime;
    struct date RDate;
    struct tm today;
    char buf[128];
    static int mrun = 0;
    float DecTimeStart;
    float DecTimeStop;
    float DecActTime;

//int PrgNumInM = 0; ///< Actual number of PRG File in current MASTER or MASTERSZA File
//int PrgNumExe = 0; ///< number of PRG file in execution
/*************************/
    char    str[80];
    int er; 
//  char timebuf[9];
//  char datebuf[9];
//  long    dp = 500;
    struct tm newtime;
//    long ltime;
    float t_acc = 0;
//  int sunrs;
//  int sunsm;

//   _strdate(datebuf);

//    time( &ltime );
//  _strtime(timebuf);
//  time( &ltime );

//  newtime = localtime( &ltime );

    /**************************************************************/
    // Check if daylight saving time is in effect 
    // tm_isdst > 0 if daylight saving time is in effect
    // tm_isdst = 0 if daylight saving time is not in effect
    // tm_isdst < 0 if status of daylight saving time is unknown. 
//  if (newtime ->tm_isdst)
//      newtime ->tm_hour = newtime ->tm_hour - 1;
    //NOTE - In Daylight saving period on midnight the hours became -1 so...         
//  if((newtime -> tm_hour)  == -1)
    {
        // Necessary for measurements performed at high latitude in summer seasons
//      newtime->tm_hour = 23;
//      newtime -> tm_yday = newtime -> tm_yday - 1;
    }

    /**************************************************************/
        GetDateTime(&RDate, &RTime, &newtime);

    /**************************************************************/
    // Calc solar Zenith Angle (SZA)    
//  er = SZACalc(DAS.DGeo.latitude, DAS.DGeo.longitude, (float) DAS.DGeo.timezone, newtime ->tm_year + 1900,
//      newtime -> tm_yday, newtime ->tm_hour, newtime ->tm_min, newtime ->tm_sec,
//      0, 1024, 0, 0);

    er = SZACalc(DAS.DGeo.latitude, DAS.DGeo.longitude, (float) DAS.DGeo.timezone,
        newtime.tm_year + 1900,
        newtime.tm_yday, newtime.tm_hour, newtime.tm_min, newtime.tm_sec,
        0, 1024, 0, 0);
    
    /**************************************************************/
    sprintf(str, "%.1lf", 90 - S_zenetr);   //S_elevref = elevation refracted
    MObjectSetText(DAS.Gui.ContrPanel.Albl_Elev, str);

    sprintf(str, "%.1lf", S_azim);
    MObjectSetText(DAS.Gui.ContrPanel.Albl_Azim, str);

  

/****************************/
    
    
    //gettime(&RTime);
    GetDateTime(&RDate, &RTime, &today);
    if(Master)
    {
        if(DAS.Flag.exemode == TEMPORIZED)
        {       

            if(mrun == 0)
            {

                // check for the next available prg 
                PrgNumExe = ChkMaster(0);
                // Time to decimal time
                DecActTime = RTime.ti_hour + ((float)RTime.ti_min / 60);
                DecTimeStart = ExMast[PrgNumExe].sora + ((float) ExMast[PrgNumExe].smin / 60) + ((float) ExMast[PrgNumExe].ssec / 3600);
                DecTimeStop = ExMast[PrgNumExe].eora + ((float) ExMast[PrgNumExe].emin / 60) + ((float) ExMast[PrgNumExe].esec / 3600);
        
                if((DecActTime >= DecTimeStart) && (DecActTime <= DecTimeStop)) 
                //if(ExMast[PrgNumExe].sora == (int) RTime.ti_hour &&
                //  ExMast[PrgNumExe].smin <= (int) RTime.ti_min)        
                {
                    on = LoadExec(ExMast[PrgNumExe].prg);
                    mrun = 1;
                    sprintf(buf,"%s",ExMast[PrgNumExe].prg );
                    MObjectSetText(DAS.Gui.ContrPanel.Albl_Script, buf);
                }
            }
            else //mrun = 1
            {
//              if(ExMast[PrgNumExe].eora == (int) RTime.ti_hour && 
//                  ExMast[PrgNumExe].emin <= (int) RTime.ti_min)
                // Time to decimal time
                DecActTime = RTime.ti_hour + ((float)RTime.ti_min / 60);
                DecTimeStart = ExMast[PrgNumExe].sora + ((float) ExMast[PrgNumExe].smin / 60) + ((float) ExMast[PrgNumExe].ssec / 3600);
                DecTimeStop = ExMast[PrgNumExe].eora + ((float) ExMast[PrgNumExe].emin / 60) + ((float) ExMast[PrgNumExe].esec / 3600);
        
                if((DecActTime < DecTimeStart) || (DecActTime > DecTimeStop)) 

                {
                    on = 0;
                    mrun = 0;
                    //PrgNumExe = ChkMaster(0);
                    sprintf(buf,"MASTER-Wait");
                    MObjectSetText(DAS.Gui.ContrPanel.Albl_Script, buf);
//                  if(PrgNumExe > PrgNumInM || ExMast[PrgNumExe].prg == NULL)
//                      PrgNumExe = 0;
                }
            }
        }
        else if (DAS.Flag.exemode == SZAMASTERM)
        {
        /*********************************************************************************************/
        //SZAMASTERM Mode 1
        /*********************************************************************************************/
        // This part of code take into account the different slope of the SZA function from
        // the local noon to the local midnigth and from the local midnight to the local noon.
        // It allows also the the execution of a MASTERSZA file where can appear different PRG 
        // files for the AM and PM Measurements
        // FORMAT MASTERSZA: Start SZA, End SZA , PRG file
        // (i.e.) 100.00   88.00 a.prg
        //         87.99   70.00 e.prg  
        //         69.99    0.00 b.prg
        //          0.00   87.99 b.prg
        //         88.00  100.00 a.prg
        //        100.01  180.00 c.prg
        //        180.00  100.01 c.prg
        // TO BE DONE: the conditions "<=12" and ">12" have to be replaced with something
        // indicating the real time of local noon and local midnight ( I have to calculate
        // the "effemeridis" at the begining of the program and each time the date change!!!) 
            if(mrun == 0)
            {
                if((int) RTime.ti_hour <= 12)
                {
                    //Actual SZA between Start SZA and End SZA
                    if ( ((int)(S_zenetr * 100) < (int)(ExMast[PrgNumExe].ssza * 100))
                        && ((int)(S_zenetr * 100) > (int)(ExMast[PrgNumExe].esza * 100)) )
                    {
                        on = LoadExec(ExMast[PrgNumExe].prg);
                        mrun = 1;
                        sprintf(buf,"%s",ExMast[PrgNumExe].prg );
                        MObjectSetText(DAS.Gui.ContrPanel.Albl_Script, buf);
                    }
                }
                if((int) RTime.ti_hour > 12)
                {
                    if ( ((int)(S_zenetr * 100) > (int)(ExMast[PrgNumExe].ssza * 100))
                        && ((int)(S_zenetr * 100) < (int)(ExMast[PrgNumExe].esza * 100)) )
                    {
                        on = LoadExec(ExMast[PrgNumExe].prg);
                        mrun = 1;
                        sprintf(buf,"%s",ExMast[PrgNumExe].prg );
                        MObjectSetText(DAS.Gui.ContrPanel.Albl_Script, buf);
                    }
                }           
            }
            else //mrun=1
            {
                if((int) RTime.ti_hour <= 12)
                {
                    if ( ((int)(S_zenetr * 100) > (int)(ExMast[PrgNumExe].ssza * 100))
                        || ((int)(S_zenetr * 100) < (int)(ExMast[PrgNumExe].esza * 100)) )
                    {
                        on = 0;
                        mrun = 0;
                        PrgNumExe = ChkMaster(1);
                        sprintf(buf,"MASTERSZA-Wait");
                        MObjectSetText(DAS.Gui.ContrPanel.Albl_Script, buf);
                        if(PrgNumExe > PrgNumInM || ExMast[PrgNumExe].prg == NULL)
                            PrgNumExe = 0;
                    }
                }
                if((int) RTime.ti_hour > 12)
                {                   
                    if ( ((int)(S_zenetr * 100) < (int)(ExMast[PrgNumExe].ssza * 100))
                        || ((int)(S_zenetr * 100) > (int)(ExMast[PrgNumExe].esza * 100)) )
                    {
                        on = 0;
                        mrun = 0;
                        PrgNumExe = ChkMaster(1);
                        sprintf(buf,"MASTERSZA-Wait");
                        MObjectSetText(DAS.Gui.ContrPanel.Albl_Script, buf);
                        if(PrgNumExe > PrgNumInM || ExMast[PrgNumExe].prg == NULL)
                            PrgNumExe = 0;
                    }
                }
            }
        }
        /*********************************************************************************************/
        /*********************************************************************************************/
        else if ((DAS.Flag.exemode == SZAMODE) | (DAS.Flag.exemode == TESTSZAMODE))
        {
            /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
            //SZAMASTERM Mode 2
            /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
                
            // This part of code instead doesn't consider the different slope of the SZA Function
            // The scheduled PRG files can be specified in any order, and they will be executed 
            // when the Actual SZA is between SZAMax and SZAMin (S_zenetr > ssza & S_zenetr < esza)
            // but when the PRG file changes (the  SZAs condition are not satisfied) I have to
            // look for the following available scheduled PRG. This means that I can't increase the
            // "PrgNumExe" of 1, but I have to scan all the entries in the MASTERSZA.
            // The main advantege of this mode is the possibility to write the half of record in the 
            // MASTERSZA file, but the measurements will be the same in the 24 hours.
            // More over I don't have to use something like
            // "88.00  0.00 namefileprg
            //   0.00 88.00 namefileprg"
            // to ensure the continuity of measurements during the day
            //
            // FORMAT MASTERSZA: SZA Min, SZA Max, PRG file
            // (i.e.) 20.00 90.00 a.prg
            //        90.01 100.00 b.prg    
            //        100.01 180 c.prg
            // When the SZA is between 20 and 90 degrees DAS will execute the a.prg table (Daylight measurements)
            // When the SZA is between 90.01 and 100.00 degrees DAS will execute the b.prg table (twilight measurements)
            // When the SZA is between 100.01 and 180.00 degrees DAS will execute the c.prg table (night measurements)

            if(mrun == 0)
            {
                // check for the next available prg 
                PrgNumExe = ChkMaster(2);

                if ( ((int)(S_zenetr * 100) > (int)(ExMast[PrgNumExe].minsza * 100))
                    && ((int)(S_zenetr * 100) < (int)(ExMast[PrgNumExe].maxsza * 100)) )                    
                {
                    on = LoadExec(ExMast[PrgNumExe].prg);
                    mrun = 1;
                    sprintf(buf,"%s",ExMast[PrgNumExe].prg );
                    MObjectSetText(DAS.Gui.ContrPanel.Albl_Script, buf);
                }
            }
            else //mrun = 1
            {
                if ( ((int)(S_zenetr * 100) < (int)(ExMast[PrgNumExe].minsza * 100))
                    || ((int)(S_zenetr * 100) > (int)(ExMast[PrgNumExe].maxsza * 100)) )
                {
                    on = 0;
                    mrun = 0;
                    sprintf(buf,"SZA MODE Wait");
                    MObjectSetText(DAS.Gui.ContrPanel.Albl_Script, buf);
                }

            }       
            /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
        }   

    }

/* 
Il flag ExeDSZA all'inizio deve essere 1

 si entra nel ciclo e sicuramente esegue un ciclo di prg (fino a BEGIN)
 poi  BEGIN mette il flag ExeDSZA a zero se il SZA e' tra il massimo e il minimo di
 SZA (E_DeltaSZA).
 al successivo passaggio nell'autoexecution se ExeDSZA = 0 esegue il FixNextSZA e 
 fissa il SZA della prossima misura (NextSZA) e mette il flag ExeDSZA = -1.
 Al successivo passaggio se il Flag ExeDSZA = -1 esegue il CheckSZA che mette a 1 il 
 Flag se il SZA e' uguale al NextSZA 
 


*/
//  DAS.Flag.ExeDSZA = 0;   
    if(DAS.Flag.DeltaSZA == 1)
    {
        if (DAS.Flag.ExeDSZA == 1) //PRG Execution 
        {
            //Store last SZA
            SZADelta.LastMSZA = S_zenetr; 
        }
        else if (DAS.Flag.ExeDSZA == 0)//Fix next SZA
        {
            D_FixSZA();
        }
        else if (DAS.Flag.ExeDSZA == -1) //Waiting next SZA
        {
            D_WaitSZA();
            
        }
        else
        {
            MMessageDialog("DAS information", "Unknow value for DAS.Flag.ExeDSZA" , "OK", NULL);
        }
    }
    else
        //DAS.Flag.ExeDSZA = 1;

        // A background task or an event can launch a procedure initializing the 
        // variable MainCommand
        
        // Temperature of the CCD 
        // If the following instruction is commented the measdurements are carried out only
        // when the CCD reach the working temperature, otherwise the measurements are 
        // performed continuosly
        OMUTHR.ReachTemp = 1; 

        //if(on && (OMUTHR.ReachTemp == 1) && FLAG.sza && FLAG.exec && (DAS.Flag.ExeDSZA == 1)) 
        if(on && FLAG.sza && FLAG.exec && (DAS.Flag.ExeDSZA == 1))
        {
        /*  if((SaveCnt % CHECKDGR) == 0)
                MainCommand = QJSCAN;
            else if ((SaveCnt % SCHEDHGRAT) == 0)
            {
                MainCommand = H_GRAT_CAL;
                SaveCnt++;
            }
            else
        */

                MainCommand = Fetch();
            
            
            if(MainCommand)
            {
                // List of the activable procedures
                switch(MainCommand)
                {
                
                case AUTORNG:  on = MainCommand = 0; E_AutoRange();     on = 1; break;      //  1
                case AVGCCD:   on = MainCommand = 0; E_Average();       on = 1; break;      //  2
                case BEGIN:         MainCommand = 0; E_DeltaSZA();              break;      //  3
                case CALIBRA:  on = MainCommand = 0; E_Calibra();       on = 1; break;      //  4
                case DARKC:    on = MainCommand = 0; E_Dark();          on = 1; break;      //  5
                case EXPO:     on = MainCommand = 0; E_Expo();          on = 1; break;      //  6
                case FILTER:   on = MainCommand = 0; E_Filter();        on = 1; break;      //  7
                case GETCCD:   on = MainCommand = 0; E_GetCCD();        on = 1; break;      //  8               
                case H_FILTER: on = MainCommand = 0; E_Home_SM3();      on = 1; break;      //  9
                case H_GRAT:   on = MainCommand = 0; E_Home_SM2();      on = 1; break;      //  10
                case H_MIRROR: on = MainCommand = 0; E_Home_SM1();      on = 1; break;      //  11
                case HG_OFF:   on = MainCommand = 0; E_Hg_Off();        on = 1; break;      //  12
                case HG_ON:    on = MainCommand = 0; E_Hg_On();         on = 1; break;      //  13
                case LABEL:    on = MainCommand = 0; E_Label();         on = 1; break;      //  14
                case MEASURE:  on = MainCommand = 0; E_Measure();       on = 1; break;      //  15
                case MEASHOR:  on = MainCommand = 0; E_Meashor();       on = 1; break;      //  16
                case MIRROR:   on = MainCommand = 0; E_Mirror();        on = 1; break;      //  17
                case PLOT:     on = MainCommand = 0; E_Plot();          on = 1; break;      //  18
                case QJ_OFF:   on = MainCommand = 0; E_Qj_Off();        on = 1; break;      //  19              
                case QJ_ON:    on = MainCommand = 0; E_Qj_On();         on = 1; break;      //  20
                case RADIO:    on = MainCommand = 0; E_Radio();         on = 1; break;      //  21
                case REM:      on = MainCommand = 0; E_REM();           on = 1; break;      //  22
                case SAVE:     on = MainCommand = 0; E_Save();          on = 1; break;      //  23
                case WAIT:     on = MainCommand = 0; E_WAIT();          on = 1; break;      //  24
                case WAVELEN:  on = MainCommand = 0; E_Lambda();        on = 1; break;      //  25
                case XEND:          MainCommand = 0; Status("End");     on = 0; break;      //  26
                case ELAMPON:  on = MainCommand = 0; E_ExtLampON();     on = 1; break;      //  27  
                case ELAMPOFF: on = MainCommand = 0; E_ExtLampOFF();    on = 1; break;      //  28  
                case ESHUTOP:  on = MainCommand = 0; E_ExtShutOpen();   on = 1; break;      //  29  
                case ESHUTCL:  on = MainCommand = 0; E_ExtShutClose();  on = 1; break;      //  30  
                case H_ZEN:    on = MainCommand = 0; E_Home_SM5();      on = 1; break;      //  31
                case H_AZI:    on = MainCommand = 0; E_Home_SM6();      on = 1; break;      //  32
                case ZENITH:   on = MainCommand = 0; E_Zenith();        on = 1; break;      //  33
                case AZIMUTH:  on = MainCommand = 0; E_Azimuth();       on = 1; break;      //  34
                case AAMEASURE:on = MainCommand = 0; E_AAMeasure();     on = 1; break;      //  35
                case AVGCCDHOR:on = MainCommand = 0; E_AvgCCDHor();     on = 1; break;      //  36
                case CHKEXLAMP:on = MainCommand = 0; E_ChkExLamp();     on = 1; break;      //  37
                case AAPOSIT  :on = MainCommand = 0; E_AAPos();         on = 1; break;      //  38
                case IREFSUN  :on = MainCommand = 0; E_IRefSun();       on = 1; break;      //  39
                case MEASHOR2 :on = MainCommand = 0; E_Meashor2();      on = 1; break;      //  40  
                case SETCCDTEMP :on = MainCommand = 0; E_SetCCDTemp();  on = 1; break;      //  41  
                case SETCCDVBIN :on = MainCommand = 0; E_SetCCDVBin();  on = 1; break;      //  42  
                case SETCCDPOW  :on = MainCommand = 0; E_SetCCDPow();   on = 1; break;      //  43  
                case NDFILTER   :on = MainCommand = 0; E_NDFilter();    on = 1; break;      //  44  
                case H_NDFW     :on = MainCommand = 0; E_Home_SM4();    on = 1; break;      //  45  
                case DFMEASURE  :on = MainCommand = 0; E_DFMeasure();   on = 1; break;      //  46
                case SETCCDOFFS :on = MainCommand = 0; E_SetCCDOffSet();on = 1; break;      //  47  
                case QJSCAN     :on = MainCommand = 0; E_QjScan();      on = 1; break;      //  48  
                case H_GRAT_CAL :on = MainCommand = 0; E_HGratCal();    on = 1; break;      //  49                                                                                       
                case HGSCAN     :on = MainCommand = 0; E_HgScan();  on = 1; break;      //  49                                                                                       
                case ALMUCANTAR :on = MainCommand = 0; E_Almucantar();  on = 1; break;      //  51
                case DIRECTSUN  :on = MainCommand = 0; E_DirectSun();   on = 1; break;      //  52
    /*
                case 100: MainCommand = 0; on = 0; //   26
                          Status("PROGRAM HALTED"); break;          
                case 101: MainCommand = 0; on = 1; break; //    27
    */              
                
                }

            }

        }
}

/*
    \callergraph
    
    \callgraph

*/
void Task_AutoEx(TIMEOUT_ID id, void *data)

{
    // Here it can be added a call to a function for the execution of the operations
    // in the while(1) loop in the RunFULL function.
    // This in order to remove the MLoopWhileEvents(0) in RunFULL for a low use of the CPU
    // i.e. -->
    D_AutoExecution();


    id = MAddTimeout(AUTOEX_TASK_TIME, Task_AutoEx, data);  // rilancia il task

}




void Task_HomeGrat(TIMEOUT_ID id, void *data)
{
    int cwer = 0, ccwer = 0; //Clock Wise, Counter Clock Wise er values
    char buf[80];
    int er = 0;
    long ns, np;
    int HomeGratActive = 0;
    unsigned long   st, et, x;
    long tout;

    /**************************************************************/
    // check for reached end-run of the stepper motor for the grating
    if ((DAS.Flag.exemode == TEMPORIZED)    | 
        (DAS.Flag.exemode == PRGFILE)       |
        (DAS.Flag.exemode == TESTAMS)       |
        (DAS.Flag.exemode == MANUAL)        | 
        (DAS.Flag.exemode == SZAMASTERM)    |
        (DAS.Flag.exemode == SZAMODE))
    {
        if(FLAG.AMSPres == 0)
        {   
                
            cwer = AMS_chkbitsts(AMS1, 6); //AMS1-IOP(6) = 1: end-run Vis. 
            ccwer = AMS_chkbitsts(AMS1, 7);//AMS1-IOP(7) = 1: end-run UV
            
            if (cwer || ccwer) 
            {
                //Flag to be passed to HomeGratingFast in order to refresh the task time
                HomeGratActive = 1;
                //Read steps    
                np = AMS_ReadStep(0, 1);        
                //Grating Motor OFF     
                er = AMS_MotorOn_Off(0, 1, 0);
                //wait for remaining steps finalization

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

    tout = DAS.StepM.postime[AMS1][DAS.StepM.SM_B]+1000;
    st = GetTickCount();
    do
    {
        et = GetTickCount();
        x = labs(et - st);
        //MLoopWhileEvents(0);
            //if((x % 10 == 0) && (x > 0))
            if(x > 0)
            {
                    
                sprintf(buf, "%.1lf sec. left", (double)fabs(((double)(labs(et - st) - tout))/1000.0 ));
                Status (buf);
            
            }
    }while(labs(et - st) < tout);



                
                
                
                //delay(30000);             
                
                er = AMS_AzzeraCoord(0, 1); 
                ns = AMS_ReadStep(0, 1);
                sprintf(buf, "%ld", ns);
                
                //Mirror and Grating Motor ON
                er = AMS_MotorOn_Off(0, 1, 1);

                DXL.bufrx[0] = '0';
                DXL.bufrx[1] = '0';
                MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[1], "4358");
                HomeGratingFast(HomeGratActive);
                
            }
            else
            {
                //Home Grating Task
                MRefreshTimeout(&IDS.GRATHOME, GRAT_TASK_TIME, Task_HomeGrat, NULL);
    
            }
        }
    }
}

void WinRes(void)
{

    int PosRefWl, er;
    struct time RTime;
    struct date RDate;
    struct tm today;
    char buff[10]; 
    char str[10]; 
    char buf[256]; 


    

    PosRefWl = LookforWl_X(4358);

    SD_Grating(PosRefWl); //Positioning at 4358 A


    
    GetDateTime(&RDate, &RTime, &today);
    strftime( buff, 7,"%y%m%d", &today );
    strftime( str, 9,"%H:%M:%S", &today );
    sprintf(buf, "*++++++++++++++++++++++++++++++++++++++++++++*");
    D_WriteInitLog(buf);
    sprintf(buf, "Windows reboot on %s at %s", buff, str );
    D_WriteInitLog(buf);
    sprintf(buf, "**********************************************");
    D_WriteInitLog(buf);



    DB_WriteMode(1);
    ShutterOpening(1);
    DC_Close(0); //DA RIMETTERE!!!!!!!!!!!!!!!!!1
    if (HGFlg)
        HgLamp(0);//HG Off
    if (QJFlg)
        QjLamp(0);//QJ Off
    //Switch off 12 V, Hires, 24V 
    if(DAS.Paramini.EqType == GASCODNG1)
        er = NOVA_Out(DAS.Nova.type, 15); //1111 bin

    
    WDT_func(0); //Stop WDT
    SioDone(DXL.com);//Close Com connection
    DAS.Flag.WindowsReboot = 2;
    

    MGUITerm();
    //restart the instrument
    system("shutdown -r -t 10 -f");
    


}


void SetWindowsReset()
{

//  char buff[80];
//  float CCD_Pwr;
    int ActualHour;
    int ActualDOY;
    struct time RTime;
    struct date RDate;
    struct tm today;

    GetDateTime(&RDate, &RTime, &today);


    // Time to decimal time
    ActualHour = (int)(((double)today.tm_hour + (1.0/60.0*(double)today.tm_min)) * 10); // + ((float) today.tm_min  / 60) + ((float) today.tm_sec / 3600);
    ActualDOY = (int)(((double)today.tm_yday + (1/24*(double)today.tm_hour))) * 10;;

    //For shutdown and restart for hourly periods (for debug & testing)
if(DAS.DOption.resetType == RHOUR)
{
    //check the start time and actual time
    if(labs(ActualHour - DAS_StartHour) >= (DAS.DOption.resetFreq * 10))
    {
        //stop the measurements and wait until the current one is finished
        DB_Pause();

        //shutdown CCD (wait until when CCD peltier power is 0)
        DC_SetTemp(25.0, CELSIUS, 0);

        
        
        DAS.Flag.WindowsReboot = 1;

    }

}
    //For shutdown and restart for hourly periods
if(DAS.DOption.resetType == RDAY)
{
    //check the start time and actual time
    if(labs(ActualDOY - DAS_StartDOY) >= (DAS.DOption.resetFreq * 10))
    {
        //stop the measurements and wait until the current one is finished
        DB_Pause();

        //shutdown CCD (wait until when CCD peltier power is 0)
        DC_SetTemp(25.0, CELSIUS, 0);
        
        DAS.Flag.WindowsReboot = 1;

    }



}

}

void Task_Timer(TIMEOUT_ID id, void *data)
{

    char    str[80];
    int er; 
    char buff[32];
//  char datebuf[9];
//  long    dp = 500;
    struct time RTime;
    struct date RDate;

    struct tm newtime;
//    long ltime;
    float t_acc = 0;
    int sunrh,sunrm,sunrs;
    int sunsh,sunsm,sunss;
    float CCD_Pwr;


    if (DAS.DOption.resetEnabled)
    {
        if(DAS.Flag.WindowsReboot == 0)
            SetWindowsReset();

        MObjectGetText(DAS.Gui.ContrPanel.Albl_CS[1], buff);
        CCD_Pwr = (float)atof(buff);

        if (DAS.Flag.WindowsReboot ==1 && CCD_Pwr<=10.0)
            WinRes();
    }
//   _strdate(datebuf);

//  _strtime(timebuf);
//  time( &ltime );

//  newtime = localtime( &ltime );

    /**************************************************************/
    // Check if daylight saving time is in effect 
    // tm_isdst > 0 if daylight saving time is in effect
    // tm_isdst = 0 if daylight saving time is not in effect
    // tm_isdst < 0 if status of daylight saving time is unknown. 
//  if (newtime ->tm_isdst)
//      newtime ->tm_hour = newtime ->tm_hour - 1;
    //NOTE - In Daylight saving period on midnight the hours became -1 so...         
//  if((newtime -> tm_hour)  == -1)
//  {
        // Necessary for measurements performed at high latitude in summer seasons
//      newtime->tm_hour = 23;
//      newtime -> tm_yday = newtime -> tm_yday - 1;
//  }

    /**************************************************************/
        GetDateTime(&RDate, &RTime, &newtime);

    /**************************************************************/
    // Calc solar Zenith Angle (SZA)    
    er = SZACalc(DAS.DGeo.latitude, DAS.DGeo.longitude, (float) DAS.DGeo.timezone, 
        newtime.tm_year + 1900,
        newtime.tm_yday, newtime.tm_hour, newtime.tm_min, newtime.tm_sec,
        0, 1024, 0, 0);
    /**************************************************************/
    sprintf(str, "%.1lf", 90 - S_zenetr);   //S_elevref = elevation refracted
    MObjectSetText(DAS.Gui.ContrPanel.Albl_Elev, str);

    sprintf(str, "%.1lf", S_azim);
    MObjectSetText(DAS.Gui.ContrPanel.Albl_Azim, str);

    // Sunrise and sunset times
    /*++++++++++++++++++++++++++++++++++++++*/
    sunrh = (int)floor(S_sunrise/60);  
    sunrm = (int)floor(  ((S_sunrise/60) - floor(S_sunrise/60))*60  ); 
    sunrs = (int)floor( ( (((S_sunrise/60) - floor(S_sunrise/60))*60) - floor((((S_sunrise/60) - floor(S_sunrise/60))*60)) )*60  );

    sprintf(str, "%02d:%02d:%02d", sunrh, sunrm, sunrs);
    //sprintf(str, "%.02lf", S_sunrise);  
    MObjectSetText(DAS.Gui.ContrPanel.Albl_sunr, str);

    sunsh = (int)floor(S_sunset/60);  
    sunsm = (int)floor(  ((S_sunset/60) - floor(S_sunset/60))*60  ); 
    sunss = (int)floor( ( (((S_sunset/60) - floor(S_sunset/60))*60) - floor((((S_sunset/60) - floor(S_sunset/60))*60)) )*60  );

    //sprintf(str, "%.02lf", S_sunset);
    sprintf(str, "%02d:%02d:%02d", sunsh, sunsm, sunss);
    MObjectSetText(DAS.Gui.ContrPanel.Albl_suns, str);
    /*++++++++++++++++++++++++++++++++++++++*/
//        S_sunrise   = 720.0 - 4.0 * S_ssha - S_tstfix;
//        S_sunset    = 720.0 + 4.0 * S_ssha - S_tstfix;

    
    /**************************************************************/
    // write on the STATUS label
    sprintf(str, "Loc.: %s, Date: %d/%02d/%02d, Local Solar Time: %02d:%02d:%02d, SZA:%.02lf",
        DAS.DGeo.s_name, newtime.tm_year + 1900, newtime.tm_mon + 1,newtime.tm_mday, 
        newtime.tm_hour, newtime.tm_min, newtime.tm_sec, S_zenetr);

    MObjectSetText(DAS.Gui.ContrPanel.lbl_Time, str);
    /**************************************************************/

    /**************************************************************/
    // Set FLAG.sza
    // FLAG.sza = 1 --> perform measurements
    // FLAG.sza = 0 --> waiting mode
    if(S_zenetr < SZAMax)
    {
        FLAG.sza =1;
        FLAG.ftpstatus = 0; // back-up that will be performed when FLAG.sza = 0
    }
    else
    {
        FLAG.sza =0;
        if(FLAG.ftpstatus == 1) //Back-up performed
            FLAG.ftpstatus = 2; //Wait until the next sunset

    }
    /**************************************************************/

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

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

    //CHECK IF ALL THE CONDITION ARE SATISFIED
    //IN ORDER TO PERFORM BACKUP OF THE DATA VIA FTP
    /**************************************************************/
    if((FLAG.sza == 0) & (DAS.DOption.ftpbackup == 1) & (FLAG.ftpstatus == 0))
        er = FTP_Back_UP(BIL.DFILEM.HOMEDIRECTORY, BIL.DFILEM.DAILYDATADIRECTORY);  
    
    // MIGE Sun tracker
    if (DAS.DOption.aaopmode == 0)
        MIGESunTrack();

    // MIGE ANTI Sun tracker
    if (DAS.DOption.aaopmode == 1)
        MIGEAntiSunTrack();

    /**************************************************************/
    if(!FLAG.AMS_H)
        //MRefreshTimeout(&IDS.TIMER, TIMER_TASK_TIME, Task_Timer, NULL);
        MAddTimeout(TIMER_TASK_TIME, Task_Timer, data);  // rilancia il task


}


//Scrive sul file giornaliero ("XXXXXXXX.log"), lo stato delle periferiche
//inizializzate

void WriteStatusD(int w)
{
/*
    int     fc;
    char    tit1[80];

    fc = open(flog, O_WRONLY | O_APPEND | O_TEXT, S_IWRITE);
    if(fc < 0) return;

    sprintf(tit1, CCD_Err[--w], w);
    write(fc, &tit1, strlen(tit1));
    close(fc);
*/
}