Exec.c

Go to the documentation of this file.

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

DXL_par DXL; //Com structure
flag FLAG; //flags structure
omuthr OMUTHR;
das DAS;
paramini PARAM; //Param.ini 


int Total = 0;  // Contatore Files



double FlagTExp = 1.0; //Flag per il tempo d'integrazione
//unsigned Low = 0;
//unsigned High = 0;
char OldDate[8];  //Data d'inizio misura
char NewDate[8];  //Data di fine misura


extern int ExeREM;

void E_REM(void)
{
    // Flush stringa
    if(ExeREM)
        while(Program[PrgCnt++] != 10);
}

void E_ExtLampON(void)
{
    ExeREM = 0;

    if(FLAG.extlamp == 0)
        ExtLamp(0);

    ExeREM = 1;
    E_REM();
        
}

void E_ExtLampOFF(void)
{
    ExeREM = 0;

    if(FLAG.extlamp)
        ExtLamp(0);

    ExeREM = 1;
    E_REM();
    
}


void E_ExtShutOpen(void)
{
    ExeREM = 0;

    if(FLAG.extshutter == 1)
        ExtShutt(0);

    ExeREM = 1;
    E_REM();
}


void E_ExtShutClose(void)
{
    ExeREM = 0;

    if(FLAG.extshutter == 0)
        ExtShutt(0);

    ExeREM = 1;
    E_REM();
}

/*


/*******************************************************************************************/
//Le funzioni di Home dei motori durante una tabella di misura non funzionano bene:
//il motore si sta ancora muovendo che il ciclo ricomincia,
//probabilmente perche' ExeREM diventa 1 subito e non aspetta che finisca l'home
// SOLUZIONE: Aggiungere un parametro nella chiamata alla funzione HomeMirrorFast che faccia
//capire che si e' dentro una tabella e che commuti ExeREM a 1 solo a posizionamento terminato. 
int E_Home_SM1(void)
{
    ExeREM = 0;

    Status("Home for Mirror..");
//  AMS_MotorOn_Off(AMS1,1,0);
    //MClearTimeout(&IDS.GRATHOME);
    MRemoveTimeout(IDS.GRATHOME);
    //MClearTimeout(&IDS.REFRTEMP);
    HomeMirror();
//  AMS_MotorOn_Off(AMS1,0,0);
    //Home Grating Task
    
    MRefreshTimeout(&IDS.GRATHOME, GRAT_TASK_TIME, Task_HomeGrat, NULL);
        // PeltierTemp Task
        if((FLAG.ADPC104 == 0) | (FLAG.ADTempTest == 1))
        {
            //MRefreshTimeout(&IDS.LISTEMP, LISTEMP_TASK_TIME, Task_LIS_Temp, NULL);
        }

    ExeREM = 1;
    E_REM();

  return 0;


}

int E_Home_SM2(void)
{
    ExeREM = 0;
    Status("Home for Grating...");
//  AMS_MotorOn_Off(AMS1,0,1);
    HomeGratingFast(0);
//  AMS_MotorOn_Off(AMS1,0,0);
    
    ExeREM = 1;
    E_REM();

    return 0;
}


int E_Home_SM3(void)
{
    ExeREM = 0;
    Status("Home for Filter Wheel...");
    AMS_MotorOn_Off(AMS2,1,1);
    HomeFiltersFast();
//  AMS_MotorOn_Off(AMS2,0,0);
    
    ExeREM = 1;
    E_REM();

    return 0;
}

int E_Home_SM5(void)
{
    ExeREM = 0;
    Status("Home for Zenith...");
//  AMS_MotorOn_Off(AMS3,1,0);
    HomeZenithFast();
//  AMS_MotorOn_Off(AMS3,0,0);
    
    ExeREM = 1;
    E_REM();

    return 0;
}

int E_Home_SM6(void)
{
    int er =0;
    
    ExeREM = 0;
    Status("Home for Azimuth...");

            DB_KB_ButtonActive(0);
            AMS_Default(AMS3);
            er = DB_InitAMS(AMS3, 6, DAS.StepM.power[AMS3][DAS.StepM.SM_A], 
                DAS.StepM.step[AMS3][DAS.StepM.SM_A], DAS.StepM.slope[AMS3][DAS.StepM.SM_A], 
                DAS.StepM.speed[AMS3][DAS.StepM.SM_A], DAS.StepM.power[AMS3][DAS.StepM.SM_B], 
                DAS.StepM.step[AMS3][DAS.StepM.SM_B], DAS.StepM.slope[AMS3][DAS.StepM.SM_B], 
                DAS.StepM.speed[AMS3][DAS.StepM.SM_B]);
            //Attiva i pulsanti sulla keyboard
            DB_KB_ButtonActive(1);

    
//  HomeAzimFast();
    
    ExeREM = 1;
    E_REM();

    return 0;
}


