Index: trunk/Poubelle/archediab.old/archediab.sources/c/FindPeri.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/FindPeri.c	(revision 649)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/FindPeri.c	(revision 649)
@@ -0,0 +1,97 @@
+#include "manip.h" 
+#include "FindPeri.h" 
+#include "recons_sst.h" 
+static float Liminffene=10.,Limsupfene=40.;
+double memocoupflux;
+float pasx;
+
+
+
+//nouveauD(0,FindPeri_id,"FindPeri",exec_FindPeri);
+
+
+//--------------------  fonction  exec  de  la  fenetre : FindPeri  -------------------------------
+
+
+void exec_FindPeri(int fen,int item,double valeur,...) 
+{
+if(item>1000) item-=1000;		// pour appeler le case pour tous les cara d'un edit texte
+
+switch(item)
+    {
+    case ouverture               :
+        				selectgra(fen);
+    graph->ymin=0.;
+    graph->ymax=500.;
+    graph->ypas=100;
+    graph->xmin=Liminffene;
+    graph->xmax=Limsupfene; 
+//    printf("limites a l'ouverture %f %f \n",Liminffene,Limsupfene);
+	pasx=10.;
+	if(Liminffene!=10.)pasx=1.;
+    graph->xpas=pasx;
+    graph->grille=0;
+    graph->graduations=1;
+    graph->taille_graduations=10;
+    graph->sans_image=0;      	
+    graph->avec_icones=0;      	
+    strcpy(graph->xtitre, "delta temps");    	
+    strcpy(graph->ytitre, "flux");
+    efface(fen);
+    retrace(fen);   	
+  ecritD(fen,FP_unite6,"%d",CpFl()); //corFC
+  ecritD(fen,FP_vperesti," %7.3f ",DonnePeriod());//corFC
+//    graph->ytitre[0]=0;   
+
+//    				setup_gra(fen);
+
+                 break;
+    case fermeture               :
+    memocoupflux=Rd_CpFl(fen);
+//    Liminffene=graph->xmin;
+//    Limsupfene=graph->xmax; 
+//    printf("limites a la fermeture %f %f \n",Liminffene,Limsupfene);
+
+                 break;
+    case FP_cpfl :
+               break;
+    case FP_vcpfl :
+      init_recons_sst();
+    efface(fen);
+                 break;
+    case FP_periodest :
+                 break;
+    case FP_vperesti :
+                 break;
+    case FP_unite :
+                 break;
+    case FP_unite6 :
+                 break;
+    default  :   break;
+    }
+}
+
+
+void passargu(float Liminff,float Limsupf,float Papa)
+{
+Liminffene=Liminff;
+Limsupfene=Limsupf;
+pasx=Papa;
+}
+
+double Rd_CpFl(int fen)
+{
+double argfen;
+if(fen)
+{
+ argfen=litD(fen,FP_unite6,0L);
+ if(argfen<1)argfen=1;
+ if(argfen>2047)argfen=2047;
+ ecritD(fen,FP_unite6,"%d",(int)(argfen));
+ memocoupflux=argfen;
+ }else
+ {
+ argfen=memocoupflux;
+ }
+  return argfen;
+}
Index: trunk/Poubelle/archediab.old/archediab.sources/c/aa_hadec.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/aa_hadec.c	(revision 649)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/aa_hadec.c	(revision 649)
@@ -0,0 +1,81 @@
+#include <stdio.h>
+#include <math.h>
+#include "aa_hadec.h"
+#define GOODATAN2
+#define PI M_PI
+
+static void aaha_aux (double lat, double x, double y, double* p, double* q);
+
+
+/* given latitude (n+, radians), lat, altitude (up+, radians), alt, and
+ * azimuth (angle round to the east from north+, radians),
+ * return hour angle (radians), ha, and declination (radians), dec.
+ */
+void aa_hadec (double lat, double alt, double az, double* ha, double* dec)
+{
+	aaha_aux (lat, az, alt, ha, dec);
+}
+
+/* given latitude (n+, radians), lat, hour angle (radians), ha, and declination
+ * (radians), dec,
+ * return altitude (up+, radians), alt, and
+ * azimuth (angle round to the east from north+, radians),
+ */
+void hadec_aa (double lat, double ha, double dec, double* alt, double* az)
+{
+	aaha_aux (lat, ha, dec, az, alt);
+}
+
+/* the actual formula is the same for both transformation directions so
+ * do it here once for each way.
+ * N.B. all arguments are in radians.
+ */
+static void
+aaha_aux (double lat, double x, double y, double* p, double* q)
+{
+	static double lastlat = -1000.;
+	static double sinlastlat, coslastlat;
+	double sy, cy;
+	double sx, cx;
+#ifndef GOODATAN2
+	double sq, cq;
+	double a;
+	double cp;
+#endif
+
+	/* latitude doesn't change much, so try to reuse the sin and cos evals.
+	 */
+	if (lat != lastlat) {
+	    sinlastlat = sin (lat);
+	    coslastlat = cos (lat);
+	    lastlat = lat;
+	}
+
+	sy = sin (y);
+	cy = cos (y);
+	sx = sin (x);
+	cx = cos (x);
+
+/* define GOODATAN2 if atan2 returns full range -PI through +PI.
+ */
+#ifdef GOODATAN2
+	*q = asin ((sy*sinlastlat) + (cy*coslastlat*cx));
+	*p = atan2 (-cy*sx, -cy*cx*sinlastlat + sy*coslastlat);
+#else
+#define	EPS	(1e-20)
+	sq = (sy*sinlastlat) + (cy*coslastlat*cx);
+	*q = asin (sq);
+	cq = cos (*q);
+	a = coslastlat*cq;
+	if (a > -EPS && a < EPS)
+	    a = a < 0 ? -EPS : EPS; /* avoid / 0 */
+	cp = (sy - (sinlastlat*sq))/a;
+	if (cp >= 1.0)	/* the /a can be slightly > 1 */
+	    *p = 0.0;
+	else if (cp <= -1.0)
+	    *p = PI;
+	else
+	    *p = acos ((sy - (sinlastlat*sq))/a);
+	if (sx>0) *p = 2.0*PI - *p;
+#endif
+}
Index: trunk/Poubelle/archediab.old/archediab.sources/c/acqui_util.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/acqui_util.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/acqui_util.c	(revision 649)
@@ -189,17 +189,17 @@
 void	reset_epld(void)
 {
+char mot_tc[10];	
 printf("reset epld");
-/*
-if(gg->flag_tc_reduite)
-	{
-	int i;
-	for(i=0;i<15;i++)	emission_tc_reduite(tc2_reset_epld,i,0);
-	}
-else
-*/
-	{
-	char mot_tc[10];	
-	emission_telecommande(tc_dir_reset_epld,mot_tc);
-	}
+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);
 }
 
Index: trunk/Poubelle/archediab.old/archediab.sources/c/acquisition_archeops.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/acquisition_archeops.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/acquisition_archeops.c	(revision 649)
@@ -42,4 +42,7 @@
 					// de la lecture du block bolo
 
+block_type_gyro	blk_gyro2;	// block memoire pour les gyros qui seront traitées lors
+							// de la lecture du block bolo
+
 
 
@@ -48,15 +51,33 @@
 void lit_block_archeops(int err)
 {
-if(verifie_block_printf(blk_tm))	return;
-
-	{
-	def_nom_block
-	static int mon_num_block;
+static char ss[1000];
+def_nom_block
+static int mon_num_block;
+
+if(!fenetre(fenetre_lecture_blocks)) nouveauT(fenetre_lecture_blocks,0,"lecture blocs");
+
+if(verifie_block_printf(blk_tm))	
+		{
+		if((mon_num_block+1)==numero_block(blk_tm))
+			{
+			mon_num_block=numero_block(blk_tm);
+			if(!fenetre(fenetre_lecture_blocks)) nouveauT(fenetre_lecture_blocks,0,"lecture blocs");
+			ecritT(fenetre_lecture_blocks,fin_f,"%s\n",ss);
+			sprintf(ss,"%d ->",mon_num_block);
+			}
+		if(strlen(ss)<500) sprintf(ss+strlen(ss)," **%s ",nom_block[type_block(blk_tm)]);	
+		ecrit_fichier_ARCH(blk_tm);	// ecrit les fichiers en erreur sur le disque     
+		return;
+		}
+
+	{
 	if(mon_num_block!=numero_block(blk_tm))
 		{
 		mon_num_block=numero_block(blk_tm);
-		printf("\n%d ->",mon_num_block);
-		}
-	printf(" %s  ",nom_block[type_block(blk_tm)]);	
+		if(!fenetre(fenetre_lecture_blocks)) nouveauT(fenetre_lecture_blocks,0,"lecture blocs");
+		ecritT(fenetre_lecture_blocks,fin_f,"%s\n",ss);
+		sprintf(ss,"%d ->",mon_num_block);
+		}
+	if(strlen(ss)<500) sprintf(ss+strlen(ss)," %s  ",nom_block[type_block(blk_tm)]);	
 	}				
 
@@ -78,6 +99,8 @@
 	case block_bolo_comprime :	traite_block_bolo_comprime((block_type_bolo_comprime*)blk_tm);	break;	
 	
-	case block_sst :		traite_block_sst((block_type_sst*)blk_tm);			break;
-	case block_sst_comprime  :	traite_block_sst_comprime((block_type_sst_comprime*)blk_tm);	break;
+	case block_sst :		traite_block_sst((block_type_sst*)blk_tm);			
+					traite_block_sst_brut((block_type_sst*)blk_tm);			break;
+	case block_sst_comprime  :	traite_block_sst_comprime((block_type_sst_comprime*)blk_tm);
+					traite_block_sst_comprime_brut((block_type_sst_comprime*)blk_tm);break;
 
 	case block_gyro :		traite_block_gyro((block_type_gyro*)blk_tm);			break;
@@ -86,5 +109,5 @@
 	case block_synchro_sol :	traite_block_synchro_sol((block_type_synchro_sol*)blk_tm);	break;
 	
-	case block_status_flash :	printf("******************status flash recut  ********************* \n");son(133);			break;
+	case block_status_flash :	printf("****  status flash recut  ****   nblock=%x  - %d *** \n",((block_type_status_flash*)blk_tm)->status.nb_total_blocks,((block_type_status_flash*)blk_tm)->status.nb_total_blocks/256);break;
 	
 #ifdef	transmet_data_brute
@@ -115,4 +138,6 @@
 void	traite_block_journal(block_type_journal*	blk)
 {
+long mothexa[5];	/* les 5 mots hexa de la telecommande  */
+
 int i,code,blocknum;
 if(!fenetre(fenetre_journal)) nouveauT(fenetre_journal,0,"journal");
@@ -124,10 +149,27 @@
 	blocknum=numero_block(&blk->jj[i]);
 	if(code) break;	// code vaut 1 pour vider une page de journal incomplete
-	ecritT(fenetre_journal,fin_f,"block_num= %d   code %d   ==>  %d %d %d %d %d %d %d %d \n",
-		blocknum,code,
-		blk->jj[i].mot[0],blk->jj[i].mot[1],blk->jj[i].mot[2],blk->jj[i].mot[3],
-		blk->jj[i].mot[0],blk->jj[4].mot[5],blk->jj[i].mot[6],blk->jj[i].mot[7]);
-	}
-}
+	mothexa[0]=blk->jj[i].mot[5];	/* 4 bit choix de commande   */
+	mothexa[1]=blk->jj[i].mot[6]>>2;	/* les 4 bits poid fort du code direction */
+	mothexa[2]=((blk->jj[i].mot[6]<<2)&0xc)  + ((blk->jj[i].mot[7]>>6)&0x3);
+	mothexa[3]=(blk->jj[i].mot[7]>>2)&0xf;  
+	mothexa[4]=(blk->jj[i].mot[7]&0x3);
+
+	if(blk->jj[i].mot[0])	
+		{
+		ecritT(fenetre_journal,fin_f,"block_num= %d   code %d   ==>  telecommande_OK : %d %d %d  ->  %x %x %x %x %x \n",
+		blocknum,code,blk->jj[4].mot[5],blk->jj[i].mot[6],blk->jj[i].mot[7]
+			,mothexa[0],mothexa[1],mothexa[2],mothexa[3],mothexa[4]);
+		}
+	else
+		{
+		ecritT(fenetre_journal,fin_f,"block_num= %d   code %d   ==>  erreur telecommande : %d %d %d  ->  %x %x %x %x %x \n",
+		blocknum,code,blk->jj[4].mot[5],blk->jj[i].mot[6],blk->jj[i].mot[7]
+			,mothexa[0],mothexa[1],mothexa[2],mothexa[3],mothexa[4]);
+		}
+	}
+}
+
+
+
 
 //-----------------------------------------------------------------------------------------	
@@ -176,4 +218,47 @@
 		if(c1==13) i=80;
 		}
+	}
+}
+
+
+
+
+
+void	traite_block_gyro_comprime(block_type_gyro_comprime* blk)
+{
+int i;
+block_type_gyro  bk_gyro;
+block_type_gyro* blk2=& bk_gyro;
+if(!fenetre(fenetre_gyroscope)) return;
+//printf("***************   decompress data gyro \n");
+for(i=0;i<3;i++)	decompress_7_2((long *)blk->gyro[i],blk2->gyro[i],nb_per_block*2);
+blk2->code1=blk->code1;
+blk2->code2=blk->code2;
+traite_block_gyro(blk2);
+}
+
+
+void	traite_block_gyro(block_type_gyro* blk)
+{
+int k;
+double	y[15];
+
+int temps_cntl;
+double secondes;
+blk_gyro2 = *blk;
+
+if(!fenetre(fenetre_gyroscope)) return;
+
+for(k=0;k<72;k++)
+	{
+	y[0]=20.*(blk->gyro[0][k]-32768)/32768.;
+	y[1]=20.*(blk->gyro[1][k]-32768)/32768.;
+	y[2]=20.*(blk->gyro[2][k]-32768)/32768.;
+		
+//	printf(" y = %g %g %g %g %g \n",y[0],y[1],y[2],y[3],y[4]);
+	temps_cntl =numero_block(blk)*nb_per_block*2+k;
+	secondes=gg->periode_echantillonage*(double)temps_cntl-gg->temps_origine;
+	tracen(fenetre_gyroscope,3,secondes,y);
+//	printf("secondes=%g\n",secondes);
 	}
 }
@@ -306,4 +391,11 @@
 		gg->don.don_bolo[j]=0.5*(ancien_don_bolo[j]+s*(((val_DS(j,i)-aa)<<1)/nb_coups));		// copy bolos
 		ancien_don_bolo[j]=s*(((val_DS(j,i)-aa)<<1)/nb_coups);
+//		if( (i==1) && (j==14) ) 
+//			{
+//			def_gains
+//			printf(" brut=%d  ofset=%d  nbcoups=%d gg->don.don_bolo[j]=%d  parametr.bolo[j].bolo_gain=%d  gainampli=%g  micro-volts=%g \n"
+//				, val_DS(j,i)   ,aa     ,nb_coups    ,(int)gg->don.don_bolo[j]  ,parametr.bolo[j].bolo_gain   ,gain_ampli(gg->reglage.bolo[j])  ,(double)xbolbrut(j));
+//			}
+//
 		}
 
@@ -313,4 +405,9 @@
 		}
 	
+	gg->don.gyro[0]=20.*(blk_gyro2.gyro[0][i]-32768)/32768.;
+	gg->don.gyro[1]=20.*(blk_gyro2.gyro[1][i]-32768)/32768.;
+	gg->don.gyro[2]=20.*(blk_gyro2.gyro[2][i]-32768)/32768.;
+		
+
 	
 //	gg->don.sync[j]=synchro_DS(j,i);	
