#include "diabolo.h"
#include "bolo.h"
#include "acqui.h"
#include "fichier.h"
#include "tm.h"
#include "tache.h"
#include "regul.h"
#include "auto.h"
#include "config_transputer.h" 
#include "bit_block.h" 




void init_struct(int PCI_actif)
{
int i,j;
def_long_block
def_nom_block
printf("memoire pour stglob: %d K  \nmemoire pour  tmtc : %d K \n",
			(sizeof(stglob)>>10),(sizeof(tmtc)>>10));

gg=malloc(sizeof(stglob));

random(-1);

if(parametr.numero_version!=version_num) {erreur("erreur numero de version\n");return;}
if(parametr.n_max_bolo!=nb_max_bolo) {erreur("erreur nb_max_bolo \n");return;}
if(parametr.n_per_block!=nb_per_block) {erreur("erreur nb_per_block\n");return;}
if(parametr.n_max_mes_per!=nb_max_mes_per) {erreur("erreur nb_max_mes_per\n");return;}
if(parametr.nb_bolo!=nb_max_bolo) {erreur("erreur nb_bolo_util\n");return;}

gg->reglage=reglage_standard[0];

for(j=0;j<nb_max_bolo;j++) 
		{
//		parametr.bolo[j].bolo_code_util=0;
//		strcpy(parametr.nom_coef[parametr.bolo[j].numero_nom_coef].bolo_nom,"");
//		parametr.bolo[j].bolo_bebo=0;
//		parametr.bolo[j].bolo_num=0;
//		parametr.bolo[j].bolo_gain=1000;
//		parametr.bolo[j].bolo_capa=0;
//		parametr.bolo[j].bolo_diviseur=0;
//		parametr.presence_bebo=0;
//    		parametr.coef[nb_max_bolo][7]  non  initialisé

		gg->reglage.bolo[j].mot1=0;
		gg->reglage.bolo[j].mot2=0;
//		gg->reglage.gainbrut[j]=0;
//		gg->reglage.gain[j]=1;
		}
gg->temps_cntl=0;
gg->depou_en_cours=0;
gg->trace_ouvert=0;
for(j=0;j<8;j++) gg->trace_tout[j]=0;
gg->scan_en_cours=0;
gg->flag_corel=0;
gg->flag_tc_reduite=0;
gg->fichier_dia2_ouvert=0;
gg->fichier_arch_ouvert=0;
gg->flag_fou=0;
gg->temps_origine=0;

//----------   initialise les structures de la tache     -------------
tt=malloc(sizeof(tmtc));

tt->PCI_actif=PCI_actif;
printf("tt->PCI_actif=%d \n",tt->PCI_actif);

tt->reglage=gg->reglage;

tt->vi.temps_cntl=0;

tt->signal_scan_immediat=0;
	// donc toujours zero pour archeops

for(j=0;j<nb_max_bolo;j++) 
	{
	tt->ds.ii[j]=0;
	}


tt->te.pos_ecrit=0;tt->te.pos_lit=0;
tt->tc.pos_ecrit=0;tt->tc.pos_lit=0;
tt->tm.pos_ecrit=0;tt->tm.pos_lit=0;



j=0;
for(i=0;i<nb_type_blocks;i++)	
	{
	printf(" - size=%5d   block : %s\n",long_block[i],nom_block[i]);
	if (long_block[i]> j ) j=long_block[i];
	}
printf(" taille maxi du block de telemesure = %d  //  on reserve %d octets par block \n",
		j,sizeof(block_type_modele));
if(j>sizeof(block_type_modele)) erreur("block_type_modele trops petit");




init_tache();	// init dependant des taches    

}