int E_Home_SM4(void)
{
    int er =0;
    
    ExeREM = 0;
    Status("Home for NDFilter Wheel...");

            DB_KB_ButtonActive(0);
            AMS_Default(AMS2);
            er = DB_InitAMS(AMS2, 7, DAS.StepM.power[AMS2][DAS.StepM.SM_A], 
                DAS.StepM.step[AMS2][DAS.StepM.SM_A], DAS.StepM.slope[AMS2][DAS.StepM.SM_A], 
                DAS.StepM.speed[AMS2][DAS.StepM.SM_A], DAS.StepM.power[AMS2][DAS.StepM.SM_B], 
                DAS.StepM.step[AMS2][DAS.StepM.SM_B], DAS.StepM.slope[AMS2][DAS.StepM.SM_B], 
                DAS.StepM.speed[AMS2][DAS.StepM.SM_B]);
            //Attiva i pulsanti sulla keyboard
            DB_KB_ButtonActive(1);

    
//  HomeAzimFast();
    
    ExeREM = 1;
    E_REM();

    return 0;
}


/*******************************************************************************************/
void E_Plot(void)
{
    ExeREM = 0;
    ViewPlot(1);
    ExeREM = 1;
    E_REM();
//  delay(3000);
}

void E_Hg_On(void)
{
    ExeREM = 0;
    HgLamp(1);
    ExeREM = 1;
    E_REM();

}

void E_Hg_Off(void)
{
    ExeREM = 0;
    HgLamp(0);
    ExeREM = 1;
    E_REM();
}

void E_Qj_On(void)
{
    ExeREM = 0;
    QjLamp(1);
    ExeREM = 1;
    E_REM();

}
void E_Qj_Off(void)
{
    ExeREM = 0;
    QjLamp(0);
    ExeREM = 1;
    E_REM();

}
void E_Dark(void)
{

    struct tm today;
    ExeREM = 0;

    DC_GetCCD(0, TExp, DIL.Img.Mat[Server].Imat, 0);
    if (DAS.DOption.pixcorr)
        DB_DefectPixCorr();

    DI_ScanMaxMin(Server, &DIL.Img.Mat[Server].High, &DIL.Img.Mat[Server].Low);         
    DIL.Img.Mat[Server].ILow = DIL.Img.Mat[Server].Low ;
    DIL.Img.Mat[Server].IHigh = DIL.Img.Mat[Server].High ;

    DI_Regen(Server);

        GetDateTime(&DIL.Img.Mat[Server].DATE, &DIL.Img.Mat[Server].TIME, &today);
    //  gettime( &DIL.Img.Mat[Server].TIME );
    //  getdate( &DIL.Img.Mat[Server].DATE );

    ExeREM = 1;
    E_REM();

}


void quick(unsigned *elemento, int conta)
{
//  int qs(unsigned *elemento, int sinistra, int destra);

//  qs(elemento, 0, conta - 1);

}

//void BSort(unsigned *v, long n)
//{
/*
    long    gap, i, j, temp;
    n--;
    for(gap = n / 2; gap > 0; gap /= 2)
        for(i = gap; i <= n; i++)
            for(j = i - gap; j >= 0 && v[j] > v[j + gap]; j -= gap)
            {
                temp = v[j];
                v[j] = v[j + gap];
                v[j + gap] = temp;
            }
*/
//}
//int FlagCalibra = 0;

void E_Calibra(void)
{
    ExeREM = 0;
    D_Calibra();
    ExeREM = 1;
    E_REM();

}

int FlagBarra = 0;


void E_AutoRange(void)
{

    ExeREM = 0;
    Status("Autoranging...");
    AutoRange(0);
    ExeREM = 1;
    E_REM();

}



void E_Save(void)
{

    ExeREM = 0;
    D_Saving();
    ExeREM = 1;
    E_REM();

}

void E_Expo(void)
{
    double  l;
//  PrgCnt += 4;
    sscanf(&Program[PrgCnt], "%lf", &l);
    Status("Exposure Time");
//  TExp = l;
    E_REM();
}

void E_SetCCDTemp(void)
{

    double  l;
    int er=0;
    char    str[80];
    sscanf(&Program[PrgCnt], "%lf", &l);
    Status("CCD Temperature");
    DAS.Paramini.ITemp = l;
    OMUTHR.ReachTemp = 0;
    sprintf(str, "%.1lf", DAS.Paramini.ITemp);
    MObjectSetText(DAS.Gui.ContrPanel.lbl_Par[0], str);

    er = DB_InitCamera(1);
    E_REM();


}

void E_SetCCDOffSet(void)
{

    int os;
    int er=0;
//  char    str[80];
    sscanf(&Program[PrgCnt], "%d", &os);
    Status("CCD OffSet");
    DAS.Marconi.Offset = os;
    DC_SetUsrGain(0, 0 , DAS.Marconi.Offset , 0);

    E_REM();


}


void E_SetCCDPow(void)
{

    int l;
    int er=0;
    char    str[80];
    sscanf(&Program[PrgCnt], "%d", &l);
    Status("CCD Temperature");
    DAS.Paramini.CoolPw = l;
    OMUTHR.ReachTemp = 0;
    sprintf(str,"%.1lf%%",(double)DAS.Paramini.CoolPw / 10);
    MObjectSetText(DAS.Gui.ContrPanel.lbl_Par[1], str);
    E_REM();


}


void E_NDFilter(void)
{

    int l;
    int er=0;
//  char    str[80];
    sscanf(&Program[PrgCnt], "%d", &l);
    ExeREM = 0;
    SD_NDFilterW(l);
    ExeREM = 1;
    E_REM();



}


void E_SetCCDVBin(void)
{

    int d, er = 0;
    sscanf(&Program[PrgCnt], "%d", &d);
    Status("CCD Vertical Binning");
    DAS.Paramini.VBin = d;
    er = DB_InitCamera(1);
    E_REM();



}

