DAS_Spat.c File Reference

DAS main file. More...

#include <windows.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winioctl.h>
#include <direct.h>
#include <io.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "mgui.h"
#include "DAS_Spatram.h"
#include "dcl.h"
#include "dil.h"
#include "dscud.h"
#include "wsc.h"
#include "dxl.h"
#include "solpos.h"
#include "bil.h"
#include "DOAS.h"
#include "nrutil.h"
#include "Marq.h"
#include "portio32.h"
#include "ISMMDLL.h"
#include "wdt.h"

Include dependency graph for DAS_Spat.c:

Go to the source code of this file.

Functions
void	AMSINI_Err (int c)
void	BuildMainShell (void)
void	BuildShell (int emode, char **argum)
int	ChkConfigInstance (void)
void	ChkDASInstance (int etype)
void	ChkExeMode (int mod, char **p)
int	ChkMaster (int mod)
int	ChkWinInstance (char *buff, MOBJECT obj)
int	D_Timing (int id, long tout)
int	DB_HelpCB (MOBJECT o, void *od, void *ad)
	Help Callback Create the help in the predefined WEB Browser. More...
int	DB_InfCB (MOBJECT o, void *od, void *ad)
	Inf Callback Create the Inf shell. More...
void	DB_SelButt_CB (MOBJECT obj, MKeyEvent *pe, void *a_data)
void	DemoInitMotor (void)
int	ExMaster (int m, int mode)
int	Fetch ()
	Reads the key-word in PRG Files . More...
int	InitCCD_AMS (int mod, int emode)
void	InitColors (void)
void	InitDefaultOptions (void)
void	InitFlags (void)
int	InitTempAD (int mod)
void	LaunchBackTask (void)
	Launch the DAS Background tasks Common Tasks launched when the DAS MAIN Graphic User Interface is loaded: More...
int	LoadAMS (void)
void	LoadSetDirs (void)
int	LoadWlstep (void)
	load the file of the wavelength vs steps More...
void	ManualModeCB (MOBJECT p, void *od, void *ad)
void	MDCreateSplashExe ()
void	MDCreateWaitShell (void)
	Create a waiting window . More...
void	MGUIMain (int argc, char **argv)
	MAIN PROGRAM starting point Actions: . More...
void	MGUIQuitCB (MOBJECT shell, void *od, void *ad)
	Exit MGUI Library. Procedure that close MGUI . More...
int	NOVA_In (int novatype, unsigned int DigIn)
	Read the NOVA Input port. More...
int	NOVA_Out (int novatype, unsigned int out)
	Write the NOVA Output port. More...
void	NoWaitCB (MOBJECT p, void *od, void *ad)
void	NoWaitSplashCB (MOBJECT p, void *od, void *ad)
int	PRG_Check (int mod, char *prgname)
int	PRG_ChKBegin (int line, char *fname)
int	PRG_ChkGrating (int mod, char *filename, int record, int par)
int	PRG_ChkKeyW (int line, char *fname)
int	PRG_ChkMeasAvg (int line, char *fname)
int	PRG_ChkMirror (int mod, char *filename, int record, int par)
void	RunFULL (void)
	DAS Main LOOP for Equipment management This Procedure is called by the MGUIMain function when the execution mode is: . More...
void	RunLogMode (int mod, char *p)
void	RunOLP (char *fname)
void	SetScriptUseLabel (int master, char *prgf, int emode, MOBJECT lbl)
int	SetWorkDirMGUIenv (char *buff)
	set DAS and MGUI enviroment when the program is launched undirectly (for offlineplot or log or auto or autotimed modes) More...
void	SZA_FindMin ()
	computation of daily minimum SZA More...
void	SZA_FirstCalc (void)
void	TaskWDT (TIMEOUT_ID id, void *data)
void	WDT_CB (MOBJECT p, void *od, void *ad)
void	WDT_func (int mod)
void	WDT_Task_CB (MOBJECT o, void *od, void *ad)
void	WDTRefresh (void)
void	WriteShellTitle (MOBJECT o, int eqt)

Variables
long	AbsFilePos
	Absolute File position. More...
AzimuthSt	AST
bil	BIL
int	BlindPix = 0
	Number of blind pixels (usefull for Dark Current) More...
int	CCD_SetupFlg = 0
config	Cfg
	Camera controls & Options. More...
int	ContFP = 0
	Counter for File position. More...
unsigned long	countsopsh
	counting the number of opening shutter More...
das	DAS
int	DAS_StartDOY
int	DAS_StartHour
ccd	DC_CCD
	CCD settings. More...
ptf	DC_HP
	Platform settings. More...
int	DeltaTPrec
const char *	DeviceTypeInput [] = {{"Direct"}, {"TelesExtLamp"}, {"Calib Lamps"}, {"Alt-Az Platf"}, {"Radiometer"}, {"TelesIntLamp"}, {"TelescopeV"}, {""}}
	const char array for the Device type <-> Input association More...
d_geo	DGEO
	geographical coordinates structure More...
dil	DIL
dlog	DLOG
doas	DOAS
palette	DPAL
dpwd	DPWD
	Danbo Passw. More...
DSCB	dscb
DSCCB	dsccb
int	ExeREM = 1
master	ExMast [PRGMAXNUM]
char *	Fil_Code [] = {{"NULL"}, {"UG11"}, {"UG1 "}, {"BG12"}, {"BG25"}, {"H475"}}
	const char array for the realisation of the Filters buttons in the Filter shell More...
char *	Fil_Code8H [] = {{"NULL"}, {"UG5"}, {"UG11"}, {"BG23"}, {"NULL"}, {"NULL"}, {"LPAS"}, {"NULL"}}
	const char array for the realisation of the Filters buttons in the Filter shell More...
char *	Fil_CodeNG [] = {{"NULL"}, {"B12 "}, {"B12F"}, {"B39 "}, {"B39F"}, {"UG5 "}}
	const char array for the realisation of the Filters buttons in the Filter shell for GASCODNG2 and NG3 instruments More...
char *	Fil_CodeNG1 [] = {{"NULL"}, {"B12 "}, {"S400"}, {"B39 "}, {"S500"}, {"UG5 "}}
	const char array for the realisation of the Filters buttons in the Filter shell for GASCODNG1 instrument More...
char *	Fil_CodeTropo [] = {{"NULL"}, {"BG28"}, {"UG11"}, {"BG12"}, {"BG23"}, {"HPas"}}
	const char array for the realisation of the Filters buttons in the Filter shell for TROPOGAS instrument More...
int	FirstTime = 1
int	FlgSM_Stop = 1
	Steppers Motor Activity: 0 = Motors moving; 1 = Motors stopped. More...
FilterWheelSt	FWS
	Filter Wheel. More...
GratingSt	GRS
	Grating. More...
char *	HomePosition [] = {{"H_Mir"}, {"H_Grat"}, {"H_Filt"}, {"H_NDFilt"}, {"H_Zen"}, {"H_Azi"}, {"Close"}}
	const char array for the realisation of the Filters buttons in the ND Filter shell More...
ids	IDS
	ID tasks. More...
int	IDX
	Number of sensible horizontal pixels. More...
int	IDY
	Number of sensible vertical pixels. More...
int	Incr_Read_Temp =0
const char *	KeyCode []
unsigned int	LevelDefPix = 100
int	MainCommand =0
	Command switch in main loop. More...
int	Master = 0
unsigned int *	mattempbuff
const char *	Mir_Code [] = {{"Zenith "}, {"HorizDX"}, {"Calibra"}, {"HorizSX"}, {""}, {""}, {""}, {""}}
	const char array for the realisation of the Mirrors buttons in the Mirror shell More...
const char *	Mir_CodeTropo [] = {{"Calibra "}, {"HorizDX"}, {"NULL "}, {"HorizSX"}, {""}, {""}, {""}, {""}}
	const char array for the realisation of the Mirrors buttons in the Mirror shell for TROPOGAS More...
MirrorSt	MIS
	Mirror. More...
int	Mode
mtcl	MTCL
	MTColor. More...
int	N_AVG = 25
	Number of measurements for Averaging mode in fixed number of meas. mode. More...
int	N_RM = 0
	Number of measurements for Averaging mode in fixed exposure time mode. More...
char *	NDFil_Code [] = {{"NULL"}, {"ND1"}, {"ND2"}, {"ND3"}, {"ND4"}, {"H645"}}
	const char array for the realisation of the Filters buttons in the ND Filter shell More...
NDFilterWheelSt	NDFWS
	ND Filter Wheel. More...
nova	NOVA
int	nowait = 1
int	nowaitsplash = 1
omutemp	OMUTEMP
	structure for OMU temperatures More...
omuthr	OMUTHR
int	on = 0
	PRG execution control variabile. More...
int	ON_OFFLINEPLOT = 0
int	PaletteMode
unsigned long *	PLColor [] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
long	PrgCnt
	Counter for the position in the PRG file. More...
char	PrgFile [_MAX_PATH]
	Name of the PRG file. More...
int	PrgNum = 0
int	PrgNumExe = 0
	number of PRG file in execution More...
int	PrgNumInM = 0
	Actual number of PRG File in current MASTER or MASTERSZA File. More...
long	PrgSiz
	Size of the PRG file. More...
char *	Program
	buffer for the PRG file More...
long	REL_FILE_POS [51]
	relative File position More...
int	Server = 0
stepm	STEPM
	Stepper Motors. More...
dsza	SZADelta
int	SZAMax = 100
	Maximum SZA for performing measurements. More...
double	TExp
	CCD Exposure time. More...
tools	TOOLS
	tools structure More...
long	Total_Spec
int	TOTTEXP = 5
	Total Exposure time in Averaging mode. More...
long	wav []
	Step Number definition - for SD_Grating. More...
int	WDT_flagstop
unsigned char	WDT_Timeout = 100
int	wl []
	WaveLength definition - for SD_Grating. More...
int	WlSet
	Wavelength position definition - for SD_Grating. More...
ZenithSt	ZST

Detailed Description

DAS main file.

Author

Daniele Bortoli

Definition in file DAS_Spat.c.

Function Documentation

AMSINI_Err()

void AMSINI_Err

(

int

c

)

Definition at line 2573 of file DAS_Spat.c.

References _MAX_PATH, d_fileman::CONFIGDIREQUIPMENT, D_WriteInitLog(), bil::DFILEM, and MMessageDialog().

Referenced by SZA_FirstCalc().