//_________________________________________________________________________________________________________________
int	test_erreur(void)
{
int err,i;
DateTimeRec date;
err=tt->te.pos_ecrit-tt->te.pos_lit;	if (err<0) err+=long_table_err;
if(err>0) 
	{
	GetTime(&date);
	printf("%dh%d:%d  : %d erreurs table: ",date.hour,date.minute,date.second,err);
	for(i=0;(i<err);i++)	{
		if(i<5)	switch(tt->te.err[tt->te.pos_lit])
			{
			case	900+err_sync_repart	: printf(" sync_repart");break;
//			case	900+err_fifo_demi	: printf(" fifo_demi");break;
			case	900+err_fifo_pleine	: printf(" fifo_pleine");break;
			case	900+err_sync_bebo	: printf(" sync-bebo");break;
			case	900+err_sync_ctrl	: printf(" sync-ctrl");break;
			case	900+err_lect_pci	: printf(" lect_pci");break;
			case	900+err_lect_ctrl	: printf(" lect_ctrl");break;
			case	900+err_synchro_block	: printf(" synchro_block");break;
			case	900+err_recut_un_block_ok: printf(" err_recut_un_block_ok");break;
			case	900+err_longueur_block  : printf(" err_longueur_block");break;
			case	900+err_sauve_block  	: printf(" err_sauve_block");break;
			case	900+err_pile_pleine	: printf(" err_pile_pleine");son(133);break;
			
			case	920+erreur_bit_erreur	: printf(" bit_erreur");break;
			case	920+erreur_bit_vide	: printf(" bit_vide");break;
			case	920+erreur_type		: printf(" bit_type_erreur");break;
			case	920+erreur_longueur	: printf(" bit_erreur_longueur");break;
			case	920+erreur_somme	: printf(" bit_erreur_somme");break;
			case	920+erreur_fin		: printf(" bit_erreur_fin");break;
			case	920+cherche_debut	: printf(" bit_cherche_debut");break;
			
			
			
			case	8	: printf(" +");break;
			case	9	: printf(" -");break;
			default	:	
				if(tt->te.err[tt->te.pos_lit]>=920)	
					printf("bit_%d ",tt->te.err[tt->te.pos_lit]-920);
				else	printf("  %d",tt->te.err[tt->te.pos_lit]);
				break;
			}
	tt->te.pos_lit++;  	if(	tt->te.pos_lit>=long_table_err) tt->te.pos_lit=0;
	}
	printf("\n");
	}
return(err);
}					
//_________________________________________________________________________________________________________________
 


// appel des bolo pour tracé des courbes individuelles
void affi_bolo(void)
{
static int affi1=0,affi2=0;
int j;
static long t=0;
if(!t) t=TickCount();
if(t>TickCount()) return;
t=TickCount()+60;		 //attente au minimum 1 sec entre 2 appels

for(j=0;j<nb_max_bolo;j++)	if(parametr.bolo[j].bolo_code_util) exec_bolo(j+1,tache_de_fond,0); 
}	






//*****************************************************************************************
//											***
#ifdef _archeops	//---------   pour  Archeops    ------------------------------	***
//											***
//*****************************************************************************************



//_________________________________________________________________________________________________________________
void	reset_epld(void)
{
char mot_tc[10];	
printf("reset epld");
emission_tc_reduite(tc2_reset,tc3_reset,tc4_reset);
emission_telecommande(tc_dir_reset_epld,mot_tc);

}

void	reset_trp(void)
{
char mot_tc[10];	
printf("reset trp");
emission_tc_reduite(tc2_reset,tc3_reset,tc4_reset);
emission_telecommande(tc_dir_reset_trp,mot_tc);
}