//mod = 0 single measurement
//mod = 1 averaged measurement with autoranging
//mod = 2 averaged measurement without autoranging....
void PerformMeas(int mod, int ar, double te, int mt, int sv, int pl)
{


repeat:

    if(mod == 1)
    {
        
        //Autoranging (ar=1) or fixed texp (ar=0)
        if(ar == 0)
            TExp = te;   
        //Light measurements (mt=1) or dark measurement (mt=0)
        if(mt)
            D_Average(1); // 1 = perform autoranging, 0 = DO NOT PERFORM autoranging

        else
            DB_GetCCD(0);
    }
    if(mod == 2)
    {
        
        //Autoranging (ar=1) or fixed texp (ar=0)
        if(ar == 0)
            TExp = te;   
        //Light measurements (mt=1) or dark measurement (mt=0)
        if(mt)
            D_Average(0);
        else
            DB_GetCCD(0);
    }
    if(mod == 0) //single measurements
    {
        //Autoranging (ar=1) or fixed texp (ar=0)
        if(ar)
            AutoRange(0);
        else
        {
            //if te not zero, use te as TExp otherwise 
            //TExp remains the same previously calculated
            if (te != 0) 
                TExp = te;
        }   
                
        //Light measurements (mt=1) or dark measurement (mt=0)
        if(mt)
            DB_GetCCD(1);
        
                
        else
            DB_GetCCD(0);
    }

    //Check the image maximum value
//  if (DIL.Img.Mat[Server].IHigh >= 65000) //CCD Saturated
//      goto repeat;

    //save measurement
    if(sv)
    {
        D_Saving();
    }   
    //plot spectrum
    if(pl)
        if(DAS.Flag.plotW)
            D_Plot();


    Status("Ready");

}




void E_AvgCCDHor(void)
{

    int er=0;
    int l, f, m, a, d, s, g, wl;
    double t;
    extern struct date dok;

    int StsTot = 0;
    int StsMir = 0, StsGrat = 0, StsFW = 0;

    // The progression of "PrgCnt" is now in the Fetch function
    // PrgCnt += 7;

    sscanf(&Program[PrgCnt], "%d%d%d%d%lf%d%d%d", &m, &wl, &f, &a, &t, &d, &s, &g);

    l= LookforWl_X(wl);

    
    if (DAS.DOption.smposmode)
        SD_PosOMUDev(m, l, f);
        //SD_Position(m, l, f, 0, 0);
    else
    {
        //mirror positioning
        SD_Mirror(m);
        //grating positioning   
        SD_Grating(l);
        //filter wheel positioning
        SD_FilterW(f);
        //Zenith positioning
//      SD_Zenith(z);
        //Azimuth positioning
//      SD_Azimuth(az);
    }
    ExeREM = 0;
    /******************************************************************/

    //*********************** Start First Measurement ******************

    PerformMeas(1, a, t, d, s, g); //Measuremet with TExp computed by Autoranging with external lamp

    //*********************** End First Measurement ******************

    //*********************** Start Second Measurement ******************
    //Close External Shutter
    if (FLAG.extshutter == 0)
    {
        ExtShutt(0);
        FLAG.extshutter = 1;
        
    }
    
    PerformMeas(2, a, t, d, s, g); //Measuremet with previous TExp (computed by Autoranging with external lamp)
    //*********************** End Second Measurement ******************

    //*********************** Start Third Measurement ******************
    PerformMeas(0, a, t, d, s, g); //Measurement with TExp computed by Autoranging without external lamp
    
    //Open External Shutter
    if (FLAG.extshutter)
    {
        ExtShutt(0);
        FLAG.extshutter = 0;
    }

    //*********************** End Third Measurement ******************

    ExeREM = 1;
    E_REM();

}


void E_Average(void)
{

    int er=0;
    int l, f, m, a, d, s, g, wl;
    double t;

    
    extern struct date dok;
    int StsTot = 0;
    int StsMir = 0, StsGrat = 0, StsFW = 0;

    sscanf(&Program[PrgCnt], "%d%d%d%d%lf%d%d%d", &m, &wl, &f, &a, &t, &d, &s, &g);

    l= LookforWl_X(wl);



    //Posiziona specchio
    SD_Mirror(m);
    //Posiziona reticolo    
    SD_Grating(l);
    //Posiziona Ruota dei filtri
    SD_FilterW(f);

    ExeREM = 0;

    PerformMeas(1, a, t, d, s, g); //Measuremet with TExp computed by Autoranging 

    
    ExeREM = 1;
    E_REM();

}




void Radio(int g)
{
//  double tup, tdw;
//  Mirror(1);
    E_AutoRange();
//  tdw = TExp;

//  Mirror(3);
    E_AutoRange();
//  tup = TExp;

//  if(tdw < tup) TExp = tdw;
//  else TExp = tup;

//  Mirror(1);
    E_GetCCD();
    E_Save();
    if(g)
     {
//      E_Grafo();
     }
//  Mirror(3);
    E_GetCCD();
    E_Save();
    if(g)
//   {  E_Grafo(); }

//  Mirror(1);
    E_GetCCD();
    E_Save();
//  if(g)
//   {  E_Grafo(); }

}
void E_Radio(void)
{
    int l, f, p, m, a, d, s, g;
    double  t;
//  PrgCnt += 7;

    sscanf(&Program[PrgCnt], "%d%d%d%d%d%lf%d%d%d", &l, &f, &p, &m, &a, &t, &d, &s, &g);

    E_REM();

//  Grating(l);
//  FW(f);
//  Polarizer(p);

    ExeREM = 0;
//  Radio(g);
    ExeREM = 1;

}


