#include "cw3dgrph.h" 
#include "3DGraphCtrl.h"
#include <ansi_c.h>
#include <cvirte.h>		
#include <userint.h>
#include <utility.h>
#include <formatio.h> 
#include <oaidl.h> 
#include "oleauto.h" 
#include <gpib.h>
#include <rs232.h>
#include <userint.h>
#include "hp875x.h" 
#include "asynctmr.h" 
#include "initialisation_banc.h"
#include "esp_controleur.h"  
#include "emission.h"

  
int acquisition_AS_single_scan(int panel,int choix_analyseur)
{
	
	
	
	char tampon[100],tampon2[1000],tampon3[5000];
	char dir_name[5000],date[100],sp[100],att[100],Ref_Lev[100],Res_Band[100];
	const char field_comp_txt[6][3] = {"Hx", "Hy", "Hz", "Ex", "Ey", "Ez"};
	
	int i,j,k,p;
	int nb_pas_x,nb_pas_y,nb_pas_1,nb_pas_2;
	int pos_courante_x,pos_courante_y,pos_courante_z;
	int zero_span,cf,nb_freq; 
	int vitesse; 
	int compteur,pourcentage;
	int puissance;
	int param_ampli,param_generateur,choix_appareil,attenuation; 
	int erreur;	
	int h,mn,s,day,month,year,etat;
	int field_comp;

	
	float pas,pasX,pasY,pas_x,pas_y,pasx_x,pasx_y,pasx_z,pasy_x,pasy_y,pasy_z,nb_pas_x_f,nb_pas_y_f;
	float pas1_x,pas1_y,pas1_z,pas2_x,pas2_y,pas2_z; 
	float length_x,length_y, Pt1Pt2,Pt1Pt3;
	float tabxy[3]={0};
	float pos[3][3];
	float xo,yo,zo,probe_dist;
	float span;
	

	double champ[100]={0};
	double tab_freq[100]={0};
	

	
	FILE *fichier,*fichier1,*fichier2,*fichier3,*fichierf,*xml;
 
	//Variables pour l'affichage du GRAPH3D
	int ii,jj;
	int r,g,b;
	int couleur[64];
	int values[64];
	
	int nb_blocks, nb_bytes;
	char message[100];
	
	long ix[2];
    double **data;
	
	
	
	unsigned int numAllocatedBlocks, numAllocatedBytes;
	void *memory = malloc (1234);
	
	
	
	
	VARIANT vArray,var1,var2;
	SAFEARRAY * psa;
	SAFEARRAYBOUND rgsabound[2];
    
    CAObjHandle plotsHandle = 0;
	CAObjHandle axesHandle=0;
	CAObjHandle axeHandle=0; 


	GetProjectDir (dir_name);
	sprintf(dir_name,"%s\\resultats_emission\\",dir_name);
	SplitPath (dir_name, NULL, dir_name, NULL);
	SetDir (dir_name);
	GetSystemTime (&h, &mn, &s);
	sprintf(dir_name,"%s_%dh-%dm-%ds",DateStr(),h,mn,s);
	MakeDir (dir_name);
	SetDir (dir_name);
	
	stop=0;
	
	//Lecture des fréquences
	GetNumTextBoxLines (panel,EMISSION_frequences, &nb_freq);
	GetTextBoxLineLength (panel,EMISSION_frequences, nb_freq-1, &val);


	//Création des fichiers de résultats 
	//----------------------------------------------------------------
	fichier=fopen("mesure_xyz.txt","wt");							
	fprintf(fichier,"%%x(mm)\t\ty(mm)\t\tz(mm)\t");										 
	fclose(fichier);												 
																	 
	for (i=0;i<nb_freq;i++)											 
		{															 
			GetTextBoxLine (panel,EMISSION_frequences, i, tampon);   
			sscanf(tampon,"%lf",&tab_freq[i]);						 
																	 
			fichier=fopen("mesure_xyz.txt","at");					 
			
			GetCtrlVal(panel, EMISSION_FIELD_COMPONENT, &field_comp);
			fprintf(fichier,"\t%s(%4.2f Hz)",field_comp_txt[field_comp],tab_freq[i]);  
			
		} 															 
	//fichier=fopen("mesure_xyz.txt","at");							 
	fprintf(fichier,"\n");
	fclose(fichier);											 
	//-----------------------------------------------------------------	
			
	// Chargement du fichier colormap pour la création des couleurs 
	GetProjectDir (tampon3);
	sprintf(tampon3,"%s\\colormap\\colormap.txt",tampon3);
	fichier1=fopen(tampon3,"rt");
	for (i=0;i<64;i++)
			{
				//fscanf(fichier,"%d\t%d\t%d",&rgb[i][0],&rgb[i][1],&rgb[i][2]);
				fscanf(fichier1,"%d\t%d\t%d",&r,&g,&b);
				couleur[63-i] = MakeColor (r, g, b);
				values[i]=i;
			}
	fclose(fichier1);   

				
	// OBTENTION DES HANDLES QUAND LES CONTROLES ACTIVEX SONT CREES
    GetObjHandleFromActiveXCtrl (panel,EMISSION_3DGRAPH, &graphHandle);
    CW3DGraphLib__DCWGraph3DGetPlots (graphHandle, NULL, &plotsHandle);
    CW3DGraphLib_CWPlots3DItem (plotsHandle, NULL, CA_VariantInt(1),&plotHandle); 

			
	stop=0;
	compteur=0;
	SetCtrlVal(panel,EMISSION_NUMERICSLIDE,0);
			
	
	//Récupération des positions de la surface à scanner (les 3 points du rectangle)			
	//----------------------------------------------------
	//Point 1
	GetCtrlVal(panel,EMISSION_pos_x1,&pos[0][0]);
	GetCtrlVal(panel,EMISSION_pos_y1,&pos[1][0]);
	GetCtrlVal(panel,EMISSION_pos_z1,&pos[2][0]);
	xo=pos[0][0];
	yo=pos[1][0];
	zo=pos[2][0];

	//Point 2
	GetCtrlVal(panel,EMISSION_pos_x2,&pos[0][1]);
	GetCtrlVal(panel,EMISSION_pos_y2,&pos[1][1]);
	//GetCtrlVal(panel,EMISSION_pos_z2,&pos[2][1]);
	pos[2][1]=pos[2][0];	

	//Point 3
	GetCtrlVal(panel,EMISSION_pos_x3,&pos[0][2]);
	GetCtrlVal(panel,EMISSION_pos_y3,&pos[1][2]);
	//GetCtrlVal(panel,EMISSION_pos_z3,&pos[2][2]);
	pos[2][2]=pos[2][0]; 
	//-----------------------------------------------------
			

	//Lecture des paramètres:
	GetCtrlVal (panel, EMISSION_vitesse, &vitesse);
	demande_vitesse(1,vitesse);
	demande_vitesse(2,vitesse);
	demande_vitesse(3,vitesse);
			
		
	//Surface à scanner et Pas en x et y  , les pas sont affichés en mm  
	GetCtrlVal (panel, EMISSION_Length_X, &length_x);	
	GetCtrlVal (panel, EMISSION_Length_Y, &length_y);
	
	GetCtrlVal (panel, EMISSION_pas_x, &pasX);
	GetCtrlVal (panel, EMISSION_pas_y, &pasY);	
	
	
	// 1. utilisation des dimensions Length_x et Length_y
	//----------------------------------------------------
	
	GetCtrlVal(panel,EMISSION_BINSWITCH_AREA,&val_area); 
	if ( val_area==1)
		{
			Pt1Pt2=length_x;
			Pt1Pt3=length_y; 
			nb_pas_x=(int)(Pt1Pt2/pasX);
			nb_pas_y=(int)(Pt1Pt3/pasY);
			
			if (nb_pas_x==0)
				{
					pasx_x=0.0;
					pasx_y=0.0;
					pasx_z=0.0;
				}
			else
				{
					pasx_x=pasX;
					pasx_y=0.0;
					pasx_z=0.0;
				}
	
			if (nb_pas_y==0)
				{
					pasy_x=0.0;
					pasy_y=0.0;
					pasy_z=0.0;
				}
			else
				{
					pasy_x=0.0;
					pasy_y=pasY;
					pasy_z=0.0;
				} 
			
		}
		//---------------------------------------------------- 
			
	else
				
	// 2. utilisation des 3 points Pt1, Pt2 & Pt3
	//----------------------------------------------------
		{
			Pt1Pt2= sqrt( pow((pos[0][1]-pos[0][0]),2) + pow((pos[1][1]-pos[1][0]),2) + pow((pos[2][1]-pos[2][0]),2));
			Pt1Pt3= sqrt( pow((pos[0][2]-pos[0][0]),2) + pow((pos[1][2]-pos[1][0]),2) + pow((pos[2][2]-pos[2][0]),2));
			nb_pas_x=(int)(Pt1Pt2/pasX);
			nb_pas_y=(int)(Pt1Pt3/pasY); //RoundRealToNearestInteger
			
			if (nb_pas_x==0)
				{
					pasx_x=0.0;
					pasx_y=0.0;
					pasx_z=0.0;
				}
			else
				{
					pasx_x=pasX;
					pasx_y=0.0;
					pasx_z=0.0;
				}
	
			if (nb_pas_y==0)
				{
					pasy_x=0.0;
					pasy_y=0.0;
					pasy_z=0.0;
				}
			else
				{
					pasy_x=0.0;
					pasy_y=pasY;  
					pasy_z=0.0;
				}
		}
		  //---------------------------------------------------- 
		
	
			
	// choix du sens de déplacement selon les directions X ou Y
	//--------------------------------------------------------------
	GetCtrlVal (panel, EMISSION_BINSWITCH_SC, &val_sens);
	if (val_sens==0)
			
		{
			nb_pas_1=nb_pas_x;
			pas1_x=pasy_x;
			pas1_y=pasy_y;
			pas1_z=pasy_z;
	
			nb_pas_2=nb_pas_y;
			pas2_x=pasx_x;
			pas2_y=pasx_y;
			pas2_z=pasx_z;
				
		}
	else
		{
			nb_pas_1=nb_pas_y;
			pas1_x=pasx_x;
			pas1_y=pasx_y;
			pas1_z=pasx_z;

			nb_pas_2=nb_pas_x;
			pas2_x=pasy_x;
			pas2_y=pasy_y;
			pas2_z=pasy_z;
		}
	//------------------------------------------------------------------
		
	
			
	GetCtrlVal(panel, EMISSION_BINSWITCH_GEN,&param_generateur); 
	GetCtrlVal(panel, EMISSION_puissance,&puissance); 				 
			
	// Ouverture de port GPIB du générateur de signaux Marconi2031 (Anritsu 68347C) 
	//----------------------------------------------------------------------------
	if (param_generateur==1)
		{
			GetCtrlVal(panel, EMISSION_MENU_GEN,&val_gen); 
			if (val_gen==0)
				{
					sprintf(write_buffer,"IMODE NORMAL;CFRQ:VALUE %eHZ; RFLV:VALUE %dDBM;ON\n",tab_freq[0],puissance);
					gpibWrite (Marconi2031, write_buffer);	
				}
			else
				{
					sprintf(write_buffer,"RFLV:VALUE %dDBM;ON\n",puissance);  
	     			gpibWrite(Anritsu_68347C,write_buffer);
				}
		
		}
			
		
		
	//Initialisation de l'analyseur de spectre
	//-------------------------------------------------------
	GetCtrlVal(panel, EMISSION_BINSWITCH_ZS,&zero_span);
	
	//HP 8591A
	if (zero_span==0 && choix_analyseur==0)
		{
			sprintf(write_buffer,"IP;SNGLS");  	 // Instrument Preset , single sweep , 
			gpibWrite(analyseur,write_buffer);
		}
	
	//HP E4402B & Ag N9020A
	if (zero_span==0 && choix_analyseur==1 || zero_span==0 && choix_analyseur==2)
		{
			sprintf(write_buffer,":INIT:CONT OFF"); // Instrument Preset , single sweep , 	  
			gpibWrite(analyseur,write_buffer);
		}
	//-------------------------------------------------------
			
			
	// Configuration de l'analyseur de spectre si necessaire.
	// lecture des valeurs SPAN , CF et ATT
	//---------------------------------------------------------
	GetCtrlVal (panel, EMISSION_MENU_INSTRUM, &val);
	GetCtrlVal(panel, EMISSION_SPAN,&span); 
	GetCtrlVal(panel, EMISSION_ATT,&attenuation);
	
	// HP 8591A
	if (choix_analyseur==0)
		{
			//GetCtrlVal(panel, EMISSION_CF,&cf);
			//sprintf(write_buffer,"SP %dMHZ;CF %dMHZ;",span,cf);
			sprintf(write_buffer,"SP %fMHZ;",span);
			gpibWrite(analyseur,write_buffer);
			// Prise en compte de l'Attenuation de l'analyseur 
			sprintf(write_buffer,"AT %dDB",attenuation);
			gpibWrite(analyseur,write_buffer);
			//Seep time			
			sprintf(write_buffer,"ST 70MS");
			gpibWrite(analyseur,write_buffer);
			//RBW			
			sprintf(write_buffer,"RB 3KHZ");
			gpibWrite(analyseur,write_buffer);
			//VBW			
			sprintf(write_buffer,"VB 10KHZ");
			gpibWrite(analyseur,write_buffer);
			//Ref Level			
			sprintf(write_buffer,"RL -10DBM");
			gpibWrite(analyseur,write_buffer); 
		} 
	
	// E4404 & N9020A
	if (choix_analyseur==1 || choix_analyseur==2 )
	{
		//GetCtrlVal(panel,PANEL_SCAN_CF,&cf);
		//sprintf(write_buffer,":SENS:FREQ:CENT %d MHZ;",cf);
		//ibwrt (device, write_buffer, strlen(write_buffer));
		sprintf(write_buffer,":SENS:FREQ:SPAN %d MHZ;",span);
		gpibWrite(analyseur,write_buffer);
		// Prise en compte de l'Attenuation de l'analyseur
		sprintf(write_buffer,":SENS:POW[:RF]:ATT %ddB",attenuation);  
		gpibWrite(analyseur,write_buffer);
		// choix du Format
		//sprintf(write_buffer,":FORM REAL,32;"); 
		//gpibWrite(analyseur,write_buffer); 
	}
	//----------------------------------------------------------
	
	
	// Génération du fichier matlab pour générer la cartographie 3D du scan
	//---------------------------------------------------------------------
	fichier2=fopen("champ.m","at");
	
	fprintf(fichier2,"x=0:%f:%f; %%en mm\n",pasx_x,Pt1Pt2);
	fprintf(fichier2,"y=0:%f:%f; %%en mm\n",pasy_y,Pt1Pt3);
	fprintf(fichier2,"mesure=load('mesure_xyz.txt');\n");
	fprintf(fichier2,"compteur1=1;\n");
	fprintf(fichier2,"compteur2=1;\n");
	fprintf(fichier2,"for m=1:length(mesure)\n");  
	;
	for (k=1;k<=nb_freq;k++)
		{
			fprintf(fichier2,"\tchamp_freq%i(compteur1,compteur2)=mesure(m,3+%i);\n",k,k); 
		}	
	  
	fprintf(fichier2,"\tcompteur1=compteur1+1;\n"); 
	fprintf(fichier2,"\tif (compteur1==length(y)+1) \n"); 
	fprintf(fichier2,"\t\tcompteur1=1;\n"); 
	fprintf(fichier2,"\t\tcompteur2=compteur2+1;\n");
	fprintf(fichier2,"\tend;\n"); 
	fprintf(fichier2,"end;\n"); 
	GetCtrlVal(panel, EMISSION_FIELD_COMPONENT, &field_comp);	
	
	for (k=1;k<=nb_freq;k++)
		{
			fprintf(fichier2,"figure(%i);\n",k);	
			fprintf(fichier2,"surf (x,y,champ_freq%i);\nshading interp;\ncolorbar;\n",k); 
			fprintf(fichier2,"xlabel('X(mm)','FontWeight', 'bold','FontAngle','oblique','FontSize',12);\n");
			fprintf(fichier2,"ylabel('Y(mm)','FontWeight', 'bold','FontAngle','oblique','FontSize',12);\n\n");
			fprintf(fichier2,"title('%s(%fHz)','FontWeight', 'bold','FontAngle','oblique','FontSize',12);\n",field_comp_txt[field_comp],tab_freq[k-1]) ;
			fprintf(fichier2,"figure(2*%i+1);\n",k);
			fprintf(fichier2,"contourf (x,y,champ_freq%i,60);\nshading flat;\ncolorbar;\n",k);
			fprintf(fichier2,"xlabel('X(mm)','FontWeight', 'bold','FontAngle','oblique','FontSize',12);\n");
			fprintf(fichier2,"ylabel('Y(mm)','FontWeight', 'bold','FontAngle','oblique','FontSize',12);\n\n");
			fprintf(fichier2,"title('%s(%fHz)','FontWeight', 'bold','FontAngle','oblique','FontSize',12);\n",field_comp_txt[field_comp],tab_freq[k-1]) ;
		}
	fclose(fichier2);   
	//-------------------------------------------------------------------------
	
	
	//Sauvegarde des paramètres de positionnement
	//------------------------------------------------
	fichier3=fopen("param_mesure.txt","at");
	fprintf(fichier3,"Paramètres de Mesure du %s %s\n",DateStr (),TimeStr ());
	fprintf(fichier3,"------------------------------------------------\n"); 
	fprintf(fichier3,"Point 1 : %f,%f,%f\n",pos[0][0],pos[1][0],pos[2][0]);
	fprintf(fichier,"Point_2=[%f %f %f];\n",pos[0][1],pos[1][1],pos[2][1]);
	fprintf(fichier3,"Point_3=[%f %f %f];\n",pos[0][2],pos[1][2],pos[2][2]);
	fprintf(fichier3,"Nb Pas x = %d , Nb Pas y = %d\n",nb_pas_x,nb_pas_y);
	fprintf(fichier3,"Pas x = %f mm\tPas y = %f mm\n\n",pasx_x,pasy_y);
	p=0;
	for (i=0;i<nb_freq;i++)
		{   
			p=4+i;
			fprintf(fichier3,"colonne(%d)=>champ(%e Hz)\n",p,tab_freq[i]);  
		}
			
	//Lecture et sauvegarde des paramètres de l'analyseur
	//---------------------------------------------------
	
	if (choix_analyseur==0) 
		{
			// Resolution Bandwidth
			gpibWrite(analyseur,"RB?");
			gpibRead(analyseur,read_buffer,2000);
			sscanf(read_buffer,"%s",Res_Band);
			fprintf(fichier3,"\nRBW=%s ",Res_Band);
	
			// SPAN 
			gpibWrite(analyseur,"SP?");
			gpibRead(analyseur,read_buffer,2000);
			sscanf(read_buffer,"%s",sp);
			fprintf(fichier3,"\nSPAN=%s ",sp);
			
			// Référence/ Range Level 
			gpibWrite(analyseur,"RL?");
			gpibRead(analyseur,read_buffer,2000);
			sscanf(read_buffer,"%s\n",Ref_Lev);
			fprintf(fichier3,"\nRef level=%s ",Ref_Lev);
			
			// Atténuation
			gpibWrite(analyseur,"AT?");
			gpibRead(analyseur,read_buffer,2000);
			sscanf(read_buffer,"%s",att);
			fprintf(fichier3,"\nAttenuation=%s ",att);
		}
	
	else 
		{
			// Resolution Bandwidth
			gpibWrite(analyseur,":SENS:BAND|BWID :RES?");
			gpibRead(analyseur,read_buffer,2000);
			sscanf(read_buffer,"%s",Res_Band);
			fprintf(fichier3,"\nRBW=%s ",Res_Band);
	
			// SPAN 
			gpibWrite(analyseur,":SENS:FREQ:SPAN?");
			gpibRead(analyseur,read_buffer,2000);
			sscanf(read_buffer,"%s",sp);
			fprintf(fichier3,"\nSPAN=%s ",sp);
			
			// Référence/ Range Level 
			gpibWrite(analyseur,":DISP:WIND:TRAC:Y[:SCAL]: RLEV?");
			gpibRead(analyseur,read_buffer,2000);
			sscanf(read_buffer,"%s\n",Ref_Lev);
			fprintf(fichier3,"\nRef level=%s ",Ref_Lev);
			
			// Atténuation
			gpibWrite(analyseur,":SENS:POW[:RF]:ATT?");
			gpibRead(analyseur,read_buffer,2000);
			sscanf(read_buffer,"%s",att);
			fprintf(fichier3,"\nAttenuation=%s ",att);
		}
	//-------------------------------------------------------
		
	//Sauvegarde des paramètres du générateur
	//-------------------------------------
	fprintf(fichier3,"\nGénérateur : P=%d dBm\n",puissance);	
			
			
	//Sauvegarde des notes
	GetCtrlVal (panel,EMISSION_TEXTBOX_NOTES,tampon3); 
	fprintf(fichier3,"\n-------------------------------------\n%s\n-------------------------------------\n",tampon3);
		
	fclose(fichier3);  */
	//--------------------------------------------------------
		
		
			
	//Allocation du tableau contenant les mesures
	//-------------------------------------------
	data = (double **)malloc((nb_pas_1+1)*sizeof(double *));
	for (i=0;i<=nb_pas_1;i++)
		data[i]=(double *)malloc((nb_pas_2+1)*sizeof(double));  
	
	
	
	//Initialisation du graph
	CW3DGraphLib_CWPlot3DClearData (plotHandle, NULL);
	//CW3DGraphLib__DCWGraph3DSetDefaultView (graphHandle, NULL);
	CW3DGraphLib_CWPlot3DSetColorMapStyle (plotHandle, NULL, CW3DGraphLibConst_cwCustom);
	CA_VariantSet1DArray (&vArray, CAVT_INT, 64, &couleur);
	CW3DGraphLib_CWPlot3DSetColorMapColors (plotHandle, NULL, vArray);
	CA_VariantSet1DArray (&vArray, CAVT_INT, 64, &values);
	CW3DGraphLib_CWPlot3DSetColorMapValues (plotHandle, NULL, vArray);
	CW3DGraphLib_CWPlot3DSetColorMapInterpolate (plotHandle, NULL, VTRUE);
	CW3DGraphLib_CWPlot3DSetColorMapAutoScale (plotHandle, NULL, VTRUE);
	CW3DGraphLib__DCWGraph3DGetAxes (graphHandle, NULL, &axesHandle);
	CW3DGraphLib_CWAxes3DItem (axesHandle, NULL, CA_VariantInt(1),&axeHandle);
	CW3DGraphLib_CWAxis3DSetMinMax (axeHandle, NULL, CA_VariantInt(0),CA_VariantInt(nb_pas_1));
	CW3DGraphLib_CWAxes3DItem (axesHandle, NULL, CA_VariantInt(2),&axeHandle);
	CW3DGraphLib_CWAxis3DSetMinMax (axeHandle, NULL, CA_VariantInt(0),CA_VariantInt(nb_pas_2)); */ 
			
			
			
	// Balayage du rectangle fixé par les points: Pt1, Pt2 et Pt3
    //-----------------------------------------------------------------------
	
	//lecture_pos_xyz(&pos_courante_x,&pos_courante_y,&pos_courante_z);

	pos_courante_x=pos[0][0],pos_courante_y=pos[1][0],pos_courante_z =pos[2][0] ;

	

	//fichier=fopen("mesure_xyz.txt","at");
	
	fprintf(fichierf,"Freq(Hz)\t\t%s\n",field_comp_txt[field_comp]);   
	
										 
	xml=fopen("mesure_xyz.xml", "at");
	fprintf(xml,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); 

	fprintf(xml, "<EmissionScan>\n");
	fprintf(xml,"<Filename>mesure_xyz.xml</Filename> ");
	
	   
	fprintf(xml,"<Date>%s %dh-%dmn-%ds</Date>",DateStr(),h,mn,s); 
	fprintf(xml,"<Source>ESEO</Source>");
	fprintf(xml,"<Copyright>This document is the property of ESEO</Copyright>"); 
	
	fprintf(xml, "<Field_Component>%s</Field_Component>\n", field_comp_txt[field_comp]);
	
	fprintf(xml, "<Setup><Config>\n<Att>%s</Att>\n<RefLevel>%s</RefLevel>\n<Span>%s</Span>\n</Config>\n",att,Ref_Lev,sp);
	
	
	GetCtrlVal (panel,EMISSION_btn_LNA_60_dB,&val_LNA);  
	if(val_LNA==1)
		fprintf(xml,"<Transducer>\n<Gain>60.0</Gain>\n</Transducer> ");
	else
		fprintf(xml,"<Transducer>\n<Gain>0.0</Gain>\n</Transducer>");
	
	fprintf(xml, "</Setup>");
	fprintf(xml, "<Data>\n");
	fprintf(xml, "<Coordinates>Left-handed Cartesian</Coordinates>\n");
	fprintf(xml, "<X0>%fmm</X0>\n",pos[0][0]); 
	fprintf(xml, "<Xstep>%fmm</Xstep>\n",pasX);
	fprintf(xml, "<Xmax>%fmm</Xmax>\n",pos[0][0]+length_x);
	
	fprintf(xml, "<Y0>%fmm</Y0>\n",pos[1][0]); 
	fprintf(xml, "<Ystep>%fmm</Ystep>\n",pasY);
	fprintf(xml, "<Ymax>%fmm</Ymax>\n",pos[1][0]+length_y);*/
	
	GetCtrlVal(panel, EMISSION_probe_dist, &probe_dist);
	fprintf(xml, "<Z0>%fmm</Z0>\n", probe_dist);   
	
	fprintf(xml, "<Frequencies>\n<Unit>Hz</Unit>\n<List>");
	for(k=0;k<nb_freq;k++)
			fprintf(xml, "%e ", tab_freq[k]);
	fprintf(xml, "\n</List>\n</Frequencies>\n");
	fprintf(xml, "<Measurement>\n<Unit>dBm</Unit>\n<Unit_x>mm</Unit_x>\n<Unit_y>mm</Unit_y>\n<Unit_z>mm</Unit_z>\n"); 
	fprintf(xml,"<List>\n");  

	for (i=0;i<=nb_pas_1;i++)
		{//Boucle sur l'axe des X

			for (j=0;j<=nb_pas_2;j++)
				{//Boucle sur l'axe des Y
					
					if (stop==1) //Fin du scan
						{
							if (zero_span==0 && choix_analyseur==0)
								{
									sprintf(write_buffer,"CONTS;");  //single Sweep
									gpibWrite(analyseur,write_buffer); 
								}
							ibloc (analyseur);    //Passage au mode "Local" (commande manuelle)
					
							if (param_generateur==1)
								{
									if (val_gen==0) 
										ibloc (Marconi2031); //Passage au mode "Local" (commande manuelle)
									else
										ibloc (Anritsu_68347C); //Passage au mode "Local" (commande manuelle)
								} 
							return 0;
						} 
			
					if (j==0) 
						{
							demande_vitesse(1,vitesse);
							demande_vitesse(2,vitesse);
							demande_vitesse(3,vitesse);
				 		}
					
					fichier=fopen("mesure_xyz.txt","at");
					
					tabxy[0]=pos[0][0]+(pas2_x*i)+(pas1_x*j);
		    		tabxy[1]=pos[1][0]+(pas2_y*i)+(pas1_y*j);
		    		tabxy[2]=pos[2][0]+(pas2_z*i)+(pas1_z*j); 
			         
					deplacement_pt1_pt2(pos_courante_x,pos_courante_y,pos_courante_z,tabxy[0],tabxy[1],tabxy[2]);

		    		pos_courante_x=tabxy[0];
		    		pos_courante_y=tabxy[1];
		    		pos_courante_z=tabxy[2];
					
					fprintf(fichier,"%f\t%f\t%f",tabxy[0],tabxy[1],probe_dist); 
					fprintf(xml,"%f\t%f\t%f\t",tabxy[0],tabxy[1],probe_dist); 
        			fprintf(stderr,"682" );
        
					//Boucle sur les fréquences
					for (k=0;k<nb_freq;k++)
						{
							 if (param_generateur==1)
								 {
									 if (val_gen==0)  // Set Marconi 2031 parameters 
										{  //sprintf(write_buffer,":SOUR:FREQ:CW %e;",tab_freq[k]);
											sprintf(write_buffer,"CFRQ:VALUE %eHZ; RFLV:VALUE %dDBM;ON\n",tab_freq[k],puissance);  
											gpibWrite(Marconi2031, write_buffer);
										}
									else
										{	// Set Anritsu 68347C parameters  
											sprintf(write_buffer,"CFRQ:VALUE %eHZ; RFLV:VALUE %dDBM;ON\n",tab_freq[k],puissance);  
											gpibWrite(Anritsu_68347C, write_buffer);
										}	
							 	 }
							 fprintf(stderr,"700" );
	
							if (choix_analyseur==0)  // HP 8591A
								{
									sprintf(write_buffer,"CF %fHZ;",tab_freq[k]);
									gpibWrite(analyseur,write_buffer); 
								}
							
							fprintf(stderr,"708" );	
							if (choix_analyseur==1)  // HP E4402B
								{
									sprintf(write_buffer,":SENS:FREQ:CENT %f HZ;",tab_freq[k]);
									gpibWrite(analyseur,write_buffer);
								}
							
							if (choix_analyseur==2)  // HP N9020A
								{
									sprintf(write_buffer,"FREQ:CENT %f HZ;",tab_freq[k]);  
									gpibWrite(analyseur,write_buffer);
									sprintf(write_buffer,":FORMAT:DATA:REAL,32");  
									gpibWrite(analyseur,write_buffer);
								}
							//Delay(0.6); 
							Sleep(600);
							fprintf(stderr,"724" );
							//Mesure avec HP 8591A   
							if (choix_analyseur==0 ) 
								{
									if (zero_span==0) //Lecture en zero span 
										{   
											//	Delay(1);
											gpibWrite(analyseur,"MKA?");  			 //Marker AMplitude 
											gpibRead(analyseur,read_buffer,2000);
										}
									else
										{ 
											sprintf(write_buffer,"TS;MKPK HI;MKA?"); //Peak high Amplitude  
											gpibWrite(analyseur,write_buffer); 
											Sleep(500);
											fprintf(stderr,"740 ");
											gpibRead(analyseur,read_buffer,2000);
											ibrda (analyseur, read_buffer, 2000);
											while (!(ibsta & CMPL))
												{
													ibwait(analyseur,0);
													ProcessSystemEvents ();
												} 
										}
									fprintf(stderr,"749" );	
								}
							
							else
								{//Mesure avec HP E4404E & N9020A
									if (zero_span==0) //Lecture en zero span    
										{   
											gpibWrite(analyseur,":CALC:MARK:Y?\n");  			  
											gpibRead(analyseur,read_buffer,2000);
										}
									else
										{   	     
											sprintf(write_buffer,":INIT:IMM;*WAI;:CALC:MARK:MAX;:CALC:MARK:Y?;");  
											gpibRead(analyseur,read_buffer,2000);
											Sleep(600);
											ibrda (analyseur, read_buffer, 2000);
											while (!(ibsta & CMPL))
												{
													ibwait(analyseur,0);
													ProcessSystemEvents ();
												} 
										}	
								}
							
							// prise en compte du LNA_60dB 
							if (val_LNA==0)
								champ[k]=atof(read_buffer);
							else
								champ[k]=atof(read_buffer)-60;
								
							 fprintf(stderr,"778" );	
						   
							data[i][j]=champ[k];
			
							fprintf(fichier,"\t%e",champ[k]);
							
							fprintf(stderr,"787" );	
							
													
							// sauvegarde des coordonnées au format XML 
							fprintf(xml,"%e\n",champ[k]); 
							
							fflush(fichier);
							fflush(xml);
							
							fprintf(stderr,"796");	
							
							compteur++;

							//Mise à jour de la barre de progression
					    	pourcentage= ((float)compteur/((nb_freq)*(nb_pas_x+1)*(nb_pas_y+1)))*100;
					    	SetCtrlVal(panel,EMISSION_MESURESLIDE,pourcentage);
							
						}  // Fin de la boucle des fréquences  
					fprintf(fichier,"\n");
					fflush(fichier);
					fclose(fichier); 
					
					fprintf(stderr,"813" );	     	
		
				}  // Fin de la boucle sur Y 
			
			
			//Update du graph à la fin de chaque ligne de scan
			//--------------------------------------------------
			 fprintf(stderr,"818" );	
			if (i>0)
				{
					rgsabound[0].lLbound = 0;
					rgsabound[0].cElements = i+1;
					rgsabound[1].lLbound = 0;	 				//limite inférieure du tableau (array)
					rgsabound[1].cElements = nb_pas_2+1;   		// Nbr d'élément dans la dimension
					psa = SafeArrayCreate(VT_R8, 2, rgsabound); // Création d'un SAFEARRAY (tableau) de variants
					fprintf(stderr,"828" );						//  VT_R8 -> double ; Dimension=2 (X,Y)
		       	 	// Remplissage du tableau.					// rgsabound->limites du tableau 
					for (ii=0;ii<=i;ii++)
		        		{
		        			for (jj=0;jj<=nb_pas_2;jj++)
		        				{
		        					ix[0]=ii;
		        					ix[1]=jj;
		        					SafeArrayPutElement(psa, ix, &data[ii][jj]);
		        				}
		        		}
					fprintf(stderr,"838" );
		        	CA_VariantSetSafeArray (&vArray, CAVT_DOUBLE, psa);
		        	CW3DGraphLib_CWPlot3DPlot3DSimpleSurface (plotHandle, NULL, vArray,CA_DEFAULT_VAL);

					SafeArrayDestroy(psa);	  //libérez les ressources associées au VARIANT crée par SafearrayCreate
			
				}    
							   
			fprintf(stderr,"844" );	
	
		
		} // Fin de la boucle sur X 

	   
	
	
	fprintf(xml,"</List>\n"); 
	fprintf(xml, "</Measurement>\n");
	fprintf(xml, "</Data>\n");
	fprintf(xml, "</EmissionScan>\n"); 
	fclose(xml);
	fclose(fichier);   
	
	// Retour à la position de départ
		
	demande_vitesse(1,15);
	demande_vitesse(2,15); 
	demande_vitesse(3,15); 
	//deplacement_pt1_pt2(pos_courante_x,pos_courante_y,pos_courante_z,pos[0][0],pos[1][0],pos[2][0]);
	deplacement_pt1_pt2(pos_courante_x,pos_courante_y,pos_courante_z,xo,yo,zo); 
	//deplacement_to_xyz(xo,yo,zo); 
	   	 	
    arret_deplacement();
		
			
	//Libération du tableau contenant les mesures
	//--------------------------------------------
	/*	for (i=0;i<=nb_pas_1;i++)
			free(data[i]);
		free(data);  */



	return 0;
					
}