Index: trunk/Poubelle/archediab.old/archediab.sources/c/acquisition_general.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/acquisition_general.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/acquisition_general.c	(revision 649)
@@ -14,4 +14,5 @@
 #include "compress.h"
 #include "controle.h"
+#include "simulmission.h"
 
 
@@ -41,4 +42,5 @@
 static int count_moy_err=0;
 int err;
+static bilan_err=0;		
 
 if	(item!=tache_de_fond)		return;
@@ -56,25 +58,39 @@
 */
 
-if( count-- < 0 ) 
+//if( count-- < 0 ) 
 		{
 		count=3; 
-		ecritD(fenetre_controle,con_retard1,"%d",tt->nb_lec_fofo_ext);
-		tt->nb_lec_fofo_ext=0;
+		ecritD(fenetre_controle,con_fifo,tt->val_con_fifo/2);
+		tt->val_con_fifo=0;
 		}
 
 
 err=test_erreur();  //______________   test des erreurs   _______________________________
+
+if(err)	bilan_err+=10*err;
+
+// Pour la simulation, rempli les buffers avec les donnees simulees
+
+if (tt->PCI_actif==3) SimulMissionReadLoop();
 
 
 //_____________________   lit la table télémesure  ______________________________________
   					
-
+if(bilan_err>100)	bilan_err=100;
+if(bilan_err>50)	bilan_err-=20;
+if(bilan_err>10)	bilan_err-=5;
+if(bilan_err>0)		bilan_err--;
+if(bilan_err)	ecritD(fenetre_controle,con_erreur,20+bilan_err*10);
+else		ecritD(fenetre_controle,con_erreur,0);
 
 q=(longueur_table_tm+tt->tm.pos_ecrit-tt->tm.pos_lit)%longueur_table_tm;
+
+ecritD(fenetre_controle,con_pile,(1000*((longueur_table_tm+tt->tm.pos_ecrit-tt->tm.pos_lit)%longueur_table_tm))/longueur_table_tm);
+ecritD(fenetre_controle,con_donnee,tt->val_con_donnee);
 
 while(q)
 	{
-	ecritD(fenetre_controle,con_retard2,"%d",(longueur_table_tm+tt->tm.pos_ecrit-tt->tm.pos_lit)%longueur_table_tm);
-
+	ecritD(fenetre_controle,con_pile,(1000*((longueur_table_tm+tt->tm.pos_ecrit-tt->tm.pos_lit)%longueur_table_tm))/longueur_table_tm);
+//	printf(" pile = %d  \n",(1000*((longueur_table_tm+tt->tm.pos_ecrit-tt->tm.pos_lit)%longueur_table_tm))/longueur_table_tm);
 //*****************************************************************************************
 //											***
@@ -109,5 +125,5 @@
 	{
 	case ouverture	:	gg->flag_tc_reduite=litD(fen,e_tc_reduite,0);
-				if(tt->PCI_actif==1) reset_carte;
+				if(acquisition_PCI) reset_carte;
 	   			ecritD(fen,e_tache_inter,0);   	// arreter les interruptions
     				reset_epld();
@@ -161,7 +177,10 @@
     				break;
 
-	case e_vanne	: 	{
-				long ll=(long)(&(gg->reglage.dilu.vanne))-(long)(&(gg->reglage.dilu));
+	case e_vanne	: 	
+					{
+					long ll=(long)(&(gg->reglage.dilu.vanne))-(long)(&(gg->reglage.dilu));
     				int a=(int) valeur;	
+    				if(a==vanne_ouvre)	
+    					if(alerte(2,"voulez-vous vraiment ouvrir la vanne ??")!=1) break;
     				emission_tc_reduite(tc2_auto_dilu,ll,a);
     				}
@@ -189,5 +208,5 @@
 	case e_tache_inter :	calfreq(0);	//  command ou arrete le flag epld sortie data
 				if(TTm)		stoptimer(TTm);
-    				if(tt->PCI_actif==1) reset_carte;
+    				if(acquisition_PCI) reset_carte;
     				tt->vi.a=0;
     				if(valeur) 
Index: trunk/Poubelle/archediab.old/archediab.sources/c/bit_block.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/bit_block.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/bit_block.c	(revision 649)
@@ -18,5 +18,5 @@
  
 
-#define	cadence_taux	16
+#define	cadence_taux	16	// cadence de filtrage du taux d'occupation de telemetrie
 #define mode_acquisition	0x00	//0xff en mode inverse, 0x00 en mode normal
 unsigned long	buffer;
@@ -137,5 +137,5 @@
 							//Calcul du taux de remplissage
 							taux=taux+(((0xffff-taux)*Nplein)>>cadence_taux);
-							tt->nb_lec_fofo_ext=((taux*1000)>>cadence_taux);
+							tt->val_con_donnee=((taux*1000)>>cadence_taux);
 							return(lit_bit_un_block);
 										
@@ -169,5 +169,5 @@
 				compteur=0;
 				taux=taux-((taux*Nvide)>>cadence_taux);
-				tt->nb_lec_fofo_ext=((taux*1000)>>cadence_taux);
+				tt->val_con_donnee=((taux*1000)>>cadence_taux);
 			}	
 			if(buffer==debut_block_mesure)
Index: trunk/Poubelle/archediab.old/archediab.sources/c/bolo.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/bolo.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/bolo.c	(revision 649)
@@ -22,7 +22,5 @@
 int a,c,i;
 int n=gg->reglage.horloge.nb_mesures;
-//if(fen > 5 ) return;
 if(item>1000) item-=1000;		// pour appeler le case pour tous les cara d'un edit texte
-//controlemanip(0);
 //printf("execbolo avec fen=%d , item=%d \n",fen,item);
 switch(item)
@@ -78,5 +76,52 @@
 
 				break;
-
+//  avec fenetre de dialogue pour envoyer une valeur directe
+	case b_carre 	:	ouvreD(fen_change_bolo,change_bolo_id,"chgbolo",0);
+				if(1==modal(fen_change_bolo))
+						{
+						valeur=litD(fen_change_bolo,chb_val,0);	
+						printf("  val=%d  %n",(int)valeur);
+						ecritD(fen,b_carre,(int)valeur);
+						ecritgain(fen);	
+						}	
+				ferme(fen_change_bolo);
+				break;
+
+	case b_tri 	:	ouvreD(fen_change_bolo,change_bolo_id,"chgbolo",0);
+				if(1==modal(fen_change_bolo))
+						{
+						valeur=litD(fen_change_bolo,chb_val,0);	
+						printf("  val=%d  %n",(int)valeur);
+						ecritD(fen,b_tri,(int)valeur);
+						ecritgain(fen);	
+						}	
+				ferme(fen_change_bolo);
+				break;
+
+	case b_trans 	:	ouvreD(fen_change_bolo,change_bolo_id,"chgbolo",0);
+				if(1==modal(fen_change_bolo))
+						{
+						valeur=litD(fen_change_bolo,chb_val,0);	
+						printf("  val=%d  %n",(int)valeur);
+						ecritD(fen,b_trans,(int)valeur);
+						ecritgain(fen);	
+						}	
+				ferme(fen_change_bolo);
+				break;
+
+	case b_lin 	:	ouvreD(fen_change_bolo,change_bolo_id,"chgbolo",0);
+				if(1==modal(fen_change_bolo))
+						{
+						valeur=litD(fen_change_bolo,chb_val,0);	
+						printf("  val=%d  %n",(int)valeur);
+						ecritD(fen,b_lin,(int)valeur);
+						ecritgain(fen);	
+						}	
+				ferme(fen_change_bolo);
+				break;
+	
+
+
+/*
 //  reecrit les valeurs dans la fenetre pour appel par un autre programme						
 	case b_carre 	:	ecritD(fen,b_carre,(int)valeur);		ecritgain(fen);		break;
@@ -84,4 +129,6 @@
 	case b_trans 	:	ecritD(fen,b_trans,(int)valeur);		ecritgain(fen);		break;	
 	case b_lin 	:	ecritD(fen,b_lin,(int)valeur);			ecritgain(fen);		break;	
+
+*/
 	case b_gain 	:	vg[fen-1]=0;  ecritD(fen,b_gain,(int)valeur);	ecritgain(fen);		break;												
 	case b_phase 	:	ecritD(fen,b_phase,(int)valeur);		ecritgain(fen);		break;
Index: trunk/Poubelle/archediab.old/archediab.sources/c/corel.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/corel.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/corel.c	(revision 649)
@@ -2,8 +2,8 @@
 #include "corel.h" 
 
-
+/*
 double coef_corel[nb_max_bolo][nb_max_bolo];
 int flag_corel[nb_max_bolo];
-
+*/
 
 
@@ -30,4 +30,6 @@
 	{
 	for(j=0;j<nb_max_bolo;j++)	gg->corel[j]=xbolbrut(j);
+	for(j=0;j<3;j++)		gg->corel[nb_max_bolo+j]=gg->don.gyro[j];
+	for(j=0;j<46;j++)		gg->corel[nb_max_bolo+3+j]=xbolbrut(j);
 	}
 	
Index: trunk/Poubelle/archediab.old/archediab.sources/c/diabolo.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/diabolo.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/diabolo.c	(revision 649)
@@ -19,5 +19,8 @@
 #include "config_transputer.h" 
 #include "dilution.h" 
+#include "recons_sst.h" 
+#include "tm.h" 
 
+void InitSimulMission(void);
 
 stglob* gg;			// pointeur global  sur la structure 
@@ -44,9 +47,16 @@
 //flag=2;	// en mode simulation
 if(clavier(touche_alt) ) flag=2; else flag=1;		// en mode acquisition
+if(clavier(touche_controle) ) flag=4;				// avec emission des telecommandes au demarrage
+if(clavier(touche_alt) && clavier(touche_controle) ) {
+  flag=3;	 	// en mode simulateur de donnees mission
+  InitSimulMission();
+  }
 #endif
 
-//return(1);
+
 
 init_struct(flag);
+
+init_recons_sst();
 
 //printf(" long_entete 	  	= %ld \n",	sizeof(F_entete));
@@ -65,4 +75,5 @@
 
 nouveauM(0,diabolo_id,exec_menu_diabolo);
+nouveauSM(0,menu_trace_tout_id,exec_menu_trace_tout);
 
 ouvreD(fenetre_acquisition,acquisition_id,"acquisition",exec_acquisition);
@@ -85,4 +96,5 @@
 #endif
 
+initRS(port_A,baud1200+data8+stop10+noParity,0);	
 
 #ifdef lire_les_donnees_POM2
@@ -117,5 +129,5 @@
 
 
-if(flag==1)					//  mets en route les interruptions
+if( (flag==1) ou 	(flag==4) )				//  mets en route les interruptions
 	{
 	ecritD(fenetre_acquisition,e_tache_inter,1);
@@ -125,4 +137,8 @@
 select(fenetre_controle);
 select(fenetre_acquisition);
+
+// $CHECK$ on est toujours en mode 4 avec la derniere modif AB ???
+tt->PCI_actif=4;
+if (flag==3) tt->PCI_actif=3;
 
 return(option_texte+option_unclick);
@@ -154,5 +170,11 @@
 void exec_controle(int fen,int item,double valeur,...) 
 {
-if(item==caseferme)  {stop_exec(fen);}
+switch(item)
+    {
+    case caseferme	:  stop_exec(fen);break;
+    case con_reset_epld	:	reset_epld();	break;
+    case con_reset_trp	:	reset_trp();	break;
+    default	:	break;
+    }	
 }
 
Index: trunk/Poubelle/archediab.old/archediab.sources/c/dilution.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/dilution.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/dilution.c	(revision 649)
@@ -55,5 +55,5 @@
 // la telecommande passe a travers le transputer sans etre traitee par lui
 //  elle arrive directement sur l'EPLD
-
+/*
 void  ecrit_bit_dilution(int valeur,int bit);
 
@@ -82,5 +82,5 @@
 emission_telecommande(tc_dir_transputer,mot_tc);
 }
-
+*/
 //   fonction ecrit un  des dac dilution
 //  c'est une telecommande normale 64 bit  a supprimer
@@ -120,5 +120,15 @@
 
 switch(item)
-    {
+	 {
+	 case dil_switch_helium :	emission_tc_reduite(tc2_dilution,(valeur==1),nbit_switch_helium);	break;
+   	 case dil_EVB :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_vanne_EVB);	break;
+   	 case dil_EVO :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_vanne_EVO);	break;
+    	case dil_EVF :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_vanne_EVF);	break;
+    	case dil_EVV :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_vanne_EVV);	break;
+    	case dil_sw_pp5 :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_switch_pile_par_5);	break;
+    	case dil_sw_pp15 :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_switch_pile_par_15);	break;
+
+  /*  
+    
     case dil_switch_helium :	ecrit_bit_dilution((int)valeur,switch_helium);	break;
     case dil_EVB :		ecrit_bit_dilution((int)valeur,vanne_EVB);	break;
@@ -128,5 +138,5 @@
     case dil_sw_pp5 :		ecrit_bit_dilution((int)valeur,switch_pile_par_5);	break;
     case dil_sw_pp15 :		ecrit_bit_dilution((int)valeur,switch_pile_par_15);	break;
-
+*/
 //  ----   commande directe d'un mot avec les 3 case de codage hexadecimales
 
@@ -137,5 +147,10 @@
 //  ----   telecommande du raz periodique des fets 
     case dil_raz_modul :
-    case dil_fet_raz :
+    case dil_fet_raz :	
+  		 i =0;
+ 		if(litD(fen,dil_fet_raz,0)==2)	i+=1;
+		if(litD(fen,dil_fet_raz,0)==3)	i+=7;
+     		emission_tc_reduite(tc2_raz_fet,0,i);
+/*
     		{
     		char mot_tc[10];
@@ -150,14 +165,14 @@
 		emission_telecommande(tc_dir_transputer,mot_tc);
 		}
-
+*/
                  break;
                  
-    case dil_ch1 :		ecrit_bit_dilution((int)valeur,chauffage1);	break;
-    case dil_ch2 :		ecrit_bit_dilution((int)valeur,chauffage2);	break;
-    case dil_ch3 :		ecrit_bit_dilution((int)valeur,chauffage3);	break;
-    case dil_ch4 :		ecrit_bit_dilution((int)valeur,chauffage4);	break;
-    case dil_ch5 :		ecrit_bit_dilution((int)valeur,chauffage5);	break;
-    case dil_ch6 :		ecrit_bit_dilution((int)valeur,chauffage6);	break;
-    case dil_ch7 :		ecrit_bit_dilution((int)valeur,chauffage7);	break;
+    case dil_ch1 :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_chauffage1);	break;
+    case dil_ch2 :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_chauffage2);	break;
+    case dil_ch3 :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_chauffage3);	break;
+    case dil_ch4 :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_chauffage4);	break;
+    case dil_ch5 :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_chauffage5);	break;
+    case dil_ch6 :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_chauffage6);	break;
+    case dil_ch7 :		emission_tc_reduite(tc2_dilution,(valeur==1),nbit_chauffage7);	break;
     
 //    case dil_dac_1 :
@@ -227,5 +242,7 @@
  // j=numero de bebo	T[k] = R[k+4] en Kelvin
 		if ((R[k]-c(j,6))>1.) 
-			{if((log(R[k]-c(j,6))-c(j,0))>0.001) llR= log(log(R[k]-c(j,6))-c(j,0)) ; else llR=0;} 
+			{if((log(R[k]-c(j,6))-c(j,0))>0.001) llR= log(log(R[k]-c(j,6))-c(j,0)) ; else llR=0; 
+//			printf("\nk=%d j=%d R=%g c2=%g c3=%g llR=%g",k,j,R[k],c(j,2),c(j,3),llR);
+			} 
 		else llR=0;
 		R[k+4]	= exp( 	c(j,1) + c(j,2)* llR + c(j,3)* llR* llR + c(j,4)* llR* llR* llR + c(j,5)* llR* llR* llR* llR) ; 