int E_GetCCD(void)
{

    ExeREM = 0;
    Status("Getting CCD Image...");
    DB_GetCCD(1);
    ExeREM = 1;
    E_REM();
    return 0;


}

void E_Lambda(void)
{
    int wl, l;
// The progression of "PrgCnt" is now in the Fetch function
//  PrgCnt += 7;
    sscanf(&Program[PrgCnt], "%d", &wl);
    l= LookforWl_X(wl);
    ExeREM = 0;
    SD_Grating(l);
    ExeREM = 1;
    E_REM();
}

void E_WAIT(void)
{
    unsigned    l, c;
// The progression of "PrgCnt" is now in the Fetch function
//  PrgCnt += 4;
    sscanf(&Program[PrgCnt], "%u", &l);

    for(c = 0; c < l / 100; c++)
    {
        Sleep(100);
        MLoopWhileEvents(0);
    }
    E_REM();
}
void E_Label(void)
{
    char    lab[255];
    int     c = 0;
// The progression of "PrgCnt" is now in the Fetch function
//  PrgCnt += 5;
//  while(Program[PrgCnt++] != 34);
    PrgCnt =PrgCnt+2;
    do
        lab[c++] = Program[PrgCnt];
    while(Program[PrgCnt++] != 34);
    E_REM();
//  lab[c] = 0;
//  Status(lab);
}

void E_Filter(void)
{
    int l;
// The progression of "PrgCnt" is now in the Fetch function
//  PrgCnt += 6;
    sscanf(&Program[PrgCnt], "%d", &l);
    ExeREM = 0;
    SD_FilterW(l);
    ExeREM = 1;
    E_REM();
}

void E_Mirror(void)
{
    int l;
// The progression of "PrgCnt" is now in the Fetch function
//  PrgCnt += 6;
    sscanf(&Program[PrgCnt], "%d", &l);
    ExeREM = 0;
    SD_Mirror(l);
    ExeREM = 1;
    E_REM();
}

int DB_StsMotor(int c)
{
    int sts = 0, d, er = 0; 

    switch(c)
    {
        case 0:
        {
            DXL.add = 0;
            do
            {
                DXL_TxStr("800", 3);
                d = STS0LEN;
                er = DXL_RxStr(DXL.bufrx, &d);
                MLoopWhileEvents(0);
            }while(DXL.bufrx[0] == '0' && DXL.bufrx[1] == '0' && er == 0);
            sts = 1;
        }
        break;

        case 1:
        {
            DXL.add = 0;
            do
            {
                DXL_TxStr("801", 3);
                d = STS0LEN;
                er = DXL_RxStr(DXL.bufrx, &d);
                MLoopWhileEvents(0);
                
            }while(DXL.bufrx[0] == '0' && DXL.bufrx[1] == '0' && er == 0);
            sts = 1;
        }
        break;

        case 2:
        {
            DXL.add = 1;
            do
            {
                DXL_TxStr("800", 3);
                d = STS0LEN;
                er = DXL_RxStr(DXL.bufrx, &d);
                MLoopWhileEvents(0);
            }while(DXL.bufrx[0] == '0' && DXL.bufrx[1] == '0' && er == 0);
            sts = 1;
            DXL.add=0;
        }
        break;
        
    }
    return sts;
}







void E_IRefSun(void)
{

    char str[16];
    float azi, elev;
    int er=0;
    int l, f, m, a, d, s, g, wl;
    double t;

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

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


    sscanf(&Program[PrgCnt], "%d%d%d%d%lf%d%d%d", &m, &wl, &f, &a, &t, &d, &s, &g);

    l= LookforWl_X(wl);


    if (DAS.DOption.smposmode)
        SD_Position(m, l, f, elev, azi);
    else
    {
        //mirror positioning
        SD_Mirror(m);
        //grating positioning   
        SD_Grating(l);
        //filter wheel positioning
        SD_FilterW(f);
        //Zenith positioning
        SD_Zenith(elev);
        //Azimuth positioning
        SD_Azimuth(azi,0);
    }
    
    
    ExeREM = 0;
    PerformMeas(0, a, t, d, s, g);

    ExeREM = 1;
    E_REM();
}


void E_AAPos(void)
{

    int er=0;
//  int l, f, m, d, g;
    double z, az;
//  double t;


    sscanf(&Program[PrgCnt], "%lf%lf", &z, &az);


        SD_Position(-1, -1, -1, z, az);
        E_REM();
}