{
    char buf[512];
    char str[_MAX_PATH];

    switch (c)
    {
    case 1:
        sprintf(str,"File %s\\AMS.ini not found,\nThe program will be closed.\n ", BIL.DFILEM.CONFIGDIREQUIPMENT);
        MMessageDialog ("DAS ERROR ", str, "OK",NULL); 
        sprintf(buf,"File 'AMS.INI' not found");
        D_WriteInitLog(buf);
        exit(0);
        break;
    case 2:
        MMessageDialog ("DAS ERROR ", "Error in reading the AMS Power in file '.\\Config\\AMS.INI',\n\
The program will be closed.\n ", "OK",NULL); 
        sprintf(buf,"Bad AMS Power read");
        D_WriteInitLog(buf);
        exit(0);
        break;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildMainShell()

void BuildMainShell

(

void

)

Definition at line 2597 of file DAS_Spat.c.

References DB_SelButt_CB(), EM_KEY_PRESS, das::Gui, MDCreate_CP(), MGetScreenHeight(), MGetScreenWidth(), MObjectAddEventNotifyCallback(), MObjectGetHeight(), MObjectGetWidth(), MShellRealizeXY(), shells::Sh_Main, and gui::Shells.

Referenced by SZA_FirstCalc().

{
    int WSc, WSh,HSc, HSh;

    DAS.Gui.Shells.Sh_Main = MDCreate_CP();
    WSc = MGetScreenWidth();
    HSc = MGetScreenHeight();
    MShellRealizeXY( DAS.Gui.Shells.Sh_Main, (WSc-901)/2, 0);
    WSh = MObjectGetWidth(DAS.Gui.Shells.Sh_Main);
    HSh = MObjectGetHeight(DAS.Gui.Shells.Sh_Main);
    MObjectAddEventNotifyCallback(DAS.Gui.Shells.Sh_Main, (OBJ_EVENT_CB) DB_SelButt_CB, EM_KEY_PRESS, (void *) 0);

}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildShell()

void BuildShell	(	int	emode,
		char **	argum
	)

Definition at line 3516 of file DAS_Spat.c.

References DB_HelpCB(), DOASMODE, HELP, LOGMODE, MDCreateDOAS_MainSh(), OFFLINEPLOT, RunFULL(), RunLogMode(), and RunOLP().

Referenced by MGUIMain().

{

    int c = emode;
    int er = 0;
    switch (c)
    {
        case OFFLINEPLOT:
            if(argum[2] != 0)
                RunOLP(argum[2]);
            else
                RunOLP(NULL);
            break;
        case HELP:
            er = DB_HelpCB(NULL, NULL, NULL);
            break;
        case DOASMODE:
            MDCreateDOAS_MainSh(&DOAS); 
            break;
        case LOGMODE:
            RunLogMode(0, argum[1]);
            break;
        default:
            RunFULL();
            break;
    }       
            
}

Here is the call graph for this function:

Here is the caller graph for this function:

ChkConfigInstance()

int ChkConfigInstance

(

void

)

Definition at line 2128 of file DAS_Spat.c.

References MMessageDialog().

{

    HWND    wconfig;
    char buff[1024];

    sprintf(buff,"DAS Config");


    wconfig = FindWindow(NULL, buff);
    if(wconfig != NULL)
    {
        sprintf(buff,"'DAS Config' window is already open!!!!");
        MMessageDialog("DAS Info", buff, "OK",NULL);
        return 1;
                
    }
    else
        return 0;


}

Here is the call graph for this function:

ChkDASInstance()

void ChkDASInstance

(

int

etype

)

Definition at line 2048 of file DAS_Spat.c.

References DASREL, DASREV, DASREVDATE, GASCODNG1, GASCODNG2, GASCODNG3, GASCODNG4, LIS_, MGUITerm(), MMessageDialog(), SPATRAM, SPATRAM2, SPATRAM3, SPATRAMPLUS, and TROPOGAS.

Referenced by SZA_FirstCalc().

{

    HWND    das;
    char buff[1024], str[32];
    int c = etype;


    switch (c)
    {
        case TROPOGAS:
            sprintf(str,"TROPOGAS");
            break;
        case SPATRAM:
            sprintf(str,"SPATRAM");
            break;
        case LIS_:
            sprintf(str,"LIS");
            break;
        case SPATRAMPLUS:
            sprintf(str,"SPATRAMPLUS");
            break;
        case GASCODNG1:
            sprintf(str,"GASCODNG1");
            break;
        case GASCODNG2:
            sprintf(str,"GASCODNG2");
            break;
        case GASCODNG3:
            sprintf(str,"GASCODNG3");
            break;
        case GASCODNG4:
            sprintf(str,"GASCODNG4");
            break;
        case SPATRAM3:
            sprintf(str,"SPATRAM3");
            break;
        case SPATRAM2:
            sprintf(str,"SPATRAM2");
            break;

        default:
            sprintf(str,"UNKNOWN");
            break;
    }

    sprintf(buff,"DAS Release %d.%.1lf (%s) - [Setting for %s]", DASREL, DASREV, DASREVDATE, str);


    das = FindWindow(NULL, buff);
    if(das != NULL)
    {
        sprintf(buff,"A copy of DAS is already running\nIn this execution mode \
you can't execute more than 1 DAS instance at the same time !!!\n\
Please contact DanBo for more information's \n\n\
If you are Dr. G. Giovanelli please press the GG button\n\n");

/*  sprintf(buff,"A copy of DAS is already running\nIn this execution mode \
you can't execute more than 1 DAS instance at the same time !!!\n\
Please contact DanBo for more information's \n\n\
if you are Dr. G. Giovanelli please press the GG button\n\n");
*/
        MMessageDialog("DAS Info", buff, "OK","GG",NULL);

//      MMessageDialog("DAS Info", buff, "OK",NULL);
                
        sprintf(buff,"CAZZO Giorgio ti ho detto N+1 volte che ne puoi \
avviare uno solo alla volta\n\n\
Domina il tuo dito indice!!!\n\n  ");
        MMessageDialog("DAS Info", buff, "OK",NULL);

        MGUITerm();
        exit(0);
    }


}

Here is the call graph for this function:

Here is the caller graph for this function:

ChkExeMode()

void ChkExeMode	(	int	mod,
		char **	p
	)

Definition at line 3177 of file DAS_Spat.c.

References _MAX_PATH, DBDEMO, DI_FileExist(), DI_FindDirName(), DI_FindDrive(), DOASMODE, env, flag::exemode, das::Flag, HELP, LOGMODE, MANUAL, Master, MDCreateSplashExe(), MGetCurrentDirectory(), MGUITerm(), MMessageDialog(), OFFLINEPLOT, PRG_Check(), PrgFile, PRGFILE, SetWorkDirMGUIenv(), SZAMASTERM, SZAMODE, TEMPORIZED, TESTAD, TESTAMS, TESTCCD, and TESTSZAMODE.

Referenced by MGUIMain().

{

    char buff[_MAX_PATH], str[_MAX_PATH];
    int er, l;
    
    if(mod > 1)
    {
        if((strcmp(p[1], "MASTER") == 0)) // MASTER
        {
            Master = 1;
            DAS.Flag.exemode = TEMPORIZED;

        }
        else if ((strcmp(p[1], "MASTERSZA") == 0)) // MASTERSZA
        {
            Master = 1;
            DAS.Flag.exemode = SZAMASTERM;
            //Effemeridis Computation

        }
        else if ((strcmp(p[1], "SZAPRG") == 0)) // SZAPRG
        {
            Master = 1;
            DAS.Flag.exemode = SZAMODE;
        }
        else if ((strcmp(p[1], "TESTSZAPRG") == 0)) // STESTZAPRG
        {
            Master = 1;
            DAS.Flag.exemode = TESTSZAMODE;
        }

        else if( (strcmp(p[1], "TESTAMS") == 0) | (strcmp(p[1], "testams") == 0)| (strcmp(p[1], "TestAMS") == 0)) //si vogliono testare i motori e i rele'
        {
            DAS.Flag.exemode = TESTAMS;
                
        }
        else if( (strcmp(p[1], "OFFLINEPLOT") == 0) | (strcmp(p[1], "offlineplot") == 0) )//si vuole utilizzare il PLOT offline
        {
            DAS.Flag.exemode = OFFLINEPLOT;


        }
        else if( (strcmp(p[1], "TESTCCD") == 0) | (strcmp(p[1], "testccd") == 0) | (strcmp(p[1], "TestCCD") == 0)) //si vuole testare la camera a CCD
        {
            DAS.Flag.exemode = TESTCCD;

        }
        else if( (strcmp(p[1], "TESTAD") == 0) | (strcmp(p[1], "testad") == 0)| (strcmp(p[1], "TestAD") == 0)) //si vuole testare il convAD delle temp
        {
            DAS.Flag.exemode = TESTAD;

        }
        else if( (strcmp(p[1], "?") == 0) | (strcmp(p[1], "help") == 0) | (strcmp(p[1], "HELP") == 0)) // ovvio
        {
            DAS.Flag.exemode = HELP;
//          er = DB_HelpCB(NULL, NULL, NULL);
//          if (er)
//              exit(0);
                
        }
        else if( (strcmp(p[1], "demo") == 0) | (strcmp(p[1], "DEMO") == 0) | (strcmp(p[1], "Demo") == 0)) // ovvio
        {
//          FLAG.demo = 1;              
//          FLAG.testams = 1;
//          FLAG.testccd = 1;
//          FLAG.plotoffline = 1;
            DAS.Flag.exemode = DBDEMO;


        }
        else if( (strcmp(p[1], "DOAS") == 0) | (strcmp(p[1], "doas") == 0)| (strcmp(p[1], "Doas") == 0)) //si vuole testare il convAD delle temp
        {
            DAS.Flag.exemode = DOASMODE;
            
        }

        else
        {
            //Check if the argument is a valid PRG file or LOG files
            sprintf(str,"%s",p[1]);
            l = strlen(str);
            sprintf(buff,"%s", "xxxx");
            strncpy(buff, str+l-4, 4);
        
            if( (strcmp(buff,".prg") == 0) |(strcmp(buff,".PRG") == 0) |(strcmp(buff,".Prg") == 0) )
            {
                
                if(DI_FileExist(p[1])) // DI_FileExist --> Return: 1 if PATH exist, else return 0
                {
                    strcpy(PrgFile, p[1]);
                    //Check the syntax of the PRG file 
                    er = PRG_Check(0, PrgFile);
//                  if er
//                  //SET Execution Mode
                    DAS.Flag.exemode = PRGFILE;
                }
                else
                {
                    sprintf(str, "PRG file:\n'%s'\n not encountred.\n Please check the name of the file\n Now the program will be terminated", p[1]);
                    MMessageDialog("DAS information", str, " Ok ", NULL);  
                    MGUITerm();
                    exit(0);
                }

            }
            else if( (strcmp(buff,".log") == 0) |(strcmp(buff,".LOG") == 0) |(strcmp(buff,".Log") == 0) )
            {
                
                DAS.Flag.exemode = LOGMODE;
                

            }
            else
            {
                sprintf(str, "'%s'\nUnrecognized Argument \n The Program will be terminated", p[1]);
                if(MMessageDialog("DAS inf.", str, " Ok ", "Quick Help", NULL))
                {
                    sprintf(str, "'Allowed Arguments:\n\n\
1) DEMO\n\
2) DOAS\n\
3) TESTAD\n\
4) TESTCCD\n\
5) TESTAMS\n\
6) MASTER\n\
7) SZAPRG\n\
8) OFFLINEPLOT\n\
9) OFFLINEPLOT Valid *.bif (dat) file\n\
10) Valid *.LOG file\n\
11) Valid *.PRG file\n");
                    if(!MMessageDialog("DAS information", str, " Ok ", NULL))
                    MGUITerm();
                    exit(0);
                    

                }
                else
                {
                    MGUITerm();
                    exit(0);
                }
            }

        }
    }
    else
        DAS.Flag.exemode = MANUAL;



    // If DAS executed in one of the automatic modes,
    // a Splash window is created allowing the user to select
    // to start the program in MANUAL mode or let it continue
    // Usefull when DAS is automatically loaded at the BOOT of the instrument!!!!!
    if ((DAS.Flag.exemode == SZAMASTERM)    |
        (DAS.Flag.exemode == TEMPORIZED)    |
        (DAS.Flag.exemode == SZAMODE)       |
        (DAS.Flag.exemode == TESTSZAMODE)   |
        (DAS.Flag.exemode == PRGFILE)       )
        {
            MDCreateSplashExe();
        }






}

Here is the call graph for this function:

Here is the caller graph for this function:

ChkMaster()

int ChkMaster

(

int

mod

)

Definition at line 2730 of file DAS_Spat.c.

References master::eora, GetDateTime(), PrgNumExe, PrgNumInM, S_zenetr, master::sora, time::ti_hour, time::ti_min, and time::ti_sec.

Referenced by D_AutoExecution(), and SZA_FirstCalc().

{

    int i, c = mod;
    struct time RTime;
    struct date RDate;
    struct tm today;
    float DecActTime, DecTimeStart, DecTimeStop;

    switch (c)
    {
    case 0: // Temporized Mode (DAS argument MASTER)

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

        // Time to decimal time
        DecActTime = RTime.ti_hour + ((float) RTime.ti_min / 60) + ((float) RTime.ti_sec / 3600);

        for (i=0;i<PrgNumInM; i++)
        {
            DecTimeStart = ExMast[i].sora + ((float)ExMast[i].smin / 60) + ((float)ExMast[i].ssec / 3600);
            DecTimeStop = ExMast[i].eora + ((float)ExMast[i].emin / 60) + ((float)ExMast[i].esec / 3600);
            if((DecActTime > DecTimeStart) && (DecActTime < DecTimeStop)) 
            //if(ExMast[i].sora == (int) RTime.ti_hour &&
                    //ExMast[i].smin <= (int) RTime.ti_min)        
                {
                    
                    PrgNumExe = i;
                }
        }

        break;

    case 1: // MASTERSZA Mode 1
    /************************************************************************/
        GetDateTime(&RDate, &RTime, &today);

//      gettime(&RTime);
        for (i=0;i<PrgNumInM; i++)
        {
            if((int) RTime.ti_hour <= 12)
            {
            //Actual SZA between Start SZA and End SZA
                if ( ((int)(S_zenetr * 100) < (int)(ExMast[i].ssza * 100))
                    && ((int)(S_zenetr * 100) > (int)(ExMast[i].esza * 100)) )
                        PrgNumExe = i;
                
            }
            if((int) RTime.ti_hour > 12)
            {
                if ( ((int)(S_zenetr * 100) > (int)(ExMast[i].ssza * 100))
                    && ((int)(S_zenetr * 100) < (int)(ExMast[i].esza * 100)) )
                {
                    PrgNumExe = i;
                }
            }
        }
        break;
    /************************************************************************/
    case 2: // SZAMODE 
        for (i=0;i<PrgNumInM; i++)
        {
            if ( ((int)(S_zenetr * 100) > (int)(ExMast[i].minsza * 100))
                && ((int)(S_zenetr * 100) < (int)(ExMast[i].maxsza * 100)) )                    
            {
                    PrgNumExe = i;
            }
        }
        break;

    }

    return PrgNumExe;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ChkWinInstance()

int ChkWinInstance	(	char *	buff,
		MOBJECT	obj
	)

Definition at line 2153 of file DAS_Spat.c.

References MShellRaise().

Referenced by DB_KeyB_CB(), and DB_PasWd().

{

    HWND    wtest;
//  char str[1024];

    wtest = FindWindow(NULL, buff);
    if(wtest != NULL)
    {
        //sprintf(str,"'%s' window is already open!!!!", buff);
        //MMessageDialog("DAS Info", str, "OK",NULL);
        MShellRaise(obj);
        return 1;
                
    }
    else
        return 0;


}

Here is the call graph for this function:

Here is the caller graph for this function:

D_Timing()

int D_Timing	(	int	id,
		long	tout
	)

Definition at line 1477 of file DAS_Spat.c.

References gui::ConfigPanel, das::Gui, configpanel::lbltelap, MLoopWhileEvents(), MObjectSetText(), st, WDT_flagstop, and WDT_func().

Referenced by WDT_CB().

{
    unsigned long   st, et, x;
    char buf[80];

    st = GetTickCount();
    do
    {
        et = GetTickCount();
        x = labs(et - st);
        MLoopWhileEvents(0);
            if((x % 10) == 0 && x > 0)
            {
                sprintf(buf, "%.1lf", (double)fabs((tout-(double)(labs(et - st) ))/1000.0 ));
                MObjectSetText(DAS.Gui.ConfigPanel.lbltelap, buf);
            }
        if (WDT_flagstop) 
        {
            WDT_func(0);
            return 0;
        }
    }while((labs(et - st) < tout) && (WDT_flagstop == 0));
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DB_HelpCB()

int DB_HelpCB	(	MOBJECT	o,
		void *	od,
		void *	ad
	)

Help Callback
Create the help in the predefined WEB Browser.

Definition at line 881 of file DAS_Spat.c.

References _MAX_PATH, bil::DFILEM, DI_FileExist(), and d_fileman::HOMEDIRECTORY.

Referenced by AboutCB(), BuildShell(), HlpTopCB(), and MDCreate_CP().

{
    int er;
    char str[_MAX_PATH];
    char buf[_MAX_PATH];
/*  er = MMessageDialog("?", "Informations ?", "Yes", "No", NULL);
    if (!er) 
        return 1;
    return 0;
*/
    //build the help file name
    sprintf(str, "%s\\Help\\html\\chm\\DAS.chm",BIL.DFILEM.HOMEDIRECTORY);

    //check for the existence of the hh.exe int the winnt dir
    if(DI_FileExist("C:\\WINNT\\hh.exe")) // DI_FileExist --> Return: 1 if PATH exist, else return 0
    {
        sprintf(buf, "C:\\WINNT\\hh.exe %s",str); 
        er = WinExec(buf, SW_SHOWMAXIMIZED);
    }
    else if(DI_FileExist("C:\\Windows\\hh.exe"))
    {
        sprintf(buf, "C:\\Windows\\hh.exe %s",str);
        er = WinExec(buf, SW_SHOWMAXIMIZED);
    }
    else
    {
        sprintf(buf, "%s\\Help\\html\\index.html",BIL.DFILEM.HOMEDIRECTORY);
        system(buf);
    }

    return 0;
    
}

Here is the call graph for this function:

Here is the caller graph for this function:

DB_InfCB()

int DB_InfCB	(	MOBJECT	o,
		void *	od,
		void *	ad
	)

Inf Callback
Create the Inf shell.

Definition at line 915 of file DAS_Spat.c.

References _MAX_PATH, bil::DFILEM, DI_FileExist(), and d_fileman::HOMEDIRECTORY.

Referenced by MDCreate_CP().

{
    int er;
    char str[_MAX_PATH];
    char buf[_MAX_PATH];
/*  er = MMessageDialog("?", "Informations ?", "Yes", "No", NULL);
    if (!er) 
        return 1;
    return 0;
*/
    //build the help file name
    sprintf(str, "%s\\Help\\html\\chm\\DAS.chm",BIL.DFILEM.HOMEDIRECTORY);

    //check for the existence of the hh.exe int the winnt dir
    if(DI_FileExist("C:\\WINNT\\hh.exe")) // DI_FileExist --> Return: 1 if PATH exist, else return 0
    {
        sprintf(buf, "C:\\WINNT\\hh.exe %s",str); 
        er = WinExec(buf, SW_SHOWMAXIMIZED);
    }
    else if(DI_FileExist("C:\\Windows\\hh.exe"))
    {
        sprintf(buf, "C:\\Windows\\hh.exe %s",str);
        er = WinExec(buf, SW_SHOWMAXIMIZED);
    }
    else
    {
        sprintf(buf, "%s\\Help\\html\\index.html",BIL.DFILEM.HOMEDIRECTORY);
        system(buf);
    }

    return 0;
    
}

Here is the call graph for this function:

Here is the caller graph for this function:

DB_SelButt_CB()

void DB_SelButt_CB	(	MOBJECT	obj,
		MKeyEvent *	pe,
		void *	a_data
	)

Definition at line 858 of file DAS_Spat.c.

References ESC, MKeyEvent::keycode, on, SPACEBAR, and Status().

Referenced by BuildMainShell().

{
    int     c = (int) a_data;
    switch (pe->keycode)
    {

        case ESC:
        on = 0;
        Status("PROGRAM HALTED");
        break;


        case SPACEBAR:
        on = 1;
        Status(" ");

        break;


    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

DemoInitMotor()

void DemoInitMotor

(

void

)

Definition at line 1047 of file DAS_Spat.c.

References controlpanel::Albl_LS, optionini::amsprogbar, gui::ContrPanel, D_Positioning(), D_VRange(), das::DOption, paramini::EqType, GASCODNG1, GASCODNG2, GASCODNG3, GASCODNG4, das::Gui, controlpanel::LedSM, mige::linked, LookforWl_X(), das::MIGE, Mir_Code, Mir_CodeTropo, MObjectSetText(), MPixmapSetImageFile(), das::Paramini, FilterWheelSt::Pos, MirrorSt::Pos, ZenithSt::Pos, AzimuthSt::Pos, SPATRAM2, SPATRAM3, SPATRAMPLUS, st, Status(), TROPOGAS, and GratingSt::Wl.

Referenced by InitCCD_AMS().

{

    char    buf[80];
    unsigned long   st;

    
    //Simulate home mirror
    /*************************************************/
    MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[0][0], "SYS\\ledoff.bmp");
    sprintf(buf, "%s", "Homing");
    MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[0], buf);     
    Status("Home for Mirror...");

    st = GetTickCount();

    if(DAS.DOption.amsprogbar)
        D_VRange("Homing Mirror",0, 255, 0, 0);

    D_Positioning(DAS.Gui.ContrPanel.Albl_LS[0], 1, 1000);

    if(DAS.DOption.amsprogbar)
        D_VRange(NULL, 100, 0,0,0);

    MIS.Pos = 0;
        if (DAS.Paramini.EqType == TROPOGAS || DAS.Paramini.EqType == SPATRAM3 || DAS.Paramini.EqType == GASCODNG4 )
        sprintf(buf, "%s",Mir_CodeTropo[MIS.Pos]);
    else
        sprintf(buf, "%s",Mir_Code[MIS.Pos]);

    MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[0], buf);     
    MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[0][0], "SYS\\ledGreen.bmp"); 
    Status("Home for Mirror..DONE");
    /**************************************************/
    //Simulate home grating
    MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[0][1], "SYS\\ledoff.bmp");
    sprintf(buf, "%s", "Homing");
    MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[1], buf);     
    Status("Home for Grating...");

    st = GetTickCount();

    if(DAS.DOption.amsprogbar)
        D_VRange("Homing Grating",0, 255, 255, 0);

    D_Positioning(DAS.Gui.ContrPanel.Albl_LS[1], 1, 1000);

    if(DAS.DOption.amsprogbar)
        D_VRange(NULL, 100, 0,0,0);

    GRS.Wl = LookforWl_X(4358);//Lookfor4358();
    sprintf(buf, "%d", 4358);
    MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[1], buf);     
    MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[0][1], "SYS\\ledGreen.bmp"); 
    Status("Home for Grating..DONE");

    /**************************************************/
    //Simulate home filter wheel
    MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[1][0], "SYS\\ledoff.bmp");
    sprintf(buf, "%s", "Homing");
    MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[2], buf);     
    Status("Home for Filter Wheel...");

    st = GetTickCount();

    if(DAS.DOption.amsprogbar)
        D_VRange("Homing Filter Wheel",0, 0, 0, 255);

    D_Positioning(DAS.Gui.ContrPanel.Albl_LS[2], 1, 1000);

    if(DAS.DOption.amsprogbar)
        D_VRange(NULL, 100, 0,0,0);

    FWS.Pos = 0;
    sprintf(buf, "%s", "NULL");
    MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[2], buf);     
    MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[1][0], "SYS\\ledGreen.bmp"); 
    Status("Home for Filter Wheel..DONE");

    if(DAS.Paramini.EqType == TROPOGAS||
        DAS.Paramini.EqType == SPATRAMPLUS ||
        DAS.Paramini.EqType == GASCODNG1 ||
        DAS.Paramini.EqType == GASCODNG2 ||
        DAS.Paramini.EqType == GASCODNG3 ||
        DAS.Paramini.EqType == GASCODNG4 ||
        DAS.Paramini.EqType == SPATRAM2  ||
        DAS.Paramini.EqType == SPATRAM3)
    {
        if(DAS.MIGE.linked == 1)
        {
            /**************************************************/
            //Simulate home Zenith
            MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[2][0], "SYS\\ledoff.bmp");
            sprintf(buf, "%s", "Homing");
            MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[4], buf);     
            Status("Home for Zenith Axis...");

            st = GetTickCount();

            if(DAS.DOption.amsprogbar)
                D_VRange("Homing Zenit Axis",0, 0, 128, 255);

            D_Positioning(DAS.Gui.ContrPanel.Albl_LS[4], 1, 1000);

            if(DAS.DOption.amsprogbar)
                D_VRange(NULL, 100, 0,0,0);

            ZST.Pos = 0;
            sprintf(buf, "%s", "0");
            MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[4], buf);     
            MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[2][0], "SYS\\ledGreen.bmp"); 
            Status("Home for Zenith Wheel..DONE");

    /**************************************************/
    //Simulate home Azimuth
    MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[2][1], "SYS\\ledoff.bmp");
    sprintf(buf, "%s", "Homing");
    MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[5], buf);     
    Status("Home for Azimuth Axis...");

    st = GetTickCount();

    if(DAS.DOption.amsprogbar)
        D_VRange("Homing Azimuth Axis",0, 128, 128, 255);

    D_Positioning(DAS.Gui.ContrPanel.Albl_LS[5], 1, 1000);

    if(DAS.DOption.amsprogbar)
        D_VRange(NULL, 100, 0,0,0);

    AST.Pos = 0;
    sprintf(buf, "%s", "0");
    MObjectSetText(DAS.Gui.ContrPanel.Albl_LS[5], buf);     
    MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[2][1], "SYS\\ledGreen.bmp"); 
    Status("Home for Azimuth..DONE");
        }
    else
    {
        MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[2][1], "SYS\\ledoffg.bmp");
        MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[2][0], "SYS\\ledoffg.bmp");
    }
    }
    else
    {
        MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[2][1], "SYS\\ledoffg.bmp");
        MPixmapSetImageFile(DAS.Gui.ContrPanel.LedSM[2][0], "SYS\\ledoffg.bmp");


    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

ExMaster()

int ExMaster	(	int	m,
		int	mode
	)

Definition at line 739 of file DAS_Spat.c.

References delay(), bil::DFILEM, d_fileman::HOMEDIRECTORY, MMessageDialog(), master::prg, PRG_Check(), PRGMAXNUM, PrgNumInM, ReadLine(), SaveCnt, Status(), SZAMASTERM, SZAMODE, TEMPORIZED, and TESTSZAMODE.

Referenced by SZA_FirstCalc().

