#include "diabolo.h"
#include "bolo.h" 
#include "auto.h" 
#include "tm.h" 

//#define bon_type(j)		( (litD(fen,auto_thermo,0)&&(parametres.bolo_type[j]==0)) ou(litD(fen,auto_voie1,0)&&(parametres.bolo_type[j]==1)) ou(litD(fen,auto_voie2,0)&&(parametres.bolo_type[j]==2)) ou(litD(fen,auto_voie3,0)&&(parametres.bolo_type[j]==3)) ) 
#define bon_type(j)	1


int	vg[nb_max_bolo];			// 0 ou vieux gain pour remonter le gain


//--------------------  fonction  exec  de  la  fenetre : auto  -------------------------------

void exec_auto(int fen,int item,double valeur,...) 
{
int j;
if(item>1000) item-=1000;		// pour appeler le case pour tous les cara d'un edit texte

switch(item)
    {
    case ouverture	:
/*    case auto_bolo_couleur :
    case auto_bolo_couleur+1 :
    case auto_bolo_couleur+2 :
    case auto_bolo_couleur+3 :
    case auto_bolo_couleur+4 :
    case auto_bolo_couleur+5 :
    case auto_bolo_couleur+6 :
    case auto_bolo_couleur+7 :
    case auto_bolo_couleur+8 :
    case auto_bolo_couleur+9 :
    case auto_bolo_couleur+10 :
    case auto_bolo_couleur+11 :
    case auto_bolo_couleur+12 :
    
    				for(i=0;i<max_couleur;i++)	
    					{
    					bolo_couleur[i]=litD(fen,auto_bolo_couleur+i,0L);
    					if( (bolo_couleur[i]<1) ou (bolo_couleur[i]>nb_max_bolo) )   bolo_couleur[i]=0;
    					printf(" i=%d bolo=%d    ",i,bolo_couleur[i]);
    					}
    				printf("\n");
*/				break;		
				    
    
    
    
    case caseferme  :		cache(fen);	infos(fen)->action=0;	break;
   
    case auto_tout_auto :	
				for(j=0;j<nb_max_bolo;j++)	
					if( fenetre(j+1) && (!litD(j+1,b_bloq,0L)) && bon_type(j) )
						{ecritD(j+1,b_auto,1);auto_control(j,auto_force);}
				break;
         
    case auto_rien_auto :  					
				for(j=0;j<nb_max_bolo;j++)	
					if( fenetre(j+1) && (!litD(j+1,b_bloq,0L)) && bon_type(j))
						ecritD(j+1,b_auto,0);
				break;

    case auto_transitoire_auto :	
				for(j=0;j<nb_max_bolo;j++)	
					if( fenetre(j+1) && (!litD(j+1,b_bloq,0L)) && bon_type(j) )
						exec_bolo(j+1,b_auto_trans,0);
				break;
         

    case auto_fixe_gain :  					
				for(j=0;j<nb_max_bolo;j++)	
					if( fenetre(j+1) && bon_type(j))  
						if(!litD(j+1,b_bloq,0L)) 	exec_bolo(j+1,b_gain,litD(fen,auto_gain,0L));
				break;


    case auto_fixe_courant :  					
				for(j=0;j<nb_max_bolo;j++)	
					if( fenetre(j+1) && bon_type(j))  
						if(!litD(j+1,b_bloq,0L)) 	exec_bolo(j+1,b_tri,litD(fen,auto_courant,0L));
				break;

						
    case auto_auto_val :	break;
    case auto_gain :		break;
    default  :			break;
    }
}