void E_DFMeasure(void)
{
    int er=0;
    int l, f, m, a, d, s, g,nf;
    int wl;
    double t;
    extern struct date dok;


    int StsTot = 0;
    int StsMir = 0, StsGrat = 0, StsFW = 0;
// The progression of "PrgCnt" is now in the Fetch function
//  PrgCnt += 7;
 

    sscanf(&Program[PrgCnt], "%d%d%d%d%d%lf%d%d%d", &m, &wl, &f, &nf, &a, &t, &d, &s, &g);

    l= LookforWl_X(wl);


    if (DAS.DOption.smposmode)
    {
        SD_PosOMUDev(m, l, f);
        if(DAS.DOption.filtertype == FDOUBLE)
        {
            if((DAS.Paramini.EqType == SPATRAM2) || (DAS.Paramini.EqType == SPATRAMPLUS) || (DAS.Paramini.EqType == SPATRAM3))
                SD_NDFilterW(nf); //ND1
        }
        if(DAS.DOption.filtertype == FPLUS)
        {
            //if(DAS.Paramini.EqType == GASCODNG1)
            //{
                SD_FNTorqueM(nf);//ND1
                delay(700);
            //}
        }
    }
        //SD_Position(m, l, f, 0, 0);
    else
    {
        //mirror positioning
        SD_Mirror(m);
        //grating positioning   
        SD_Grating(l);
        //filter wheel positioning
        SD_FilterW(f);
        //Neutral  filter wheel positioning
        SD_NDFilterW(nf);
        if(DAS.DOption.filtertype == FDOUBLE)
        {
            if((DAS.Paramini.EqType == SPATRAM2) || (DAS.Paramini.EqType == SPATRAMPLUS) || (DAS.Paramini.EqType == SPATRAM3))
                SD_NDFilterW(nf); //ND1
        }
        if(DAS.DOption.filtertype == FPLUS)
        {
            //if(DAS.Paramini.EqType == GASCODNG1)
            //{
                SD_FNTorqueM(nf);//ND1
                delay(700);
            //}
        }
        //Zenith positioning
        //SD_Zenith(z);
        //Azimuth positioning
        //SD_Azimuth(az);
    }

    ExeREM = 0;

    if(DAS.DOption.measmode == 0) //Single
        PerformMeas(0, a, t, d, s, g);
    if(DAS.DOption.measmode == 1) //AVG
    {
        if(DAS.DOption.avgautor)
            PerformMeas(1, a, t, d, s, g);
        else
            PerformMeas(2, a, t, d, s, g);
        
    }
 
    ExeREM = 1;
    E_REM();


}

void E_AAMeasure(void)
{

    int er=0;
    int l, f, m, a, d, s, g, wl;
    double z, az;
    double t;

    sscanf(&Program[PrgCnt], "%d%d%d%lf%lf%d%lf%d%d%d", &m, &wl, &f, &z, &az, &a, &t, &d, &s, &g);

    l= LookforWl_X(wl);


    if(z == 360)
        z = -S_zenetr; //per misure di Io nel piano azimuthale in cui ho fatto misure (da controllarese deve essere positivo negativo o 90-)


    if (DAS.DOption.smposmode)
        SD_Position(m, l, f, z, az);
    else
    {
        //mirror positioning
        SD_Mirror(m);
        //grating positioning   
        SD_Grating(l);
        //filter wheel positioning
        SD_FilterW(f);
        //Zenith positioning
        SD_Zenith((float)z);
        //Azimuth positioning
        SD_Azimuth((float)az,0);
    }

    if(DAS.DOption.filtertype == FDOUBLE)
    {
        if((DAS.Paramini.EqType == SPATRAM2) || (DAS.Paramini.EqType == SPATRAMPLUS) || (DAS.Paramini.EqType == SPATRAM3))
                SD_NDFilterW(0); //Reset NDFilterWheel position
    }

    if(DAS.DOption.filtertype == FPLUS)
    {
                SD_FNTorqueM(0); //Reset NDFilterWheel position
    }
    
    ExeREM = 0;

    
    if(DAS.DOption.measmode == 0) //Single
        PerformMeas(0, a, t, d, s, g);
    if(DAS.DOption.measmode == 1) //AVG
    {
        if(DAS.DOption.avgautor)
            PerformMeas(1, a, t, d, s, g);
        else
            PerformMeas(2, a, t, d, s, g);

    }

    ExeREM = 1;
    E_REM();

}

void E_Measure(void)
{
    int er=0;
    int l, f, m, a, d, s, g;
    int wl;
    double t;
    extern struct date dok;


    int StsTot = 0;
    int StsMir = 0, StsGrat = 0, StsFW = 0;
// The progression of "PrgCnt" is now in the Fetch function
//  PrgCnt += 7;
 

    sscanf(&Program[PrgCnt], "%d%d%d%d%lf%d%d%d", &m, &wl, &f, &a, &t, &d, &s, &g);

    l= LookforWl_X(wl);


    if (DAS.DOption.smposmode)
        SD_PosOMUDev(m, l, f);

        //SD_Position(m, l, f, 0, 0);
    else
    {
        //mirror positioning
        SD_Mirror(m);
        //grating positioning   
        SD_Grating(l);
        //filter wheel positioning
        SD_FilterW(f);
        //Zenith positioning
        //SD_Zenith(z);
        //Azimuth positioning
        //SD_Azimuth(az);
    }

    ExeREM = 0;

    if(DAS.DOption.measmode == 0) //Single
        PerformMeas(0, a, t, d, s, g);
    if(DAS.DOption.measmode == 1) //AVG
    {
        if(DAS.DOption.avgautor)
            PerformMeas(1, a, t, d, s, g);
        else
            PerformMeas(2, a, t, d, s, g);

    }
 
    ExeREM = 1;
    E_REM();


}