void	calfreq(int flag_on)	//  fabrique l'etat.bolo    gg->reglage.horloge  et  gg->periode_echantillonage
				// le flag_on dit s'il faut commander la sortie des data
{
double p,f1,f2,f3;
int pp,b,tm,flag;
char mot_tc[10];

p=litD(fenetre_acquisition,e_periode,0L);
if(p<4) p=4;	if(p>16) p=16;	//   butée sur la periode 
pp=p*5.;  p=(double)pp / 5.;
ecritD(fenetre_acquisition,e_periode,"%6.1f",p);  	// reconstruit p  

b=litD(fenetre_acquisition,e_nb_mes,0L);
if(b<18) {b=18;ecritD(fenetre_acquisition,e_nb_mes,b);}
if(b>44) {b=44;ecritD(fenetre_acquisition,e_nb_mes,b);}
b=b*2;


tm=litD(fenetre_acquisition,e_temp_mort,0L);	// temps mort = 1 .. nbmes par 1/4 per
if(tm<2) {tm=2;ecritD(fenetre_acquisition,e_temp_mort,tm);}
if(tm>13) {tm=13;ecritD(fenetre_acquisition,e_temp_mort,tm);}


flag=flag_on;
if(litD(fenetre_acquisition,e_flag1,0L))	flag +=2;		
if(litD(fenetre_acquisition,e_flag2,0L))	flag +=4;		

//printf(" b=%d  tm=%d  a=%d   h=%d \n",b,tm,a,h);

if(gg->flag_tc_reduite)
	{
	
	if((pp!=gg->reglage.horloge.periode) ou clavier(touche_alt) )	 emission_tc_reduite(tc2_horloge,tc3_periode,pp);
	if((b!=gg->reglage.horloge.nb_mesures) ou clavier(touche_alt) )	 emission_tc_reduite(tc2_horloge,tc3_nb_mesures,b);
	if((tm!=gg->reglage.horloge.temp_mort) ou clavier(touche_alt) )	 emission_tc_reduite(tc2_horloge,tc3_temp_mort,tm);
	if(flag ou (flag!=gg->reglage.horloge.flag) ou clavier(touche_alt) )  emission_tc_reduite(tc2_horloge,tc3_flag,flag);
	}

else
	{
	mot_tc[0]=tc_horloge;		//	commande valeur des horloges		
	mot_tc[1]=pp;			//	periode en multiple de 0.2µsec : de 20 a 80  soit  4 a 16 µsec 
	mot_tc[2]=b/2 ;			//	nb pts/demi periode de 23 a 44
	mot_tc[3]=tm;
	mot_tc[4]=flag;			//	c'est le flag qui met en route la sortie des mesures
	emission_telecommande(tc_dir_transputer,mot_tc);

	gg->reglage.horloge.periode=pp;
	gg->reglage.horloge.nb_mesures=b;			//  nombre de mesures dans une periode complete
	gg->reglage.horloge.temp_mort=tm;
	gg->reglage.horloge.flag=flag;

	}
// affichage de toutes les fréquences  
f1=1000/p;f2=f1/bitmot;f3=f2*1000./(double)(gg->reglage.horloge.nb_mesures);
ecritD(fenetre_acquisition,e_freq,"freq: %5.1f kHz  --  %5.2f kHz,    modulation: %5.1f Hz",f1,f2,f3);
printf("freq --> : %5.1f kHz  --  %5.2f kHz,    modulation: %5.1f Hz\n",f1,f2,f3);
gg->periode_echantillonage=0.5/f3;					//  2 fois la frequence de modulation
printf(" periode d'échantillonage= %g \n",gg->periode_echantillonage);

tt->reglage=gg->reglage;
fich_save_partiel(1);
}


#endif
//*****************************************************************************************
//											***
#ifdef _diabolo			//---------   pour  Diabolo    ------------------------------	***
//											***
//*****************************************************************************************

void	reset_epld(void)
{
}