void auto_transitoire(int bolo,int ct)	
{
int i;
double a,tt,dd;
int n=gg->reglage.horloge.nb_mesures;
static double	coef[nb_max_bolo]={0,0};
static double	val_p[nb_max_bolo];
def_gains
if(ct%4!=0)	return;

if(coef[0]==0)	for(i=0;i<nb_max_bolo;i++)	coef[i]=0.05;


tt=0;for(i=0;i<n;i++)
	{
	a=(double) ((gg->bol_per[bolo-1][i]&0x7fff)-0x4000);	//  16 bit utiles dans     gg->bol_per
			// FONCTION :   3 -1 -1 -1 -3 1 1 1 
	switch(8*i/n)
			{
			case 0	:	tt	+=	3*a;	break;
			case 1	:	tt	-=	a;	break;
			case 2	:	tt	-=	a;	break;
			case 3	:	tt	-=	a;	break;
			case 4	:	tt	-=	3*a;	break;
			case 5	:	tt	+=	a;	break;
			case 6	:	tt	+=	a;	break;
			case 7	:	tt	+=	a;	break;
			default	:	break;
			}
	}
tt/=0.01*(double)parametr.bolo[bolo-1].bolo_gain*gain_ampli(gg->reglage.bolo[bolo-1]);

printf("transitoire auto ct=%d  bolo %d  : ",ct,bolo);
printf(" valeur tt=%g ",tt);


if(ct==16)		// premiere mesure en 20  :  change le coef  en  16 
	{
	double rr;
/*	correction faite				= ( tt - val_p[bolo-1] )
	correction qu'il falait faire			=	- val_p[bolo-1]
	
	la correction  en valeur de dac faite	=	 val_p[bolo-1] * coef[bolo-1]
	
	la correction dac qu'il aurait fallu faire 	 val_p[bolo-1] * coef[bolo-1]	* (- val_p[bolo-1]) / ( tt - val_p[bolo-1] )
*/	
	if(val_p[bolo-1] -tt ) 		rr =  ( val_p[bolo-1]) / (  val_p[bolo-1]-tt );
	if(rr<0.2) rr=0.2;
	if(rr>4) rr=4;
	coef[bolo-1]= coef[bolo-1] * rr;
	printf(" calcul du coef = coef=%g \n", coef[bolo-1]);

	}
	

val_p[bolo-1]=tt;
//dd=(double)gg->reglage.dac[d_trans][bolo-1] + tt * coef[bolo-1] ;	// nouvelle valeur de transitoire
dd=(double)dac_T(gg->reglage.bolo[bolo-1]) + tt * coef[bolo-1] ;	// nouvelle valeur de transitoire

while( (dd<-10) ou (dd>4010) )  {coef[bolo-1]*=0.8;dd=(double)dac_T(gg->reglage.bolo[bolo-1]) + tt * coef[bolo-1] ;}
	
printf(" coef=%g  :  valeur nouvelle du DAC =%g \n",coef[bolo-1],dd);

exec_bolo(bolo,b_trans,dd);
}



int	test_saturation(int bolo)
{
int i,sat;
int n=gg->reglage.horloge.nb_mesures;

sat=0;for(i=0;i<n;i++)
	{
	if ( ((gg->bol_per[bolo-1][i]&0x7fff)<0x400)  
		ou ((gg->bol_per[bolo-1][i]&0x7fff)>0x7c00) ) sat++;//  16 bit utiles dans     gg->bol_per
	}
return(sat);
}