{
    FILE    *fd;
    char    buf[MAX_PATH];
    int i,fn, er;

    if(m == 0) return 0;

    if (mode == TEMPORIZED)
    {
        fd = fopen("MASTER", "rt");
        if(fd == NULL) return -1;
        //Read 3 line of comments
        ReadLine(buf, 80, fd);
        ReadLine(buf, 80, fd);
        ReadLine(buf, 80, fd);
        do
        {
        //Read the start time (hour and minutes), the end time and the PRG file to be executed - 
        //format:HHs MMs HHe MMe filename.PRG (es. 15 45 16 45 Test.prg)
            fscanf(fd, "%d%d%d%d%d%d%s", &ExMast[PrgNumInM].sora, &ExMast[PrgNumInM].smin,&ExMast[PrgNumInM].ssec,
                     &ExMast[PrgNumInM].eora, &ExMast[PrgNumInM].emin, &ExMast[PrgNumInM].esec,
                     &ExMast[PrgNumInM].prg);

            //PrgNum++;
            PrgNumInM++;
            SaveCnt = 1;
            fgets(buf, 80, fd);

        }while(!feof(fd) && PrgNumInM < PRGMAXNUM);
        fclose(fd);
    }
    if (mode == SZAMASTERM)
    {
        fd = fopen("MASTERSZA", "rt");
        if(fd == NULL) return -2;
        do
        {
        //Read the start and end values for SZA and the PRG file to be executed
        //format:SZAs SZAe filename.PRG (es. 85.00 95.00 Test.prg
            fscanf(fd, "%f %f %s", &ExMast[PrgNumInM].ssza, &ExMast[PrgNumInM].esza, &ExMast[PrgNumInM].prg);

            PrgNumInM++;
            SaveCnt = 1;
            fgets(buf, 80, fd);

        }while(!feof(fd) && PrgNumInM < PRGMAXNUM);
        fclose(fd);
    }

    if (mode == SZAMODE)
    {
        fd = fopen("SZAPRG", "rt");
        if(fd == NULL) return -3;
        do 
        {
        //Read the Min and Max SZA and the PRG file to be executed
        //format:MinSZA (xxx.xx) MaxSZA (yyy.yy)  filename.PRG (es. 85.00 95.00 Test.prg)
            fscanf(fd, "%f %f %s", &ExMast[PrgNumInM].minsza, &ExMast[PrgNumInM].maxsza, &ExMast[PrgNumInM].prg);

            PrgNumInM++;
            SaveCnt = 1;
            fgets(buf, 80, fd);

        } while(!feof(fd) && PrgNumInM < PRGMAXNUM);    
        fclose(fd);

    }
    if (mode == TESTSZAMODE)
    {
        fd = fopen("SZAPRG", "rt");
        if(fd == NULL) return -3;
        do 
        {
        //Read the Min and Max SZA and the PRG file to be executed
        //format:MinSZA (xxx.xx) MaxSZA (yyy.yy)  filename.PRG (es. 85.00 95.00 Test.prg)
            fscanf(fd, "%f %f %s", &ExMast[PrgNumInM].minsza, &ExMast[PrgNumInM].maxsza, &ExMast[PrgNumInM].prg);

            PrgNumInM++;
            SaveCnt = 1;
            fgets(buf, 80, fd);

        } while(!feof(fd) && PrgNumInM < PRGMAXNUM);

        
        fclose(fd);

    }   

    //Check Existence of all PRG files
    for (i=0; i<PrgNumInM; i++)
    {
        sprintf(buf, "%s\\%s",BIL.DFILEM.HOMEDIRECTORY, ExMast[i].prg);
        fn = access(buf, 0);
        if (fn == -1)
        {
            sprintf(buf, "File %s\\%s NOT Encountred.\n Please Check!!!!!",BIL.DFILEM.HOMEDIRECTORY, ExMast[i].prg);
            MMessageDialog("DAS Information", buf, " Ok ", NULL);  

        }
        else
        {
            Status("PRG Files encountered");
            delay(1000);
        }   

    }

    //Check the é.PRGs Syntax
    for (i=0; i<PrgNumInM; i++)
    {
        er = PRG_Check(0, ExMast[i].prg);
    }



    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Fetch()

int Fetch

(

void

)

Reads the key-word in PRG Files
.

Returns

int = keyword's code (see Automatic and Unattended Mode)

Definition at line 298 of file DAS_Spat.c.

References KeyCode, PrgCnt, and Program.

Referenced by D_AutoExecution(), and PRG_Check().

{
    //Read the key-word
    char    cmd[16];
    char buf[16];
    int             c;
    int lencmd = 0;
    int NumCommands;
    int PosComm = 0;

    
    
    //if (Program[PrgCnt]!= 10)
    //0x0a = line feed
    //0x0d = carriage return
    if (Program[PrgCnt]!= 10)
    {   
        sscanf(&Program[PrgCnt], "%s", cmd);
        sprintf (buf, "%s", cmd);
//      Status(buf);

    //******************************
    //Added on 15/01/2005 Remember to remove the commands
    // "PrgCnt += X" in the E_xxxxxx Functions 
        lencmd =strlen(cmd);
        PrgCnt += lencmd;
        NumCommands = sizeof(KeyCode)/sizeof (KeyCode[0]);
    //****************************
        for(c = 0; c < NumCommands; c++)
        {
            if(strcmp(cmd, KeyCode[c]) == 0)
            {
                PosComm = c + 1;
                break;
            }
            else
                PosComm = 0;

        }
        return PosComm;

    }
    else
    {
        
        return 2000;
    }   
        
}

Here is the caller graph for this function:

InitCCD_AMS()

int InitCCD_AMS	(	int	mod,
		int	emode
	)

Definition at line 1793 of file DAS_Spat.c.

References flag::AMSPres, CCD_Error(), D_WriteInitLog(), DB_InitCamera(), DB_InitMotor(), DB_KB_ButtonActive(), DBDEMO, DC_ErrorMessage(), delay(), DemoInitMotor(), FLAG, GASCODNG1, GASCODNG2, GASCODNG3, GASCODNG4, das::Gui, HiresPS(), LIS_, LoadDB_DispCoeff(), MANUAL, MDCreateWaitShell(), MShellRaise(), das::Nova, NOVA7892, NOVA945GSE, NOVA_Out(), PeltierPS(), PRGFILE, shells::Sh_Main, gui::Shells, ShutterOpening(), SPATRAM, SPATRAM2, SPATRAM3, SPATRAMPLUS, Status(), SZAMASTERM, SZAMODE, TEMPORIZED, TESTAMS, TESTSZAMODE, TROPOGAS, and nova::type.

Referenced by SZA_FirstCalc().

{

    int er;
    char buf[1024];


    ShutterOpening(0);

    if(mod == TROPOGAS )
    {
        
        //1) Init AMS
        //2) Switch-on Power Supply for CCD Camera
        //3) Init Camera
        //4) Switch-on Power Supply for OMU Peltier (24V)
        
        /********************************************************
        *****************   INIT AMS        *********************
        *********************************************************/
        
        if ((emode == TEMPORIZED) | (emode == PRGFILE) | (emode == TESTAMS) | (emode == MANUAL) | (emode == SZAMASTERM)| (emode == SZAMODE))
        //if ((emode == TEMPORIZED) | (emode == PRGFILE) | (emode == TESTAMS) | (emode == MANUAL) )
        {
            //Disattiva i pulsanti sulla keyboard
            DB_KB_ButtonActive(0);
            //  Inizializza ed esegue l'home per i motori
            er = DB_InitMotor(1);
            //Attiva i pulsanti sulla keyboard
            DB_KB_ButtonActive(1);
        }
        else if((emode == DBDEMO) || (emode == TESTSZAMODE )) 
        {
            DemoInitMotor();
        }

        //Switch on the HIRES Power supply
    if (emode != TESTAMS)
    {
            if(!FLAG.AMSPres)
                HiresPS(1);

                Status ("Waiting 1 Sec.");
                delay(1000);
                Status("Init CCD Camera");
        //Init Camera
        /********************************************************
        *****************   INIT CAMERA     *********************
        *********************************************************/
        DB_KB_ButtonActive(0);
        // Init HIRES_IV and MARCONI CCD sensor
        er = DB_InitCamera(0);
        if(er)
        {
            if ((er > 0) & (er < 50))
            {
                sprintf(buf,DC_ErrorMessage(er));
                CCD_Error(buf);
            }
            else
                sprintf(buf,"Error %d in DB_InitCamera", er);

            Status(buf);
            //sprintf(buf," Camera NOT Found");
            D_WriteInitLog(buf);
        }
        else
        {
            sprintf(buf," Camera found");
            D_WriteInitLog(buf);
        }
    }
        DB_KB_ButtonActive(1);

        //The focus is taken by the Control Panel
        MShellRaise(DAS.Gui.Shells.Sh_Main);
        /******************************************************/
        // Load the dispersion coefficient for DOAS Use
        er = LoadDB_DispCoeff();
        /*******************************************************/
    
        //Switch on the 24V Power Supply
        if (emode != TESTAMS)
            if(!FLAG.AMSPres)
            {
                PeltierPS(1);
                Status ("Waiting 1 Sec.");
                delay(1000);
            }   
    }
    else if((mod == LIS_) | (mod == SPATRAM))// for SPATRAM, LIS
    {
        //1) Init Camera
        //2) Init AMS
        /********************************************************
        *****************   INIT CAMERA     *********************
        *********************************************************/
        DB_KB_ButtonActive(0);
        // Init HIRES_IV and MARCONI CCD sensor
        er = DB_InitCamera(0);
        if(er)
        {
            if ((er > 0) & (er < 50))
            {
                sprintf(buf,DC_ErrorMessage(er));
                CCD_Error(buf);
            }
            else
                sprintf(buf,"Error %d in DB_InitCamera", er);

            Status(buf);
            //sprintf(buf," Camera NOT Found");
            D_WriteInitLog(buf);
        }
        else
        {
            sprintf(buf," Camera found");
            D_WriteInitLog(buf);
        }
        DB_KB_ButtonActive(1);

        //The focus taken by the CP shell
        MShellRaise(DAS.Gui.Shells.Sh_Main);
        /******************************************************/
        // Load the dispersion coefficient for DOAS Use
        er = LoadDB_DispCoeff();
        /*******************************************************/
        /********************************************************
        *****************   INIT AMS        *********************
        *********************************************************/
        if ((emode == TEMPORIZED) | (emode == PRGFILE) | (emode == TESTAMS) | (emode == MANUAL)| (emode == SZAMASTERM)| (emode == SZAMODE))
        {
            //Disattiva i pulsanti sulla keyboard
            DB_KB_ButtonActive(0);
            //  Inizializza ed esegue l'home per i 3 motori
            er = DB_InitMotor(1);
            //Attiva i pulsanti sulla keyboard
            DB_KB_ButtonActive(1);
        }
        else if((emode == DBDEMO)||(emode == TESTSZAMODE))
        {
            DemoInitMotor();
        }
    }
    else if(mod == GASCODNG2    || 
            mod == GASCODNG3    || 
            mod == GASCODNG4    ||
            mod == SPATRAM3     ||
            mod == SPATRAM2     ||
            mod == SPATRAMPLUS  ||
            mod == GASCODNG1 )// for GASCODNG1, NG2, NG3, SPATRAM2, SPATRAMPLUS
    {
        //0) Switch ON Hires and AMS Power supply through the NOVA Digital Output port
        //1) Init Camera
        //2) Init AMS
        //3) Switch ON 24V Power supply (for Peltier) through the NOVA Digital Output port

        /*********************************************************/
        //switch on the 12 Volt and Hires Power Supply
        /*********************************************************/
        if (DAS.Nova.type == NOVA7892)
        {
            er = NOVA_Out(DAS.Nova.type, 6); //0110  bin
            delay(1000);
        }
        if (DAS.Nova.type == NOVA945GSE)
        {
            er = NOVA_Out(DAS.Nova.type, 9); //1001 bin
            delay(3000);
        }
/*
        nb = 2;
        er = ChkDigIO(DAS.Nova.DigOut, nb);
        if (er == 1)
            DAS.Nova.DigOut &= ~((unsigned char) pow(2,(double)(nb)));
        else if (er == 0)
            DAS.Nova.DigOut |= (unsigned char) pow(2,(double)(nb));

        er = NOVA_Out(DAS.Nova.type, DAS.Nova.DigOut);
*/
        //OutByte(576, DAS.Nova.DigOut);
        
        if(mod == SPATRAM2 || mod == GASCODNG4 || mod== SPATRAM3)
            MDCreateWaitShell();
        /********************************************************
        *****************   INIT CAMERA     *********************
        *********************************************************/
        DB_KB_ButtonActive(0);
        // Init HIRES_IV and MARCONI CCD sensor
        er = DB_InitCamera(0);
        if(er)
        {
            if ((er > 0) & (er < 50))
            {
                sprintf(buf,DC_ErrorMessage(er));
                CCD_Error(buf);
            }
            else
                sprintf(buf,"Error %d in DB_InitCamera", er);

            Status(buf);
            //sprintf(buf," Camera NOT Found");
            D_WriteInitLog(buf);
        }
        else
        {
            sprintf(buf," Camera found");
            D_WriteInitLog(buf);
        }
        DB_KB_ButtonActive(1);

        //The focus taken by the CP shell
        MShellRaise(DAS.Gui.Shells.Sh_Main);
        /******************************************************/
        // Load the dispersion coefficient for DOAS Use
        er = LoadDB_DispCoeff();
        /*******************************************************/
        /********************************************************
        *****************   INIT AMS        *********************
        *********************************************************/
        if ((emode == TEMPORIZED) | (emode == PRGFILE) | (emode == TESTAMS) | (emode == MANUAL)| (emode == SZAMASTERM)| (emode == SZAMODE))
        {
            //Disattiva i pulsanti sulla keyboard
            DB_KB_ButtonActive(0);
            //  Inizializza ed esegue l'home per i 3 motori
            er = DB_InitMotor(1);
            //Attiva i pulsanti sulla keyboard
            DB_KB_ButtonActive(1);
        }
        else if((emode == DBDEMO) | (emode == TESTSZAMODE))
        {
            DemoInitMotor();
        }
        
        /*********************************************************/
        //switch on the 24 Volt Power Supply
        /*********************************************************/
/*          nb = 1;

        er = ChkDigIO(DAS.Nova.DigOut, nb);
        if (er == 1)
            DAS.Nova.DigOut &= ~((unsigned char) pow(2,(double)(nb)));
        else if (er == 0)
            DAS.Nova.DigOut |= (unsigned char) pow(2,(double)(nb));
        er = NOVA_Out(DAS.Nova.type, DAS.Nova.DigOut);
*/
        //OutByte(576, DAS.Nova.DigOut);
        delay(1000);

    }
    //return er;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

InitColors()

void InitColors

(

void

)

Definition at line 3371 of file DAS_Spat.c.

References mtcl::black, dil::Cfg, bil::DPLOT, d_view::DrawBG, MAllocColor(), MGetNColors(), MPaletteMode(), cfg::NColors, PaletteMode, mtcl::PLColor, and mtcl::white.

Referenced by MGUIMain().

{
    
    PaletteMode = MPaletteMode();
    DIL.Cfg.NColors = MGetNColors();

    // Colors allocation ( for compatibility with old version)
    BIL.DPLOT.DrawBG = MAllocColor(220, 220, 220);
    MTCL.PLColor[0] = MTCL.black;
    MTCL.PLColor[1] = MTCL.white;
}

Here is the call graph for this function:

Here is the caller graph for this function:

InitDefaultOptions()

void InitDefaultOptions

(

void

)

Definition at line 3448 of file DAS_Spat.c.

References optionini::avgmode, optionini::darkremove, optionini::darksource, flag::DeltaSZA, das::DOption, flag::ExeDSZA, optionini::filename, FLAG, das::Flag, optionini::ftpbackup, optionini::hlineafter, optionini::hlinebefore, optionini::imgtype, optionini::pixcorr, flag::plotW, flag::plotYRange, optionini::resetFreq, optionini::resetType, optionini::savingmode, flag::settempvar, flag::WindowsReboot, and flag::Wl.

{

    // Assign the default values
    DAS.DOption.savingmode = 1; //Flag to set saving mode: 0=ASCII, 1=Binary 
    DAS.DOption.filename = 1; //Flag to set file name mode 0=free choice, 1 = automatic file names
    DAS.DOption.imgtype = 0; //Flag to set image mode 0=Mono, 1 = RGB
    DAS.DOption.pixcorr = 1; //Flag to set defective pixel correction: 0=NOT Corrected, 1=Corrected
    DAS.DOption.avgmode = 1;//Flag to set Averaging mode: 0 = Repeat measurements for fixed number,
                            //                           1 = Repeat measurements for fixed time 
    DAS.DOption.darkremove = 1; // Flag to set Dark Removal from measurements; 0 = No Dark Removal
                            //                                          1 = Dark Removal    
    DAS.DOption.darksource = 1; //Flag to set Dark source: 0 = Blind Pixels
                        //                      1 = Full Frame 
    FLAG.Wl = 1; //Flag for X scale: 0 = Pixel;1 = WL [A]; 2 = WL [nm] 
    DAS.Flag.plotW = 0;
    //FLAG.plotW = 0; //Flag for the plot display: 0 = NO Plot; 1 = PLOT
    FLAG.plotYRange = 1; //0 = full range; 1 = min/max
    FLAG.settempvar = 0; //0 = Fixed CCD Temp, 1 = CCD Temp VS sza
    DAS.DOption.hlinebefore = 1; //Number of HiddenLines before the central line in Plot 
    DAS.DOption.hlineafter = 1; //Number of HiddenLines after the central line in Plot 
    DAS.DOption.ftpbackup = 0;
    DAS.Flag.DeltaSZA = 0; //flag for continuos measurements (0) or delta sza meas (1)
    DAS.Flag.ExeDSZA = 1;//flag for the activation of measurement in case of DeltaSZA measurements
    DAS.DOption.resetType = 1; //Reset type 1=day(s), 0=hour(s)
    DAS.DOption.resetFreq = 7; //Reset frequency
    DAS.Flag.WindowsReboot = 0; //Flag that became 1 when Windows reboot is setted (\ref SetWinowsReset)

}

InitFlags()

void InitFlags

(

void

)

Definition at line 952 of file DAS_Spat.c.

References stepm::Addr, flag::ADPC104, flag::ADTempTest, ADTESTER, AMS1, AMS2, AMS3, flag::AMS_H, optionini::amsprogbar, bil::BLENS, omuthr::CoolCnt, nova::DigIn, nova::DigOut, MirrorSt::Dir, das::DOption, GratingSt::dp, flag::exec, flag::extlamp, flag::extshutter, doas::FFTFilter, flag::fileprg, FLAG, das::Flag, tools::FlagDisplay, tools::FlagFilter, tools::FlagShutter, tools::FlagSpikes, dpwd::FlgSh_PWD, flag::manhormeas, das::Marconi, das::Nova, MirrorSt::Off, marconi::Offset, flag::OMU_TempReached, adtester::OutputMode, omuthr::PID_kd, omuthr::PID_ki, omuthr::PID_kp, omuthr::PID_On, blens::Pix, MirrorSt::Pos, ZenithSt::Pos, PrgFile, marconi::ReachTemp, optionini::resetEnabled, optionini::resetFreq, optionini::resetType, flag::settemp070, flag::settemp7080, flag::settemp8095, stepm::SM_A, stepm::SM_B, das::StepM, flag::sza, das::Tools, flag::UPS_Battery, flag::VMRsf, nova::WDT_TOUT, and flag::WindowsReboot.

Referenced by MGUIMain().

{


    
    ZST.Pos = 0;


    FLAG.ADPC104 = 0; //Flag for PC104 Presence

    DPWD.FlgSh_PWD = 1; //PassWord Flag

    PrgFile[0] = 0; //PRG File
  
    DAS.Marconi.ReachTemp = 0;

    GRS.dp = 1500; //dead pulse for grating backlash recovery


    ADTESTER.OutputMode = 0;    // for the AD Converter
    
    BIL.BLENS.Pix = 1; // for the lens tool

    MIS.Pos = 0; //Init Mirror Position
    MIS.Dir = 0; //Init Mirror Direction
    MIS.Off = 0; //Init Mirror Offset

    DAS.StepM.SM_A = 0;
    DAS.StepM.SM_B = 1;
    DAS.StepM.Addr[AMS1] = 0;
    DAS.StepM.Addr[AMS2] = 1;
    DAS.StepM.Addr[AMS3] = 2;
/*
    DAS.StepM.SM1 = 0;      //Motor A (su Y11) InputMirror
    DAS.StepM.SM2 = 1;      //Motor B (su Y12) Grating
    DAS.StepM.SM3 = 2;      //Motor A (su Y11) FilterWheel
    DAS.StepM.SM4 = 3;      //Not Available
    DAS.StepM.SM5 = 4;      //Motor A (su Y11) Zenith
    DAS.StepM.SM6 = 5;      //Motor B (su Y12) Azimuth
*/
    FLAG.sza = 0;
    FLAG.exec = 1;
    FLAG.settemp8095 = 1;
    FLAG.settemp7080 = 1;
    FLAG.settemp070 = 1;
    
    FLAG.fileprg = 0; //Flag indicating the execution of a PRG file: = 0 --> No PRG File; = 1 --> PRG file in execution
    FLAG.ADTempTest = 0;
    FLAG.VMRsf = 0;

    TOOLS.FlagFilter = 0;
    TOOLS.FlagSpikes = 0;
    TOOLS.FlagDisplay = 2;

    DOAS.FFTFilter = 5;

    FLAG.OMU_TempReached = 0;

    
//  pdas->pOMUTHR.->CoolCnt = 1;
//  pdas->pOMUTHR.->PID_On = 1;
    
    OMUTHR.CoolCnt = 1;
    OMUTHR.PID_On = 1;

    OMUTHR.PID_kp = 38;
    OMUTHR.PID_ki = 5;
    OMUTHR.PID_kd = (float) 0.008;

    FLAG.extshutter = 0; // 0 = external shutter open; 1 = external shutter closed

    //on 15/06/2005 only the shutter channel is used
    FLAG.extlamp = 0;   // 0 = external lamp OFF; 1 = external lamp ON
    FLAG.manhormeas = 0;
    FLAG.AMS_H = 0;
    DAS.DOption.amsprogbar =0;
    DAS.Nova.DigOut = 0;
    DAS.Nova.DigIn = 0;
    DAS.Tools.FlagShutter = 0;

    DAS.Marconi.Offset = 270;

    DAS.Flag.UPS_Battery = 0;

    DAS.Nova.WDT_TOUT = 250;
    DAS.DOption.resetEnabled = 1;
    DAS.DOption.resetType = 1; //Reset period type 1=day(s), 0=hour(s)
    DAS.DOption.resetFreq = 7; //Reset period interval
    DAS.Flag.WindowsReboot = 0; //Flag that became 1 when Windows reboot is setted (\ref SetWinowsReset)


    
}

Here is the caller graph for this function:

InitTempAD()

int InitTempAD

(

int

mod

)

Definition at line 2681 of file DAS_Spat.c.

References AllocFloatMat(), omuthr::CoolPT, D_InitPC104(), D_WriteInitLog(), DB_Pause(), MANUAL, das::Paramini, PRGFILE, SZAMASTERM, SZAMODE, TEMPORIZED, omuthr::Temptemp, TESTAD, paramini::TPelt, and WinRes().

Referenced by SZA_FirstCalc().

{
    
    int er = 0;
    char buf[64];
    int adsts;
    
    if ((mod == TEMPORIZED) |
        (mod == PRGFILE)    |
        (mod == TESTAD)     |
        (mod == MANUAL)     |
        (mod == SZAMASTERM) |
        (mod == SZAMODE))
    {
        er = D_InitPC104();
        if(er)
        {
            sprintf(buf," DMM NOT Found");
            D_WriteInitLog(buf);

            adsts = 1;
            
            //Pause Execution
            DB_Pause();
            //Windows reset
            WinRes();

        }
        else
        {
            sprintf(buf," DMM Found");
            D_WriteInitLog(buf);
            OMUTHR.Temptemp = AllocFloatMat(16, 4096);//buffer per la normalizzazione delle temperature
            OMUTHR.CoolPT = (float)DAS.Paramini.TPelt * 10;
            adsts = 0;

        }
    }
    else
        adsts = 1;


    return adsts;
}

Here is the call graph for this function:

Here is the caller graph for this function:

LaunchBackTask()

void LaunchBackTask

(

void

)

Launch the DAS Background tasks Common Tasks launched when the DAS MAIN Graphic User Interface is loaded:

• Timer (Task_Timer)
• Reference position for Grating (Task_HomeGrat)
• Write some informations on the 'date'.log file (Task_LOG)

Tasks depending on the Execution Modes:

Returns

void

Definition at line 2624 of file DAS_Spat.c.

References flag::ADPC104, flag::ADTempTest, ids::AUTOEX, AUTOEX_TASK_TIME, ids::CCDTEMP, CCDTEMP_TASK_TIME, flag::exemode, FLAG, das::Flag, GRAT_TASK_TIME, ids::GRATHOME, ids::LISTEMP, LISTEMP_TASK_TIME, ids::LOG, LOG_TASK_TIME, MANUAL, MRefreshTimeout(), PRGFILE, REFRESHTEMP_TASK_TIME, ids::REFRTEMP, SZAMASTERM, SZAMODE, Task_AutoEx(), Task_CCD_Temp(), Task_HomeGrat(), Task_LIS_Temp(), Task_LOG(), Task_REFRESH_Temp(), Task_Timer(), TEMPORIZED, TESTAD, TESTCCD, TESTSZAMODE, ids::TIMER, and TIMER_TASK_TIME.

Referenced by SZA_FirstCalc().

{
    //Timer Task
    MRefreshTimeout(&IDS.TIMER, TIMER_TASK_TIME, Task_Timer, NULL);

    //Home Grating Task
    MRefreshTimeout(&IDS.GRATHOME, GRAT_TASK_TIME, Task_HomeGrat, NULL);

    //Log Task
    MRefreshTimeout(&IDS.LOG, LOG_TASK_TIME, Task_LOG, NULL);

    //Refresh Temperatures Task
    if ((DAS.Flag.exemode == TEMPORIZED)| 
        (DAS.Flag.exemode == PRGFILE)   |
        (DAS.Flag.exemode == TESTAD)    |
        (DAS.Flag.exemode == MANUAL)    |
        (DAS.Flag.exemode == SZAMASTERM)|
        (DAS.Flag.exemode == SZAMODE))
    {
        if(FLAG.ADTempTest == 0)
            MRefreshTimeout(&IDS.REFRTEMP, REFRESHTEMP_TASK_TIME, Task_REFRESH_Temp, NULL);
    }

    if ((DAS.Flag.exemode == TEMPORIZED)|
        (DAS.Flag.exemode == PRGFILE)   |
        (DAS.Flag.exemode == TESTCCD)   |
        (DAS.Flag.exemode == MANUAL)    |
        (DAS.Flag.exemode == SZAMASTERM)|
        (DAS.Flag.exemode == SZAMODE) )
    {
        // CCDTemp Task
        MRefreshTimeout(&IDS.CCDTEMP, CCDTEMP_TASK_TIME, Task_CCD_Temp, NULL);
        
        // PeltierTemp Task
        if((FLAG.ADPC104 == 0) | (FLAG.ADTempTest == 1))
        {
            MRefreshTimeout(&IDS.LISTEMP, LISTEMP_TASK_TIME, Task_LIS_Temp, NULL);
        }

        // Automatic Execution
        MRefreshTimeout(&IDS.AUTOEX, AUTOEX_TASK_TIME, Task_AutoEx, NULL);

    }

    if (DAS.Flag.exemode == TESTSZAMODE)
    {
        // Automatic Execution
        MRefreshTimeout(&IDS.AUTOEX, AUTOEX_TASK_TIME, Task_AutoEx, NULL);

    }

    //WDT (Watch Dog Timer) task
    //MRefreshTimeout(&IDS.WDT, WDT_TASK_TIME, TaskWDT, NULL);

}

Here is the call graph for this function:

Here is the caller graph for this function:

LoadAMS()

int LoadAMS

(

void

)

Definition at line 1201 of file DAS_Spat.c.

References _MAX_PATH, d_fileman::CONFIGDIREQUIPMENT, bil::DFILEM, FlushLine(), stepm::hometype, stepm::multiplier, stepm::NAMS, paramini::Offset, das::Paramini, stepm::power, ReadLine(), stepm::slope, stepm::speed, stepm::step, and das::StepM.

Referenced by SZA_FirstCalc().

{

    FILE    *fs;
    char    str[80];
    int c, i, k;
    
    char    buff[_MAX_PATH];
    
    sprintf(buff, "%s\\AMS.INI", BIL.DFILEM.CONFIGDIREQUIPMENT);
    

    fs = fopen(buff, "r");
    if(fs == NULL) return 1;

    // Header
    ReadLine(str, 80, fs); //###############################################
    ReadLine(str, 80, fs); //#                  AMS.INI                    #
    ReadLine(str, 80, fs); //#    Main configuration file for AMS Devices  #
    ReadLine(str, 80, fs); //###############################################
    ReadLine(str, 80, fs); //# ------------------------------------------- #
    ReadLine(str, 80, fs); //#       by DanBo Date  at Time                #
    ReadLine(str, 80, fs); //# ------------------------------------------- #    

    // Number of AMS
    ReadLine(str, 80, fs);//# Number of AMS                   # 
    fscanf(fs, "%d", &DAS.StepM.NAMS);
    FlushLine(str, 80, fs);

    
    for (i = 0; i < DAS.StepM.NAMS; i++)
    {
        for (k=0; k<2; k++)
        {
        ReadLine(str, 80, fs);//# Input Mirror Stepper Motor - SM1 # 
        ReadLine(str, 80, fs);//# SM1 Power (0 = 0A - 76 = 1.52A) #

        fscanf(fs, "%d", &DAS.StepM.power[i][k]);
        if((DAS.StepM.power[i][k] < 0) | (DAS.StepM.power[i][k] > 76))
            return 2;

        FlushLine(str, 80, fs);
        ReadLine(str, 80, fs);//# SM1 Step (0=400s/r, 1=800s/r,2=1000/sr) #

        fscanf(fs, "%d", &DAS.StepM.step[i][k]);
        if((DAS.StepM.step[i][k] < 0) | (DAS.StepM.step[i][k] > 14))
            return 3;
    
        FlushLine(str, 80, fs);
        ReadLine(str, 80, fs);//# SM1 Slope (0 - 255) #
    
        fscanf(fs, "%d", &DAS.StepM.slope[i][k]);
        if((DAS.StepM.slope[i][k] < 0) | (DAS.StepM.slope[i][k] > 255))
            return 4;

        FlushLine(str, 80, fs);
        ReadLine(str, 80, fs);//# SM1 Speed Hz (PS = 125*(n+1), n=0,1..255) #

        fscanf(fs, "%d", &DAS.StepM.speed[i][k]);
        if((DAS.StepM.speed[i][k] < 0) | (DAS.StepM.speed[i][k] > 255))
            return 5;
        
        FlushLine(str, 80, fs);
        ReadLine(str, 80, fs);//# SM1 Multiplier                            #

        fscanf(fs, "%f", &DAS.StepM.multiplier[i][k]);
        FlushLine(str, 80, fs);


        }
    }
        
        

    // Legge gli offset dei vari stepper
    // ad oggi 9 valori
    ReadLine(str, 80, fs);
    ReadLine(str, 80, fs);
    for(c = 0; c < 9; c++)
        fscanf(fs,"%d" , &DAS.Paramini.Offset[c]);
    FlushLine(str, 80, fs);

    ReadLine(str, 80, fs);
    ReadLine(str, 80, fs);

    for(i = 0; i < DAS.StepM.NAMS; i++)
    {
        for(k = 0; k < 2; k++)
        {
            fscanf(fs,"%d" , &DAS.StepM.hometype[i][k]);
        }
    }
        
    FlushLine(str, 80, fs);


    ReadLine(str, 80, fs);
    fclose(fs);

    return 0;



}

Here is the call graph for this function:

Here is the caller graph for this function:

LoadSetDirs()

void LoadSetDirs

(

void

)

Definition at line 3384 of file DAS_Spat.c.

References _MAX_PATH, d_fileman::CONFIGDIRCOMMON, DAS_Message(), d_fileman::DATADIRECTORY, bil::DFILEM, DI_PathExist(), d_fileman::DIRDCL, d_fileman::HOMEDIRECTORY, and d_fileman::LOGDIR.

Referenced by MGUIMain().

{


    int er;
    char buf[_MAX_PATH];

    /**********************************************************************/
    //Load home Directory
    _getcwd( BIL.DFILEM.HOMEDIRECTORY, _MAX_PATH );
    /**********************************************************************/
    /**********************************************************************/
    //Set LOG Directory
    sprintf(BIL.DFILEM.LOGDIR, "%s\\%s", BIL.DFILEM.HOMEDIRECTORY, "Log" );
    sprintf(buf, "%s\\", BIL.DFILEM.LOGDIR );
    // Check Path Existence
    // Return: 1 if PATH exist, else return 0
    er = DI_PathExist(buf);
    if (!er)
    {
        sprintf(buf,"Path '%s' deos not exist,\nDAS will create the requested folder ", BIL.DFILEM.LOGDIR);
        DAS_Message(buf, 0);
        //er = MMessageDialog ("DAS ERROR ", buf, "OK",NULL);
       if( _mkdir( BIL.DFILEM.LOGDIR ) == 0 ) //Create LOG Folder
       {
            sprintf(buf,"Path '%s' created ", BIL.DFILEM.LOGDIR);
            DAS_Message(buf, 0);
            //MMessageDialog ("DAS inf ", "Path created", "OK",NULL);
       }
    }
    /**********************************************************************/
    /**********************************************************************/
    //Set Data Directory
    sprintf(BIL.DFILEM.DATADIRECTORY, "%s\\%s", BIL.DFILEM.HOMEDIRECTORY, "Data" );
    sprintf(buf, "%s\\", BIL.DFILEM.DATADIRECTORY );
    // Check Path Existence
    // Return: 1 if PATH exist, else return 0
    er = DI_PathExist(buf);
    if (!er)
    {
        sprintf(buf,"Path '%s' deos not exist,\nDAS will create the requested folder ", BIL.DFILEM.DATADIRECTORY);
        DAS_Message(buf, 0);
        //er = MMessageDialog ("DAS ERROR ", buf, "OK",NULL);
        if( _mkdir( BIL.DFILEM.DATADIRECTORY ) == 0 ) //Create DATA Folder
        {
            sprintf(buf,"Path '%s' created ", BIL.DFILEM.DATADIRECTORY);
            DAS_Message(buf, 0);
           //MMessageDialog ("DAS inf ", "Path created", "OK",NULL);
        }
    }

    /**********************************************************************/
    //Set Common Config Directory
    sprintf(BIL.DFILEM.CONFIGDIRCOMMON, "%s\\%s", BIL.DFILEM.HOMEDIRECTORY, "Config" );
    /**********************************************************************/
    /**********************************************************************/
    //Set Camera Select Config Directory
    sprintf(BIL.DFILEM.DIRDCL, "%s\\%s", BIL.DFILEM.HOMEDIRECTORY, "dcl");
    /**********************************************************************/


}

Here is the call graph for this function:

Here is the caller graph for this function:

LoadWlstep()

int LoadWlstep

(

void

)

load the file of the wavelength vs steps

Definition at line 258 of file DAS_Spat.c.

References _MAX_PATH, d_fileman::CONFIGDIREQUIPMENT, bil::DFILEM, FlushLine(), ReadLine(), wav, and wl.

Referenced by MGUIMain().

{
    FILE    *fs;
    char    str[80];
    int c, i;
    char buff[_MAX_PATH];

    sprintf(buff, "%s\\wlstep.ini",BIL.DFILEM.CONFIGDIREQUIPMENT);

    
    fs = fopen(buff, "r");
    if(fs == NULL) return 1;

    // 
    ReadLine(str, 80, fs); //###############################################
    ReadLine(str, 80, fs); //#                  Param.INI                  #
    ReadLine(str, 80, fs); //#    Main configuration file for SPATRAM      #
    ReadLine(str, 80, fs); //#                  equipment                  #
    ReadLine(str, 80, fs); //###############################################
    ReadLine(str, 80, fs); //# ------------------------------------------- #
    ReadLine(str, 80, fs); //#       by DanBo Date  at Time                #

    fscanf(fs, "%d", &c);  //Number of items
    FlushLine(str, 80, fs);
    
    for (i=0;i<c;i++)
    {
        fscanf(fs, "%d %d", &wl[i], &wav[i]); 


    }
    fclose(fs);
     
     
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ManualModeCB()

void ManualModeCB	(	MOBJECT	p,
		void *	od,
		void *	ad
	)

Definition at line 2224 of file DAS_Spat.c.

References flag::exemode, das::Flag, MANUAL, Master, MGUITerm(), MObjectSetBackgroundRGB(), and PrgFile.

Referenced by MDCreateSplashExe().

{

    
    MOBJECT c = (void *)ad;
    

    if (c==0)
    {
        DAS.Flag.exemode = MANUAL;
        Master=0;
        PrgFile[0] = 0;
        MObjectSetBackgroundRGB(p, 1, 255, 0);  
    }
    else
    {
        MObjectSetBackgroundRGB(p, 1, 255, 0);  
        MGUITerm();
        exit(0);

    }
//  MShellUnrealize(c);
//  MShellDestroy(c);
}

Here is the call graph for this function:

Here is the caller graph for this function:

MDCreateSplashExe()

void MDCreateSplashExe

(

)

Definition at line 2267 of file DAS_Spat.c.

References BOTTOM_ALIGN, CENTER_ALIGN, palette::DB_BG, palette::DB_BG_Albl, palette::DB_FG_Plbl, paramini::EqType, flag::exemode, False, das::Flag, GASCODNG1, HELV_LARGE, HELV_MEDIUM, lbl, MANUAL, ManualModeCB(), MCreateColForm(), MCreateLabel(), MCreatePButton(), MCreatePixmapFromFile(), MCreateRowForm(), MCreateShell(), MLoopWhileEvents(), MObjectAlign(), MObjectSetBackgroundRGB(), MObjectSetCompositeHeight(), MObjectSetCompositeWidth(), MObjectSetForegroundRGB(), MObjectSetResize(), MObjectSetShadow(), MObjectSetText(), MObjectSetTransparency(), MPButtonSetCallback(), MShellDestroy(), MShellRealize(), MShellUnrealize(), das::Nova, NOVA_Out(), nowaitsplash, NoWaitSplashCB(), das::Paramini, SF_MODAL, st, TOP_ALIGN, True, nova::type, WS_ETCHED_IN, WS_NONE, and WS_SHADOW_OUT.

Referenced by ChkExeMode().

{

    
    MOBJECT _colform000;
    MOBJECT _rowform000;
    MOBJECT lbl;
    MOBJECT lbl1;
    MOBJECT sh1;
    MOBJECT px1;
    MOBJECT pbutt1;
    char buff[128]; 

    unsigned long   st, et, x;
    char buf[80];
    double tout;
    int er;




    sh1 = MCreateShell("About DAS Execution", SF_MODAL);    

    _colform000 = MCreateColForm(sh1);
    MObjectSetBackgroundRGB(_colform000, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);

    px1 = MCreatePixmapFromFile(_colform000, "sys\\info1.bmp");
    MObjectAlign(px1, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetShadow(px1, WS_NONE, 0, 0);
    MObjectSetCompositeWidth(px1, 32);
    MObjectSetCompositeHeight(px1, 32);

    _rowform000 = MCreateRowForm(_colform000);
    MObjectSetResize(_rowform000, True, True);
    MObjectSetBackgroundRGB(_rowform000, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);

    sprintf(buff, "%s","DAS Info");
    lbl = MCreateLabel(_rowform000, buff, HELV_LARGE);
    MObjectSetForegroundRGB(lbl, DPAL.DB_FG_Plbl[0], DPAL.DB_FG_Plbl[1], DPAL.DB_FG_Plbl[2]);
    MObjectSetBackgroundRGB(lbl, DPAL.DB_BG_Albl[0], DPAL.DB_BG_Albl[1], DPAL.DB_BG_Albl[2]);
    MObjectSetShadow(lbl, WS_ETCHED_IN, 3, 0);
    MObjectSetTransparency(lbl, 0);

    sprintf(buff, "%s","   DAS is setted for automatic execution   ");
    lbl = MCreateLabel(_rowform000, buff, HELV_MEDIUM);
    MObjectSetForegroundRGB(lbl, DPAL.DB_FG_Plbl[0], DPAL.DB_FG_Plbl[1], DPAL.DB_FG_Plbl[2]);
    MObjectSetShadow(lbl, WS_ETCHED_IN, 3, 0);

    sprintf(buff, "%s", "   The program will start in %.1lf seconds   ");
    lbl1 = MCreateLabel(_rowform000, buff, HELV_MEDIUM);
    MObjectSetForegroundRGB(lbl1, DPAL.DB_FG_Plbl[0], DPAL.DB_FG_Plbl[1], DPAL.DB_FG_Plbl[2]);
    MObjectSetShadow(lbl1, WS_ETCHED_IN, 3, 0);


    sprintf(buff, "%s","   You can select the 'Manual mode' or to Quit the DAS with the buttons on the right!   ");
    lbl = MCreateLabel(_rowform000, buff, HELV_MEDIUM);
    MObjectSetForegroundRGB(lbl, DPAL.DB_FG_Plbl[0], DPAL.DB_FG_Plbl[1], DPAL.DB_FG_Plbl[2]);
    MObjectSetShadow(lbl, WS_ETCHED_IN, 3, 0);


    _rowform000 = MCreateRowForm(_colform000);
    MObjectSetResize(_rowform000, False, False);
    MObjectAlign(_rowform000, CENTER_ALIGN, BOTTOM_ALIGN);
    MObjectSetBackgroundRGB(_rowform000, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);

    

    pbutt1 = MCreatePButton(_rowform000, "MANUAL MODE", HELV_MEDIUM);
    MPButtonSetCallback(pbutt1, ManualModeCB, (void *) 0);
    MObjectAlign(pbutt1, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetShadow(pbutt1, WS_SHADOW_OUT, 3, 0);

    pbutt1 = MCreatePButton(_rowform000, "QUIT", HELV_MEDIUM);
    MPButtonSetCallback(pbutt1, ManualModeCB, (void *) 1);
    MObjectAlign(pbutt1, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetShadow(pbutt1, WS_SHADOW_OUT, 3, 0);

    pbutt1 = MCreatePButton(_rowform000, "Skip Wait", HELV_MEDIUM);
    MPButtonSetCallback(pbutt1, NoWaitSplashCB, (void *) 0);
    MObjectAlign(pbutt1, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetShadow(pbutt1, WS_SHADOW_OUT, 3, 0);


    MShellRealize(sh1);

    //Switch on 12 V, Hires, 24V 
    if(DAS.Paramini.EqType == GASCODNG1)
        er = NOVA_Out(DAS.Nova.type, 9); //1001 bin


    tout = 30000;
    st = GetTickCount();

    do
    {
        et = GetTickCount();
        x = labs(et - st);
        //g = x % 10;
        //sprintf(buf, " %u %u", x, g);
        //Status (buf);
        MLoopWhileEvents(0);
            if((x % 100 == 0) && (x > 0))
            //if(x > 0)
            {

//              if(DAS.DOption.amsprogbar)
//              {
                    //D_VRange(NULL, (long) x * 100 / tout, 255, 0, 0 );
                    
                    sprintf(buf, "The program will start in %.1lf seconds ", fabs(((double)(labs(et - st) - tout))/1000.0 ));
                    MObjectSetText(lbl1,buf);
                    
//              }
            }
    }while((labs(et - st) < tout) & (DAS.Flag.exemode != MANUAL) & nowaitsplash == 1);

        MShellUnrealize(sh1);
        MShellDestroy(sh1);


}

Here is the call graph for this function:

Here is the caller graph for this function:

MDCreateWaitShell()

void MDCreateWaitShell

(

void

)

Create a waiting window .

Returns

void

Definition at line 2408 of file DAS_Spat.c.

References BOTTOM_ALIGN, CENTER_ALIGN, palette::DB_BG, palette::DB_BG_Albl, palette::DB_FG_Plbl, False, HELV_LARGE, HELV_MEDIUM, lbl, MCreateColForm(), MCreateLabel(), MCreatePButton(), MCreatePixmapFromFile(), MCreateRowForm(), MCreateShell(), MLoopWhileEvents(), MObjectAlign(), MObjectSetBackgroundRGB(), MObjectSetCompositeHeight(), MObjectSetCompositeWidth(), MObjectSetForegroundRGB(), MObjectSetResize(), MObjectSetShadow(), MObjectSetText(), MObjectSetTransparency(), MPButtonSetCallback(), MShellDestroy(), MShellRealize(), MShellUnrealize(), nowait, NoWaitCB(), SF_MODAL, st, TOP_ALIGN, True, WS_ETCHED_IN, WS_NONE, and WS_SHADOW_OUT.

Referenced by InitCCD_AMS().

{

    
    MOBJECT _colform000;
    MOBJECT _rowform000;
    MOBJECT lbl;
    MOBJECT lbl1;
    MOBJECT sh1;
    MOBJECT px1;
    MOBJECT pbutt1;
    char buff[128]; 

    unsigned long   st, et, x;
    char buf[80];
    double tout;



    sh1 = MCreateShell("DAS Procedure", SF_MODAL);  

    _colform000 = MCreateColForm(sh1);
    MObjectSetBackgroundRGB(_colform000, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);

    px1 = MCreatePixmapFromFile(_colform000, "sys\\info1.bmp");
    MObjectAlign(px1, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetShadow(px1, WS_NONE, 0, 0);
    MObjectSetCompositeWidth(px1, 32);
    MObjectSetCompositeHeight(px1, 32);

    _rowform000 = MCreateRowForm(_colform000);
    MObjectSetResize(_rowform000, True, True);
    MObjectSetBackgroundRGB(_rowform000, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);

    sprintf(buff, "%s","DAS Info");
    lbl = MCreateLabel(_rowform000, buff, HELV_LARGE);
    MObjectSetForegroundRGB(lbl, DPAL.DB_FG_Plbl[0], DPAL.DB_FG_Plbl[1], DPAL.DB_FG_Plbl[2]);
    MObjectSetBackgroundRGB(lbl, DPAL.DB_BG_Albl[0], DPAL.DB_BG_Albl[1], DPAL.DB_BG_Albl[2]);
    MObjectSetShadow(lbl, WS_ETCHED_IN, 3, 0);
    MObjectSetTransparency(lbl, 0);

    sprintf(buff, "%s","   DAS is waiting for the identification of the USB driver for Hires V   ");
    lbl = MCreateLabel(_rowform000, buff, HELV_MEDIUM);
    MObjectSetForegroundRGB(lbl, DPAL.DB_FG_Plbl[0], DPAL.DB_FG_Plbl[1], DPAL.DB_FG_Plbl[2]);
    MObjectSetShadow(lbl, WS_ETCHED_IN, 3, 0);

    sprintf(buff, "%s", "   The program will start in %.1lf seconds   ");
    lbl1 = MCreateLabel(_rowform000, buff, HELV_MEDIUM);
    MObjectSetForegroundRGB(lbl1, DPAL.DB_FG_Plbl[0], DPAL.DB_FG_Plbl[1], DPAL.DB_FG_Plbl[2]);
    MObjectSetShadow(lbl1, WS_ETCHED_IN, 3, 0);


    sprintf(buff, "%s","   You can continue DAS (if the driver is already loaded!!! )selecting  \n the button on the right!   ");
    lbl = MCreateLabel(_rowform000, buff, HELV_MEDIUM);
    MObjectSetForegroundRGB(lbl, DPAL.DB_FG_Plbl[0], DPAL.DB_FG_Plbl[1], DPAL.DB_FG_Plbl[2]);
    MObjectSetShadow(lbl, WS_ETCHED_IN, 3, 0);


    _rowform000 = MCreateRowForm(_colform000);
    MObjectSetResize(_rowform000, False, False);
    MObjectAlign(_rowform000, CENTER_ALIGN, BOTTOM_ALIGN);
    MObjectSetBackgroundRGB(_rowform000, DPAL.DB_BG[0], DPAL.DB_BG[1], DPAL.DB_BG[2]);

    

    pbutt1 = MCreatePButton(_rowform000, "Skip Wait", HELV_MEDIUM);
    MPButtonSetCallback(pbutt1, NoWaitCB, (void *) 0);
    MObjectAlign(pbutt1, CENTER_ALIGN, TOP_ALIGN);
    MObjectSetShadow(pbutt1, WS_SHADOW_OUT, 3, 0);

    MShellRealize(sh1);



    tout = 20000;
    st = GetTickCount();

    do
    {
        et = GetTickCount();
        x = labs(et - st);
        MLoopWhileEvents(0);
            if((x % 100 == 0) && (x > 0))
            {
//              if(DAS.DOption.amsprogbar)
//              {
        
                    sprintf(buf, "The program will start in %.1lf seconds ", fabs(((double)(labs(et - st) - tout))/1000.0 ));
                    MObjectSetText(lbl1,buf);
                    
//              }
            }
    }while(labs(et - st) < tout && nowait == 1);

        MShellUnrealize(sh1);
        MShellDestroy(sh1);


}

Here is the call graph for this function:

Here is the caller graph for this function:

MGUIMain()

void MGUIMain	(	int	argc,
		char **	argv
	)

MAIN PROGRAM starting point
Actions:
.

• Detect and set the DAS Working Dir and set the MGUI environment (SetWorkDirMGUIenv)
• Init Flags and Structure's elements(InitFlags)
• Alloc colors and init palette mode (InitColors)
• Load DAS home Dir and set Data, Config and LOG dirs (LoadSetDirs)
• Load the actual date of program start
• Load Geo coordinates of the station (LoadGeoCoord)
• Load the palette for data visualization (LoadTruePalette)
• Load the color table for the MGUI objects (LoadDasSysCol)
• Load some of the run-time options from the file .\config\options.ini (LoadDB_Options)
• Load the FTP settings for the data backup via FTP (LoadFTPSetting)
• Check 2nd argument in order to set the execution mode (ChkExeMode):
  • arg = MASTER –> Exemode = TEMPORIZED (Automatic timed)
  • arg = SZAPRG –> Exemode = SZAMODE (SZA Driven)
  • arg = *.prg –> Exemode = PRGFILE (Automatic)
  • arg = TESTAMS –> Exemode = TESTAMS
  • arg = OFFLINEPLOT –> Exemode = OFFLINEPLOT(Off Line Plot)
  • arg = TESTCCD –> Exemode = TESTCCD,
  • arg = HELP –> Exemode = HELP,
  • arg = DEMO –> Exemode = DBDEMO
  • arg = " " –> Exemode = MANUAL (DAS MAIN Graphic User Interface)
  • arg = TESTAD –> Exemode = TESTAD
  • arg = DOAS –> Exemode = DOASMODE (DOAS Mode)
  • arg = *.log –> Exemode = LOGMODE (LOG Mode)
• Build appropriate GUI depending on the selected execution mode
  • Execution Mode = OFFLINEPLOT
    • Check the existence of a 3rd argument (data file name - *.dat or *.bif)
      • 3rd argument –> Buid the GUI and Plot the selected data file (RunOLP)
      • NO 3rd arhument –> Buid the GUI for the data visualization (RunOLP)
  • Execution mode = DOASMODE
    • Create the DOAS GUI (DOAS Mode)
  • Execution mode = LOGMODE
    • Check if the argument is a valid LOG file, read the file and plot it (LOG Mode)
  • Execution mode = TEMPORIZED, TESTAMS, TESTCCD, TESTAD, DBDEMO, PRGGFILE, MANUAL)
    • Create the DAS main shell (RunFULL)

      Returns

      void

Definition at line 3546 of file DAS_Spat.c.

References _MAX_PATH, BuildShell(), ChkExeMode(), d_fileman::CONFIGDIRCOMMON, d_fileman::CONFIGDIREQUIPMENT, D_WriteInitLog(), DAS_StartDOY, DAS_StartHour, bil::DFILEM, das::DGeo, DI_PathExist(), das::DOption, ERR_Option(), flag::exemode, das::Flag, optionini::ftpbackup, GetDateTime(), d_fileman::HOMEDIRECTORY, InitColors(), InitFlags(), LoadDasSysCol(), LoadDB_DispCoeff(), LoadDB_Options(), LoadDefaultDPAL(), LoadEquipment(), LoadFTPSetting(), LoadGeoCoord(), LoadGeoDB(), LoadHardware(), LoadSetDirs(), LoadTruePalette(), LoadWlstep(), MEnableCustomizing(), MMessageDialog(), dlog::odate, spectrumheader::olddate, dlog::otime, d_geo::s_name, SetWorkDirMGUIenv(), bil::SPH, and WriteInit().

{

//  int mrun = 0;
    int er;
//    time_t ltime;
    struct tm today;
    char buff[128], str[_MAX_PATH];

        struct date RDate;
        struct time RTime;




    MEnableCustomizing();




    /**********************************************************************/
    /**********************************************************************/
    // DAS Working directory and MGUI Environment
    er = SetWorkDirMGUIenv(argv[0]);
    if (er == -1) 
    {
        //Unable to set the enviromental variable
    }

    /**********************************************************************/
    /**********************************************************************/ 
        
    InitFlags();// For Flags and structure initialization
    /**********************************************************************/
    /**********************************************************************/
    // For Color and palette init
    InitColors();
    /**********************************************************************/

    /**********************************************************************/
    //Load home dir. and set Data, Config and Log Dirs
    LoadSetDirs();
    /**********************************************************************/

    /**********************************************************************/    
    // Load Equipment.ini
    er = LoadEquipment(); //In order to know wich instrument will be used
        if(er == 1)
        {
            sprintf(str,"File %s\\Equipment.ini not found,\nThe program will be closed.\n ", BIL.DFILEM.CONFIGDIRCOMMON);
            MMessageDialog ("DAS ERROR ", str, "OK",NULL); 
            exit(0);
        }
        if(er > 1)
        {
            sprintf(str,"Equipment with code '%d' not recognized!!!!\nCheck the '%s\\Equipment.ini' file\nor\nConsulte the DAS Help\nThe program will be closed.\n ", er, BIL.DFILEM.CONFIGDIRCOMMON);
            MMessageDialog ("DAS ERROR ", str, "OK",NULL); 
            exit(0);
        } 
    /**********************************************************************/
    //Set path for the DCL
    sprintf(buff, "%s", BIL.DFILEM.CONFIGDIREQUIPMENT );
    // Return: 1 if PATH exist, else return 0
    er = DI_PathExist(buff);
    if (er)
    {
        //Set path for the DCL
//      DC_SetPathName(buff);
    }

    /**********************************************************************/
    er = LoadWlstep();
        if(er)
        {
            sprintf(str,"File '%s\\WlStep.ini' not found,\nThe program will be closed.\n ", BIL.DFILEM.CONFIGDIREQUIPMENT);
            MMessageDialog ("DAS ERROR ", str, "OK",NULL); 
            exit(0);
        }

    er = LoadHardware();
        if(er)
        {
            sprintf(str,"File %s\\Hardware.ini not found,\nThe program will be closed.\n ", BIL.DFILEM.CONFIGDIREQUIPMENT);
            MMessageDialog ("DAS ERROR ", str, "OK",NULL); 
            exit(0);
        }

    
    /**********************************************************************/
    //Load the actual date of program start

    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.odate, 7,"%y%m%d", &today );
    strftime( DLOG.otime, 9,"%H:%M:%S", &today );
    sprintf(BIL.SPH.olddate, "%s",DLOG.odate);
    DAS_StartHour = (int)(((double)today.tm_hour + 30.0/60.0) * 10); 
    DAS_StartDOY = (int)(((double)today.tm_yday + 12.0/24.0) * 10); //next reset at StartDay + DAS.DOption.resetFreq
    
    
    sprintf(buff, "*******************************************************");
    D_WriteInitLog(buff);
    sprintf(buff, "DAS Started on %s at %s", DLOG.odate, DLOG.otime );
    D_WriteInitLog(buff);

    /**********************************************************************/
    
    /**********************************************************************/
    //Load the color table for the MGUI objects
    er = LoadDasSysCol();
    if(er)
    {
        LoadDefaultDPAL();
        sprintf(str,"File %s\\DASSysColor.INI not found,\nThe default DAS colors will be used.\n ", BIL.DFILEM.CONFIGDIREQUIPMENT);
        MMessageDialog ("DAS ERROR ", str, "OK",NULL); 
        
        LoadDefaultDPAL();
    }   
    /**********************************************************************/
    /**********************************************************************/
    // Load the palette for data visualization
    er = LoadTruePalette();
    if(er)
    {
        sprintf(str,"File '%s\\PALETTES\\DANBOMAP1.MAP' not found,\n", BIL.DFILEM.HOMEDIRECTORY);
        MMessageDialog ("DAS ERROR ", str, "OK",NULL); 
        
    }   

    /**********************************************************************/
    
    /**********************************************************************/
    //Load Geo coordinates of the station
    er = LoadGeoCoord();
    if(er)
    {
        sprintf(str,"File '%s\\GeoCoord.INI' not found,\nPlease supply a valid GeoCoord.INI file for the computation of the SZA and Sun Position", BIL.DFILEM.CONFIGDIREQUIPMENT);
        MMessageDialog ("DAS ERROR ", str, "OK",NULL); 
    }   
    /**********************************************************************/
    //Load Database of stations Geo coordinates 
    er = LoadGeoDB();
    /**********************************************************************/
    //Load dispersion Parameters 
    er = LoadDB_DispCoeff();


    /**********************************************************************/
    /**********************************************************************/
    //Log File
    WriteInit(DAS.DGeo.s_name, DLOG.odate,DLOG.otime);
    /**********************************************************************/
    /**********************************************************************/
    //Load Fonts
    //  er = LoadDFONT();
    //  if(er)
    //  {
    //      LoadDefaultDFONT();
    //  }   
    /**********************************************************************/
    /**********************************************************************/
    //Load options from file .\config\'Instrument'\options.ini


    er = LoadDB_Options();
    if(er)
    {
        if (er == 1)
        {
            sprintf(str, "%s\nPlease supply a valid %s\\Option.INI file or contact Danbo - db@uevora.pt\nNow DAS will quit!!", ERR_Option(er), BIL.DFILEM.CONFIGDIREQUIPMENT );
            MMessageDialog("DAS Inf. - Errors in OPTION.INI file", str, "OK", NULL);
            exit(0);
    
        }
        if (er > 1 && er < 40)  
        {
            //Errors for OPTION.INI files
            sprintf(str, "Err.: %d - %s\nEdit %s\\Option.INI file and correct or contact Danbo - db@uevora.pt\nNow DAS will quit!!",er,  ERR_Option(er), BIL.DFILEM.CONFIGDIREQUIPMENT );
            MMessageDialog("DAS Inf. - Errors in OPTION.INI file", str, "OK", NULL);
            exit(0);
        

        //Init Default Options
        //InitDefaultOptions();
        }
        if (er == 999)
        {
            sprintf(str, "The %s\\Option.INI file is present but not valid.\nProbably the file is from a previous DAS realise\nPlease supply a valid %s\\Option.INI file or contact Danbo - db@uevora.pt\nDAS can NOT continue the execution and it will quit!!", BIL.DFILEM.CONFIGDIREQUIPMENT,BIL.DFILEM.CONFIGDIREQUIPMENT );
            MMessageDialog("DAS Inf. - Errors in OPTION.INI file", str, "OK", NULL);
            exit(0);
    
        }

    }
    /**********************************************************************/
    /**********************************************************************/
    // Load the FTP settings for the data backup via FTP
    if(DAS.DOption.ftpbackup)
    {
        er = LoadFTPSetting();
        if (er)
        {
            sprintf(str, "The %s\\FTP.INI file not found.\n The Data back-up can not be done!\nPlease supply a valid %s\\FTP.INI file or contact Danbo - db@uevora.pt\nNow DAS will quit!!", BIL.DFILEM.CONFIGDIREQUIPMENT,BIL.DFILEM.CONFIGDIREQUIPMENT );
            MMessageDialog("DAS Inf. - Errors in FTP.INI file", str, "OK", NULL);

            DAS.DOption.ftpbackup = 0;
        }
    }
    /**********************************************************************/
    /**********************************************************************/
    // Check the execution mode (TEMPORIZED, TESTAMS, OFFLINEPLOT, TESTCCD, 
    // TESTAD, DEMO, ?, PrgFile, MANUAL)
    ChkExeMode(argc, argv);
    /**********************************************************************/

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

    /**********************************************************************/
    /* Build and Execute the shell depending on the execution mode*/
    /**********************************************************************/
    BuildShell(DAS.Flag.exemode, argv);

}

Here is the call graph for this function:

MGUIQuitCB()

int MGUIQuitCB	(	MOBJECT	shell,
		void *	od,
		void *	ad
	)

Exit MGUI Library. Procedure that close MGUI .

Returns

void

Definition at line 728 of file DAS_Spat.c.

References MGUITerm(), MMessageDialog(), MShellDestroy(), and MShellUnrealize().

Referenced by MDCreateDOAS_MainSh(), RunLogMode(), and RunOLP().

{
    if (MMessageDialog("DAS Exit Message", "Do you really want to quit ?", " Yes ", " No ", NULL))
        return;
    MShellUnrealize(shell);
    MShellDestroy(shell);
    MGUITerm();
    exit(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

NOVA_In()

int NOVA_In	(	int	novatype,
		unsigned int	DigIn
	)

Read the NOVA Input port.

Parameters

novatype	= type of NOVA monoboard
DigIn	= value read on the input port

Definition at line 1306 of file DAS_Spat.c.

References DBDEMO, DIO_GetInput(), flag::exemode, das::Flag, InByte(), ISMM_Close(), ISMM_Open(), MMessageDialog(), NOVA7892, and NOVA945GSE.

Referenced by CONFP_AMS_NOVA(), and NOVAIn_CB().

{

    int er=0;

    

    if(novatype == NOVA7892)
    {
        er=InByte(0x240, &DigIn);
        return er;
    }
    if(novatype == NOVA945GSE)
    {

        //Definition for NOVA945GSE I/O (IT8712F)
        HANDLE hIsmm;
//      HWM_DATA gHwmData;
//      UCHAR szBuf[32];
//      WORD wNodeCount, wBufSize, ii;
//      FLOAT *pfValue;
//      ULONG *plValue;
        //DIO Var
//      WORD wDioConfig;
//      WORD wDioOut;



        hIsmm = ISMM_Open();
        if (hIsmm == INVALID_HANDLE_VALUE)
        {
            //printf("Can not open iSMM device\n");
            if (DAS.Flag.exemode == DBDEMO)
                return 0;
            else
            {
                MMessageDialog("I/O Tester", "Can not open iSMM device", "OK", NULL);
                return -1;
            }
        }
        // get DIO Config
        //if ( DIO_GetConfig(hIsmm, &wDioConfig) )
//      er = DIO_GetConfig(hIsmm, &wDioConfig) ;
//      if ( er )
//      {               MMessageDialog("Super I/O Tester", "DIO Found", "OK", NULL);
//      }

        // get DIO Input
        if ( DIO_GetInput(hIsmm, &(unsigned short) DigIn))
        {

        }

        // set DIO OutPut
        //if ( DIO_SetOutput(hIsmm, (WORD) &DigIn) )
        //{

        //}

        

        ISMM_Close(hIsmm);
        return er;
    }
    return er;

}

Here is the call graph for this function:

Here is the caller graph for this function:

NOVA_Out()

int NOVA_Out	(	int	novatype,
		unsigned int	DigOut
	)

Write the NOVA Output port.

Parameters

novatype	= type of NOVA monoboard
DigOut	= value to be written on the output port

Definition at line 1375 of file DAS_Spat.c.

References DBDEMO, DIO_GetConfig(), DIO_GetOutput(), DIO_SetOutput(), DWORD, flag::exemode, das::Flag, ISMM_Close(), ISMM_Open(), MMessageDialog(), NOVA6612G2, NOVA7892, NOVA945GSE, OutByte(), and WORD.

Referenced by InitCCD_AMS(), MDCreateSplashExe(), NOVAOut_CB(), ShutCB(), and WinRes().

{

    int er=0;

    

    if(novatype == NOVA7892)
    {
        er=OutByte(0x240, out);
        return er;
    }

    if(novatype == NOVA6612G2)
    {

        //Definition for NOVA6612G2 I/O (W83697HF)
        HANDLE  hndFile;            // Handle to device, obtain from CreateFile
//      UCHAR data_b;
        WDTPARAM    cParam;
        DWORD   nReturn;

        hndFile = CreateFile(WDT_DEVICE, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE,
            NULL, OPEN_EXISTING, 0, NULL);

        cParam.data_b=out;
        DeviceIoControl(hndFile, IOCTL_SYS_DIO_WRITE,
            &cParam, sizeof(WDTPARAM), 0, 0, &nReturn, NULL);

        CloseHandle(hndFile);
        return er;
    }


    if(novatype == NOVA945GSE)
    {

        //Definition for NOVA945GSE I/O (IT8712F)
        HANDLE hIsmm;
//      HWM_DATA gHwmData;
//      UCHAR szBuf[32];
//      WORD wNodeCount, wBufSize, ii;
//      FLOAT *pfValue;
//      ULONG *plValue;
        //DIO Var
        WORD wDioConfig;
        WORD wDioOut;



        hIsmm = ISMM_Open();
        if (hIsmm == INVALID_HANDLE_VALUE)
        {
            //printf("Can not open iSMM device\n");
            if (DAS.Flag.exemode == DBDEMO)
                return 0;
            else
            {

                MMessageDialog("I/O Tester", "Can not open iSMM device", "OK", NULL);
                return -1;
            }
        }
        // get DIO Config
        if ( DIO_GetConfig(hIsmm, &wDioConfig) )
        er = DIO_GetConfig(hIsmm, &wDioConfig) ;
//      if ( er )
//      {               MMessageDialog("Super I/O Tester", "DIO Found", "OK", NULL);
//      }

        // get DIO Output
        if ( DIO_GetOutput(hIsmm, &wDioOut) )
        {
        }

        // set DIO OutPut
        if ( DIO_SetOutput(hIsmm, (WORD) out) )
        {

        }
        

        ISMM_Close(hIsmm);
        return er;
    }

    return er;

}

Here is the call graph for this function:

Here is the caller graph for this function:

NoWaitCB()

void NoWaitCB	(	MOBJECT	p,
		void *	od,
		void *	ad
	)

Definition at line 2393 of file DAS_Spat.c.

References nowait.

Referenced by MDCreateWaitShell().

{

    
    MOBJECT c = (void *)ad;
    
    nowait = 0;
    


}

Here is the caller graph for this function:

NoWaitSplashCB()

void NoWaitSplashCB	(	MOBJECT	p,
		void *	od,
		void *	ad
	)

Definition at line 2251 of file DAS_Spat.c.

References nowaitsplash.

Referenced by MDCreateSplashExe().

{

    
    MOBJECT c = (void *)ad;
    
    nowaitsplash = 0;
    


}

Here is the caller graph for this function:

PRG_Check()

int PRG_Check	(	int	mod,
		char *	prgname
	)

Definition at line 531 of file DAS_Spat.c.

References _MAX_PATH, AAMEASURE, AAPOSIT, ALMUCANTAR, AUTORNG, AVGCCD, AVGCCDHOR, AZIMUTH, BEGIN, CALIBRA, CHKEXLAMP, DARKC, delay(), bil::DFILEM, DFMEASURE, DI_FileExist(), DI_SplitName(), DIRECTSUN, ELAMPOFF, ELAMPON, ESHUTCL, ESHUTOP, EXPO, Fetch(), FILTER, GETCCD, H_AZI, H_FILTER, H_GRAT, H_GRAT_CAL, H_MIRROR, H_NDFW, H_ZEN, HG_OFF, HG_ON, HGSCAN, d_fileman::HOMEDIRECTORY, IREFSUN, LABEL, LoadExec(), MEASHOR, MEASHOR2, MEASURE, MGUITerm(), MIRROR, MMessageDialog(), NDFILTER, PLOT, PRG_ChKBegin(), PRG_ChkGrating(), PRG_ChkMeasAvg(), PRG_ChkMirror(), PrgCnt, PrgSiz, Program, QJ_OFF, QJ_ON, QJSCAN, RADIO, REM, SAVE, SETCCDOFFS, SETCCDPOW, SETCCDTEMP, SETCCDVBIN, WAIT, WAVELEN, XEND, and ZENITH.

Referenced by ChkExeMode(), DB_ToolsKeyB_CB(), and ExMaster().

{
    int er = 0, flin = 0, ls, ferr;
    int  inf = 0, error = 0 ;
    long siz = 0;
    long accbyte = 0;
    long tmp;
    char buff[32], str[_MAX_PATH], fname[32],ffnerr[_MAX_PATH];
    int m ;
    
    //sprintf(buff,"\0");

    er = LoadExec(prgname);

    DI_SplitName(prgname, str, buff);
    
    
    ls = strlen(buff);
    sprintf(fname,"\0");
    sprintf(ffnerr,"\0");
    strncat(fname, buff, ls-3);
    strcat(fname,"err");
    strcat(str,fname);
    strcat(ffnerr,str);

/**********************/
    if(DI_FileExist(ffnerr)) // DI_FileExist --> Return: 1 if PATH exist, else return 0
    {
        //Delete the old err file
        remove(ffnerr);
    }

    
/**********************/
    if (er)
    {
        do 
        {           
            flin ++;
            er = Fetch();
                switch(er)
                {
                    case AUTORNG:   while(Program[PrgCnt++] != 10);     break; //   1
                    case AVGCCD:
                            error = PRG_ChkMeasAvg(flin, ffnerr);
                            while(Program[PrgCnt++] != 10); 
                                                                        break; //   2
                    case BEGIN:     
                            error = PRG_ChKBegin(flin, ffnerr);
                            while(Program[PrgCnt++] != 10);
                                                                        break; //   3

                    case CALIBRA:   while(Program[PrgCnt++] != 10);     break; //   4
                    case DARKC:     while(Program[PrgCnt++] != 10);     break; //   5
                    case EXPO:      while(Program[PrgCnt++] != 10);     break; //   6
                    case FILTER:    while(Program[PrgCnt++] != 10);     break; //   7
                    case GETCCD:    while(Program[PrgCnt++] != 10);     break; //   8               
                    case H_FILTER:  while(Program[PrgCnt++] != 10);     break; //   9
                    case H_GRAT:    while(Program[PrgCnt++] != 10);     break; //   10
                    case H_MIRROR:  while(Program[PrgCnt++] != 10);     break; //   11
                    case HG_OFF:    while(Program[PrgCnt++] != 10);     break; //   12
                    case HG_ON:     while(Program[PrgCnt++] != 10);     break; //   13
                    case LABEL:     while(Program[PrgCnt++] != 10);     break; //   14
                    case MEASURE:
                            error = PRG_ChkMeasAvg(flin, ffnerr);
                            while(Program[PrgCnt++] != 10); 
                                                                        break; //   15
                    case MEASHOR:
                            error = PRG_ChkMeasAvg(flin, ffnerr);
                            while(Program[PrgCnt++] != 10); 
                                                                        break; //   16
                    case MIRROR:
                            sscanf(&Program[PrgCnt], "%d", &m);
                            error = PRG_ChkMirror(0, ffnerr, flin, m);
                            while(Program[PrgCnt++] != 10); 
                                                                        break; //   17
                    case PLOT:      while(Program[PrgCnt++] != 10);     break; //   18
                    case QJ_OFF:    while(Program[PrgCnt++] != 10);     break; //   19              
                    case QJ_ON:     while(Program[PrgCnt++] != 10);  break; //  20
                    case RADIO:     while(Program[PrgCnt++] != 10);  break; //  21
                    case REM:       while(Program[PrgCnt++] != 10);  break; //  22
                    case SAVE:      while(Program[PrgCnt++] != 10);  break; //  23
                    case WAIT:      while(Program[PrgCnt++] != 10);  break; //  24
                    case WAVELEN:   
                            sscanf(&Program[PrgCnt], "%d", &m);
                            error = PRG_ChkGrating(0, ffnerr, flin, m);
                            while(Program[PrgCnt++] != 10);          break; //  25
                    case XEND:      PrgCnt = PrgSiz;                 break; //  26

                    case ELAMPON:   while(Program[PrgCnt++] != 10);  break; //  27
                    case ELAMPOFF:  while(Program[PrgCnt++] != 10);  break; //  28              
                    case ESHUTOP:   while(Program[PrgCnt++] != 10);  break; //  29
                    case ESHUTCL:   while(Program[PrgCnt++] != 10);  break; //  30  
                        
                    case H_ZEN:    while(Program[PrgCnt++] != 10);   break;     //  31
                    case H_AZI:    while(Program[PrgCnt++] != 10);   break;     //  32
                    case ZENITH:   while(Program[PrgCnt++] != 10);   break;     //  33
                    case AZIMUTH:  while(Program[PrgCnt++] != 10);   break;     //  34
                    case AAMEASURE:while(Program[PrgCnt++] != 10);   break;     //  35
                    case AVGCCDHOR:while(Program[PrgCnt++] != 10);   break;     //  36
                    case CHKEXLAMP:while(Program[PrgCnt++] != 10);   break;     //  37
                    case AAPOSIT  :while(Program[PrgCnt++] != 10);   break;     //  38
                    case IREFSUN  :while(Program[PrgCnt++] != 10);   break;     //  39
                    case MEASHOR2 :while(Program[PrgCnt++] != 10);   break;     //  40  
                    case SETCCDTEMP :while(Program[PrgCnt++] != 10); break;     //  41  
                    case SETCCDVBIN :while(Program[PrgCnt++] != 10); break;     //  42  
                    case SETCCDPOW :while(Program[PrgCnt++] != 10);  break;     //  43  
                    case NDFILTER :while(Program[PrgCnt++] != 10);   break;     //  44  
                    case DFMEASURE:while(Program[PrgCnt++] != 10);   break;     //  44
                    case H_NDFW     :while(Program[PrgCnt++] != 10); break;     //  45  
                    case SETCCDOFFS :while(Program[PrgCnt++] != 10);    break;      //  47  
                    case QJSCAN     :while(Program[PrgCnt++] != 10);    break;      //  48  
                    case H_GRAT_CAL :while(Program[PrgCnt++] != 10);    break;      //  49                                                                                       
                    case HGSCAN     :while(Program[PrgCnt++] != 10);    break;      //  50
                    case ALMUCANTAR :while(Program[PrgCnt++] != 10);    break;      //  51
                    case DIRECTSUN  :while(Program[PrgCnt++] != 10);    break;      //  52

                    case 0:
                        while(Program[PrgCnt++] != 10); 
                        inf = 1;
                        //OpenFile for Writing errors
                        ferr = open(ffnerr, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
                            sprintf(buff, "Error at line %d: Command NOT FOUND\n", flin);
                            write(ferr, buff, strlen(buff));
                        close(ferr);
                        //sprintf(buff,"Command not found at line %d ", flin );
                        //MMessageDialog("DAS Inf.", buff,"OK", NULL);
                    
                        break;
                    case 2000:
                        PrgCnt = PrgSiz; 
                        inf = 1;
                        //OpenFile for Writing errors
                        ferr = open(ffnerr, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
                            sprintf(buff, "Error at line %d: XEND NOT FOUND\n", flin);
                            write(ferr, buff, strlen(buff));
                        close(ferr);
                        //sprintf(buff,"Command not found at line %d ", flin );
                        //MMessageDialog("DAS Inf.", buff,"OK", NULL);

                    


                }
                inf = inf + error;
                tmp = (PrgCnt + 2) - (accbyte);
                accbyte= accbyte + tmp;
                //  accbyte= PrgCnt;
            
        //}while (accbyte < PrgSiz );
        }while (PrgCnt < PrgSiz );
        if (inf == 0)
        {
            //DI_SplitName(PrgFile, str, buff);
            sprintf(str, "File:%s correctely Compiled",prgname);
            if (mod)
                MMessageDialog("DAS Inf.", str,"OK", NULL);
            //Status (str);
            delay(1000);
            return 0;

        }
        else
        {
            //DI_SplitName(PrgFile, str, buff);
//          sprintf(str, "PRG File:\n%s\ncontains error/s\nThe DAS will close!!!!\n Retry with other PRG.",PrgFile);
//          MMessageDialog("DAS Inf.", str,"OK", NULL);
            sprintf(str, "PRG File:\n%s\ncontains error/s\nYou can:\n Close DAS\nView the errors\n ",prgname);
            er = MMessageDialog("DAS Inf. - PRG Errors", str,"Close", "View err",NULL);
            if (er)
            {
                sprintf(str,"%s\\MEDIT.EXE %s", BIL.DFILEM.HOMEDIRECTORY, ffnerr);
                er = WinExec(str, SW_SHOW);
                sprintf(str,"%s\\MEDIT.EXE %s", BIL.DFILEM.HOMEDIRECTORY, prgname);
                er = WinExec(str, SW_SHOW);
                //exit(0);
                return 1;

            }
            else
            {
                MGUITerm();
                exit(0);
            }

        }
    }
    else
    {
        sprintf(buff,"Problem in opening the PRG file!!!!");
        MMessageDialog("DAS Inf.", buff,"OK", NULL);
        return 2;
    }
    
}

Here is the call graph for this function:

Here is the caller graph for this function:

PRG_ChKBegin()

int PRG_ChKBegin	(	int	line,
		char *	fname
	)

Definition at line 515 of file DAS_Spat.c.

Referenced by PRG_Check().

{
    int er = 0, eracc = 0;
//  int l, m, g;
//  double t;
//  char buff[_MAX_PATH];




        return er;
}

Here is the caller graph for this function:

PRG_ChkGrating()

int PRG_ChkGrating	(	int	mod,
		char *	filename,
		int	record,
		int	par
	)

Definition at line 376 of file DAS_Spat.c.

References _MAX_PATH, and LookforWl_X().

Referenced by PRG_Check(), and PRG_ChkMeasAvg().

{

    int ferr, er = 0;
    char buff[_MAX_PATH];
    int l;

    l= LookforWl_X(par);
    if (l> 18 ) //error on grating position
    {
        //OpenFile for Writing errors
        ferr = open(filename, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
            sprintf(buff, "Error at line %d: Grating Position Current value %d. Allowed values 0 to 13\n", record, l);
            write(ferr, buff, strlen(buff));
        close(ferr);
        //sprintf(buff,"Error in file:%s\nLine:%d\nMirror position: \nCurrent value %d\nAllowed values 0 to 3",PrgFile, line,m);
        //MMessageDialog("DAS Inf.", buff,"OK", NULL);
        er = 1;
    }
    else if (l<0) 
    {
        //OpenFile for Writing errors
        ferr = open(filename, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
            sprintf(buff, "Error at line %d: Wavelength value %d not encounterd in the wlstep.ini file\n", record, par);
            write(ferr, buff, strlen(buff));
        close(ferr);
        //sprintf(buff,"Error in file:%s\nLine:%d\nMirror position: \nCurrent value %d\nAllowed values 0 to 3",PrgFile, line,m);
        //MMessageDialog("DAS Inf.", buff,"OK", NULL);
        er = 1;
    }





    return er;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PRG_ChkKeyW()

int PRG_ChkKeyW	(	int	line,
		char *	fname
	)

Definition at line 348 of file DAS_Spat.c.

{
    

    return 0;
}

PRG_ChkMeasAvg()

int PRG_ChkMeasAvg	(	int	line,
		char *	fname
	)

Definition at line 414 of file DAS_Spat.c.

References _MAX_PATH, PRG_ChkGrating(), PRG_ChkMirror(), PrgCnt, Program, and wl.

Referenced by PRG_Check().

{

    int er = 0, eracc = 0;
    int f, m, a, d, s, g, ferr,wl;
    double t;
    char buff[_MAX_PATH];


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

    er = PRG_ChkMirror(0,fname, line, m);
    eracc = eracc + er;

    er = PRG_ChkGrating(0,fname, line, wl);
    eracc = eracc + er;

    if ((f < 0) | (f > 6)) //error on filter position
    {
        //OpenFile for Writing errors
        ferr = open(fname, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
            sprintf(buff, "Error at line %d: Filter Position Current value %d. Allowed values 0 to 6\n", line,f);
            write(ferr, buff, strlen(buff));
        close(ferr);
        //sprintf(buff,"Error in file:%s\nLine:%d\nMirror position: \nCurrent value %d\nAllowed values 0 to 3",PrgFile, line,m);
        //MMessageDialog("DAS Inf.", buff,"OK", NULL);
        er = 1;

    }

    if ((a < 0) | (a > 1)) //error on autoranging
    {
        //OpenFile for Writing errors
        ferr = open(fname, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
            sprintf(buff, "Error at line %d: Autoranging Mode, Current value %d. Allowed values 0 to 1\n", line,a);
            write(ferr, buff, strlen(buff));
        close(ferr);
        //sprintf(buff,"Error in file:%s\nLine:%d\nMirror position: \nCurrent value %d\nAllowed values 0 to 3",PrgFile, line,m);
        //MMessageDialog("DAS Inf.", buff,"OK", NULL);
        er = 1;

    }

    if ((t < 0) | (t > 45)) //error on exposure time
    {
        //OpenFile for Writing errors
        ferr = open(fname, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
            sprintf(buff, "Error at line %d: Exposure Time Current value %f. Allowed values 0 to 45 sec\n", line,t);
            write(ferr, buff, strlen(buff));
        close(ferr);
        //sprintf(buff,"Error in file:%s\nLine:%d\nMirror position: \nCurrent value %d\nAllowed values 0 to 3",PrgFile, line,m);
        //MMessageDialog("DAS Inf.", buff,"OK", NULL);
        er = 1;

    }

    if ((d < 0) | (d > 1)) //error on dark or light
    {
        //OpenFile for Writing errors
        ferr = open(fname, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
            sprintf(buff, "Error at line %d: type of Measurements Current value %d. Allowed values 0 (Dark) to 1 (Light)\n", line,d);
            write(ferr, buff, strlen(buff));
        close(ferr);
        //sprintf(buff,"Error in file:%s\nLine:%d\nMirror position: \nCurrent value %d\nAllowed values 0 to 3",PrgFile, line,m);
        //MMessageDialog("DAS Inf.", buff,"OK", NULL);
        er = 1;

    }

    if ((s < 0) | (s > 1)) //error on saving file parameter
    {
        //OpenFile for Writing errors
        ferr = open(fname, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
            sprintf(buff, "Error at line %d: Saving on file, Current value %d. Allowed values 0 (NO SAVE) to 1 (SAVE)\n", line,s);
            write(ferr, buff, strlen(buff));
        close(ferr);
        //sprintf(buff,"Error in file:%s\nLine:%d\nMirror position: \nCurrent value %d\nAllowed values 0 to 3",PrgFile, line,m);
        //MMessageDialog("DAS Inf.", buff,"OK", NULL);
        er = 1;

    }

    if ((g < 0) | (g > 1)) //error on plot display
    {
        //OpenFile for Writing errors
        ferr = open(fname, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
            sprintf(buff, "Error at line %d: Plot Display Current value %d. Allowed values 0 (NO PLOT) to 1 (SHOW PLOT)\n", line,g);
            write(ferr, buff, strlen(buff));
        close(ferr);
        //sprintf(buff,"Error in file:%s\nLine:%d\nMirror position: \nCurrent value %d\nAllowed values 0 to 3",PrgFile, line,m);
        //MMessageDialog("DAS Inf.", buff,"OK", NULL);
        er = 1;

    }


    return eracc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PRG_ChkMirror()

int PRG_ChkMirror	(	int	mod,
		char *	filename,
		int	record,
		int	par
	)

Definition at line 355 of file DAS_Spat.c.

References _MAX_PATH.

Referenced by PRG_Check(), and PRG_ChkMeasAvg().

{

    int ferr, er = 0;
    char buff[_MAX_PATH];

    if ((par < 0) | (par > 3)) //error on mirror position
    {
        //OpenFile for Writing errors
        ferr = open(filename, O_WRONLY | O_APPEND | O_TEXT| O_CREAT, S_IWRITE);
            sprintf(buff, "Error at line %d: Mirror Position Current value %d. Allowed values 0 to 3\n", record,par);
            write(ferr, buff, strlen(buff));
        close(ferr);
        //sprintf(buff,"Error in file:%s\nLine:%d\nMirror position: \nCurrent value %d\nAllowed values 0 to 3",PrgFile, line,m);
        //MMessageDialog("DAS Inf.", buff,"OK", NULL);
        er = 1;
    }

    return er;
}

Here is the caller graph for this function:

RunFULL()

void RunFULL

(

void

)

DAS Main LOOP for Equipment management
This Procedure is called by the MGUIMain function when the execution mode is:
.

• TEMPORIZED: execution driven by MASTER file
• PRGFILE: execution driven by *.prg file
• TESTAMS: execution for testing AMS's devices
• TESTCCD: execution for testing CCD Camera
• DBDEMO: execution in demo mode
• MANUAL: execution in manual mode (for lab use)
• TESTAD: execution for testing PC 104 AD converter
• SZAPRG: execution driven by SZAPRG File

Actions:

• Load file Param.ini (Equipment type and CCD parameters) (LoadParam)
• Check if only 1 instance of DAS is running (ChkDASInstance)
• Load file AMS.ini (Stepper Motors Parameters) (LoadAMS)
• Crate the main shell (BuildMainShell)
• Init CCD Camera and AMS Controller (InitCCD_AMS)
• Choose the sensitive Keyboard buttons (Checking the DAS.Flag.exemode status) (DB_ChooseButtons)
• Read the PRG file if PRGFILE mode (LoadExec) or read the MASTER or the MASTERSZA or SZAPRG projects (ExMaster)
• first SZA Calculation (SZA_FirstCalc)
• Launch background tasks (LaunchBackTask)
• the program transfer the control to MGUI library and gains control only through callbacks (as button press) or events generated by the background's tasks (MMainLoop)

  Returns

  void

Definition at line 2994 of file DAS_Spat.c.

Referenced by BuildShell(), and SZA_FirstCalc().

{

    char str[_MAX_PATH];
//  struct time RTime;
    int er = 0;
    long np;

    // Load Param.ini
    er = LoadParam();
    if (er) //Param.ini not found
    {
        sprintf(str,"File %s\\Param.ini not found,\nPlease supply a valid 'Param.ini' file in the %s forlder\n\
or contact Danbo - db@uevora.pt\nNow DAS will quit!! ", BIL.DFILEM.CONFIGDIREQUIPMENT,BIL.DFILEM.CONFIGDIREQUIPMENT);
        MMessageDialog ("DAS ERROR ", str, "OK",NULL); 
        DAS_Error(2);
        exit(0);
    }

    DAS.Flag.ExeDSZA = 1; //To enable the SZAPRG measurement mode

    DAS_Error(0); //Write on LOG "Param.ini Loaded OK"

        //check if more than 1 instance of DAS is running
    ChkDASInstance(DAS.Paramini.EqType); 
        
    //Load AMS.ini
    er = LoadAMS(); //AMS.ini not found
    if(er)
    {
        if (er == 1)
        {
            sprintf(str,"File %s\\Param.ini not found,\nPlease supply a valid 'Param.ini' file in the %s forlder\n\
    or contact Danbo - db@uevora.pt\nNow DAS will quit!! ", BIL.DFILEM.CONFIGDIREQUIPMENT,BIL.DFILEM.CONFIGDIREQUIPMENT);
            MMessageDialog ("DAS ERROR ", str, "OK",NULL); 
            exit(0);

        }
        else
            //Error in reading AMS.ini
            AMSINI_Err(er);
    }
    
    DAS_Error(1); //Write on LOG "AMS.ini Loaded OK"

    // CREATE the MAIN SHELL (Control Panel) 
    BuildMainShell();
        
    //Write the Parameters on the appropriate labels in the control Panel
    AssignParam(0);
        
    //Write the title of the Main Shell depending on the Equipment
    WriteShellTitle(DAS.Gui.Shells.Sh_Main, DAS.Paramini.EqType);

    // Write in the Script-Use Label the execution mode or the PRG file or MASTER
    SetScriptUseLabel(Master, PrgFile, DAS.Flag.exemode, DAS.Gui.ContrPanel.Albl_Script);

    //Start WDT 
//  WDT_func(1);
    
    //Init CCD and AMS  
    er  = InitCCD_AMS(DAS.Paramini.EqType, DAS.Flag.exemode);

    //Stop WDT 
//  WDT_func(0);

    if (er)
    {
        DAS_Error(3);
    }


    // Init AD Converter - PC_104 device.
    //if DMM NOT Found the InitTempAD function return 1
    FLAG.ADPC104 = InitTempAD(DAS.Flag.exemode);

    // choose the sensitive Keyboard buttons ( checking the DAS.Flag.exemode status)
    DB_ChooseButtons(DAS.Flag.exemode);

    // Read the PRG file if not in TEMPORIZED or SZAMASTERM or SZAMODE modes
    //if(PrgFile[0] != 0 && Master == 0)
    if(DAS.Flag.exemode == PRGFILE && Master == 0)
    {
        DB_KB_ButtonActive(0);
        MObjectSetSensitive(DAS.Gui.PushButt.KeyB[25]);
        MObjectSetSensitive(DAS.Gui.PushButt.KeyB[27]);
        FLAG.fileprg = 1;
        on = LoadExec(PrgFile);
    }
    else on = 0;


    //DAS.Marconi.AVGmat  = AllocLongMat(IDX, IDY);


    
    //Read the MASTER or the MASTERSZA or SZAPRG projects or the *.prg file and check the syntax of the *.PRG
    Master = ExMaster(Master, DAS.Flag.exemode);

    //Check the "Master" value
    Master_Error(Master);

    PrgNum = 0;
        
    //first SZA Calculation
    SZA_FirstCalc();


    // Launch background tasks
    LaunchBackTask();

    OMU_HC();


    // Now DAS transfer the control to MGUI library and gains control only through
    // callbacks (as button press) or events generated by the background's tasks
    MMainLoop();

}

Here is the caller graph for this function:

RunLogMode()

void RunLogMode	(	int	mod,
		char *	p
	)

Definition at line 3478 of file DAS_Spat.c.

References _MAX_PATH, AllocFloatMat(), omutemp::CCDPwr, omutemp::CCDTemp, DB_2DPlot(), DI_SplitName(), omutemp::dimx, omutemp::dimy, MGUIQuitCB(), MGUITerm(), MMainLoop(), MMessageDialog(), MShellSetWMCloseCallback(), omutemp::PltPwr, omutemp::pTempMat, omutemp::ptimeMat, ReadLogFile(), SET2D_GRID, and omutemp::sh.

Referenced by BuildShell().

{

    char buff[128], str[_MAX_PATH];
    unsigned long lx;
    int tiy = OMUTEMP.dimy = 16;

    
    DI_SplitName(p, str, buff);
        OMUTEMP.dimx = ReadLogFile(0, str, buff,  0, 0, OMUTEMP);
        if (OMUTEMP.dimx >=5)
        {
            //Remenber to de-alloc theese arrays
            OMUTEMP.pTempMat = AllocFloatMat(OMUTEMP.dimx, OMUTEMP.dimy);
            lx = (unsigned long) OMUTEMP.dimx;
            OMUTEMP.ptimeMat = (struct dtime *) calloc( lx, sizeof(struct dtime ));
            OMUTEMP.CCDTemp = (float *) calloc( lx, sizeof(float));
            OMUTEMP.CCDPwr = (float *) calloc( lx, sizeof(float));
            OMUTEMP.PltPwr = (float *) calloc( lx, sizeof(float));
        }
        else
        {
            sprintf(str, "'%s'\nUnrecognized Argument \n The Program will be terminated", p);
            MMessageDialog("DAS information", str, " Ok ", NULL);  
            MGUITerm();
            exit(0);
        }
        ReadLogFile(1, str, buff, OMUTEMP.dimx, OMUTEMP.dimy,  OMUTEMP);
        sprintf(str,"TEMPERATURE HISTORY - File:%s", p);

        DB_2DPlot(str, OMUTEMP.dimx, OMUTEMP.dimy, 512, 256, SET2D_GRID);
            
        MShellSetWMCloseCallback(OMUTEMP.sh, MGUIQuitCB, 0L);
        MMainLoop();

}

Here is the call graph for this function:

Here is the caller graph for this function:

RunOLP()

void RunOLP

(

char *

fname

)

Definition at line 3114 of file DAS_Spat.c.

References d_fileman::DBFILENAME, bil::DFILEM, FBIF, FDAT, d_fileman::FKIND, LoadDB_DispCoeff(), LoadParam(), MGUIQuitCB(), MMainLoop(), MMessageDialog(), MShellSetWMCloseCallback(), bil::VFO, viewformobj::View_Sh, ViewPlot(), and Visualizza().

Referenced by BuildShell().

{

    int er = 0, l;
    char buff[32];

    er = LoadParam();

    /******************************************************/
    // Load the dispersion coefficient for DOAS Use
    er = LoadDB_DispCoeff();
    /*******************************************************/


    // Create Command KeyBoard
//  MDCreateLISC(0, 0);
/**********************************************************************/
    // choose the sensitive Keyboard buttons ( checking the DAS.Flag.exemode status)
//  DB_ChooseButtons(DAS.Flag.exemode);
/**********************************************************************/

    ViewPlot(0); //OffLine Plot

//  Server = DI_Init(0); //0=No Pop-Up Menu, 1=Yes Pop-Up Menu 

    if(fname != 0)
    {
        sprintf(BIL.DFILEM.DBFILENAME,"%s",fname);
        l = strlen(BIL.DFILEM.DBFILENAME);
        sprintf(buff,"%s", "xxxx");
        strncpy(buff, BIL.DFILEM.DBFILENAME+l-4, 4);
        
        if( (strcmp(buff,".dat") == 0) |(strcmp(buff,".Dat") == 0) )
        {
            BIL.DFILEM.FKIND = FDAT; 
            Visualizza(BIL.DFILEM.FKIND,BIL.DFILEM.DBFILENAME);
        }
        else if( (strcmp(buff,".bif") == 0) | (strcmp(buff,".Bif") == 0) )
        {
            BIL.DFILEM.FKIND = FBIF;
            Visualizza(BIL.DFILEM.FKIND,BIL.DFILEM.DBFILENAME);
        }
        else if( (strcmp(buff,".bhg") == 0) | (strcmp(buff,".Bhg") == 0) )
        {
            BIL.DFILEM.FKIND = FBIF;
            Visualizza(BIL.DFILEM.FKIND,BIL.DFILEM.DBFILENAME);
        }
        else
        {
            MMessageDialog("DAS information", "Unsupported format!!", " Ok ", NULL);  
//          break;
        }
                
    }   


    MShellSetWMCloseCallback(BIL.VFO.View_Sh, MGUIQuitCB, 0L);
    MMainLoop();


}

Here is the call graph for this function:

Here is the caller graph for this function:

SetScriptUseLabel()

void SetScriptUseLabel	(	int	master,
		char *	prgf,
		int	emode,
		MOBJECT	lbl
	)

Definition at line 2509 of file DAS_Spat.c.

References AboutCB(), DBDEMO, DI_SplitName(), MObjectSetText(), PRGFILE, SZAMASTERM, SZAMODE, TEMPORIZED, TESTAD, TESTAMS, TESTCCD, and TESTSZAMODE.

Referenced by SZA_FirstCalc().

{

    char buf[32];
    char str[255];
    int er=0;




    //If the program started in temporized mode write MASTER on the label on the control panel
    if(master)
    {
        if (emode == SZAMASTERM) 
            sprintf(buf,"MASTER SZA" );
        if (emode == TEMPORIZED) 
            sprintf(buf,"MASTER" );
        if ((emode == SZAMODE))
            sprintf(buf,"SZAMODE" );
        if ((emode == TESTSZAMODE))
            sprintf(buf,"TESTSZAMODE" );

        MObjectSetText(lbl, buf);
    }
    // altrimenti scrive il nome della tabella da eseguire
    else if(emode == PRGFILE)
    {
        //Devo mettere qualcosa che costruisca solo il nome del file
        //(devo leggere il file al contrario fino a che trovo "\")
        DI_SplitName(prgf, str, buf);
        //sprintf(buf,"%s",PrgFile );
        MObjectSetText(lbl, buf);

    }
    else
    {
        switch (emode)
        {
            case DBDEMO:
                sprintf(buf,"DEMO Use" );
                MObjectSetText(lbl, buf);
                AboutCB(NULL, NULL, (void *)1); //with 1 is a Modal Shell
                break;
            case TESTAMS:
                sprintf(buf,"TEST AMS Use" );
                MObjectSetText(lbl, buf);
                break;
            case TESTCCD:
                sprintf(buf,"TEST CCD Use" );
                MObjectSetText(lbl, buf);
                break;
            case TESTAD:
                sprintf(buf,"TEST AD Use" );
                MObjectSetText(lbl, buf);
                break;
            default:
                sprintf(buf,"Man Use" );
                MObjectSetText(lbl, buf);
                break;
        }
    }
     
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetWorkDirMGUIenv()

int SetWorkDirMGUIenv

(

char *

buff

)

set DAS and MGUI enviroment when the program is launched undirectly (for offlineplot or log or auto or autotimed modes)

Returns

int er = 0 –> Env setted er = -1–> ERROR Env. NOT setted

Definition at line 3353 of file DAS_Spat.c.

Referenced by ChkExeMode(), CloseShTempCB(), DB_ToolsKeyB_CB(), MDCreate2DPlot(), and MGUIMain().

{
    int s, er;
    
    // Sets the DAS Working Directory
    s = DI_FindDrive(buff);
    er = _chdrive(s);
    DI_FindDirName(buff, env);
    er = _chdir(env);

    // Set MGUI path
    sprintf(env, "MGUIDIR=%sSYS", MGetCurrentDirectory());
    er = putenv(env);
    
    return er;
    
}   

Here is the caller graph for this function:

SZA_FindMin()

void SZA_FindMin

(

void

)

computation of daily minimum SZA

Definition at line 2808 of file DAS_Spat.c.

References dsza::Dailymaxsza, dsza::Dailyminsza, das::DGeo, d_geo::latitude, d_geo::longitude, S_zenetr, SZACalc(), and d_geo::timezone.

Referenced by SZA_FirstCalc(), and Task_LOG().

{

    struct tm *newtime;
    long ltime;
    int h, m, t, er;
    float SZA[1440];
    float min = 360.0;
    float max= 0.0;


    time( &ltime );
    newtime = localtime( &ltime );


    t=0;
    for(h=0;h<24;h++)
    {
        for(m=0;m<60;m++)
        {
        
            newtime ->tm_hour = h;
            newtime ->tm_min = m;
            newtime ->tm_sec = 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);

            SZA[t] = (float)S_zenetr;
            t++;
    
        }
    }


    for(h = 0;  h< t; h++)
    {
        if(SZA[h] < min) min = SZA[h];
        if(SZA[h] > max) max = SZA[h];
    }
    // return the minimum element in the Numbers
    SZADelta.Dailyminsza = min;
    SZADelta.Dailymaxsza = max;

}

Here is the call graph for this function:

Here is the caller graph for this function:

SZA_FirstCalc()

void SZA_FirstCalc

(

void

)

Definition at line 2858 of file DAS_Spat.c.

References _MAX_PATH, flag::ADPC104, controlpanel::Albl_Azim, controlpanel::Albl_Elev, controlpanel::Albl_Script, controlpanel::Albl_sunr, controlpanel::Albl_suns, AMSINI_Err(), AssignParam(), BuildMainShell(), ChkDASInstance(), ChkMaster(), d_fileman::CONFIGDIREQUIPMENT, gui::ContrPanel, DAS_Error(), DB_ChooseButtons(), DB_KB_ButtonActive(), bil::DFILEM, das::DGeo, paramini::EqType, flag::ExeDSZA, flag::exemode, ExMaster(), flag::fileprg, FLAG, das::Flag, flag::ftpstatus, GetDateTime(), das::Gui, InitCCD_AMS(), InitTempAD(), pushbutt::KeyB, d_geo::latitude, LaunchBackTask(), controlpanel::lbl_Time, LoadAMS(), LoadExec(), LoadParam(), d_geo::longitude, Master, Master_Error(), MMainLoop(), MMessageDialog(), MObjectSetSensitive(), MObjectSetText(), OMU_HC(), on, das::Paramini, PrgFile, PRGFILE, PrgNum, gui::PushButt, RunFULL(), S_azim, d_geo::s_name, S_sunrise, S_sunset, S_zenetr, SetScriptUseLabel(), shells::Sh_Main, gui::Shells, flag::sza, SZA_FindMin(), SZACalc(), SZAMASTERM, SZAMax, SZAMODE, TEMPORIZED, TESTSZAMODE, d_geo::timezone, and WriteShellTitle().

{

    char    str[80];
    int er; 
//  char timebuf[9];
//  char datebuf[9];
//  long    dp = 500;
    struct tm newtime;
    struct time RTime;
    struct date RDate;
//    long ltime;
    float t_acc = 0;
    int mode;
//   _strdate(datebuf);

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

    //newtime = localtime( &ltime );

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


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

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

    /**************************************************************/
    // 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, "%.01lf", 90 - S_zenetr);   //S_elevref = elevation refracted
    MObjectSetText(DAS.Gui.ContrPanel.Albl_Elev, str);

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


    sprintf(str, "%.02lf", S_sunrise);   //S_elevref = elevation refracted
    MObjectSetText(DAS.Gui.ContrPanel.Albl_sunr, str);

    sprintf(str, "%.02lf", S_sunset);
    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;

    /**************************************************************/
    // 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

    }
    /**************************************************************/
    
    /**************************************************************/
    // write on the STATUS label
    sprintf(str, "Station: %s, Date: %d/%02d/%02d, Time: %02d:%02d:%02d, SolarZenithAngle:%.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);
    /**************************************************************/

    if (DAS.Flag.exemode == TEMPORIZED)
        mode = 0;
    else if (DAS.Flag.exemode == SZAMASTERM)
        mode = 1;
    else if(DAS.Flag.exemode == SZAMODE)
        mode = 2;
    else if(DAS.Flag.exemode == TESTSZAMODE)
        mode = 2;

    er = ChkMaster(mode);

    SZA_FindMin();
}

Here is the call graph for this function:

TaskWDT()

void TaskWDT	(	TIMEOUT_ID	id,
		void *	data
	)

Definition at line 1767 of file DAS_Spat.c.

References MRefreshTimeout(), TaskWDT(), ids::WDT, WDT_TASK_TIME, and WDTRefresh().

Referenced by TaskWDT(), and WDT_Task_CB().

{

    WDTRefresh();

    // Refresh the WDT tineout (if this instruction is not executed 
    //after 250 sec the PC reboot!!!)

    MRefreshTimeout(&IDS.WDT, WDT_TASK_TIME, TaskWDT, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

WDT_CB()

void WDT_CB	(	MOBJECT	p,
		void *	od,
		void *	ad
	)

Definition at line 1507 of file DAS_Spat.c.

References gui::ConfigPanel, D_Timing(), das::Gui, configpanel::lbltelap, MObjectGetText(), MObjectSetText(), das::Nova, configpanel::WDT_edt, WDT_flagstop, WDT_func(), and nova::WDT_TOUT.

Referenced by CONFP_AMS_NOVA().

{
    int     c = (int) ad, er;
    char buf[80];
    long timeout;

    MObjectGetText(p, buf);
    er = strcmp(buf, "Start");
    if (er==0)
    {
        MObjectSetText(p, "Stop");
        MObjectGetText(DAS.Gui.ConfigPanel.WDT_edt, buf);
        DAS.Nova.WDT_TOUT = atoi(buf);

        timeout = (long) (DAS.Nova.WDT_TOUT) * 1000;
        WDT_flagstop = 0;
        
        WDT_func(1); //1 --> Start WDT
        D_Timing(0, timeout);
    }
    else
    {
        WDT_flagstop = 1;
        MObjectSetText(p, "Start");
        WDT_func(0); //0 --> Stop WDT
        MObjectSetText(DAS.Gui.ConfigPanel.lbltelap, " ");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

WDT_func()

void WDT_func

(

int

mod

)

Definition at line 1572 of file DAS_Spat.c.

References DWORD, InByteR(), ISMM_Close(), ISMM_Open(), das::Nova, NOVA6612G2, NOVA7892, NOVA945GSE, OutByte(), nova::type, WDT_SetTimeout(), WDT_Start(), WDT_TASK_TIME, WDT_TIMEOPT_SECOND, and nova::WDT_TOUT.

Referenced by D_Timing(), ShutCB(), WDT_CB(), WDT_Task_CB(), and WinRes().

{

    int er;


    if (mod) //Start WDT 
    {
        if(DAS.Nova.type == NOVA7892)
        {
            er = OutByte(0x443, WDT_TASK_TIME);
            er = InByteR(0x443);
        }
        if(DAS.Nova.type == NOVA6612G2)
        {
            
                // The following parameters are used in the IOCTL call
            HANDLE  hndFile;            // Handle to device, obtain from CreateFile
//          UCHAR data_b;
            WDTPARAM    cParam;
            DWORD   nReturn;

            
            
            hndFile = CreateFile(WDT_DEVICE, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE,
                NULL, OPEN_EXISTING, 0, NULL);

            cParam.timeout=(unsigned char) WDT_TASK_TIME;
            DeviceIoControl(hndFile, IOCTL_SYS_WDT_SET_TIMEOUT,
                &cParam, sizeof(WDTPARAM), NULL, 0, &nReturn, NULL);
            DeviceIoControl(hndFile, IOCTL_SYS_WDT_START,
                NULL, 0, NULL, 0, &nReturn, NULL);

            CloseHandle(hndFile);
        }
        if(DAS.Nova.type == NOVA945GSE)
        {
            
            //Definition for NOVA945GSE I/O (IT8712F)
            HANDLE hIsmm;
//          HWM_DATA gHwmData;
//          UCHAR szBuf[32];
//          WORD wNodeCount, wBufSize, ii;
//          FLOAT *pfValue;
//          ULONG *plValue;
            //DIO Var
//          WORD wDioConfig;
//          WORD wDioOut;


            
            
            hIsmm = ISMM_Open();
            if (hIsmm == INVALID_HANDLE_VALUE)
            {
                printf("Can not open iSMM device\n");
            }

            WDT_SetTimeout(hIsmm, DAS.Nova.WDT_TOUT, WDT_TIMEOPT_SECOND);

            WDT_Start(hIsmm,1);

            ISMM_Close(hIsmm);
        }



    }
    else //STOP WDT
    {
        if(DAS.Nova.type == NOVA7892)
        {
            er = InByteR(0x843);
        }
        if(DAS.Nova.type == NOVA6612G2)
        {

                // The following parameters are used in the IOCTL call
            HANDLE  hndFile;            // Handle to device, obtain from CreateFile
//          UCHAR data_b;
//              WDTPARAM    cParam;
            DWORD   nReturn;

            
            hndFile = CreateFile(WDT_DEVICE, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE,
                NULL, OPEN_EXISTING, 0, NULL);
        
            DeviceIoControl(hndFile, IOCTL_SYS_WDT_STOP,
            NULL, 0, NULL, 0, &nReturn, NULL);

            CloseHandle(hndFile);
        }
        if(DAS.Nova.type == NOVA945GSE)
        {
            //Definition for NOVA945GSE I/O (IT8712F)
            HANDLE hIsmm;
//          HWM_DATA gHwmData;
//          UCHAR szBuf[32];
//          WORD wNodeCount, wBufSize, ii;
//          FLOAT *pfValue;
//          ULONG *plValue;
            //DIO Var
//          WORD wDioConfig;
//          WORD wDioOut;
            
            hIsmm = ISMM_Open();
            if (hIsmm == INVALID_HANDLE_VALUE)
            {
                printf("Can not open iSMM device\n");
            }

            WDT_Start(hIsmm,0);

            ISMM_Close(hIsmm);
        }

    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

WDT_Task_CB()

void WDT_Task_CB	(	MOBJECT	o,
		void *	od,
		void *	ad
	)

Definition at line 1547 of file DAS_Spat.c.

References MObjectGetText(), MObjectSetText(), MRefreshTimeout(), TaskWDT(), ids::WDT, WDT_func(), and WDT_TASK_TIME.

Referenced by CONFP_AMS_NOVA().

{

    int er;
    char buf[80];

    MObjectGetText(o, buf);
    er = strcmp(buf, "Launch Task");
    if (er==0)
    {
        MObjectSetText(o, "Task in Exec.");
        MRefreshTimeout(&IDS.WDT, WDT_TASK_TIME, TaskWDT, NULL);
    }
    else
    {
        MObjectSetText(o, "Launch Task");
        WDT_func(0);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

WDTRefresh()

void WDTRefresh

(

void

)

Definition at line 1701 of file DAS_Spat.c.

References DWORD, InByteR(), ISMM_Close(), ISMM_Open(), das::Nova, NOVA6612G2, NOVA7892, NOVA945GSE, nova::type, WDT_SetTimeout(), WDT_Start(), WDT_TASK_TIME, WDT_TIMEOPT_SECOND, and nova::WDT_TOUT.

Referenced by TaskWDT().

{
    int er=0;
    
    // The following parameters are used in the IOCTL call
//    HANDLE  hndFile;            // Handle to device, obtain from CreateFile
//      UCHAR data_b;
//      WDTPARAM    cParam;
//  DWORD   nReturn;
        if(DAS.Nova.type == NOVA7892)
        {
            er = InByteR(0x843); //TIMER STOP

            er = InByteR(0x443); //TIMER START
        }
        if(DAS.Nova.type == NOVA6612G2)
        {

                // The following parameters are used in the IOCTL call
            HANDLE  hndFile;            // Handle to device, obtain from CreateFile
//          UCHAR data_b;
            WDTPARAM    cParam;
            DWORD   nReturn;

            
            hndFile = CreateFile(WDT_DEVICE, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE,
                NULL, OPEN_EXISTING, 0, NULL);
            cParam.timeout=(unsigned char) WDT_TASK_TIME;
            DeviceIoControl(hndFile, IOCTL_SYS_WDT_SET_TIMEOUT,
                &cParam, sizeof(WDTPARAM), NULL, 0, &nReturn, NULL);
            CloseHandle(hndFile);
        }
        if(DAS.Nova.type == NOVA945GSE)
        {
            //Definition for NOVA945GSE I/O (IT8712F)
            HANDLE hIsmm;
//          HWM_DATA gHwmData;
//          UCHAR szBuf[32];
//          WORD wNodeCount, wBufSize, ii;
//          FLOAT *pfValue;
//          ULONG *plValue;
            //DIO Var
//          WORD wDioConfig;
//          WORD wDioOut;
            
            hIsmm = ISMM_Open();
            if (hIsmm == INVALID_HANDLE_VALUE)
            {
                printf("Can not open iSMM device\n");
            }

            WDT_SetTimeout(hIsmm, DAS.Nova.WDT_TOUT, WDT_TIMEOPT_SECOND);

            WDT_Start(hIsmm,1);

            ISMM_Close(hIsmm);
        }


}

Here is the call graph for this function:

Here is the caller graph for this function:

WriteShellTitle()

void WriteShellTitle	(	MOBJECT	o,
		int	eqt
	)

Definition at line 2176 of file DAS_Spat.c.

References DASREL, DASREV, DASREVDATE, GASCODNG1, GASCODNG2, GASCODNG3, GASCODNG4, LIS_, MShellSetTitle(), SPATRAM, SPATRAM2, SPATRAM3, SPATRAMPLUS, and TROPOGAS.

Referenced by SZA_FirstCalc().

{

    int c = eqt;
    char buf[128], str[16];

    switch (c)
    {
        case TROPOGAS:
            sprintf(str,"TROPOGAS");
            break;
        case SPATRAM:
            sprintf(str,"SPATRAM");
            break;
        case LIS_:
            sprintf(str,"LIS");
            break;
        case SPATRAMPLUS:
            sprintf(str,"SPATRAMPLUS");
            break;
        case GASCODNG1:
            sprintf(str,"GASCODNG1");
            break;
        case GASCODNG2:
            sprintf(str,"GASCODNG2");
            break;
        case GASCODNG3:
            sprintf(str,"GASCODNG3");
            break;
        case GASCODNG4:
            sprintf(str, "GASCODNG4");
            break;
        case SPATRAM3:
            sprintf(str,"SPATRAM3");
            break;
        case SPATRAM2:
            sprintf(str,"SPATRAM2");
            break;

        default:
            sprintf(str,"UNKNOWN");
            break;
    }
    sprintf(buf,"DAS Release %d.%.1lf (%s) - [Setting for %s]", DASREL, DASREV, DASREVDATE, str);
    MShellSetTitle(o, buf);                 

}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

AbsFilePos

long AbsFilePos

Absolute File position.

Definition at line 122 of file DAS_Spat.c.

Referenced by ViewNext(), and ViewNext_BIN().

AST

AzimuthSt AST

Definition at line 71 of file DAS_Spat.c.

BIL

bil BIL

Definition at line 74 of file DAS_Spat.c.

BlindPix

int BlindPix = 0

Number of blind pixels (usefull for Dark Current)

Definition at line 120 of file DAS_Spat.c.

Referenced by AutoR_No_Shutt(), AutoR_TestMeas(), AutoR_With_Shutt(), D_AssignLabelPlot(), D_Average(), D_Calibra(), D_pbr_CB(), DB_GetCCD(), DrawAreaPlotCB(), ReadHeader_ASCII(), ReadHeader_BIN(), and RemoveBlindPixels().

CCD_SetupFlg

int CCD_SetupFlg = 0

Definition at line 138 of file DAS_Spat.c.

Referenced by ApplyChCB(), CCDSetupCB(), and WriteParaminiCB().

Cfg

config Cfg

Camera controls & Options.

Definition at line 46 of file DAS_Spat.c.

ContFP

int ContFP = 0

Counter for File position.

Definition at line 123 of file DAS_Spat.c.

Referenced by CloseFile(), CloseFile_BIN(), ClosePlotCB(), D_PButt_CB(), MenuFileOLP_CB(), ViewNext(), ViewNext_BIN(), ViewPre(), and ViewPre_BIN().

countsopsh

unsigned long countsopsh

counting the number of opening shutter

Definition at line 133 of file DAS_Spat.c.

Referenced by DB_GetCCD(), and ShutterOpening().

DAS

das DAS

Definition at line 85 of file DAS_Spat.c.

DAS_StartDOY

int DAS_StartDOY

Definition at line 107 of file DAS_Spat.c.

Referenced by MGUIMain(), and SetWindowsReset().

DAS_StartHour

int DAS_StartHour

Definition at line 106 of file DAS_Spat.c.

Referenced by MGUIMain(), and SetWindowsReset().

DC_CCD

ccd DC_CCD

CCD settings.

Definition at line 44 of file DAS_Spat.c.

DC_HP

ptf DC_HP

Platform settings.

Definition at line 45 of file DAS_Spat.c.

DeltaTPrec

int DeltaTPrec

Definition at line 111 of file DAS_Spat.c.

Referenced by Task_LIS_Temp().

DeviceTypeInput

const char* DeviceTypeInput[] = {{"Direct"}, {"TelesExtLamp"}, {"Calib Lamps"}, {"Alt-Az Platf"}, {"Radiometer"}, {"TelesIntLamp"}, {"TelescopeV"}, {""}}

const char array for the Device type <-> Input association

Definition at line 247 of file DAS_Spat.c.

Referenced by CONFP_opt_page6().

DGEO

d_geo DGEO

geographical coordinates structure

Definition at line 53 of file DAS_Spat.c.

DIL

dil DIL

Definition at line 72 of file DAS_Spat.c.

DLOG

dlog DLOG

Definition at line 52 of file DAS_Spat.c.

Referenced by WriteLogAMS(), and writelogmotor().

DOAS

doas DOAS

Definition at line 63 of file DAS_Spat.c.

DPAL

palette DPAL

Definition at line 73 of file DAS_Spat.c.

DPWD

dpwd DPWD

Danbo Passw.

Definition at line 49 of file DAS_Spat.c.

dscb

DSCB dscb

Definition at line 67 of file DAS_Spat.c.

dsccb

DSCCB dsccb

Definition at line 68 of file DAS_Spat.c.

ExeREM

int ExeREM = 1

Definition at line 143 of file DAS_Spat.c.

Referenced by D_Calibra(), E_AAMeasure(), E_Almucantar(), E_AutoRange(), E_Average(), E_AvgCCDHor(), E_Azimuth(), E_Calibra(), E_ChkExLamp(), E_Dark(), E_DFMeasure(), E_DirectSun(), E_ExtLampOFF(), E_ExtLampON(), E_ExtShutClose(), E_ExtShutOpen(), E_Filter(), E_GetCCD(), E_Hg_Off(), E_Hg_On(), E_HGratCal(), E_HgScan(), E_Home_SM1(), E_Home_SM2(), E_Home_SM3(), E_Home_SM4(), E_Home_SM5(), E_Home_SM6(), E_IRefSun(), E_Lambda(), E_Meashor(), E_Meashor2(), E_Measure(), E_Mirror(), E_NDFilter(), E_Plot(), E_Qj_Off(), E_Qj_On(), E_QjScan(), E_Radio(), E_REM(), E_Save(), E_Zenith(), and FTP_Back_UP().

ExMast

master ExMast[PRGMAXNUM]

Definition at line 55 of file DAS_Spat.c.

Referenced by D_AutoExecution().

Fil_Code

char* Fil_Code[] = {{"NULL"}, {"UG11"}, {"UG1 "}, {"BG12"}, {"BG25"}, {"H475"}}

const char array for the realisation of the Filters buttons in the Filter shell

Definition at line 207 of file DAS_Spat.c.

Referenced by D_BuildH(), DB_Fil_CB(), HeaderInPlot(), MDCreateSh_Fil(), MDCreateSh_SimPos(), SD_FilterW(), SD_Position(), and SD_PosOMUDev().

Fil_Code8H

char* Fil_Code8H[] = {{"NULL"}, {"UG5"}, {"UG11"}, {"BG23"}, {"NULL"}, {"NULL"}, {"LPAS"}, {"NULL"}}

const char array for the realisation of the Filters buttons in the Filter shell

Definition at line 204 of file DAS_Spat.c.

Referenced by D_BuildH(), DB_Fil_CB(), DB_NDFil_CB(), HeaderInPlot(), MDCreateSh_Fil(), MDCreateSh_NDFil(), MDCreateSh_SimPos(), SD_FilterW(), SD_NDFilterW(), SD_Position(), and SD_PosOMUDev().

Fil_CodeNG

char* Fil_CodeNG[] = {{"NULL"}, {"B12 "}, {"B12F"}, {"B39 "}, {"B39F"}, {"UG5 "}}

const char array for the realisation of the Filters buttons in the Filter shell for GASCODNG2 and NG3 instruments

Definition at line 216 of file DAS_Spat.c.

Referenced by D_BuildH(), DB_Fil_CB(), DB_NDFil_CB(), HeaderInPlot(), MDCreateSh_Fil(), MDCreateSh_NDFil(), MDCreateSh_SimPos(), SD_FilterW(), SD_NDFilterW(), SD_Position(), and SD_PosOMUDev().

Fil_CodeNG1

char* Fil_CodeNG1[] = {{"NULL"}, {"B12 "}, {"S400"}, {"B39 "}, {"S500"}, {"UG5 "}}

const char array for the realisation of the Filters buttons in the Filter shell for GASCODNG1 instrument

Definition at line 213 of file DAS_Spat.c.

Referenced by D_BuildH(), DB_Fil_CB(), HeaderInPlot(), MDCreateSh_Fil(), MDCreateSh_SimPos(), SD_FilterW(), SD_Position(), and SD_PosOMUDev().

Fil_CodeTropo

char* Fil_CodeTropo[] = {{"NULL"}, {"BG28"}, {"UG11"}, {"BG12"}, {"BG23"}, {"HPas"}}

const char array for the realisation of the Filters buttons in the Filter shell for TROPOGAS instrument

Definition at line 210 of file DAS_Spat.c.

Referenced by D_BuildH(), DB_Fil_CB(), DB_NDFil_CB(), HeaderInPlot(), MDCreateSh_Fil(), MDCreateSh_NDFil(), MDCreateSh_SimPos(), SD_FilterW(), SD_NDFilterW(), SD_Position(), and SD_PosOMUDev().

FirstTime

int FirstTime = 1

Definition at line 110 of file DAS_Spat.c.

Referenced by Task_LIS_Temp().

FlgSM_Stop

int FlgSM_Stop = 1

Steppers Motor Activity: 0 = Motors moving; 1 = Motors stopped.

Definition at line 140 of file DAS_Spat.c.

Referenced by AMS_DoPos(), Task_CCD_Temp(), and Task_LIS_Temp().

FWS

FilterWheelSt FWS

Filter Wheel.

Definition at line 57 of file DAS_Spat.c.

Referenced by DB_PushButtonMouse_CB(), DB_save_img(), ExecSimPosCB(), HeaderInPlot(), HomeFiltersFast(), HomeNDFiltersFast(), ListTargetCB(), MDCreateSh_Fil(), MDCreateSh_NDFil(), MDCreateSh_SimPos(), SD_FilterW(), SD_Position(), and SD_PosOMUDev().

GRS

GratingSt GRS

Grating.

Definition at line 60 of file DAS_Spat.c.

HomePosition

char* HomePosition[] = {{"H_Mir"}, {"H_Grat"}, {"H_Filt"}, {"H_NDFilt"}, {"H_Zen"}, {"H_Azi"}, {"Close"}}

const char array for the realisation of the Filters buttons in the ND Filter shell

Definition at line 227 of file DAS_Spat.c.

Referenced by MDCreateSh_Home().

IDS

ids IDS

ID tasks.

Definition at line 54 of file DAS_Spat.c.

Referenced by DB_ToolsKeyB_CB(), E_Home_SM1(), HomeTrack(), and Task_HomeGrat().

IDX

int IDX

Number of sensible horizontal pixels.

Definition at line 118 of file DAS_Spat.c.

Referenced by AllocMat(), ApplyImgCB(), BuildLogRatio(), D_AssignLabelPlot(), D_Average(), D_AverageTFix(), D_Calibra(), D_pbr_CB(), D_PButt_CB(), D_PrintSpectrum(), DatOrBinFormat(), DB_CalcFluxI(), DB_Column(), DB_GetCCD(), DB_InitCamera(), DB_InitDil(), DB_save_img(), DrawAreaPlotCB(), DT_CorrFileEvora(), DT_CorrHeader(), FilterData(), GetDefPix(), ImatGrafInImat(), ImatInImatGraf(), LoadIo(), MaskCol(), MaskPix(), MaskRow(), MenuFileOLP_CB(), ReadHeader_ASCII(), ReadHeader_BIN(), RemoveBlindPixels(), RemoveSpikes(), SaveDataOffLine(), SaveIo(), ShiftImg(), SmoothData(), SmoothFloatData(), ViewNext(), ViewNext_BIN(), Visualizza(), WriteColumn(), WriteDataFile(), and WriteSelColandSmoothed().

IDY

int IDY

Number of sensible vertical pixels.

Definition at line 119 of file DAS_Spat.c.

Referenced by AllocMat(), ApplyImgCB(), BuildLogRatio(), D_AssignLabelPlot(), D_Average(), D_AverageTFix(), D_Calibra(), D_pbr_CB(), D_PButt_CB(), D_PrintSpectrum(), DatOrBinFormat(), DB_CalcFluxI(), DB_Column(), DB_GetCCD(), DB_InitCamera(), DB_InitDil(), DB_save_img(), DrawAreaPlotCB(), DT_CorrFileEvora(), DT_CorrHeader(), GetDefPix(), ImatGrafInImat(), ImatInImatGraf(), LoadIo(), LoadTestPalette(), MenuFileOLP_CB(), PButtSelAll_CB(), ReadHeader_ASCII(), ReadHeader_BIN(), RemoveBlindPixels(), SaveDataOffLine(), SaveIo(), SaveSpectrum(), ViewNext(), ViewNext_BIN(), ViewPlot(), Visualizza(), WriteColumn(), WriteDataFile(), and WriteSelColandSmoothed().

Incr_Read_Temp

int Incr_Read_Temp =0

Definition at line 101 of file DAS_Spat.c.

Referenced by D_readtemp(), and Task_LIS_Temp().

KeyCode

const char* KeyCode[]

Initial value:

= {{"AUTORNG"}, {"AVGCCD"}, {"BEGIN"}, {"CALIBRA"}, {"DARKC"}, {"EXPO"},
                    {"FILTER"}, {"GETCCD"}, {"H_FILTER"}, {"H_GRAT"}, {"H_MIRROR"}, {"HG_OFF"},
                    {"HG_ON"}, {"LABEL"}, {"MEASURE"}, {"MIRROR"}, {"PLOT"},{"QJ_OFF"},
                    {"QJ_ON"}, {"RADIO"}, {"REM"}, {"SAVE"}, {"WAIT"}, {"WAVELEN"}, {"XEND"}, 
                    {"MEASHOR"}, {"ELAMPON"}, {"ELAMPOFF"}, {"ESHUTOP"}, {"ESHUTCL"},
                    {"H_ZEN"}, {"H_AZI"}, {"ZENITH"}, {"AZIMUTH"}, {"AAMEASURE"}, {"AVGCCDHOR"},
                    {"CHKEXLAMP"}, {"AAPOSIT"}, {"IREFSUN"}, {"MEASHOR2"},{"SETCCDTEMP"},{"SETCCDVBIN"},
                    {"SETCCDPOW"}, {"NDFILTER"}, {"H_NDFW"}, {"DFMEASURE"}, {"SETCCDOFFS"}, {"QJSCAN"}, 
                    {"H_GRAT_CAL"}, {"HGSCAN"}, {"ALMUCANTAR"}, {"DIRECTSUN"} }

Definition at line 164 of file DAS_Spat.c.

Referenced by Fetch(), and MDCreatesh_vitesa().

LevelDefPix

unsigned int LevelDefPix = 100

Definition at line 126 of file DAS_Spat.c.

Referenced by ActEditCB(), and GetDefPix().

MainCommand

int MainCommand =0

Command switch in main loop.

Definition at line 105 of file DAS_Spat.c.

Referenced by D_AutoExecution().

Master

int Master = 0

Definition at line 100 of file DAS_Spat.c.

Referenced by ChkExeMode(), D_AutoExecution(), ManualModeCB(), SZA_FirstCalc(), Task_LIS_Temp(), and ViewPlot().

mattempbuff

unsigned int* mattempbuff

Definition at line 128 of file DAS_Spat.c.

Mir_Code

const char* Mir_Code[] = {{"Zenith "}, {"HorizDX"}, {"Calibra"}, {"HorizSX"}, {""}, {""}, {""}, {""}}

const char array for the realisation of the Mirrors buttons in the Mirror shell

Definition at line 231 of file DAS_Spat.c.

Referenced by CONFP_AMS_SM_OFFSET(), CONFP_opt_page6(), D_BuildH(), DB_Mir_CB(), DemoInitMotor(), HeaderInPlot(), HomeMirror(), MDCreateSh_Mir(), MDCreateSh_SimPos(), SD_Mirror(), SD_Position(), and SD_PosOMUDev().

Mir_CodeTropo

const char* Mir_CodeTropo[] = {{"Calibra "}, {"HorizDX"}, {"NULL "}, {"HorizSX"}, {""}, {""}, {""}, {""}}

const char array for the realisation of the Mirrors buttons in the Mirror shell for TROPOGAS

Definition at line 234 of file DAS_Spat.c.

Referenced by CONFP_AMS_SM_OFFSET(), CONFP_opt_page6(), D_BuildH(), DB_Mir_CB(), DemoInitMotor(), HeaderInPlot(), HomeMirror(), MDCreateSh_Mir(), MDCreateSh_SimPos(), SD_Mirror(), SD_Position(), and SD_PosOMUDev().

MIS

MirrorSt MIS

Mirror.

Definition at line 61 of file DAS_Spat.c.

Referenced by DB_PushButtonMouse(), DB_PushButtonMouse_CB(), DB_save_img(), ExecSimPosCB(), HeaderInPlot(), HomeMirror(), ListTargetCB(), MDCreateSh_Mir(), MDCreateSh_SimPos(), SD_Mirror(), SD_Position(), and SD_PosOMUDev().

Mode

int Mode

Definition at line 108 of file DAS_Spat.c.

MTCL

mtcl MTCL

MTColor.

Definition at line 62 of file DAS_Spat.c.

N_AVG

int N_AVG = 25

Number of measurements for Averaging mode in fixed number of meas. mode.

Definition at line 113 of file DAS_Spat.c.

Referenced by ActEditCB(), CONFP_opt_page1(), D_Average(), D_BuildH(), DB_RadioAvgModeCB(), HeaderInPlot(), LoadDB_Options(), and WriteOptioniniCB().

N_RM

int N_RM = 0

Number of measurements for Averaging mode in fixed exposure time mode.

Definition at line 114 of file DAS_Spat.c.

Referenced by D_Average(), D_BuildH(), and HeaderInPlot().

NDFil_Code

char* NDFil_Code[] = {{"NULL"}, {"ND1"}, {"ND2"}, {"ND3"}, {"ND4"}, {"H645"}}

const char array for the realisation of the Filters buttons in the ND Filter shell

Definition at line 219 of file DAS_Spat.c.

Referenced by D_AssignLabelPlot(), DB_NDFil_CB(), HeaderInPlot(), MDCreateSh_NDFil(), and SD_NDFilterW().

NDFWS

NDFilterWheelSt NDFWS

ND Filter Wheel.

Definition at line 58 of file DAS_Spat.c.

Referenced by DB_PushButtonMouse_CB(), MDCreateSh_NDFil(), and SD_NDFilterW().

NOVA

nova NOVA

Definition at line 77 of file DAS_Spat.c.

nowait

int nowait = 1

Definition at line 2389 of file DAS_Spat.c.

Referenced by MDCreateWaitShell(), and NoWaitCB().

nowaitsplash

int nowaitsplash = 1

Definition at line 2249 of file DAS_Spat.c.

Referenced by MDCreateSplashExe(), and NoWaitSplashCB().

OMUTEMP

omutemp OMUTEMP

structure for OMU temperatures

Definition at line 65 of file DAS_Spat.c.

OMUTHR

omuthr OMUTHR

Definition at line 75 of file DAS_Spat.c.

on

int on = 0

PRG execution control variabile.

Definition at line 109 of file DAS_Spat.c.

Referenced by D_AutoExecution(), DB_SelButt_CB(), DB_ToolsKeyB_CB(), and SZA_FirstCalc().

ON_OFFLINEPLOT

int ON_OFFLINEPLOT = 0

Definition at line 117 of file DAS_Spat.c.

Referenced by ActEditCB(), BuildLogRatio(), DB_DisplayCB(), DB_EqTypePlotCB(), DB_FilterCB(), DB_SpikesCB(), DB_XUnitsCB(), DrawAreaPlotCB(), PBYScale_CB(), ViewNext(), ViewNext_BIN(), ViewPlot(), and Visualizza().

PaletteMode

int PaletteMode

Definition at line 158 of file DAS_Spat.c.

Referenced by ColorSaveCB(), DB_CellExposeCB(), DB_ChangeColorCellCB(), and InitColors().

PLColor

unsigned long* PLColor[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

Definition at line 251 of file DAS_Spat.c.

PrgCnt

long PrgCnt

Counter for the position in the PRG file.

For PRG File.

Definition at line 93 of file DAS_Spat.c.

Referenced by D_Measure(), E_AAMeasure(), E_AAPos(), E_Almucantar(), E_Average(), E_AvgCCDHor(), E_Azimuth(), E_DFMeasure(), E_DirectSun(), E_Expo(), E_Filter(), E_IRefSun(), E_Label(), E_Lambda(), E_Meashor(), E_Meashor2(), E_Measure(), E_Mirror(), E_NDFilter(), E_Radio(), E_REM(), E_SetCCDOffSet(), E_SetCCDPow(), E_SetCCDTemp(), E_SetCCDVBin(), E_WAIT(), E_Zenith(), Fetch(), FTP_Back_UP(), LoadExec(), PRG_Check(), and PRG_ChkMeasAvg().

PrgFile

char PrgFile[_MAX_PATH]

Name of the PRG file.

Definition at line 91 of file DAS_Spat.c.

Referenced by ChkExeMode(), DB_ToolsKeyB_CB(), InitFlags(), ManualModeCB(), SZA_FirstCalc(), Task_LIS_Temp(), and ViewPlot().

PrgNum

int PrgNum = 0

Definition at line 96 of file DAS_Spat.c.

Referenced by SZA_FirstCalc().

PrgNumExe

int PrgNumExe = 0

number of PRG file in execution

Definition at line 98 of file DAS_Spat.c.

Referenced by ChkMaster(), and D_AutoExecution().

PrgNumInM

int PrgNumInM = 0

Actual number of PRG File in current MASTER or MASTERSZA File.

Definition at line 97 of file DAS_Spat.c.

Referenced by ChkMaster(), D_AutoExecution(), and ExMaster().

PrgSiz

long PrgSiz

Size of the PRG file.

Length of PRG file (bytes)

Definition at line 94 of file DAS_Spat.c.

Referenced by LoadExec(), and PRG_Check().

Program

char* Program

buffer for the PRG file

pointer to PRG file

Definition at line 90 of file DAS_Spat.c.

Referenced by D_Measure(), E_AAMeasure(), E_AAPos(), E_Almucantar(), E_Average(), E_AvgCCDHor(), E_Azimuth(), E_DFMeasure(), E_DirectSun(), E_Expo(), E_Filter(), E_IRefSun(), E_Label(), E_Lambda(), E_Meashor(), E_Meashor2(), E_Measure(), E_Mirror(), E_NDFilter(), E_Radio(), E_REM(), E_SetCCDOffSet(), E_SetCCDPow(), E_SetCCDTemp(), E_SetCCDVBin(), E_WAIT(), E_Zenith(), Fetch(), LoadExec(), PRG_Check(), and PRG_ChkMeasAvg().

REL_FILE_POS

long REL_FILE_POS[51]

relative File position

Definition at line 124 of file DAS_Spat.c.

Referenced by D_PButt_CB(), MenuFileOLP_CB(), ViewNext(), ViewNext_BIN(), and Visualizza().

Server

int Server = 0

Definition at line 253 of file DAS_Spat.c.

Referenced by ApplyImgCB(), AutoR_No_Shutt(), AutoR_TestMeas(), AutoR_With_Shutt(), CloseFile(), CloseFile_BIN(), D_Average(), D_AverageTFix(), D_BuildH(), D_Calibra(), D_XProfile(), D_YProfile(), DB_GetCCD(), DB_InitCamera(), DB_InitDil(), DB_Save(), DrawAreaPlotCB(), E_Dark(), GetDefPix(), HeaderInPlot(), ImatGrafInImat(), ImatInImatGraf(), MaskCol(), MaskPix(), MaskRow(), RemoveBlindPixels(), ViewNext(), ViewNext_BIN(), and Visualizza().

STEPM

stepm STEPM

Stepper Motors.

Definition at line 50 of file DAS_Spat.c.

SZADelta

dsza SZADelta

Definition at line 76 of file DAS_Spat.c.

Referenced by CONFP_param_page4(), DB_Pause(), edtDSZA_CB(), edtSZA_CB(), LoadDB_Options(), Task_CCD_Temp(), and WriteOptioniniCB().

SZAMax

int SZAMax = 100

Maximum SZA for performing measurements.

Definition at line 116 of file DAS_Spat.c.

Referenced by ActEditCB(), CONFP_opt_page3(), LoadDB_Options(), SZA_FirstCalc(), Task_Timer(), and WriteOptioniniCB().

TExp

double TExp

CCD Exposure time.

CCD Exposure time [sec].

Definition at line 130 of file DAS_Spat.c.

Referenced by AutoR_No_Shutt(), AutoR_TestMeas(), AutoR_With_Shutt(), AutoRange(), D_Average(), D_AverageTFix(), D_BuildH(), D_Measure(), DB_AskCB(), DB_CloseAsk(), DB_GetCCD(), DB_HorComm_CB(), DB_KeyB_CB(), DB_save_img(), E_ChkExLamp(), E_Dark(), GetDefPix(), HeaderInPlot(), and PerformMeas().

TOOLS

tools TOOLS

tools structure

Definition at line 51 of file DAS_Spat.c.

Total_Spec

long Total_Spec

Definition at line 95 of file DAS_Spat.c.

TOTTEXP

int TOTTEXP = 5

Total Exposure time in Averaging mode.

Definition at line 115 of file DAS_Spat.c.

Referenced by ActEditCB(), CONFP_opt_page1(), D_Average(), DB_RadioAvgModeCB(), LoadDB_Options(), and WriteOptioniniCB().

wav

long wav[]

Initial value:

= { 36803, 24479, 12180, 0, -12238, -24031, -35587,
                      -46808, -57645, -68842, -80254, -92674, -102911, -112526,
                      -121684, -130148, -137532, -144533}

Step Number definition - for SD_Grating.

Definition at line 195 of file DAS_Spat.c.

Referenced by CONFP_param_page2(), LoadWlstep(), SD_Grating(), SD_Position(), SD_PosOMUDev(), valstedt(), and WritewlstepiniCB().

WDT_flagstop

int WDT_flagstop

Definition at line 146 of file DAS_Spat.c.

Referenced by D_Timing(), and WDT_CB().

WDT_Timeout

unsigned char WDT_Timeout = 100

Definition at line 145 of file DAS_Spat.c.

wl

int wl[]

Initial value:

= { 2823, 3337, 3850, 4358, 4861, 5332, 5814, 
                     6282, 6734, 7201, 7677, 8195, 8622, 9023,
                     9405, 9758, 10066, 10358 }

WaveLength definition - for SD_Grating.

Definition at line 182 of file DAS_Spat.c.

Referenced by AutoR_SetND_Filter(), CalcSpectrumLimits(), CONFP_param_page2(), D_BuildH(), D_Calibra(), DB_save_img(), E_AAMeasure(), E_Almucantar(), E_Average(), E_AvgCCDHor(), E_DFMeasure(), E_DirectSun(), E_IRefSun(), E_Lambda(), E_Meashor(), E_Meashor2(), E_Measure(), HeaderInPlot(), LoadWlstep(), Lookfor4358(), LookforWl_X(), MDCreateDOAS_SetupSh(), MDCreateSh_Home(), MDCreateSh_SimPos(), MDCreateSh_Wl(), PRG_ChkMeasAvg(), SD_Grating(), SD_Position(), SD_PosOMUDev(), valwledt(), wledtCB(), and WritewlstepiniCB().

WlSet

int WlSet

Wavelength position definition - for SD_Grating.

Definition at line 135 of file DAS_Spat.c.

Referenced by DB_KeyB_CB(), DB_SheelESC(), and DB_Wl_CB().

ZST

ZenithSt ZST

Definition at line 70 of file DAS_Spat.c.