@@ -235,4 +252,6 @@
 	}
 
+gg->temperature_cryo=R[4];     // Charge la temperature_cryo (0.1K) pour les calculs futurs avec les bolos 
+/* La germanium doit toujours etre en premier par rapport aux autres thermos absolus */
 
 if(R[0]<90.)	ecritD(fenetre_dilution,dil_temp
@@ -298,21 +317,17 @@
 
 
-ecritD(fenetre_dilution,dil_temperatures,"temp-Haut =   %4.1f°   %4.1f°   %4.1f°   %4.1f° \rtemp-Bas  =   %4.1f°   %4.1f°   %4.1f°   %4.1f°  "
-	,val_temperature(blk->ADC_dil[ t_h1]),val_temperature(blk->ADC_dil[ t_h2]),val_temperature(blk->ADC_dil[ t_h3]),val_temperature(blk->ADC_dil[ t_h4])
-	,val_temperature(blk->ADC_dil[ t_b1]),val_temperature(blk->ADC_dil[ t_b2]),val_temperature(blk->ADC_dil[ t_b3]),val_temperature(blk->ADC_dil[ t_b4])	
+ecritD(fenetre_dilution,dil_temperatures,"temp-Haut =  %4.1f°  %4.1f° Base  =  %4.1f°  %4.1f° \r tube He: %4.1f° piles %4.1f° driver %4.1f°"
+	,val_temperature(blk->ADC_dil[ t_h2]),val_temperature(blk->ADC_dil[ t_h4])
+	,val_temperature(blk->ADC_dil[ t_b1]),val_temperature(blk->ADC_dil[ t_b2]),val_temperature(blk->ADC_dil[ t_b3])	
+	,val_temperature(blk->ADC_dil[ t_pile]),val_temperature(blk->ADC_dil[ t_a1])
 	);
 
-ecritD(fenetre_dilution,dil_t_h1,cnt_temperature(t_h1));
-ecritD(fenetre_dilution,dil_t_h2,cnt_temperature(t_h2));
-ecritD(fenetre_dilution,dil_t_h3,cnt_temperature(t_h3));
-ecritD(fenetre_dilution,dil_t_h4,cnt_temperature(t_h4));
-ecritD(fenetre_dilution,dil_t_a1,cnt_temperature(t_a1));
-ecritD(fenetre_dilution,dil_t_a2,cnt_temperature(t_a2));
-ecritD(fenetre_dilution,dil_t_a3,cnt_temperature(t_a3));
-ecritD(fenetre_dilution,dil_t_a4,cnt_temperature(t_a4));
-ecritD(fenetre_dilution,dil_t_b1,cnt_temperature(t_b1));
-ecritD(fenetre_dilution,dil_t_b2,cnt_temperature(t_b2));
-ecritD(fenetre_dilution,dil_t_b3,cnt_temperature(t_b3));
-ecritD(fenetre_dilution,dil_t_b4,cnt_temperature(t_b4));
+ecritD(fenetre_dilution,dil_t_h1,cnt_temperature(t_h2));
+ecritD(fenetre_dilution,dil_t_h2,cnt_temperature(t_h4));
+ecritD(fenetre_dilution,dil_t_h3,cnt_temperature(t_b1));
+ecritD(fenetre_dilution,dil_t_h4,cnt_temperature(t_b2));
+ecritD(fenetre_dilution,dil_t_a1,cnt_temperature(t_b3));
+ecritD(fenetre_dilution,dil_t_a2,cnt_temperature(t_pile));
+ecritD(fenetre_dilution,dil_t_a3,cnt_temperature(t_a1));
 
 
Index: trunk/Poubelle/archediab.old/archediab.sources/c/gyroscope.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/gyroscope.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/gyroscope.c	(revision 649)
@@ -24,44 +24,2 @@
 
 
-
-
-
-void	traite_block_gyro_comprime(block_type_gyro_comprime* blk)
-{
-int i;
-block_type_gyro  bk_gyro;
-block_type_gyro* blk2=& bk_gyro;
-if(!fenetre(fenetre_gyroscope)) return;
-//printf("***************   decompress data gyro \n");
-for(i=0;i<3;i++)	decompress_7_2((long *)blk->gyro[i],blk2->gyro[i],nb_per_block*2);
-blk2->code1=blk->code1;
-blk2->code2=blk->code2;
-traite_block_gyro(blk2);
-}
-
-
-void	traite_block_gyro(block_type_gyro* blk)
-{
-int k;
-double	y[15];
-
-int temps_cntl;
-double secondes;
-
-if(!fenetre(fenetre_gyroscope)) return;
-
-for(k=0;k<72;k++)
-	{
-	y[0]=blk->gyro[0][k];
-	y[1]=blk->gyro[1][k];
-	y[2]=blk->gyro[2][k];
-		
-//	printf(" y = %g %g %g %g %g \n",y[0],y[1],y[2],y[3],y[4]);
-	temps_cntl =numero_block(blk)*nb_per_block*2+k;
-	secondes=gg->periode_echantillonage*(double)temps_cntl-gg->temps_origine;
-	tracen(fenetre_gyroscope,3,secondes,y);
-//	printf("secondes=%g\n",secondes);
-	}
-}
-
-
Index: trunk/Poubelle/archediab.old/archediab.sources/c/menu.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/menu.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/menu.c	(revision 649)
@@ -18,4 +18,7 @@
 #include "dilution.h"
 #include "senseur_stellaire.h"
+#include "sstbrut.h"
+#include "FindPeri.h" 
+#include "phaseSST.h"
 #include "gyroscope.h"
 
@@ -24,4 +27,6 @@
 
 int j,ann;
+
+
 
 void exec_menu_diabolo(int fen,int item,double valeur,...)
@@ -70,9 +75,24 @@
 								break;
 
-	case	d_senseur_stellaire		:	if(fenetre(fenetre_senseur_stellaire)) select(fenetre_senseur_stellaire);
+	case	d_sst_brut		:	if(fenetre(fenetre_sstbrut)) select(fenetre_sstbrut);
+								else	ouvreD(fenetre_sstbrut,sstbrut_id,"senseur_stellaire",exec_sstbrut);
+								break;
+
+	case	d_senseur_stellaire	:	if(fenetre(fenetre_senseur_stellaire)) select(fenetre_senseur_stellaire);
 								else	ouvreD(fenetre_senseur_stellaire,senseur_stellaire_id,"senseur_stellaire",exec_senseur_stellaire);
-								if(fenetre(fenetre_gyroscope)) select(fenetre_gyroscope);
+								break;
+
+	case	d_recons_sst	:	if(fenetre(fenetre_Find_Period)) select(fenetre_Find_Period);
+								else	ouvreD(fenetre_Find_Period,FindPeri_id,"FindPeriod",exec_FindPeri);
+								if(fenetre(fenetre_Phase_SST)) select(fenetre_Phase_SST);
+								else	ouvreD(fenetre_Phase_SST,phase_id,"phase",exec_phase);
+								break;
+
+	case	d_gyros		:		if(fenetre(fenetre_gyroscope)) select(fenetre_gyroscope);
 								else	ouvreD(fenetre_gyroscope,0,"fenetre_gyroscope",exec_gyroscope);
 								break;
+	default					:	break;
+	}
+}
 
 /*
@@ -82,25 +102,17 @@
 */
 
-
-
-
-
-
-
-	case	d_trace_carte	:	ferme_annexe();
-								ann=1;
-								ouvreD(fenetre_annexe   ,carte_id   ,"carte",exec_carte);		
+void exec_menu_trace_tout  (int fen,int item,double valeur,...)
+{
+switch(item)
+	{
+case	d_trace_temperature	:	if(fenetre(fenetre_trace_tout_temperature)) select(fenetre_trace_tout_temperature);
+								else	ouvreD(fenetre_trace_tout_temperature ,trace_tout_id ,"trace temperature"       ,exec_trace_tout );
 								break;
-
-	case	d_pointage		:	ferme_annexe();
-								ann=2;
-								ouvreD(fenetre_annexe   ,pointage_id   ,"pointage",exec_pointage);		
+case	d_trace_bolos	:	if(fenetre(fenetre_trace_tout_bolos)) select(fenetre_trace_tout_bolos);
+								else	ouvreD(fenetre_trace_tout_bolos ,trace_tout_id ,"trace bolos"       ,exec_trace_tout );
 								break;
-
-	case	d_foyer			:	ferme_annexe();
-								ann=3;
-								ouvreD(fenetre_annexe   ,foyer_id   ,"foyer",exec_foyer);		
+case	d_trace_gyros	:	if(fenetre(fenetre_trace_tout_gyros)) select(fenetre_trace_tout_gyros);
+								else	ouvreD(fenetre_trace_tout_gyros ,trace_tout_id ,"trace gyros"       ,exec_trace_tout );
 								break;
-
 	default					:	break;
 	}
Index: trunk/Poubelle/archediab.old/archediab.sources/c/mesures_bolo.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/mesures_bolo.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/mesures_bolo.c	(revision 649)
@@ -70,6 +70,7 @@
 //													//
 //	Ptot =  coef3  *  ( (10*Tb) ** coef4    -    (10*Tcryo)  **  coef4 )				//
-Tcryo=0.1;
-
+/* Desormais 30/06/1999, Tcryo est calculee avec la germanium */
+//Tcryo=0.1;
+Tcryo= gg->temperature_cryo ;
 Ptot=0;	if( (c(4)>0.01) && (T>0.01) )	Ptot = c(3) * ( pow(10.*T,c(4)) - pow(10.*Tcryo,c(4)) );
 
@@ -79,8 +80,9 @@
 //		tau	=	- ln ( 1 +  Pciel / coef6 )	coef6= I * Bi (tables xavier)		//
 
-Pciel = 0;  if( c(5)>Pelec)	Pciel = c(5) - Pelec;
-a=1;	if( c(6) >0.1 )		a =  1 - Pciel / c(6) ;
-tau=0;	if( a>0 )		tau =  - log ( a );
-
+//Pciel = 0;  if( c(5)>Pelec)	Pciel = c(5) - Pelec;
+Pciel = 0;  if( Ptot>Pelec)	Pciel = Ptot - Pelec;  /* Pour avoir la puissance de rayonnement absorbé */
+//a=1;	if( c(6) >0.1 )		a =  1 - Pciel / c(6) ;
+//tau=0;	if( a>0 )		tau =  - log ( a );
+tau=Tcryo ;  /* FXD pour avoir Tcryo 16/07/99 */
 
 
@@ -92,9 +94,9 @@
 
 
-ecritT(fenetre_mesures_bolo,fin_f," R=%7.3fM  I=%6.3fnA  V=%7.3fmV   Pelec=%5.1fpW",R*1e-6,I*1e3,V*1e-3,Pelec);
+ecritT(fenetre_mesures_bolo,fin_f," R=%7.3fM  I=%6.3fnA  V=%7.3fmV   Pelec=%6.2fpW",R*1e-6,I*1e3,V*1e-3,Pelec);
 
 if(T>0.01) ecritT(fenetre_mesures_bolo,fin_f,"  T=%6.1fmK  ", T*1e3);
 
-if( Ptot>0.1) ecritT(fenetre_mesures_bolo,fin_f," Ptot=%5.1fpW   Pciel=%5.1fpW   tau=%5.3f  ",Ptot,Pciel,tau);
+if( Ptot>0.01) ecritT(fenetre_mesures_bolo,fin_f," Ptot=%6.2fpW   Pciel=%6.2fpW   Tcryo=%6.1f  ",Ptot,Pciel,tau*1e3);
 
 
Index: trunk/Poubelle/archediab.old/archediab.sources/c/phaseSST.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/phaseSST.c	(revision 649)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/phaseSST.c	(revision 649)
@@ -0,0 +1,40 @@
+#include "manip.h" 
+#include "phaseSST.h" 
+
+
+
+
+
+//--------------------  fonction  exec  de  la  fenetre : phase  -------------------------------
+
+
+void exec_phase(int fen,int item,double valeur,...) 
+{
+if(item>1000) item-=1000;		// pour appeler le case pour tous les cara d'un edit texte
+
+switch(item)
+    {
+    case ouverture               :
+    				selectgra(fen);
+    graph->ymin=-0.1;
+    graph->ymax=0.1;
+    graph->ypas=0.1;
+    graph->xmin=0.;
+    graph->xmax=360.; 
+    graph->xpas=90.;
+    graph->grille=0;
+    graph->graduations=1;
+    graph->taille_graduations=10;
+    graph->sans_image=0;      	
+    graph->avec_icones=0;      	
+    strcpy(graph->xtitre, "phases");    	
+    strcpy(graph->ytitre, "Timedrift"); 
+    retrace(fen);   	
+                 break;
+    case fermeture               :
+                 break;
+    case PHS_dtdephase :
+                 break;
+    default  :   break;
+    }
+}
Index: trunk/Poubelle/archediab.old/archediab.sources/c/rafraichis_fenetre.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/rafraichis_fenetre.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/rafraichis_fenetre.c	(revision 649)
@@ -22,4 +22,6 @@
 	ecritD(fenetre_acquisition,e_telemesure,1+(0x0f & (int)gg->reglage.dilu.transmission));
 	ecritD(fenetre_acquisition,e_flash,1+((0x30 & (int)gg->reglage.dilu.transmission)>>4));
+	ecritD(fenetre_acquisition,e_vanne,(int)gg->reglage.dilu.vanne);
+	ecritD(fenetre_acquisition,e_helium,(int)gg->reglage.dilu.helium);
 
 	// affichage de toutes les fréquences  
@@ -68,5 +70,6 @@
 		ecritD(fenetre_regulation,regu_int+i,gg->reglage.regul[i].integ+1);
 		ecritD(fenetre_regulation,regu_deriv+i,gg->reglage.regul[i].deriv+1);
-		ecritD(fenetre_regulation,regu_chauffage+i,gg->reglage.regul[i].chauffage);
+		if(gg->reglage.regul[i].chauffage>0)	ecritD(fenetre_regulation,regu_chauffage+i,gg->reglage.regul[i].chauffage);
+			else				ecritD(fenetre_regulation,regu_chauffage+i,-gg->reglage.regul[i].chauffage);
 		}
 