void auto_control(int bolo,int mode)	// voir les modes
{
static int ct[nb_max_bolo],cg[nb_max_bolo];	// static compteur pour changement carre et gain  auto
static int at[nb_max_bolo];			// attente pour ne pas changer plusieurs fois a la suite
double nseuil;
double  y;int yi;
int cc;
double r,coef;	//  point convert.  /  µV 
def_gains;
//printf("autocontrole de bolo%d en mode %d \n",bolo,mode);

coef=pt_micV(bolo);			//  point convert.  /  µV 
coef=coef*litD(fenetre_auto,auto_correct,0L);	// correction augmentée artificiellement
nseuil=litD(fenetre_auto,auto_auto_val,0L);		// seuil defini dans la fenetre violette
cc=xbolbrut(bolo-1)*coef;							// correction exacte

if(  (ct[bolo-1]>10) ou   (ct[bolo-1]<-10)  ) {ct[bolo-1]=0;cg[bolo-1]=0;}	// initialisation si n'importe quoi
if(  (at[bolo-1]>20) ou   (at[bolo-1]<0)  ) 	at[bolo-1]=0;			// initialisation si n'importe quoi


//____________  test de depassement 	: 	change  ct ++ ou --  : change le carré si ct > 2 en module

if	 (xbolbrut(bolo-1)>nseuil)  ct[bolo-1]++;
else	{
	if (xbolbrut(bolo-1)<-nseuil) 	ct[bolo-1]--;
	else ct[bolo-1]=0;
	}


//printf("bolo %d : moyenne=%g   valeur=%g  ct=%d  cg=%d \n",bolo,gg->xx[bolo-1][1],gg->xx[bolo-1][0],ct[bolo-1],cg[bolo-1]);

//_____________   action de correction

if(((longueur_table_tm+tt->tm.pos_ecrit-tt->tm.pos_lit)%longueur_table_tm)>2)	return;

if ( (litD(fenetre_auto,auto_verouille,0)==1) && gg->scan_en_cours &&  (mode==auto_val) ) return;							// pas de corrections pendant le scan
if ( (litD(fenetre_auto,auto_verouille,0)==2)  && (gg->don.sync[sync_subscan] && gg->don.sync[sync_scan]) &&  (mode==auto_val) ) return;			// pas de corrections pendant les subscan


if(litD(bolo,b_bloq,0L))  return;				// sort si blocqué



if(test_saturation(bolo)>5)					//*****************************  baisse le gain si sature
	{
	printf("bolo %d sature (sat=%d) cg=%d \n",bolo,test_saturation(bolo),cg[bolo-1]);
	if(!vg[bolo-1]) vg[bolo-1]=gainbrut(gg->reglage.bolo[bolo-1]);
	cg[bolo-1]++;
	at[bolo-1]=5; 						// ne va pas changer le carre avant 5 sec
	if(cg[bolo-1]>2)
		{
		yi=gainbrut(gg->reglage.bolo[bolo-1]);
		if (yi>=16)	yi=yi&3;
		yi--;
		if(yi<0) yi=0;
//		exec_bolo(bolo,b_gain,yi);
		ecritD(bolo,b_gain,yi);ecritgain(bolo);
		cg[bolo-1]=0;
		son(130);
		}			
	}


if(at[bolo-1]) {at[bolo-1]--;return;}


if( (mode==auto_carre) ou (mode==auto_force) ou (ct[bolo-1]>2) ou (ct[bolo-1]<-2) )//*************************  change le carre		
	{
	at[bolo-1]=5; 						// attend 5 coups avant de changer une seconde fois								// change le carre apres 3 fois depassement
	if( (r=litD(bolo,b_auto_R,0L)) ==0 ) 	
		{
		y=(double)dac_V(gg->reglage.bolo[bolo-1])-cc;
		exec_bolo(bolo,b_carre,y);
		}
	else 							//  ************     mesure a resistance donnee
		{
		cc=cc*2;					// correction double pour converger plus vite  
		y=(double)dac_V(gg->reglage.bolo[bolo-1])-cc;	// nouvelle valeur de tension
		exec_bolo(bolo,b_carre,y);
		
		r = 1e-6 *	( y / pt_micV(bolo) ) /r ;	// y/pt_micV  donne des microvolts
								// I = V / R (V en volt, R en MOhm) -> I en µA
												
		printf(" carre=%g  I=V/r =%g nA  ",y,r*1000);	// V en pts,  I en nA 
															 
		r *= pt_micA(bolo);				// changement i en valeur triangle
		printf(" triangle=%g  \n",r);
		exec_bolo(bolo,b_tri,r);
		}
	ct[bolo-1]=0;
	son(130);
	}			

//if(bolo==3) printf(" vg=%d  at=%d \n",vg[bolo-1],at[bolo-1]);
if(at[bolo-1]) return;

if(vg[bolo-1]) 			//  *********************  remonte le gain
	{
	yi=gainbrut(gg->reglage.bolo[bolo-1]);
	if (yi>=16)	yi=yi&3;
	if(yi>=vg[bolo-1])	vg[bolo-1]=0;
	else		{
//			exec_bolo(bolo,b_gain,yi+1);
			printf("remonte gain\n");
			ecritD(bolo,b_gain,yi+1);ecritgain(bolo);
			son(130);
			at[bolo-1]=5; // attend 5 coups avant de rechanger le carre ou le gain
			}		
	cg[bolo-1]=0;
	son(130);
	}
	

}




//-----------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------
//--------------------  fonction  exec  de  la  fenetre : automatismes  -------------------
//-----------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------



void exec_automatismes(int fen,int item,double valeur,...) 
{
int i,a;
long ll;
if(item>0)	for(i=0;i<nombre_de_voies;i++)
    	{
    	ll=(long)(&(gg->reglage.autom[i].mode))-(long)(&(gg->reglage.autom[0]));
    	a=litD(fenetre_automatismes,atm_auto+i,0L)-1;
    	if( (a!=gg->reglage.autom[i].mode) ou ( /*clavier(touche_alt) et*/ (item==atm_auto+i) ) )   
    		emission_tc_reduite(tc2_auto_bolo,ll,a);

    	ll=(long)(&(gg->reglage.autom[i].gain))-(long)(&(gg->reglage.autom[0]));
    	a=litD(fenetre_automatismes,atm_gain+i,0L)-1+20;
    	if( (a!=gg->reglage.autom[i].gain) ou ( /*clavier(touche_alt) et*/ (item==atm_gain+i) ) )   
    		emission_tc_reduite(tc2_auto_bolo,ll,a);

    	ll=(long)(&(gg->reglage.autom[i].courant))-(long)(&(gg->reglage.autom[0]));
    	a=litD(fenetre_automatismes,atm_courant+i,0L)-1;
    	if( (a!=gg->reglage.autom[i].courant) ou ( /*clavier(touche_alt) et*/ (item==atm_courant+i) ) )   
    		emission_tc_reduite(tc2_auto_bolo,ll,a);

    	ll=(long)(&(gg->reglage.autom[i].delai))-(long)(&(gg->reglage.autom[0]));
    	a=litD(fenetre_automatismes,atm_delai+i,0L);
    	if( (a!=gg->reglage.autom[i].delai) ou ( /*clavier(touche_alt) et*/  (item==atm_delai+i) ) )   
    		emission_tc_reduite(tc2_auto_bolo,ll,a);
	}
}