void	calfreq(int flag_on)				//  fabrique l'etat.bolo    gg->reglage.horloge.nb_mesures  et  gg->periode_echantillonage
{
double p,f1,f2,f3;
int a,h,pp,b,tm;
int j;
char mot_tc[10];

p=litD(fenetre_acquisition,e_periode,0L);
b=litD(fenetre_acquisition,e_nb_mes,0L);
tm=litD(fenetre_acquisition,e_temp_mort,0L);	// temps mort = 1 .. nbmes par 1/4 per
if(tm<1) {tm=1;ecritD(fenetre_acquisition,e_temp_mort,tm);}
if(tm>b) {tm=b;ecritD(fenetre_acquisition,e_temp_mort,b);}
//  lecture externe ou local
h=litD(fenetre_acquisition,e_horloge_ext_,0L);

//if(p<5) p=5;				//    butée en periode minimum pour éviter de planter le Mac 


//----------------------------------------				nombre de mesures

if(b<4)	b=4;	if(b>44) b=44;		
gg->reglage.horloge.nb_mesures=(b/2)*4;

//----------------------------------------				periode de l'horloge de base
if (h&1)	p=p*frequ_horloge_externe;		
else		p=p*frequ_horloge_interne;

a=(p/frequ_divise)-ofset_periode ;

if(a<0) a=0;
if(a>1020) a=1020;  			// 10 bits maxi  attention a l'ofset 

pp=a+ofset_periode;
p=(double)(pp)*frequ_divise;
if (h&1)	 p=p/frequ_horloge_externe;		
else		p=p/frequ_horloge_interne;

ecritD(fenetre_acquisition,e_periode,"%6.1f",p);  // reconstruit p et pp 


//printf(" b=%d  tm=%d  a=%d   h=%d \n",b,tm,a,h);

mot_tc[0]=tc_horloge;			//79..72		
mot_tc[1]=(tm%7)+ ((b/2)<<3) ;	//71..64 3 bit temps mort et 5 bit  mb (nombre de coups par 1/4 de periode = b/2)
mot_tc[2]=(a>>8);			//63..56 poid fort (2 bits)
mot_tc[3]=a;				//55..48 poid faible (8 bits)
mot_tc[4]=h&3;			//47..40 horloge externe et bolo-iram
emission_telecommande(0,mot_tc);


// affichage de toutes les fréquences  
f1=1000/p;f2=f1/bitmot;f3=f2*1000./(double)(gg->reglage.horloge.nb_mesures);
gg->periode_echantillonage=0.5/f3;		//  2 fois la frequence de modulation
											// periode * 16 * nbdemesure / 2  
//printf(" durée= %ld \n",gg->periode_echantillonage);

ecritD(fenetre_acquisition,e_freq,"freq: %5.1f kHz  --  %5.2f kHz,    modulation: %5.1f Hz",f1,f2,f3);



	{//_______________    fabrique les detections synchrones de la modulation électrique 
	int i,v,tm;
	tm=litD(fenetre_acquisition,e_temp_mort,0L);
	gg->reglage.temp_mort=tm;
												// detection plus/moins avec tm  points supprimé
												//		ds[0] ==  plus / moins	
												//		ds[1] ==  plus / plus
												//		ds[2] ==  + - 0 /  - + 0
	
	tt->ds.dsnorme=0;
	i=0;
	for(v=0	;v<gg->reglage.horloge.nb_mesures/2	;v++)	
		{
		if(v<tm) 	tt->ds.dstable[i]=0;
		else 		{tt->ds.dstable[i]=1;	tt->ds.dsnorme++;}
		i++;
		}
	for(v=0;v<gg->reglage.horloge.nb_mesures/2	;v++)	
		{
		if(v<tm) 	tt->ds.dstable[i]=0;
		else 		{tt->ds.dstable[i]=-1;	tt->ds.dsnorme++;}
		i++;
		}	
	}
//printf(" normes = %d  %d \n",tt->ds.dsnorme[0],tt->ds.dsnorme[1]);
tt->reglage=gg->reglage;
fich_save_partiel(1);
}


//*****************************************************************************************
//											***
#endif		//--------------------------------------------------------------------	***
//											***
//*****************************************************************************************




void 	deglitch(void)
{
int j;
double x,dx;
static int debut=1;
static double X[nb_max_bolo];
static double DX[nb_max_bolo];
if(debut) 
	{
	for(j=0;j<nb_max_bolo;j++)
		{
		X[j]=0;DX[j]=1000;
		}
	debut=0;
	}

for(j=0;j<nb_max_bolo;j++)	
	{
	x=gg->don.don_bolo[j];
	dx=x-X[j]; if(dx<0)  dx=-dx;
	if( dx > DX[j] ) 
		{
		printf("glitch bolo %d  ancien X=%g  nouveau x=%g  DX=%g \n",j+1,X[j],x,DX[j]);
		gg->don.don_bolo[j]=X[j];
		DX[j] *=1.1;
		}
	else	{
			DX[j]=0.9 * DX[j] + 0.5 * dx +1 ; 
			X[j]=x;
			}		// en moyenne, 5 fois l'interval moyen
	}

}