Index: trunk/Poubelle/archediab.old/archediab.sources/c/recons_sst.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/recons_sst.c	(revision 649)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/recons_sst.c	(revision 649)
@@ -0,0 +1,590 @@
+#include "diabolo.h" 
+#include "senseur_stellaire.h" 
+#include "recons_sst.h" 
+#include "FindPeri.h" 
+#include "stabilite.h"
+FILE* f;
+long nstarcatal,nposaxesimu;
+struct star {
+  float ra; // en heures dans le catalogue de depart
+  float dec;// en degres dans le catalogue de depart
+  short mag; // mag * 100
+};
+#define nstpturn 100
+struct sstgraph {
+  int netdet; // nombre d'etoiles detectees
+  float raax; // coordonnees equatoriales de l'axe de rotation du telescope
+  float decax;
+  long numcat[nstpturn]; //numero de l'etoile dans le fichier de depart
+  float phase[nstpturn]; //phase de l'etoile (angle/Nord - Est=+90¡ - ds plan perp axe rot ballon)
+  float cosinus[nstpturn]; // de l'angle entre la direction de l'etoile et l'axe de rotation du ballon
+  float fluxcat[nstpturn]; //flux de l'etoile en unites arbitraires
+  int	icl[nstpturn]; //ordre de l'etoile pour un classement par phases croissantes
+};
+struct star* stars;
+struct sstgraph* listord;
+int fichierslus=0;
+float instant[nmemechant],sfluxvu[nmemechant],barette[nmemechant],phd0[nmemechant];
+float deltap[nmemechant],rapflx[nmemechant];
+float deltapcat[nstpturn],rapflxcat[nstpturn];
+float cases[ncasdiftps];float maxcas;float somcas;
+float sflxv,maintenant,laplushaute;
+float tdeb;int flagstar;int flagwind;
+float separtps,separenz;
+float Period=10.,NewPeriod;float Phase;int Sens=9999;
+float WidthCas,StepCas;
+float tpsminfen,tpsmaxfen;
+float Liminffen,Limsupfen;
+double CoupFlux;
+float Papa,poidsvois;
+float tauxper;long nstastat,ndsper;
+int flagChPer,flagvuefiltree;
+int nptsfenper,nptsfenphs;
+float somtps,somecartps,somecarz;
+float memtemps,membar;
+int ncoups;int statcalcphase[ncasphase];int CasesVides;
+float pasenphase,ecarmoytps[ncasphase],ecarmoyz[ncasphase];
+float sini[ncasphase],cosini[ncasphase];
+float phaseret=-9999;
+float pluvieux;int nlistevue,numaccro,flcatmin;
+#define D2R .0174533 //1 degre = D2R radians
+#define H2R .261799 // 1 heure siderale = H2R radians
+#define P2 1.570796 // pi sur 2
+#define PI 3.14159265359 // pi
+#define DPI 6.2831853 // 2*pi
+//variables geometriques du senseur stellaire :
+
+#define sommetdeg 49. // 1/2 angle d'ouverture du cone moye balay par la barette (en degres)
+#define ouvertdeg 1.44 // extension de la barette en delta (en degres)
+float sommet,ouvert; // memes angles en radians
+   float decaxe;
+   float raaxe;
+
+
+void init_recons_sst()
+
+//appele au debut par diabolo.c, puis a chaque reset de la fenetre findperiod
+{
+int i;
+double valeur=0;
+//printf("periode echantillonnage %f",gg->periode_echantillonage);
+pasenphase=360./(float)(ncasphase);
+for(i=0;i<nmemechant;i++)
+{
+instant[i]=0.;
+sfluxvu[i]=0.;
+barette[i]=0.;
+}
+for(i=0;i<ncasdiftps;i++)
+{
+cases[i]=0;
+}
+flagvuefiltree=0;
+//exec_FindPeriod(fenetre_Find_Period,ouverture,valeur);
+flagwind=0;
+maxcas=0;
+Period=LowSeek;Phase=-9999.;Sens=-9999;
+somcas=0;
+tdeb=0;
+flagstar=0;
+CoupFlux=10.;
+if(fenetre(fenetre_Find_Period)) CoupFlux=Rd_CpFl(fenetre_Find_Period);
+//printf("coupure en flux %d \n",(int)(CoupFlux));
+tauxper=0.;
+nstastat=0;
+ndsper=0;
+nptsfenper=0;
+nptsfenphs=0;
+memtemps=-1.;
+ncoups=0;
+somtps=0;somecartps=0;somecarz=0;
+
+				Liminffen=LowSeek;
+				Limsupfen=HighSeek;
+				Papa=10.;
+				if(fenetre(fenetre_Find_Period))
+				 {
+				 if(DonnePeriod() != -1)
+				  {
+				  Liminffen=DonnePeriod()-1;
+				  Limsupfen=DonnePeriod()+1;
+				  Papa=1.;
+				  }
+				 flagwind=1;
+				 }
+				
+				passargu(Liminffen,Limsupfen,Papa);
+					//nouveauD(fenetre_Find_Period,FindPeriod_id,"FindPeriod",exec_FindPeriod);
+					//nouveauD(fenetre_Phase_SST,phase_id,"phase",exec_phase);
+				//corFC	flagwind=0;
+				raz_fen_phase();
+ 				if (fenetre(fenetre_Find_Period)) {
+   					selectgra(fenetre_Find_Period);
+    				graph->xmin=Liminffen;
+    				graph->xmax=Limsupfen;
+    				graph->xpas=Papa;
+    				retrace(fenetre_Find_Period);
+					ecritD(fenetre_Find_Period,FP_vperesti," %7.3f",DonnePeriod());
+    			}
+
+    tpsminfen=Liminffen;
+    tpsmaxfen=Limsupfen; 
+StepCas=(HighSeek-LowSeek)/(float)(ncasdiftps);
+WidthCas=2*StepCas;
+tabulesincos();
+CasesVides=ncasphase;
+//lecture des catalogues STELLAIRES!
+if(fichierslus==0)
+{
+fichierslus=1;
+printf(" \n");
+  // Catalogue Dominique Yvon
+  {
+     short ref;
+     long n;
+     if (FSOpen("\phyp6HADY.dat",0,&ref)) {
+         printf("***ERREUR*** ouverture hyp6Hammam.dat\n");
+         return;
+     }
+     n = sizeof(long);
+     FSRead(ref, &n, (char*) &nstarcatal);
+   printf("nstarcatal = %d\n", nstarcatal);
+     n = nstarcatal*sizeof(struct star);
+     stars = (struct star*) malloc(n);
+     FSRead(ref, &n, (char*) stars);
+     FSClose(ref);
+     printf("Hyp6DY m<6 : read %d stars\n", nstarcatal);
+  }
+   for(i=0;i<5;i++)
+   {
+   printf("alpha %f,delta %f, mag %d \n",stars[i].ra,stars[i].dec,stars[i].mag);
+	}
+  {
+     short ref;
+     long n;
+     if (FSOpen("\psstgraphs.dat",0,&ref)) {
+         printf("***ERREUR*** ouverture sstgraphs.dat\n");
+         return;
+     }
+     n = sizeof(long);
+     FSRead(ref, &n, (char*) &nposaxesimu);
+   printf("nstarcatal = %d\n", nposaxesimu);
+     n = nposaxesimu*sizeof(struct sstgraph);
+     listord = (struct sstgraph*) malloc(n);
+     FSRead(ref, &n, (char*) listord);
+     FSClose(ref);
+     printf("sstgraph.dat : read %d positions simulees\n", nposaxesimu);
+  }
+	printf("nombre d'etoiles selectionnees %d\n",listord[0].netdet);
+	numaccro=0;flcatmin=1;
+}
+}
+
+void exec_recons_sst()
+{
+int i,icour;
+int cascour,casper,vudsper;
+int valid;
+float delbar,delebarre;
+float deltan,deltintin;
+float delcas,pocac;
+sflxv=0.;
+if(nfoundstars>0)
+{
+if(nfoundstars>MAXFOUNDSTARS) nfoundstars=MAXFOUNDSTARS;
+laplushaute=0.;
+for(i=0;i<nfoundstars;i++)
+{
+if(mfoundstars[i]>sflxv)
+{sflxv=mfoundstars[i];
+laplushaute=zfoundstars[i];
+}
+//printf("%d %f %f %f\n",i,tfoundstars[i],zfoundstars[i],mfoundstars[i]);
+}
+
+if(sflxv>CoupFlux)
+{
+maintenant=tfoundstars[0];
+membar=laplushaute;
+if(flagstar==0)
+ {
+ tdeb=maintenant;
+ flagstar=1;
+ }
+ if(maintenant-tdeb>LowSeek)
+ {
+ vudsper=0;
+ valid=0;
+ delbar=0;
+ delebarre=10000;
+ deltan=0.;
+ deltintin=1.;
+for(i=0;i<nmemechant;i++)
+{
+if(sfluxvu[i]==0.) break;
+separtps=maintenant-instant[i];
+separenz=laplushaute-barette[i];
+if(separtps>LowSeek && fabs(sfluxvu[i]-sflxv)/sflxv<.5)
+ {
+ if(separtps>tpsminfen && separtps<tpsmaxfen)
+ {
+ trace_point(fenetre_Find_Period);
+ nptsfenper++;
+ if(nptsfenper==QuorumRafrai && fenetre(fenetre_Find_Period))
+ { selectgra(fenetre_Find_Period);efface(fenetre_Find_Period);nptsfenper=0;}
+ }
+ // recherche de periode
+ if(separtps<HighSeek)
+ {
+ casper=(int)((Period-LowSeek)/StepCas);
+ cascour=(int)((separtps-LowSeek)/StepCas);
+ delcas=separtps-StepCas*(cascour+.5)-LowSeek;
+ pocac=fabs(delcas/StepCas);
+// printf("separtps %f delcas %f pocac %f\n",separtps,delcas,pocac);
+ 
+ 
+ if(cascour>0 && cascour<ncasdiftps-1)
+  {
+  cases[cascour]+=25./separtps*(1.-pocac);
+  if(delcas>0.){cases[cascour+1]+=25./separtps*pocac;}
+  else {cases[cascour-1]+=25./separtps*pocac;}
+  somcas+=25./separtps;
+   if(fabs(cascour-casper)<2)
+   {vudsper++;
+   }
+  if(cases[cascour]>maxcas)
+   {
+   maxcas=cases[cascour];
+   poidsvois=cases[cascour-1]+cases[cascour]+cases[cascour+1];
+   NewPeriod=LowSeek+
+   (cascour+.5+(cases[cascour+1]-cases[cascour-1])/poidsvois)*StepCas;
+    if(poidsvois>5*somcas/ncasdiftps){
+    flagChPer=0;
+    if(fabs(Period-NewPeriod)>1.)
+    {nstastat=0;ndsper=0;tauxper=0.;
+    { if(DonnePeriod() != -1 && fenetre(fenetre_Find_Period))
+    {selectgra(fenetre_Find_Period);efface(fenetre_Find_Period);nptsfenper=0;}}}
+    if(fabs(Period-NewPeriod)>.1) flagChPer=1;
+    if(fabs(Period-NewPeriod)>.010)
+    {raz_fen_phase();}
+    Period=NewPeriod;
+    }
+//   printf("maxcas %f somcas/ncasdiftps %f Periode : %f\n",maxcas,
+//   somcas/(float)(ncasdiftps),Period);
+   }
+  }
+  }
+  delbar=separenz;
+  deltan=separtps-Period;
+  if(DonnePeriod() != -1 
+  && fabs(deltan-Period)<FourchTps && fabs(deltan-Period-2*deltintin)<FourchTps 
+  && fabs(delebarre-2*delbar)<8 && valid==1)
+  {
+	tracephase();
+//	membar=.3*barette[i]+.7*membar;
+	nptsfenphs++;
+	if(nptsfenphs==RafraiPhase)	{raz_fen_phase();}
+//	printf("periode %8.3f phases tpsdiodes %8.1f sens %d\n",DonnePeriod(),DonnePhase(),DonneSens());
+
+  }
+  if(DonnePeriod() != -1 && fabs(deltan)<FourchTps && fabs(delbar)<8)
+  {valid=1;delebarre=delbar;deltintin=deltan;}
+  
+ }
+}
+nstastat++;
+if(vudsper!=0)ndsper++;
+if(nstastat>StatValidePeriode)
+{
+	tauxper=(float)(ndsper)/(float)(nstastat);
+
+//	printf("efficacite periode %f\n",tauxper);
+}
+
+if(nstastat==50)	{nstastat=0;ndsper=0;}
+if(DonnePeriod()==-1){
+raz_fen_phase();
+if(fenetre(fenetre_Find_Period) && tpsminfen != 10.){
+    				selectgra(fenetre_Find_Period);
+    				graph->xmin=10.;
+    				graph->xmax=40.;
+    				graph->xpas=10.;
+    				Liminffen=graph->xmin;
+    				Limsupfen=graph->xmax;
+				    tpsminfen=graph->xmin;
+    				tpsmaxfen=graph->xmax;
+    				passargu(Liminffen,Limsupfen,Papa);
+    				efface(fenetre_Find_Period);
+    				retrace(fenetre_Find_Period);
+					nptsfenper=0;
+}
+
+} else
+{
+if(flagChPer==1){
+		selectgra(fenetre_Find_Period);
+    				graph->xmin=DonnePeriod()-1.;
+    				graph->xmax=DonnePeriod()+1.;
+    				graph->xpas=1.;
+    				Liminffen=graph->xmin;
+    				Limsupfen=graph->xmax;
+				    tpsminfen=graph->xmin;
+    				tpsmaxfen=graph->xmax;
+    				passargu(Liminffen,Limsupfen,Papa);
+    				efface(fenetre_Find_Period);
+    				retrace(fenetre_Find_Period);
+					nptsfenper=0;
+}
+}
+if(fenetre(fenetre_Find_Period))
+{selectgra(fenetre_Find_Period);ecritD(fenetre_Find_Period,FP_vperesti," %7.3f",DonnePeriod());}
+if(Liminffen==LowSeek && DonnePeriod() != -1 && fenetre(fenetre_Find_Period)) 
+{
+    				selectgra(fenetre_Find_Period);
+    				graph->xmin=DonnePeriod()-1.;
+    				graph->xmax=DonnePeriod()+1.;
+    				graph->xpas=1.;
+    				Liminffen=graph->xmin;
+    				Limsupfen=graph->xmax;
+				    tpsminfen=graph->xmin;
+    				tpsmaxfen=graph->xmax;
+    				passargu(Liminffen,Limsupfen,Papa);
+    				efface(fenetre_Find_Period);
+    				retrace(fenetre_Find_Period);
+
+}
+}
+
+icour=0;
+pluvieux=maintenant;
+for(i=nmemechant-1;i>0;i--)
+ {
+ icour++;
+ if(sfluxvu[i-1]==0.) continue;
+ if(instant[i]<pluvieux)pluvieux=instant[i];
+ sfluxvu[i]=sfluxvu[i-1];
+ instant[i]=instant[i-1];
+ barette[i]=barette[i-1];
+ phd0[i]=phd0[i-1];
+  if(DonnePeriod()!=-1){if(maintenant-instant[i]>3.*DonnePeriod())
+   {
+    sfluxvu[i]=0.;
+    instant[i]=0.;
+    barette[i]=0.;
+    phd0[i]=0.;
+   }
+   }
+ }
+sfluxvu[0]=sflxv;
+instant[0]=maintenant;
+barette[0]=laplushaute;
+phd0[i]=0.;
+{float peri=DonnePeriod();
+if (peri>0.)phd0[i]=360./peri*(maintenant-peri*(int)(maintenant/peri));
+}
+// bloc recherche de l'axe ->identification des etoiles
+{float difftps=0.;
+
+if(DonnePeriod()>0. && (maintenant - pluvieux)>DonnePeriod())
+{
+nlistevue=0;
+for(i=0;i<nmemechant-1;i++)
+{
+ if(sfluxvu[i]==0. |maintenant-instant[i]>Period) break;
+difftps=(instant[i]-instant[i+1])*DPI/Period;
+nlistevue++;
+deltap[i]=difftps;
+rapflx[i]=sfluxvu[i+1]/sfluxvu[i];
+}
+//printf("%d etoiles detectees par tour\n",nlistevue);
+if(fenetre(fenetre_Find_Period))
+{selectgra(fenetre_Find_Period);ecritD(fenetre_Find_Period,Find_net," %d",nlistevue);}
+numaccro=1;
+if(numaccro==0) chercheaccro(flcatmin);
+
+
+
+
+}}
+// fin du bloc recherche de l'axe ->identification des etoiles
+
+}
+}
+}
+void chercheaccro(int seuil)
+{
+/*
+#define nstpturn 100
+struct sstgraph {
+  int netdet; // nombre d'etoiles detectees
+  float raax; // coordonnees equatoriales de l'axe de rotation du telescope
+  float decax;
+  long numcat[nstpturn]; //numero de l'etoile dans le fichier de depart
+  float phase[nstpturn]; //phase de l'etoile (angle/Nord - Est=+90¡ - ds plan perp axe rot ballon)
+  float cosinus[nstpturn]; // de l'angle entre la direction de l'etoile et l'axe de rotation du ballon
+  float fluxcat[nstpturn]; //flux de l'etoile en unites arbitraires
+  int	icl[nstpturn]; //ordre de l'etoile pour un classement par phases croissantes
+};
+*/
+int i,j;int nstartour;float temps[nstpturn],fluxion[nstpturn];
+nstartour=0;
+for(i=0;i<nposaxesimu;i++)
+	{
+	for(j=0;j<listord[i].netdet-1;j++)
+		{
+		deltapcat[j]=listord[i].phase[j+1]-listord[i].phase[j];
+		rapflxcat[j]=listord[i].fluxcat[j+1]/listord[i].fluxcat[j];
+		}
+	}
+
+
+}
+void trace_point(int fen)
+{
+if(fenetre(fen)) symbole(fen, separtps, sflxv, 2, rond, 0, bleu);
+}
+void tracephase(void)
+{
+float tempsplie,tempsmoy;float peri;float ecartps,ecarz;
+peri=DonnePeriod();
+if (peri>0.)
+{
+tempsplie=360./peri*(maintenant-peri*(int)(maintenant/peri));
+if(!flagvuefiltree)
+{
+if(fenetre(fenetre_Phase_SST))
+{symbole(fenetre_Phase_SST,tempsplie,separtps-2.*peri, 10, carre, 0, bleu);
+symbole(fenetre_Phase_SST,tempsplie,.005*(separenz), 10, croix, 0, rouge);}
+}
+
+{
+if(ncoups==0)memtemps=((int)(tempsplie)/pasenphase)*pasenphase;
+ if(tempsplie-memtemps<pasenphase && tempsplie>=memtemps)
+ {
+  ncoups++;
+  somtps+=tempsplie;
+  somecartps+=separtps-2.*peri;
+  somecarz+=(separenz)*.005;
+ } else
+ {
+  if(ncoups>0)
+  {
+   tempsmoy=somtps/(float)(ncoups);
+//   printf("temps,ecart : %f %f\n",tempsmoy,somecartps/ncoups);
+   ecartps =somecartps/(float)(ncoups);
+   ecarz = somecarz/(float)(ncoups);
+   charge_calc_phase(tempsmoy,ecartps,ecarz);
+if(fenetre(fenetre_Phase_SST) && flagvuefiltree)
+{   symbole(fenetre_Phase_SST,tempsmoy,ecartps, 10, carre, 0, bleu);
+   symbole(fenetre_Phase_SST,tempsmoy,ecarz, 10, croix, 0, rouge);
+}
+   ncoups=0;
+   somtps=0;
+   somecartps=0;
+   somecarz=0;
+   memtemps=((int)(tempsplie)/pasenphase)*pasenphase;
+  {
+  ncoups++;
+  somtps+=tempsplie;
+  somecartps+=separtps-2.*peri;
+  somecarz+=(separenz)*.005;
+ }
+ }
+ }
+
+}
+}}
+float DonnePeriod(void)
+{
+if(tauxper>.4){
+return Period;}
+else return -1.;
+}
+int CpFl(void)
+{
+return (int)(CoupFlux);
+}
+void raz_fen_phase()
+{
+int i;
+if (fenetre(fenetre_Phase_SST)){selectgra(fenetre_Phase_SST);
+efface(fenetre_Phase_SST);}
+memtemps=-1.;ncoups=0;nptsfenphs=0;phaseret=-9999.;Sens=-9999;
+CasesVides=ncasphase;for(i=0;i<ncasphase;i++) statcalcphase[i]=0;
+
+}
+void charge_calc_phase(float tempsmoy,float ecartps,float ecarz)
+{
+int caserne;
+caserne=(tempsmoy+pasenphase*.5)/pasenphase;
+if(caserne==ncasphase)caserne=0;
+if(caserne < ncasphase && caserne >= 0)
+{
+if(statcalcphase[caserne]<5 | (fabs(ecarmoytps[caserne]-ecartps)<.02 &&
+fabs(ecarmoyz[caserne]-ecarz)<3.))
+{ecarmoytps[caserne]*=statcalcphase[caserne];
+ecarmoyz[caserne]*=statcalcphase[caserne];
+ecarmoytps[caserne]+=ecartps;
+ecarmoyz[caserne]+=ecarz;
+statcalcphase[caserne]++;
+ecarmoytps[caserne]/=statcalcphase[caserne];
+ecarmoyz[caserne]/=statcalcphase[caserne];
+CasesVides=calc_phase();
+}}}
+void tabulesincos(void)
+{
+int i;float pasenrad;
+pasenrad=pasenphase*.01745329;
+for(i=0;i<ncasphase;i++)
+{
+sini[i]=sin(pasenrad*(i));
+cosini[i]=cos(pasenrad*(i));
+}
+}
+int calc_phase(void)
+{
+int i,vides;float cocoz,sisiz,cocotps,sisitps;
+float phasez,phasetps;float sensrot;
+static float phasemem;
+vides =0;
+for(i=0;i<ncasphase;i++)
+{
+if(statcalcphase[i]==0) vides++;
+}
+
+cocoz=0;
+sisiz=0;
+cocotps=0;
+sisitps=0;
+for(i=0;i<ncasphase;i++)
+{
+if(statcalcphase[i]>0)
+{
+cocoz+=cosini[i]*ecarmoyz[i];
+sisiz+=sini[i]*ecarmoyz[i];
+cocotps+=cosini[i]*ecarmoytps[i];
+sisitps+=sini[i]*ecarmoytps[i];
+}
+}
+phasez=-atan2(cocoz,sisiz);
+phasetps=-atan2(cocotps,sisitps);
+sensrot=phasez-phasetps;
+if(sensrot>3.14)sensrot-=6.28;
+if(sensrot<-3.14)sensrot+=6.28;
+if(sensrot>0.) Sens =1;
+if(sensrot<=0.) Sens =-1;
+//arbitraire, ajuste sur la simulation
+Phase=phasez*57.29577;
+phaseret=-9999.;
+if(CasesVides<3 && fabs(Phase-phasemem)<10.){ phaseret=Phase;}
+if(CasesVides<4) phasemem=Phase;
+//printf("phases : numdiodes %f, tpsdiodes %f sens %d\n",phasez,phasetps,Sens);
+return vides;}
+float DonnePhase(void)
+{
+return phaseret;
+}
+int DonneSens(void)
+{
+if(CasesVides<3){return Sens;}else {return -9999;}
+}
Index: trunk/Poubelle/archediab.old/archediab.sources/c/senseur_stellaire.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/senseur_stellaire.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/senseur_stellaire.c	(revision 649)
@@ -1,28 +1,332 @@
 #include "diabolo.h" 
 #include "senseur_stellaire.h" 