int ExtLamp(int mod)
{

    unsigned long t = 1000;

    DAS.StepM.OOP[AMS1] |= 0x80; //bit 7, 10000000, dec = 128


    // 1's complement
    DAS.StepM.OOP[AMS1] = ~DAS.StepM.OOP[AMS1]; 
    //write on the optoinsulated port
    AMS_wopto(AMS1, DAS.StepM.OOP[AMS1]);
    // again 1's complement for restoring the positive logic
    DAS.StepM.OOP[AMS1] = ~DAS.StepM.OOP[AMS1];

    delay(t);

    DAS.StepM.OOP[AMS1] &= 0x7F; //     01111111, dec = 127

    // 1's complement
    DAS.StepM.OOP[AMS1] = ~DAS.StepM.OOP[AMS1]; 
    //write on the optoinsulated port
    AMS_wopto(AMS1, DAS.StepM.OOP[AMS1]);
    // again 1's complement for restoring the positive logic
    DAS.StepM.OOP[AMS1] = ~DAS.StepM.OOP[AMS1];



    delay(t);


    return 0;

}




int ExtShutt(int mod)
{

    unsigned long t = 500;
    char buf[256];
    int er = 0;

    if(DAS.Paramini.EqType == TROPOGAS )
    {
        DAS.StepM.OOP[AMS2] |= 0x40; //bit 6, 01000000, dec = 64

        // 1's complement
        DAS.StepM.OOP[AMS2] = ~DAS.StepM.OOP[AMS2]; 
        //write on the optoinsulated port
        AMS_wopto(AMS2, DAS.StepM.OOP[AMS2]);
        // again 1's complement for restoring the positive logic
        DAS.StepM.OOP[AMS2] = ~DAS.StepM.OOP[AMS2];

        delay(t);

        DAS.StepM.OOP[AMS2] &= 0xBF; //     10111111, dec = 191

        // 1's complement
        DAS.StepM.OOP[AMS2] = ~DAS.StepM.OOP[AMS2]; 
        //write on the optoinsulated port
        AMS_wopto(AMS2, DAS.StepM.OOP[AMS2]);
        // again 1's complement for restoring the positive logic
        DAS.StepM.OOP[AMS2] = ~DAS.StepM.OOP[AMS2];

        //delay(t);

    }
    else if(DAS.Paramini.EqType == SPATRAM2)
    {
        DAS.StepM.OOP[AMS1] |= 0x40; //bit 6, 01000000, dec = 64


        // 1's complement
        DAS.StepM.OOP[AMS1] = ~DAS.StepM.OOP[AMS1]; 
        //write on the optoinsulated port
        AMS_wopto(AMS1, DAS.StepM.OOP[AMS1]);
        // again 1's complement for restoring the positive logic
        DAS.StepM.OOP[AMS1] = ~DAS.StepM.OOP[AMS1];

        delay(t);

        DAS.StepM.OOP[AMS1] &= 0xBF; //     10111111, dec = 191


        // 1's complement
        DAS.StepM.OOP[AMS1] = ~DAS.StepM.OOP[AMS1]; 
        //write on the optoinsulated port
        AMS_wopto(AMS1, DAS.StepM.OOP[AMS1]);
        // again 1's complement for restoring the positive logic
        DAS.StepM.OOP[AMS1] = ~DAS.StepM.OOP[AMS1];

        //delay(t);
    }
    else
    {
        sprintf(buf, "For this Equipment the AMS is UNKNOWN\nPlease Contact DANBO!!!!");
        er = MMessageDialog("DAS information", buf, "Ok", NULL);
        if (!er)
            return 1;

    }
    return 0;
    
}

void E_ChkExLamp(void)
{

    int flagstatus = 1; 
    int cont = 0;
    double Texp_temp = 0;
    double T1 = 0, T2 = 0; 
    extern struct date dok;

        // Check if the shutter is open or closed 
        // It has to be open (so the Exposure time has to be short...)
    ExeREM = 0;
    do
    {
        //the shutter is thinked to be open
        //first measurement with the shutter open
        AutoRange(0);
        T1 = TExp;

        //Close External Shutter

        ExtShutt(0);

        AutoRange(0);
        T2 = TExp;
        if( T1/T2 < 1) // the shutter was open at the first measurement and Now it has to be open again
        {   //Open External Shutter
            ExtShutt(0);
            FLAG.extshutter = 0;
            flagstatus = 0;
        }
        else
        {
            //the shutter was closed at the first measurement so now is already open
            FLAG.extshutter = 0;
            flagstatus = 0;
        }
//      AutoRange(0);
//      if( (TExp <= T1 + 1) & (TExp >= T1 - 1))
//          flagstatus = 0;

        cont++;

    }while((flagstatus) | (cont == 5));

    ExeREM = 1;
    E_REM();

}