-
-
+#include "compress.h" 
+#include "recons_sst.h" 
+#include <math.h>
+
+#define M_PI 3.1415926535
 
 //--------------------  fonction  exec  de  la  fenetre : senseur_stellaire  -------------------------------
 
+static int diodes[48];
+
+#define DIODE_UNUSED_1 3
+#define DIODE_UNUSED_2 7
+
+
+int diodesbuffer[dbufsz][48];int off[48];
+float zfoundstars[20];
+float mfoundstars[20];
+double tfoundstars[20];
+int nfoundstars;
+int seuilSST=5;
+
+static void init_sst_buffers(void);
+static void remove_diode_offset(void);
+static void find_stars(double secondes);
+
+static void trace_lin(int fen, double secondes);
+static void trace_radar(int fen, double secondes);
+static void init_radar(void);
+static void setup_gra(int fen);
+static void clean_radar(float phase,int fen);
+
+static double radarPer = 30.; // periode du radar, en secondes.
+static double radarTUp = 0; // le temps de reference pour pointage "NORD"
+static int    radarSens = 1;
+static int  sstHas2Bars = false;
+
+//static double tm = 0;
 
 void exec_senseur_stellaire(int fen,int item,double valeur,...) 
 {
 if(item>1000) item-=1000;		// pour appeler le case pour tous les cara d'un edit texte
-
 switch(item)
     {
     case ouverture               :
-    			
+    				selectgra(fen);
+    				setup_gra(fen);
+ 				init_sst_buffers();
+ 			    radarPer = litD(fenetre_senseur_stellaire,sst_periode,0);
+ 			    radarTUp = litD(fenetre_senseur_stellaire,sst_phase,0);
+
                  break;
     case fermeture               :
                  break;
-    case sst_azer :
-                 break;
-    case sst_sortie_brute :
+    case sst_txt :
+                 break;
+    case sst_twobars :
+                 sstHas2Bars = litD(fenetre_senseur_stellaire,sst_twobars,0);
+                 break;
+    case sst_radar :
+                 setup_gra(fen);
+                 break;
+    case sst_seuil : {
+            seuilSST = litD(fenetre_senseur_stellaire,sst_seuil,0);
+            if (seuilSST <=0) {
+              seuilSST = 1;
+            }
+            }
+            break;
+    case sst_periode :
+    case sst_sens_horaire:
+    case sst_phase : {
+            double sns = litD(fenetre_senseur_stellaire,sst_sens_horaire,0);
+            double phs = litD(fenetre_senseur_stellaire,sst_phase,0);
+            radarPer = litD(fenetre_senseur_stellaire,sst_periode,0);
+            radarTUp = phs/360. * radarPer;
+    		selectgra(fen);
+    		if (radarSens != (sns ? -1 : 1)) efface(fen);
+            radarSens = sns ? -1 : 1;
+            break;
+            }
+    case sst_efface :
+                 setup_gra(fen);
+                 efface(fen);
+                 break;
+    case tache_de_fond: 
+            selectgra(fen);
+            if(litD(fenetre_senseur_stellaire,sst_radar,0)) {
+               trace_radar(fen, valeur);
+            } else {
+               trace_lin(fen, valeur);
+            }
                  break;
     default  :   break;
     }
 }
+
+void setup_gra(fen) {
+ selectgra(fen);
+  if(litD(fenetre_senseur_stellaire,sst_radar,0)) {
+    graph->ymin=-60;
+    graph->ymax=60;
+    graph->ypas=0;
+    graph->xmin=-60;
+    graph->xmax=60; 
+    graph->xpas=0;
+    graph->grille=0;
+    graph->graduations=0;
+    graph->taille_graduations=0;
+    graph->sans_image=1;      	
+    graph->avec_icones=0;      	
+    strcpy(graph->xtitre, "");    	
+    graph->ytitre[0]=0;   
+    init_radar();
+  } else {
+    graph->ymin=0;
+    graph->ymax=48;
+    graph->ypas=5;
+    graph->xmin=0;
+    graph->xmax=240; 
+    graph->xpas=30;
+    graph->grille=0;
+    graph->graduations=1;
+    graph->taille_graduations=10;
+    graph->sans_image=0;      	
+    graph->avec_icones=0;      	
+    strcpy(graph->xtitre, "T");    	
+    graph->ytitre[0]=0;   
+  }
+  efface(fen);
+}
+
+#define seuil1 500
+#define seuil2 250
+#define seuil3 120
+#define seuil4 60
+#define seuil5 30
+#define seuil6 10
+
+#define frc(x) ((x) - (int)(x))
+
+void trace_lin(int fen, double secondes) {
+  int i;
+  //tm += gg->periode_echantillonage;
+  //if (tm>graph->xmax) tm = 0;
+  double tm = secondes - (int)(secondes/graph->xmax)*graph->xmax;
+  if(!litD(fenetre_senseur_stellaire,sst_etoiles,0)) {
+   for (i=0; i<48; i++) {
+   if(fabs(off[i])>1000.) continue;
+     if (-diodes[i] +off[i]> seuil1) 
+       symbole(fen, tm, i,  5, rondplein, 0, rouge);
+     else if (-diodes[i]+off[i] > seuil2) 
+       symbole(fen, tm, i,  4, rondplein, 0, rouge);
+     else if (-diodes[i]+off[i] > seuil3) 
+       symbole(fen, tm, i, 3, rondplein, 0, rouge);
+     else if (-diodes[i]+off[i] > seuil4) 
+       symbole(fen, tm, i, 2, rondplein, 0, rouge);
+     else if (-diodes[i]+off[i] > seuil5) 
+       symbole(fen, tm, i, 2, point, 0, rouge);
+     else if (-diodes[i]+off[i] > seuil6) 
+       symbole(fen, tm, i, 2, point, 0, noir);
+    }
+  } else {
+   for (i=0; i<nfoundstars; i++) {
+     float z = zfoundstars[i];
+     if (mfoundstars[i] > seuil1) {
+       symbole(fen, tm, z,  5, rondplein, 0, rouge);
+     } else if (mfoundstars[i] > seuil2) {
+       symbole(fen, tm, z,  4, rondplein, 0, rouge);
+     } else if (mfoundstars[i] > seuil3) {
+       symbole(fen, tm, z,  3, rondplein, 0, rouge);
+     } else if (mfoundstars[i] > seuil4) {
+       symbole(fen, tm, z,  2, rondplein, 0, rouge);
+     } else if (mfoundstars[i] > seuil5) {
+       symbole(fen, tm, z,  2, point, 0, rouge);
+     } else
+       symbole(fen, tm, z,  2, point, 0, noir);
+   }
+  }
+}
+
+#define NMAXRADARSTAR 1000
+
+struct radarStar {
+  float phase;
+  float rayon;
+  float flux;
+};
+
+static struct radarStar* radarstars = 0;
+static double lastPhase = 0;
+
+void init_radar() {
+  int i;
+  if (!radarstars) {
+    radarstars = (struct radarStar*) malloc(NMAXRADARSTAR*sizeof(struct radarStar));
+  }
+  for (i=0; i<NMAXRADARSTAR; i++) {
+    radarstars[i].phase = -1;
+    radarstars[i].rayon = -1;
+  }
+  
+}
+
+
+// Nettoyage radar pour trace jusqu'a phase
+
+static void clean_radar(float phase, int fen) {
+  int i;
+  double x,y,r,th;
+  for (i=0; i<NMAXRADARSTAR; i++) {
+  //  if (radarstars[i].phase >= 0 && radarstars[i].phase < 10 &&
+  //      ((phase > lastPhase && radarstars[i].phase > lastPhase &&
+  //        radarstars[i].phase <= phase) ||
+  //      ((phase < lastPhase && (radarstars[i].phase > lastPhase ||
+  //        radarstars[i].phase <= phase))))) {
+    if (radarstars[i].phase >= 0 && radarstars[i].phase < phase-1) {
+      r = (60-48) + radarstars[i].rayon;
+      th = (frc(radarstars[i].phase)*radarSens+.25) * 2 * M_PI ;  
+      x = r * cos(th);
+      y = r * sin(th);
+      if (radarstars[i].flux > seuil1) {
+        symbole(fen, x, y,  5, rondplein, 0, blanc);
+      } else if (radarstars[i].flux > seuil2) {
+        symbole(fen, x, y,  4, rondplein, 0, blanc);
+      } else if (radarstars[i].flux > seuil3) {
+        symbole(fen, x, y,  3, rondplein, 0, blanc);
+      } else if (radarstars[i].flux > seuil4) {
+        symbole(fen, x, y,  2, rondplein, 0, blanc);
+      } else  {
+        symbole(fen, x, y,  2, point, 0, blanc);
+      } 
+      radarstars[i].phase = -1;
+    }
+    //if (radarstars[i].phase >= 10) {
+    //  radarstars[i].phase -= 10;
+    //} 
+  }
+}
+
+static long lastRadarTrace = 0;
+
+void trace_radar(int fen, double secondes) {
+  // On a des nouvelles etoiles...
+  double phase;
+  int i,j;
+  long tk;
+    
+  phase = (secondes - radarTUp)/radarPer;
+  //phase = phase - (int)(phase);
+  
+  for (i=0; i<nfoundstars; i++) {
+    for (j=0; j<NMAXRADARSTAR; j++) {
+      if (radarstars[j].phase < 0) {
+        radarstars[j].phase = phase;//  +10; // >=10 : nouvelle...
+        radarstars[j].rayon = zfoundstars[i];
+        radarstars[j].flux  = mfoundstars[i];
+        break;
+      }
+    }
+  }
+  
+  // Le trace...
+  // mais on ne trace pas tout le temps...
+  tk = TickCount();
+  if (tk - lastRadarTrace < 10) return;
+  lastRadarTrace = tk;
+  
+  if (litD(fenetre_senseur_stellaire,sst_autolock,0)) {
+    float per,phs,sns;
+    per = DonnePeriod();
+    phs = DonnePhase();
+    sns = DonneSens();
+    if (per>0) {
+      ecritD(fenetre_senseur_stellaire, sst_periode, "%8.3f",per);
+      radarPer = per;
+    }
+    if (phs>-9000) {
+      ecritD(fenetre_senseur_stellaire, sst_phase, "%8.1f",phs);
+      radarTUp = phs/360. * radarPer;
+    }
+    if (sns > -9000) {
+      radarSens = -sns;
+      ecritC(fenetre_senseur_stellaire, sst_sens_horaire, sns > 0);
+    }
+  }
+  
+  //cercle(fen,-(60-48),-(60-48),(60-48),(60-48),jaune);	// trace le cercle x1,y1 - x2,y2		
+
+ modtrace(fen,1,blanc);
+  segment(fen, (60-48)*cos((lastPhase*radarSens+.25)*M_PI*2),  
+               (60-48)*sin((lastPhase*radarSens+.25)*M_PI*2),
+                60*cos((lastPhase*radarSens+.25)*M_PI*2),       
+                60*sin((lastPhase*radarSens+.25)*M_PI*2));
+                
+  clean_radar(phase, fen);
+  
+  modtrace(fen,1,jaune);
+  segment(fen, (60-48)*cos((frc(phase)*radarSens+.25)*M_PI*2),  
+               (60-48)*sin((frc(phase)*radarSens+.25)*M_PI*2),
+                60*cos((frc(phase)*radarSens+.25)*M_PI*2), 
+                60*sin((frc(phase)*radarSens+.25)*M_PI*2));
+              
+  for (i=0; i<NMAXRADARSTAR; i++) {
+    if (radarstars[i].phase >= 0) {
+      float x,y,r,th;
+      r = (60-48) + radarstars[i].rayon;
+      th = (frc(radarstars[i].phase)*radarSens+.25) * 2 * M_PI ;  
+      x = r * cos(th);
+      y = r * sin(th);
+      if (radarstars[i].flux > seuil1) {
+        symbole(fen, x, y,  5, rondplein, 0, rouge);
+      } else if (radarstars[i].flux > seuil2) {
+        symbole(fen, x, y,  4, rondplein, 0, rouge);
+      } else if (radarstars[i].flux > seuil3) {
+        symbole(fen, x, y,  3, rondplein, 0, rouge);
+      } else if (radarstars[i].flux > seuil4) {
+        symbole(fen, x, y,  2, rondplein, 0, rouge);
+      } else if (radarstars[i].flux > seuil5) {
+        symbole(fen, x, y,  2, point, 0, rouge);
+      } else
+        symbole(fen, x, y,  2, point, 0, noir);
+    }
+  }
+  lastPhase = frc(phase);
+
+}
+
+
 
 //#define	bit_sst(i,j,k)  (((blk->sst[i][i*3+k/4])>>(j+8*k%4))&1)   
@@ -50,129 +354,229 @@
 #define place_paquet(i,j)	 (i/8) * 24  + j*8 + (i%8) 
 
-void	traite_block_sst_comprime	(block_type_sst_comprime*	blk){}
+
+void decode_sst(block_type_sst*	blk, int i, int* diodes); // diodes = tableau a 48 entrees
+
+void decode_sst(block_type_sst*	blk, int i, int* diodes) {
+  int j; // 0-5 : numero du bloc de 8 diodes
+  int k; // 0-2 : indice du bloc de 4 bits (une diode = 12 bits = 3 blocs de 4 bits)
+  int l; // 0-7 : indice de la diode dans son bloc (8 diodes * 4 bits = 1 mot de 32 bits)
+  
+  // numero de la diode (0-47) = j*8+l;
+  // indice dans le bloc sst du mot de 32 bits (0-17) = j*3+k;
+  // indice dans mot de 32 bits du premier bit utile = 4*l;
+  
+  for (j=0; j<48; j++) diodes[j] = 0;
+  
+  for (j=0; j<6; j++)
+    for (k=0; k<3; k++)
+      for (l=0; l<8; l++) {
+        long word = blk->sst[i][j*3+k];
+        word = (word >> (4*l)) & 0xF;
+        //printf("diode %d mot %d valeur %d\n", j*8+l, k, word);
+        diodes[j*8+l] = (diodes[j*8+l] << 4) + word;
+      }
+      
+  //for (j=0; j<48; j++) if (diodes[j]>2047) diodes[j] -= 4096;
+  for (j=0; j<48; j++)  diodes[j] -= 2048;
+}
+
+
+
+//#define place_paquet(i,j)	 ((i/8) * 24  + j*8 + (i%8) )
+
+void	traite_block_sst_comprime	(block_type_sst_comprime*	blk){
+  block_type_sst blk2;
+  unsigned long	sst_vrai[nb_per_block*2];
+  int j,jc,i,k;
+  unsigned long	a,b0,b1,b2;
+
+  
+  for (j=0; j<18; j++)
+    for (i=0; i<nb_per_block*2; i++)
+      blk2.sst[i][j] = 0;
+
+  jc=0;
+  for(j=0;j<48;j++) {
+    if ((j!=0) && (j!=4)) 
+    {
+      decompress_4_1((long*)blk->sst[jc],(long*)sst_vrai,nb_per_block*2);
+      for(k=0;k<nb_per_block*2;k++) {
+         b2 = sst_vrai[k] & 0xf;
+         b1 = (sst_vrai[k] >> 4) & 0xf;
+         b0 = (sst_vrai[k] >> 8) & 0xf;
+	 a=place_paquet(j,0);
+	 blk2.sst[k][a/8] |= (b0 << (a%8)*4);
+	 a=place_paquet(j,1);
+	 blk2.sst[k][a/8] |= (b1 << (a%8)*4);
+	 a=place_paquet(j,2);
+	 blk2.sst[k][a/8] |= (b2 << (a%8)*4);
+      }
+      jc++;
+    }
+  }
+  valide_block((block_type_modele*)&blk2,block_sst,numero_block(blk));	
+  traite_block_sst(&blk2);
+}
 
 
 void	traite_block_sst(block_type_sst*	blk)
 {
-int i,j,k;
-double	y[15];
-double	x;
+int i,k;
+//double	y[15];
+//double	x;
 
 int temps_cntl;
 double secondes;
-int a,b,b0,b1,b2;
-int prem_d;
-
-if(!fenetre(fenetre_senseur_stellaire)) return;
-//  ecriture des valeurs brutes du senseur stellaire
-//  les numero 0 et 4  sont dediés aux thermometres
-//  pour l'instant machent bien 1 2 3   8 9 10 11   
-if(litD(fenetre_senseur_stellaire,sst_sortie_brute,0))
-	{
-	if(!fenetre(fenetre_senseur_stellaire_lecture_brute)) nouveauT(fenetre_senseur_stellaire_lecture_brute,0,"lecture senseur stellaire");
-
-	ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\nsenseur stellaire  \n");
-
-
-//	k=0;
-	for(k=0;k<4;k++)
-		{
-	    	for(i=0;i<16;i++)		//  16 senseurs 
-			{
-			for(j=0;j<3;j++)		//  3 paquets
-	    			{
-	    			a=place_paquet(i,j);
-	    			b= ( blk->sst[k][a/8] >>( (a%8)*4) ) & 0xf;
-				ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"%x",b);
-				}
-			ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"  ");
-			}
-	 	ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\n");
-	 	}
-
-	 ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\n");
-
-	 }
-
-//k=0;
-prem_d=litD(fenetre_senseur_stellaire,sst_prem_diode,0L);
-for(k=0;k<72;k++)
-	{
-	 for(i=0;i<12;i++)		//  seulement 12 diodes 
-		{
-		int q;
-		q=i+prem_d-1;
-				
-		a=place_paquet(q,0);
-	    	b0= ( blk->sst[k][a/8] >>( (a%8)*4) ) & 0xf;
-		a=place_paquet(q,1);
-	    	b1= ( blk->sst[k][a/8] >>( (a%8)*4) ) & 0xf;
-		a=place_paquet(q,2);
-	    	b2= ( blk->sst[k][a/8] >>( (a%8)*4) ) & 0xf;
-		
-
-		x=(double)( (b0<<8) | (b1<<4) |  b2 ) ;
-		if(x>2047) x-=4096;
-		y[i]=x;
-		}
-//	printf(" y = %g %g %g %g %g \n",y[0],y[1],y[2],y[3],y[4]);
-	temps_cntl =numero_block(blk)*nb_per_block*2+k;
-	secondes=gg->periode_echantillonage*(double)temps_cntl-gg->temps_origine;
-	tracen(fenetre_senseur_stellaire,12,secondes,y);
-	}
-}
-
-
-		
-//	les 46 valeurs en hexa
-//	i=0;			//  juste le premier point du block
-//	for(i=0;i<72;i++)
+//int a,b,b0,b1,b2;
+//char tab[5000];
+
+for (i=0; i<nb_per_block*2; i++) {
+  k=0;
+  decode_sst(blk, i, diodes);
+  temps_cntl=numero_block(blk)*nb_per_block*2+i;
+  secondes = temps_cntl*gg->periode_echantillonage;
+  
+  // 1. Suppression d'offset sur la rangee de diodes, et remise en ordre
+  remove_diode_offset();
+  // 2. Suppression des doubles impulsions et detection des etoiles
+  find_stars(secondes);
+  exec_recons_sst();
+  
+  if(fenetre(fenetre_senseur_stellaire)) 
+    exec_senseur_stellaire(fenetre_senseur_stellaire,tache_de_fond,secondes);
+}
+}
+
+void init_sst_buffers(void) {
+  int i,j;
+  for (i=0; i<dbufsz; i++)
+    for (j=0; j<48; j++) 
+      diodesbuffer[i][j] = 0;
+  nfoundstars = 0;
+}
+
+// sans objet a cause des filtres de l'electronique ?
+// se contente de permuter les diodes
+
+// diodpermut[i] = channel de la diode i
+static int diodpermut[46]=
+ { 8,24,40, 9,25,41,10,26,42,11,
+  27,43,16,32, 1,17,33, 2,18,34,
+   3,19,35,12,28,44,13,29,45,14,
+  30,46,15,31,47,20,36, 5,21,37,
+   6,22,38, 7,23,39};
+ // voies 0 et 4 non connectees, voie 1 en panne.
+
+void remove_diode_offset(void) {
+  int dd[46];
+  int i;
+  for (i=0; i<46; i++) {
+    dd[i] = diodes[i];
+  }
+  diodes[46] = diodes[47] = 0;
+  for (i=0; i<46; i++) {
+    diodes[i] = dd[diodpermut[i]];
+  }
+  return;
 /*
-for(i=0;i<72;i++)
-	{
-
-	 for(j=0;j<12;j++)		//  seulement les 12 premieres diodes 
-		{
-		x=0;
-		for(k=0;k<12;k++)	x=(x<<1)  | bit_sst(i,j,k);
-		y[j]=(double)x;
-		}
-	temps_cntl =numero_block(blk)*nb_per_block*2+i;
-	secondes=gg->periode_echantillonage*(double)temps_cntl-gg->temps_origine;
-	tracen(fenetre_senseur_stellaire,12,secondes,y);
-	}
-			
-*/
-/*	i=1;			//  juste le premier point du block
-//	for(i=0;i<72;i++)
-		{
-		for(k=0;k<12;k++)		//  12 bits
-	    		{
-	    		for(j=0;j<35;j++)		//  46 senseurs 
-				{
-				ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"%d   ",bit_sst(i,j,k));
-				}
-	 		ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\n");
-			}
-	 	ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\n");
-	 	}
-		
-//	les 46 valeurs en hexa
-//	i=0;			//  juste le premier point du block
-//	for(i=0;i<72;i++)
-	for(i=0;i<10;i++)
-		{
-	    	for(j=0;j<35;j++)		//  46 senseurs 
-			{
-			x=0;
-			for(k=0;k<12;k++)	x=(x<<1)  | bit_sst(i,j,k);
-			ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"%3x ",x);
-			}
-	 	ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\n");
-	 	}
-			
-	
-	}
-
-			
-*/	
+  int i,j;
+  float m,sig;
+  // suppression des positions non utilisees. 3 et 7 ?
+  for (i=DIODE_UNUSED_1; i<46; i++)
+    diodes[i] = diodes[ i<DIODE_UNUSED_2-1 ? i+1 : i+2 ];
+  
+  // calcul d'un fond sur la rangee. Moyenne clippee.
+  m = 0; sig = 1.e10;
+  for (i=0; i<2; i++) {
+    float s=0; float s2=0; int n=0;
+    for (j=0; j<46; j++) {
+      if (fabs(diodes[j]-m)<3*sig+1) {
+        s += diodes[j]; s2 += diodes[j]*diodes[j]; n++;
+      }
+    }
+    if (n>0) {
+      m = s/n; sig = sqrt(s2/n - m*m);
+    } else {
+      m = 0; break;
+    }
+  }
+  for (j=0; j<46; j++) 
+    diodes[j] -= m;
+    
+  diodes[46] = diodes[47] = 0;
+  */
+}
+
+
+void find_stars(double secondes) {
+  int i,j,feelasleep,sousoff;
+  float corrtemps,aufsete;
+  // Une etoile est validee seulement si impulsion dans meme canal
+  // ou dans canal juste au dessus dans les 4 echantillons qui precedent
+  // (en excluant le precedent).
+  // On demande aussi que le signal soit en train de remonter...
+  // en pratique on pourrait restreindre la contrainte avec une estimation
+  // de la vitesse de rotation. echantillon -2 ou -3...
+  nfoundstars = 0;
+  for (i=0; i<46; i++) {
+  // la diode 14 est morte (canal 1)...
+  if (i==14) continue;
+  aufsete=0.;feelasleep=0;
+  for (sousoff=0;sousoff<5;sousoff++)
+  {aufsete+=diodesbuffer[sousoff][i];feelasleep++;}
+  aufsete/=feelasleep;
+  off[i]=aufsete;
+    if ((diodes[i] -aufsete< -seuilSST ||
+    diodesbuffer[dbufsz-1][i]-aufsete< -seuilSST ||
+    diodesbuffer[dbufsz-2][i]-aufsete< -seuilSST)
+    && fabs(off[i])<1000.) {
+     if (sstHas2Bars) {
+      for (j=dbufsz-2; j>=0; j--) {
+        if (diodesbuffer[j][i] < -seuilSST) {
+          //printf("Found star same %d\n",dbufsz-j);
+          zfoundstars[nfoundstars] = i;
+          mfoundstars[nfoundstars] = diodes[i]-aufsete;
+          tfoundstars[nfoundstars] = secondes;
+          nfoundstars++;
+          if (nfoundstars >= MAXFOUNDSTARS) return;
+          break;
+        }
+        if (i < 45 && diodesbuffer[j][i+1] < -seuilSST) {
+          //printf("Found star decal %d\n",dbufsz-j);
+          zfoundstars[nfoundstars] = i+.5;
+          mfoundstars[nfoundstars] = diodes[i]-aufsete;
+          tfoundstars[nfoundstars] = secondes;
+          nfoundstars++;
+          if (nfoundstars >= MAXFOUNDSTARS) return;
+          break;
+        }
+      }
+     } else {
+       if ((diodes[i] > diodesbuffer[dbufsz-1][i]) 
+          && (diodesbuffer[dbufsz-1][i] < 
+          .5*(diodesbuffer[dbufsz-2][i]+diodesbuffer[dbufsz-3][i]))) {
+          zfoundstars[nfoundstars] = i;
+          mfoundstars[nfoundstars] = -(diodesbuffer[dbufsz-1][i]+diodesbuffer[dbufsz-2][i])/2.+aufsete;
+          corrtemps=(diodesbuffer[dbufsz-2][i]-diodes[i])*gg->periode_echantillonage;
+          corrtemps=-corrtemps/
+          ((diodesbuffer[dbufsz-2][i]+diodesbuffer[dbufsz-1][i]+diodes[i])-3.*aufsete);
+//	  corrtemps=0;
+          tfoundstars[nfoundstars] = secondes+corrtemps;
+          nfoundstars++;
+          if (nfoundstars >= MAXFOUNDSTARS) return;
+       }
+     }
+    }
+  }
+  
+  // remplissage buffer echantillons precedents
+  for (j=0; j<dbufsz-1; j++)
+    for (i=0; i<46; i++) 
+      diodesbuffer[j][i] = diodesbuffer[j+1][i];
+  for (i=0; i<46; i++) 
+    diodesbuffer[dbufsz-1][i] = diodes[i];
+}
+
+
+// Comparaison avec le GSC.
+// Preparer une carte pour une position et une heure.
Index: trunk/Poubelle/archediab.old/archediab.sources/c/sstbrut.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/sstbrut.c	(revision 649)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/sstbrut.c	(revision 649)
@@ -0,0 +1,210 @@
+#include "diabolo.h" 
+#include "sstbrut.h" 
+#include "compress.h" 
+
+
+
+//--------------------  fonction  exec  de  la  fenetre : senseur_stellaire  -------------------------------
+
+
+void exec_sstbrut(int fen,int item,double valeur,...) 
+{
+if(item>1000) item-=1000;		// pour appeler le case pour tous les cara d'un edit texte
+
+switch(item)
+    {
+    case ouverture               :
+    			
+                 break;
+    case fermeture               :
+                 break;
+    case sstb_azer :
+                 break;
+    case sstb_sortie_brute :
+                 break;
+    default  :   break;
+    }
+}
+
+//#define	bit_sst(i,j,k)  (((blk->sst[i][i*3+k/4])>>(j+8*k%4))&1)   
+
+
+//   i est le numero du point dans le block de 72
+//	j	est le numero de la diode  de 0 a 47
+//  	j%8	est la place du bit dans le mot de 8 bit 
+//	j/8	(de 0 a 5 ) est la serie de mesure
+//	k est le numero du bit dans le mot de 12 bits
+//		les k se suivent dans les données
+
+//   k est le numero du point dans le block de 72
+//	i	est le numero de la diode  de 0 a 47
+//  	j	est le paquet de 4 bits de 0 a 2 
+
+
+// on prend des paquets de 4 bits
+// chaque diode est formee de 3 paquets
+// dans l'ordre :  les paquets de 8 diodes  (8 paquets)
+//  recommencer 3 fois	(24 paquets)
+// enfin, faire 6 fois cette operation  (144 paquets)
+
+// soit q  la place du paquet  i,j,k
+#define place_paquet(i,j)	 (i/8) * 24  + j*8 + (i%8) 
+
+void	traite_block_sst_comprime_brut	(block_type_sst_comprime*	blk){
+  block_type_sst blk2;
+  unsigned long	sst_vrai[nb_per_block*2];
+  int j,jc,i,k;
+  unsigned long	a,b0,b1,b2;
+
+  
+  for (j=0; j<18; j++)
+    for (i=0; i<nb_per_block*2; i++)
+      blk2.sst[i][j] = 0;
+
+  jc=0;
+  for(j=0;j<48;j++) {
+    if ((j!=0) && (j!=4)) 
+    {
+      decompress_4_1((long*)blk->sst[jc],(long*)sst_vrai,nb_per_block*2);
+      for(k=0;k<nb_per_block*2;k++) {
+         b2 = sst_vrai[k] & 0xf;
+         b1 = (sst_vrai[k] >> 4) & 0xf;
+         b0 = (sst_vrai[k] >> 8) & 0xf;
+	 a=place_paquet(j,0);
+	 blk2.sst[k][a/8] |= (b0 << (a%8)*4);
+	 a=place_paquet(j,1);
+	 blk2.sst[k][a/8] |= (b1 << (a%8)*4);
+	 a=place_paquet(j,2);
+	 blk2.sst[k][a/8] |= (b2 << (a%8)*4);
+      }
+      jc++;
+    }
+  }
+  valide_block((block_type_modele*)&blk2,block_sst,numero_block(blk));	
+  traite_block_sst_brut(&blk2);
+}
+
+
+void	traite_block_sst_brut(block_type_sst*	blk)
+{
+int i,j,k;
+double	y[15];
+double	x;
+
+int temps_cntl;
+double secondes;
+int a,b,b0,b1,b2;
+int prem_d;
+
+if(!fenetre(fenetre_sstbrut)) return;
+//  ecriture des valeurs brutes du senseur stellaire
+if(litD(fenetre_sstbrut,sstb_sortie_brute,0))
+	{
+	if(!fenetre(fenetre_senseur_stellaire_lecture_brute)) nouveauT(fenetre_senseur_stellaire_lecture_brute,0,"lecture senseur stellaire");
+
+	ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\nsenseur stellaire  \n");
+
+
+//	k=0;
+	for(k=0;k<4;k++)
+		{
+	    	for(i=0;i<16;i++)		//  16 senseurs 
+			{
+			for(j=0;j<3;j++)		//  3 paquets
+	    			{
+	    			a=place_paquet(i,j);
+	    			b= ( blk->sst[k][a/8] >>( (a%8)*4) ) & 0xf;
+				ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"%x",b);
+				}
+			ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"  ");
+			}
+	 	ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\n");
+	 	}
+
+	 ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\n");
+
+	 }
+
+//k=0;
+prem_d=litD(fenetre_sstbrut,sstb_prem_diode,0L);
+for(k=0;k<72;k++)
+	{
+	 for(i=0;i<12;i++)		//  seulement 12 diodes 
+		{
+		int q;
+		q=i+prem_d-1;
+				
+		a=place_paquet(q,0);
+	    	b0= ( blk->sst[k][a/8] >>( (a%8)*4) ) & 0xf;
+		a=place_paquet(q,1);
+	    	b1= ( blk->sst[k][a/8] >>( (a%8)*4) ) & 0xf;
+		a=place_paquet(q,2);
+	    	b2= ( blk->sst[k][a/8] >>( (a%8)*4) ) & 0xf;
+		
+
+		x=(double)( (b0<<8) | (b1<<4) |  b2 ) ;
+		//if(x>2047) x-=4096;
+		x-=2048;
+		y[i]=x;
+		}
+//	printf(" y = %g %g %g %g %g \n",y[0],y[1],y[2],y[3],y[4]);
+	temps_cntl =numero_block(blk)*nb_per_block*2+k;
+	secondes=gg->periode_echantillonage*(double)temps_cntl-gg->temps_origine;
+	tracen(fenetre_sstbrut,12,secondes,y);
+	}
+}
+
+
+		
+//	les 46 valeurs en hexa
+//	i=0;			//  juste le premier point du block
+//	for(i=0;i<72;i++)
+/*
+for(i=0;i<72;i++)
+	{
+
+	 for(j=0;j<12;j++)		//  seulement les 12 premieres diodes 
+		{
+		x=0;
+		for(k=0;k<12;k++)	x=(x<<1)  | bit_sst(i,j,k);
+		y[j]=(double)x;
+		}
+	temps_cntl =numero_block(blk)*nb_per_block*2+i;
+	secondes=gg->periode_echantillonage*(double)temps_cntl-gg->temps_origine;
+	tracen(fenetre_senseur_stellaire,12,secondes,y);
+	}
+			
+*/
+/*	i=1;			//  juste le premier point du block
+//	for(i=0;i<72;i++)
+		{
+		for(k=0;k<12;k++)		//  12 bits
+	    		{
+	    		for(j=0;j<35;j++)		//  46 senseurs 
+				{
+				ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"%d   ",bit_sst(i,j,k));
+				}
+	 		ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\n");
+			}
+	 	ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\n");
+	 	}
+		
+//	les 46 valeurs en hexa
+//	i=0;			//  juste le premier point du block
+//	for(i=0;i<72;i++)
+	for(i=0;i<10;i++)
+		{
+	    	for(j=0;j<35;j++)		//  46 senseurs 
+			{
+			x=0;
+			for(k=0;k<12;k++)	x=(x<<1)  | bit_sst(i,j,k);
+			ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"%3x ",x);
+			}
+	 	ecritT(fenetre_senseur_stellaire_lecture_brute,fin_f,"\n");
+	 	}
+			
+	
+	}
+
+			
+*/	
Index: trunk/Poubelle/archediab.old/archediab.sources/c/stabilite.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/stabilite.c	(revision 649)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/stabilite.c	(revision 649)
@@ -0,0 +1,42 @@
+#include "manip.h" 
+#include "stabilite.h" 
+
+
+
+//nouveauD(0,stabilite_id,"stabilite",exec_stabilite);
+
+
+//--------------------  fonction  exec  de  la  fenetre : stabilite  -------------------------------
+
+
+void exec_stabilite(int fen,int item,double valeur,...) 
+{
+if(item>1000) item-=1000;		// pour appeler le case pour tous les cara d'un edit texte
+
+switch(item)
+    {
+    case ouverture               :
+       				selectgra(fen);
+    graph->ymin=-0.04;
+    graph->ymax=0.04;
+    graph->ypas=0.01;
+    graph->xmin=0.;
+    graph->xmax=360.; 
+    graph->xpas=90.;
+    graph->grille=0;
+    graph->graduations=1;
+    graph->taille_graduations=10;
+    graph->sans_image=0;      	
+    graph->avec_icones=0;      	
+    strcpy(graph->xtitre, "phases");    	
+    strcpy(graph->ytitre, "Timedrift"); 
+    retrace(fen);   	
+
+                 break;
+    case fermeture               :
+                 break;
+    case PHS_stabil :
+                 break;
+    default  :   break;
+    }
+}
Index: trunk/Poubelle/archediab.old/archediab.sources/c/tache_PCI.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/tache_PCI.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/tache_PCI.c	(revision 649)
@@ -64,5 +64,5 @@
 			//			for(i=0;i<1000;i++);
 //			ecrit_carte(tt->tc.btc[tt->tc.pos_lit].mot[j]);