void E_Meashor(void)
{
    int er=0;
    int l, f, m, a, d, s, g, wl;
    double t;
    extern struct date dok;

    int StsTot = 0;
    int StsMir = 0, StsGrat = 0, StsFW = 0;

    // The progression of "PrgCnt" is now in the Fetch function
    // PrgCnt += 7;

    sscanf(&Program[PrgCnt], "%d%d%d%d%lf%d%d%d", &m, &wl, &f, &a, &t, &d, &s, &g);

    l= LookforWl_X(wl);

    
    if (DAS.DOption.smposmode)
        SD_PosOMUDev(m, l, f);
        //SD_Position(m, l, f, 0, 0);
    else
    {
        //mirror positioning
        SD_Mirror(m);
        //grating positioning   
        SD_Grating(l);
        //filter wheel positioning
        SD_FilterW(f);
        //Zenith positioning
        //SD_Zenith(z);
        //Azimuth positioning
        //SD_Azimuth(az);
    }
    ExeREM = 0;
    /******************************************************************/
    /******************************************************************/

    //*********************** Start First Measurement ******************
    PerformMeas(0, a, t, d, s, g);
    //*********************** End First Measurement ******************

    //*********************** Start Second Measurement ******************
    //Close External Shutter
    if (FLAG.extshutter == 0)
    {
        ExtShutt(0);
        FLAG.extshutter = 1;
        
    }
    
    //Measure (d=1) or dark (d=0) - 
    if(d)
    {
            DB_GetCCD(1);
    }
    else
    {
            DB_GetCCD(0);
    }

    //
    if(s)
    {
        D_Saving();
    }
    if(g)
    {
        if(DAS.Flag.plotW)
        D_Plot();
    }
    //*********************** End Second Measurement ******************

    //*********************** Start Third Measurement ******************
    PerformMeas(0, a, t, d, s, g);


    //Open External Shutter
    if (FLAG.extshutter)
    {
        ExtShutt(0);
        FLAG.extshutter = 0;
    }
    //*********************** End Third Measurement ******************
    ExeREM = 1;
    E_REM();

}


void E_Meashor2(void)
{
    int er=0;
    int l, f, m, a, d, s, g;
    double t;
    extern struct date dok;
    int wl;

    int StsTot = 0;
    int StsMir = 0, StsGrat = 0, StsFW = 0;

    // The progression of "PrgCnt" is now in the Fetch function
    // PrgCnt += 7;

    sscanf(&Program[PrgCnt], "%d%d%d%d%lf%d%d%d", &m, &wl, &f, &a, &t, &d, &s, &g);

    l= LookforWl_X(wl);

    
    if (DAS.DOption.smposmode)
        SD_PosOMUDev(m, l, f);
        //SD_Position(m, l, f, 0, 0);
    else
    {
        //mirror positioning
        SD_Mirror(m);
        //grating positioning   
        SD_Grating(l);
        //filter wheel positioning
        SD_FilterW(f);
        //Zenith positioning
        //SD_Zenith(z);
        //Azimuth positioning
        //SD_Azimuth(az);
    }
    ExeREM = 0;
    /******************************************************************/
    /******************************************************************/

    //*********************** Start First Measurement ******************
    PerformMeas(0, a, t, d, s, g);
    //*********************** End First Measurement ******************

    //*********************** Start Second Measurement ******************
    //Close External Shutter
    if (FLAG.extshutter == 0)
    {
        ExtShutt(0);
        FLAG.extshutter = 1;
        
    }
    
    //Measure (d=1) or dark (d=0) - 
    if(d)
    {
            DB_GetCCD(1);
    }
    else
    {
            DB_GetCCD(0);
    }

    //
    if(s)
    {
        D_Saving();
    }
    if(g)
    {
        if(DAS.Flag.plotW)
        D_Plot();
    }
    //*********************** End Second Measurement ******************

    //*********************** Start Third Measurement ******************
//  PerformMeas(0, a, t, d, s, g);


    //Open External Shutter
    if (FLAG.extshutter)
    {
        ExtShutt(0);
        FLAG.extshutter = 0;
    }
    //*********************** End Third Measurement ******************
    ExeREM = 1;
    E_REM();

}


void E_Zenith(void)
{
    double  l;
    sscanf(&Program[PrgCnt], "%lf", &l);
    ExeREM = 0;
    l = (float) l;
    SD_Zenith((float)l);

    ExeREM = 1;
    E_REM();
}

void E_Azimuth(void)
{
    double  l;
    sscanf(&Program[PrgCnt], "%lf", &l);
    ExeREM = 0;

    l = (float) l;

    SD_Azimuth((float)l,0);

    ExeREM = 1;
    E_REM();
}


void E_HGratCal(void)
{
    ExeREM = 0;
    Status("Home for Grating...");
//  AMS_MotorOn_Off(AMS1,0,1);
    HomeGratingFast(0);
//  AMS_MotorOn_Off(AMS1,0,0);
    
    D_Calibra();    
    
    ExeREM = 1;
//  E_REM();


}

void E_HgScan(void)
{

    int l;
    
    //Switch On QJ Lamp
    E_Hg_On();
    ExeREM = 0;
    //Position Mirror
    SD_Mirror(2);

    for (l=1; l<10; l++)
    {
        //position grating
        SD_Grating(l);
        // Position Filterwheel
        SD_FilterW(0);
        if(DAS.DOption.filtertype == FDOUBLE)
            SD_NDFilterW(0);
        else if(DAS.DOption.filtertype == FPLUS)
            SD_FNTorqueM(0);
        //autorange
        Status("Autoranging...");
        AutoRange(0);
        Status("Getting CCD Image...");
        DB_GetCCD(1);
        //Save the Spectrum
        SaveCalib(1);

        if(DAS.Flag.plotW)
            D_Plot();


    

    }
    E_Hg_Off();
    
    ExeREM = 1;
    //E_REM();


}
                
void E_QjScan(void)
{
    //perform a full scan set of measurement with the QJ lamp
                
    int l;
    
    //Switch On QJ Lamp
    E_Qj_On();
    ExeREM = 0;
    //Position Mirror
    SD_Mirror(2);

    for (l=1; l<10; l++)
    {
        //position grating
        SD_Grating(l);
        // Position Filterwheel
        SD_FilterW(0);
        if(DAS.DOption.filtertype == FDOUBLE)
            SD_NDFilterW(0);
        else if(DAS.DOption.filtertype == FPLUS)
            SD_FNTorqueM(0);
        //autorange
        Status("Autoranging...");
        AutoRange(0);
        Status("Getting CCD Image...");
        DB_GetCCD(1);
        //Save the Spectrum
        SaveCalib(1);

        if(DAS.Flag.plotW)
            D_Plot();


    

    }
    E_Qj_Off();

    
    SaveCnt++;

    ExeREM = 1;
    //E_REM();

}


void E_DirectSun(void)
{

    char str[16];
    float azi, elev;
    int er=0;
    int l, f, m, a, d, s, g, wl, nf;
    double t;

    //sun Azimuth angle    
    sprintf(str, "%.01lf", S_azim);
    azi = atof(str);

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



    sscanf(&Program[PrgCnt], "%d%d%d%d%d%lf%d%d%d", &m, &wl, &f, &nf, &a, &t, &d, &s, &g);

    l= LookforWl_X(wl);


    if (DAS.DOption.smposmode)
    {
        //SD_PosOMUDev(m, l, f);
        SD_Position(m, l, f, elev, azi);
        if(DAS.DOption.filtertype == FDOUBLE)
        {
            if(DAS.Paramini.EqType == SPATRAM2 || DAS.Paramini.EqType == SPATRAMPLUS || DAS.Paramini.EqType == SPATRAM3)
                SD_NDFilterW(nf); //ND1
        }
        if(DAS.DOption.filtertype == FPLUS)
        {
        //  if(DAS.Paramini.EqType == GASCODNG1)
        //  {
                SD_FNTorqueM(nf);//ND1
                delay(700);
        //  }
        }

    }
        //SD_Position(m, l, f, 0, 0);
    else
    {
        //mirror positioning
        SD_Mirror(m);
        //grating positioning   
        SD_Grating(l);
        //filter wheel positioning
        SD_FilterW(f);
        //Neutral  filter wheel positioning
        SD_NDFilterW(nf);
        if(DAS.DOption.filtertype == FDOUBLE)
        {
            if(DAS.Paramini.EqType == SPATRAM2 || DAS.Paramini.EqType == SPATRAMPLUS ||DAS.Paramini.EqType == SPATRAM3)
                SD_NDFilterW(nf); //ND1
        }
        if(DAS.DOption.filtertype == FPLUS)
        {
//          if(DAS.Paramini.EqType == GASCODNG1)
//          {
                SD_FNTorqueM(nf);//ND1
                delay(700);
//          }
        }
        //Zenith positioning
        //SD_Zenith(z);
        //Azimuth positioning
        //SD_Azimuth(az);
    }

    
    ExeREM = 0;
    PerformMeas(0, a, t, d, s, g);

    ExeREM = 1;
    E_REM();



}

void E_Almucantar(void)
{

    char str[16];
    float azi, elev;
    int er=0;
    int l, f, m, a, d, s, g, wl, nf,k;
    double t;

    //sun Azimuth angle    
    sprintf(str, "%.01lf", S_azim);
    azi = atof(str);

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



    sscanf(&Program[PrgCnt], "%d%d%d%d%d%lf%d%d%d", &m, &wl, &f, &nf, &a, &t, &d, &s, &g);

    l= LookforWl_X(wl);

for(k=0; k<=360; k+=10)
{

if (DAS.DOption.smposmode)
    {
        //SD_PosOMUDev(m, l, f);
        SD_Position(m, l, f, elev, k);
        

        if(DAS.DOption.filtertype == FDOUBLE)
        {
            if(DAS.Paramini.EqType == SPATRAM2 || DAS.Paramini.EqType == SPATRAMPLUS || DAS.Paramini.EqType == SPATRAM3)
                SD_NDFilterW(nf); //ND1
        }
        if(DAS.DOption.filtertype == FPLUS)
        {
//          if(DAS.Paramini.EqType == GASCODNG1)
//          {
                SD_FNTorqueM(nf);//ND1
                delay(700);
//          }
        }

    }
        //SD_Position(m, l, f, 0, 0);
    else
    {
        //mirror positioning
        SD_Mirror(m);
        //grating positioning   
        SD_Grating(l);
        //filter wheel positioning
        SD_FilterW(f);
        //Neutral  filter wheel positioning
        SD_NDFilterW(nf);
        if(DAS.DOption.filtertype == FDOUBLE)
        {
            if(DAS.Paramini.EqType == SPATRAM2      || 
                DAS.Paramini.EqType == SPATRAMPLUS  || 
                DAS.Paramini.EqType == SPATRAM3)
                    SD_NDFilterW(nf); //ND1
        }
        if(DAS.DOption.filtertype == FPLUS)
        {
//          if(DAS.Paramini.EqType == GASCODNG1)
//          {
                SD_FNTorqueM(nf);//ND1
                delay(700);
//          }
        }
        //Zenith positioning
        //SD_Zenith(z);
        //Azimuth positioning
        //SD_Azimuth(az);
    }

    
    ExeREM = 0;
    PerformMeas(0, a, t, d, s, g);

    ExeREM = 1;
}
    E_REM();

}