-			if(tt->PCI_actif==1)	ecrit_carte(mot[j]);
+			if(acquisition_PCI)	ecrit_carte(mot[j]);
 			}
 		tt->vi.flag_ecriture_data=0;
Index: trunk/Poubelle/archediab.old/archediab.sources/c/tache_archeops.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/tache_archeops.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/tache_archeops.c	(revision 649)
@@ -10,4 +10,5 @@
 #include "carte_pci.h"
 
+#include "simulmission.h"
 
 //*****************************************************************************************
@@ -87,6 +88,16 @@
 		}
 	}
-
-else	while(1)
+else if (tt->PCI_actif==3)	// simulation donnees mission
+	{
+		// EA + JD
+		// Lecture d'un block depuis le simulateur
+		
+		if (SimulMissionBloc(tt)) {
+		
+		  // Sauvegarde du bloc dans la file d'attente
+		  sauve_un_block(tt);
+		}
+	}
+else	while(1)		//  case 1 et 4  
 	{
 	lit_carte;	if(rien_a_lire)		break;				//  fifo vide  ->  retour  ->  sort du while
@@ -146,5 +157,5 @@
 	}
 if(lec_fifo > tt->nb_lec_fofo_int)  	tt->nb_lec_fofo_int=lec_fifo;
-if(!tt->nb_lec_fofo_ext)  		{tt->nb_lec_fofo_ext=tt->nb_lec_fofo_int;tt->nb_lec_fofo_int=0;}
+if(!tt->val_con_fifo)  		{tt->val_con_fifo=tt->nb_lec_fofo_int;tt->nb_lec_fofo_int=0;}
 
 }
Index: trunk/Poubelle/archediab.old/archediab.sources/c/tache_archeops_bit2.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/tache_archeops_bit2.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/tache_archeops_bit2.c	(revision 649)
@@ -12,4 +12,5 @@
 
 
+#include "simulmission.h"
 
 
@@ -42,5 +43,4 @@
 tt->vi.b=0;
 tt->vi.c=0;
-//init_lit_bit();
 }
 
@@ -48,22 +48,4 @@
 #define	max_fifo  4000
 
-
-//		un bit pour 8 bit en parallele dans la fifo		
-/*
-char	un_bit(void)
-{
-static int i;
-static unsigned long RR;
-i++;
-if( (i<0) ou (i>7) ) 
-	{
-	lit_carte;	if(rien_a_lire)		return(bit_vide);	//  fifo vide  ->  retour  ->  sort du while
-	i=0;
-	}
-if( (RR>>i) & 1 )  	return(bit_un);
-	else		return(bit_zero);
-}
-
-*/
 
 //		un bit pour  fifo avec un seul bit (bit0) et la valeur de la periode en bit 1..6  (37 ou 38)		
@@ -101,11 +83,15 @@
 //tt->nb_lec_fofo_ext=M;
 
-
-	
-//if( RR & 1 )  	return(bit_un);
-//else		return(bit_zero);
-if( RR & 1 )  	return(bit_zero);
+#ifdef signe_inverse
+
+if( RR & 1 )  return(bit_zero);
 else		return(bit_un);
 
+#else
+	
+if( RR & 1 )  	return(bit_un);
+else		return(bit_zero);
+
+#endif
 }
 
@@ -154,6 +140,16 @@
 		}
 	}
-
-else	while(1)
+else if (tt->PCI_actif==3)	// simulation donnees mission
+	{
+		// EA + JD
+		// Lecture d'un block depuis le simulateur
+		
+		if (SimulMissionBloc(tt)) {
+		
+		  // Sauvegarde du bloc dans la file d'attente
+		  sauve_un_block(tt);
+		}
+	}
+else	while(1)		//  case 1 et 4
 	{
 	i=lit_bit(&tt->vi.btt);
@@ -165,5 +161,5 @@
 	}
 if(lec_fifo > tt->nb_lec_fofo_int)  	tt->nb_lec_fofo_int=lec_fifo;
-//if(!tt->nb_lec_fofo_ext)  		{tt->nb_lec_fofo_ext=tt->nb_lec_fofo_int;tt->nb_lec_fofo_int=0;}
+if(!tt->val_con_fifo)  		{tt->val_con_fifo=tt->nb_lec_fofo_int;tt->nb_lec_fofo_int=0;}
 
 }
Index: trunk/Poubelle/archediab.old/archediab.sources/c/tache_diabolo.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/tache_diabolo.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/tache_diabolo.c	(revision 649)
@@ -84,5 +84,5 @@
 int max_fifo;
 
-if(tt->PCI_actif==1)	max_fifo=3000;	//  3000  points maxi par interruption (10ms)  soit (3.3µs)
+if(acquisition_PCI)	max_fifo=3000;	//  3000  points maxi par interruption (10ms)  soit (3.3µs)
 	 else		max_fifo=200;	//  ((1000)faux )  points maxi par interruption (10ms)  soit  (20µs)
 
@@ -90,5 +90,5 @@
 while(1)
 	{
-	if(tt->PCI_actif==1)	{lit_carte;	if(rien_a_lire)	break;}//  fifo vide  ->  retour  ->  sort du while
+	if(acquisition_PCI)	{lit_carte;	if(rien_a_lire)	break;}//  fifo vide  ->  retour  ->  sort du while
 	lec_fifo++;
 	if (EPLD_occupe) tt->vi.flag_ecriture_data=0;
@@ -141,5 +141,5 @@
 		if( RR&FLAG_FIFO_FULL )		{ecrit_erreur(err_fifo_pleine);read_flags();reset_fifo();}	// la fifo a débordée			
 		if(lec_fifo > tt->nb_lec_fofo_int)  tt->nb_lec_fofo_int=lec_fifo;
-		if(!tt->nb_lec_fofo_ext)  	{tt->nb_lec_fofo_ext=tt->nb_lec_fofo_int;tt->nb_lec_fofo_int=0;}
+		if(!tt->val_con_fifo)  	{tt->val_con_fifo=tt->nb_lec_fofo_int;tt->nb_lec_fofo_int=0;}
 		if(lec_fifo>max_fifo) 
 			{
Index: trunk/Poubelle/archediab.old/archediab.sources/c/tache_regul.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/tache_regul.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/tache_regul.c	(revision 649)
@@ -79,5 +79,5 @@
 tt->vi.reg.cc=cc;
 cc=( 0x0fff - cc ) & 0x0fff;		//  12 bits  avec inverser la polarité 
-if( (tt->PCI_actif==1) && ( tt->vi.flag_ecriture_data>2 ) )		//    rien en attente d'ecriture: j'ecris direct en interruption		
+if( (acquisition_PCI) && ( tt->vi.flag_ecriture_data>2 ) )		//    rien en attente d'ecriture: j'ecris direct en interruption		
 	{
 	ecrit_carte(tc_regul );			// ecrit bolo 251  -->  ecrit regulation
Index: trunk/Poubelle/archediab.old/archediab.sources/c/tache_transputer.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/tache_transputer.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/tache_transputer.c	(revision 649)
@@ -70,5 +70,5 @@
 int max_fifo;
 
-if(tt->PCI_actif==1)	max_fifo=4000;	//  3000  points maxi par interruption (10ms)  soit (3.3µs)
+if(acquisition_PCI)	max_fifo=4000;	//  3000  points maxi par interruption (10ms)  soit (3.3µs)
 	 else		max_fifo=200;	//  ((1000)faux )  points maxi par interruption (10ms)  soit  (20µs)
 
@@ -78,5 +78,5 @@
 while(1)
 	{
-	if(tt->PCI_actif==1)	{lit_carte;	if(rien_a_lire)	break;}//  fifo vide  ->  retour  ->  sort du while
+	if(acquisition_PCI)	{lit_carte;	if(rien_a_lire)	break;}//  fifo vide  ->  retour  ->  sort du while
 	lec_fifo++;
 //	tt->vi.bkb[tt->vi.a^3]=octet_a_lire;	// dans l'ordre: 3 2 1 0 7 6 5 4 11 10 9 8 ...
@@ -96,5 +96,5 @@
 	}
 if(lec_fifo > tt->nb_lec_fofo_int)  	tt->nb_lec_fofo_int=lec_fifo;
-if(!tt->nb_lec_fofo_ext)  		{tt->nb_lec_fofo_ext=tt->nb_lec_fofo_int;tt->nb_lec_fofo_int=0;}
+if(!tt->val_con_fifo)  		{tt->val_con_fifo=tt->nb_lec_fofo_int;tt->nb_lec_fofo_int=0;}
 }
 
Index: trunk/Poubelle/archediab.old/archediab.sources/c/telecommande.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/telecommande.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/telecommande.c	(revision 649)
@@ -5,4 +5,6 @@
 #include "acqui.h"
 #include "tm.h"
+#include "simulmission.h"
+#include "controle.h"
 
 
@@ -135,9 +137,11 @@
 {
 unsigned char mot_tc[10];
-mot_tc[0]	=	tc_reduite;
-mot_tc[1]	=	mot1;
-mot_tc[2]	=	mot2;
-mot_tc[3]	=	mot3;
-emission_telecommande(tc_dir_transputer,mot_tc);
+	{
+	mot_tc[0]	=	tc_reduite;
+	mot_tc[1]	=	mot1;
+	mot_tc[2]	=	mot2;
+	mot_tc[3]	=	mot3;
+	emission_telecommande(tc_dir_transputer,mot_tc);
+	}
 }
 
@@ -148,4 +152,7 @@
 int j;
 
+if(!acquisition_avec_telecommande)  return;
+
+
 //*****************************************************************************************
 //											***
@@ -157,5 +164,5 @@
 
 #define	 delai(xx)	{long uu;for(uu=0;uu<(10000L*(long)xx);uu++){};}
-#define  tc_char(x)	{delai(20);if(tt->PCI_actif==1) ecrit_carte((x)&0xff);}  
+#define  tc_char(x)	{delai(40);if(acquisition_PCI) ecrit_carte((x)&0xff);}  
 #define	 tc_int(x)	{tc_char(x);tc_char(x>>8);tc_char(x>>16);tc_char(x>>24);}
 //printf("telecommande: ");
@@ -200,11 +207,65 @@
 			if( ((mot[0]&0xff)!=tc_reduite) && gg->flag_tc_reduite)
 				{
-				printf("attention: une telecommande normale !!\n\n");
+				printf("attention: une telecommande normale non envoyée !!\n\n");
 				son(130);
 				select(printf_ref);
+				break;
 				}
 //			pour test en mode simulation sans le retour des blocks reglage du transputer
-			if(tt->PCI_actif==2)	relit_telecommandes_reduites(tc);
-			else	{
+			if(tt->PCI_actif==2)	
+				{
+				relit_telecommandes_reduites(tc);
+				break;
+				}
+		    else if(tt->PCI_actif==3)
+		        {
+		        simul_telecommandes_reduites(tc);
+		        }
+			else	{char ss[200];
+						static long t;
+			
+#define tcl(iii)	((long)mot[iii])
+			
+					long mothexa[5];	/* les 5 cara hexa envoyée  */
+					/*  on range les bit: bit 1 en poid fort de tout   */
+					mothexa[0]=tcl(1);	/* 4 bit choix de commande   */
+					mothexa[1]=tcl(2)>>2;	/* les 4 bits poid fort du code direction */
+					mothexa[2]=((tcl(2)<<2)&0xc)  + ((tcl(3)>>6)&0x3);
+					mothexa[3]=(tcl(3)>>2)&0xf;  
+			 		mothexa[4]=(tcl(3)&0x3) + 0x0C;
+			      		printf("commande 18bit:   %d %d %d -> %lx%lx%lx%lx%lx ",tcl(1),tcl(2),tcl(3)
+			      			,mothexa[0],mothexa[1],mothexa[2],mothexa[3],mothexa[4]);
+					ecritD(fenetre_controle,con_subscan,"tc: %x %x %x %x %x ",mothexa[0],mothexa[1],mothexa[2],mothexa[3],mothexa[4]);
+
+				tc_char(0x11);	//  synchro
+				tc_int(debut_telecommande);
+				for(j=0;j<4;j++)	tc_char(mot[j]);
+				tc_char(0x00);		//  synchro
+				sprintf(ss,"S%X%X%X%X%X07WS%X%X%X%X%X07WS%X%X%X%X%X07W\r\n"
+						,mothexa[0],mothexa[1],mothexa[2],mothexa[3],mothexa[4]
+						,mothexa[0],mothexa[1],mothexa[2],mothexa[3],mothexa[4]
+						,mothexa[0],mothexa[1],mothexa[2],mothexa[3],mothexa[4]);
+/*				sprintf(ss,"S%x%x%x%x%x07WS%x%x%x%x%x07WS%x%x%x%x%x07W\r\l"
+						,mothexa[0],mothexa[1],mothexa[2],mothexa[3],mothexa[4]
+						,mothexa[0],mothexa[1],mothexa[2],mothexa[3],mothexa[4]
+						,mothexa[0],mothexa[1],mothexa[2],mothexa[3],mothexa[4]);*/
+				if(ss[7]!='7') erreur("adresse not equal to 7");
+				if(ss[16]!='7') erreur("adresse not equal to 7");
+				if(ss[25]!='7') erreur("adresse not equal to 7");
+				while( (TickCount()>t) et (TickCount()<(t+60*15)) ) 	// 15sec 
+					{
+					static int q;
+					q++;
+					son(130);
+					if(q%10==0) printf("attente pour envoi de telecommande\n");
+					controlemanip(0);
+					}
+				son(133);
+
+				printf(" envoi de la telecommande : %s \n",ss);
+				ecritRS(0,ss,0);
+				t=TickCount();	               	//  10 secondes  (tick = 1/60 sec) 
+				}
+/*			else	{
 				tc_char(0x11);	//  synchro
 				tc_int(debut_telecommande);
@@ -213,9 +274,17 @@
 				tc_char(0x00);tc_char(0x00);	//  synchro
 				}
+*/
 			break;
 
 	case	tc_dir_reset_epld	:	//printf("tc_reset_epld:\n");
 		
-//			for(j=0;j<14;j++) tc_char(j);
+			for(j=0;j<8;j++) tc_char(j);
+			tc_char(1);tc_char(1);
+			tc_char(0x00);tc_char(0x00);	//  synchro
+
+			break;
+
+	case	tc_dir_reset_trp	:	//printf("tc_reset_epld:\n");
+		
 			for(j=0;j<15;j++) tc_char(j);	// reset epld+transputer
 			tc_char(1);tc_char(1);
@@ -233,5 +302,5 @@
 
 //  delai pour separer les télécommandes (archeops, transputer ou non)
-if(tt->PCI_actif==1) delai(1000);
+if(acquisition_PCI) delai(1000);
 
 #endif		//--------------------------------------------------------------------	***
Index: trunk/Poubelle/archediab.old/archediab.sources/c/trace-DS.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/trace-DS.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/trace-DS.c	(revision 649)
@@ -142,14 +142,14 @@
 		if(u==npt_DS-1)
 			{
-			for(j=0;j<nb_max_bolo;j++)
-				{
-				phase_mesure[j]=atan2(y1[j],y2[j]);
-				confiance[j]=bb[j]*bb[j];
-				if(confiance[j]) 	confiance[j]=log((y1[j]*y1[j]+y2[j]*y2[j])/(bb[j]*bb[j]));
-				}
-			j=5;	// bolo pur mesurer la phase
-			phase_memoire=0.95*phase_memoire+0.05*phase_mesure[j];
-			ecritD(fenetre_trace_DS,ds_phase,"%d°",degre(phase_memoire));
-			printf(" phase=%d°(%2.1f)  \n",degre(phase_mesure[j]),confiance[j]);
+//			for(j=0;j<nb_max_bolo;j++)
+//				{
+//				phase_mesure[j]=atan2(y1[j],y2[j]);
+//				confiance[j]=bb[j]*bb[j];
+//				if(confiance[j]) 	confiance[j]=log((y1[j]*y1[j]+y2[j]*y2[j])/(bb[j]*bb[j]));
+//				}
+//			j=5;	// bolo pur mesurer la phase
+//			phase_memoire=0.95*phase_memoire+0.05*phase_mesure[j];
+//			ecritD(fenetre_trace_DS,ds_phase,"%d°",degre(phase_memoire));
+//			printf(" phase=%d°(%2.1f)  \n",degre(phase_mesure[j]),confiance[j]);
 //			printf(": phase memoire=%g  \n",phase_memoire);
 //			printf(" trace y1= %g , %g , %g , %g , %g \n",y1[0],y1[1],y1[2],y1[3],y1[4]); 
Index: trunk/Poubelle/archediab.old/archediab.sources/c/trace_tout.c
===================================================================
--- trunk/Poubelle/archediab.old/archediab.sources/c/trace_tout.c	(revision 645)
+++ trunk/Poubelle/archediab.old/archediab.sources/c/trace_tout.c	(revision 649)
@@ -5,6 +5,4 @@
 #include "trace_tout.h"
 #include "synchro.h"
-
-
 
 
@@ -38,7 +36,7 @@
 	    					graph->xpas=50;
     						graph->taille_graduations=8;
-							for(j=0;j<nb_max_bolo;j++)  SS->f1[j]=0;
-							for(j=0;j<nb_max_bolo;j++)  SS->f2[j]=0;
-							for(j=0;j<nb_max_bolo;j++)  SS->y[j]=0;
+							for(j=0;j<nb_max_trace;j++)  SS->f1[j]=0;
+							for(j=0;j<nb_max_trace;j++)  SS->f2[j]=0;
+							for(j=0;j<nb_max_trace;j++)  SS->y[j]=0;
 							
                  			
@@ -52,5 +50,5 @@
                  			SS->fmini=litD(fen,t_fmini,0L);
     						SS->fmaxi=litD(fen,t_fmaxi,0L);
-    						for(j=0;j<nb_max_bolo;j++)  SS->f1[j]=0;
+    						for(j=0;j<nb_max_trace;j++)  SS->f1[j]=0;
 
 							c1=2*3.14*SS->fmini*gg->periode_echantillonage;		c1=c1/(1+c1);	
@@ -76,5 +74,5 @@
     					{
     					SS->bolo_couleur[i]=litD(fen,t_bolo_couleur+i,0L)-1;
-    					if( (SS->bolo_couleur[i]<1) ou (SS->bolo_couleur[i]>nb_max_bolo) )   SS->bolo_couleur[i]=0;
+    					if( (SS->bolo_couleur[i]<1) ou (SS->bolo_couleur[i]>nb_max_trace) )   SS->bolo_couleur[i]=0;
     					printf(" i=%d bolo=%d    ",i,SS->bolo_couleur[i]);
     					}
@@ -95,5 +93,5 @@
 							c2=2*3.14*SS->fmaxi*gg->periode_echantillonage;	if(c2>0)	c2=c2/(1+c2);	
 							
-			    			for(j=0;j<nb_max_bolo;j++)		
+			    			for(j=0;j<nb_max_trace;j++)		
 			    				{
 			    				SS->f1[j]= (1-c1) * SS->f1[j]	+ c1 * xbol(j); 
@@ -105,5 +103,5 @@
 								{
 								SS->ipas=SS->moyenne;
-								if(SS->moyenne) for(j=0;j<nb_max_bolo;j++) SS->y[j]=SS->y[j]/(double)SS->moyenne;
+								if(SS->moyenne) for(j=0;j<nb_max_trace;j++) SS->y[j]=SS->y[j]/(double)SS->moyenne;
 //								printf("trace_tout  un  point \n");
 
@@ -118,5 +116,5 @@
 	}
 
-   								montracen_tout(fen,nb_max_bolo,x,SS);
+   								montracen_tout(fen,nb_max_trace,x,SS);
 
 
@@ -129,5 +127,5 @@
 											}
 
-								for(j=0;j<nb_max_bolo;j++) SS->y[j]=0;
+								for(j=0;j<nb_max_trace;j++) SS->y[j]=0;
 								}
 	    			
@@ -144,5 +142,5 @@
 for(i=0;i<max_couleur;i++)
 	{
-	if( (SS->bolo_couleur[i]>=1) && (SS->bolo_couleur[i]<nb_max_bolo+1) ) 	yy[i]=SS->y[SS->bolo_couleur[i]-1];
+	if( (SS->bolo_couleur[i]>=1) && (SS->bolo_couleur[i]<nb_max_trace+1) ) 	yy[i]=SS->y[SS->bolo_couleur[i]-1];
 		else		yy[i]=0;
 	}
