Changeset 649 in Sophya for trunk/Poubelle/archediab.old/archediab.sources/c

Timestamp:

Nov 25, 1999, 2:56:34 PM (26 years ago)

Author:

ansari

Message:

archediab 28 vol

Location:

trunk/Poubelle/archediab.old/archediab.sources/c

Files:

• FindPeri.c (added)
• aa_hadec.c (added)
• acqui_util.c (modified) (1 diff)
• acquisition_archeops.c (modified) (9 diffs)
• acquisition_general.c (modified) (6 diffs)
• bit_block.c (modified) (3 diffs)
• bolo.c (modified) (3 diffs)
• corel.c (modified) (2 diffs)
• diabolo.c (modified) (7 diffs)
• dilution.c (modified) (9 diffs)
• gyroscope.c (modified) (1 diff)
• menu.c (modified) (4 diffs)
• mesures_bolo.c (modified) (3 diffs)
• phaseSST.c (added)
• rafraichis_fenetre.c (modified) (2 diffs)
• recons_sst.c (added)
• senseur_stellaire.c (modified) (2 diffs)
• sstbrut.c (added)
• stabilite.c (added)
• tache_PCI.c (modified) (1 diff)
• tache_archeops.c (modified) (3 diffs)
• tache_archeops_bit2.c (modified) (6 diffs)
• tache_diabolo.c (modified) (3 diffs)
• tache_regul.c (modified) (1 diff)
• tache_transputer.c (modified) (3 diffs)
• telecommande.c (modified) (7 diffs)
• trace-DS.c (modified) (1 diff)
• trace_tout.c (modified) (9 diffs)

trunk/Poubelle/archediab.old/archediab.sources/c/acqui_util.c

@@ -189 +189 @@
 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);
 }
 

trunk/Poubelle/archediab.old/archediab.sources/c/acquisition_archeops.c

@@ -42 +42 @@
                                         // 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 +51 @@
 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 +99 @@
         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 +109 @@
         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 +138 @@
 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 +149 @@
         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 +218 @@
                 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 +391 @@
                 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 +405 @@
                 }
         
+        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);        

trunk/Poubelle/archediab.old/archediab.sources/c/acquisition_general.c

@@ -14 +14 @@
 #include "compress.h"
 #include "controle.h"
+#include "simulmission.h"
 
 
@@ -41 +42 @@
 static int count_moy_err=0;
 int err;
+static bilan_err=0;             
 
 if      (item!=tache_de_fond)           return;
@@ -56 +58 @@
 */
 
-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 +125 @@
         {
         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 +177 @@
                                 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 +208 @@
         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) 

trunk/Poubelle/archediab.old/archediab.sources/c/bit_block.c

@@ -18 +18 @@
  
 
-#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 +137 @@
                                                         //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 +169 @@
                                 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)

trunk/Poubelle/archediab.old/archediab.sources/c/bolo.c

@@ -22 +22 @@
 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 +76 @@
 
                                 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 +129 @@
         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;

trunk/Poubelle/archediab.old/archediab.sources/c/corel.c

@@ -2 +2 @@
 #include "corel.h" 
 
-
+/*
 double coef_corel[nb_max_bolo][nb_max_bolo];
 int flag_corel[nb_max_bolo];
-
+*/
 
 
@@ -30 +30 @@
         {
         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);
         }
         

trunk/Poubelle/archediab.old/archediab.sources/c/diabolo.c

@@ -19 +19 @@
 #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 +47 @@
 //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 +75 @@
 
 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 +96 @@
 #endif
 
+initRS(port_A,baud1200+data8+stop10+noParity,0);        
 
 #ifdef lire_les_donnees_POM2
@@ -117 +129 @@
 
 
-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 +137 @@
 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 +170 @@
 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;
+    }   
 }
 

trunk/Poubelle/archediab.old/archediab.sources/c/dilution.c

@@ -55 +55 @@
 // 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 +82 @@
 emission_telecommande(tc_dir_transputer,mot_tc);
 }
-
+*/
 //   fonction ecrit un  des dac dilution
 //  c'est une telecommande normale 64 bit  a supprimer
@@ -120 +120 @@
 
 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 +138 @@
     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 +147 @@
 //  ----   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 +165 @@
                 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 +242 @@
  // 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 +252 @@
         }
 
+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 +317 @@
 
 
-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));
 
 

trunk/Poubelle/archediab.old/archediab.sources/c/gyroscope.c

@@ -24 +24 @@
 
 
-
-
-
-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);
-        }
-}
-
-

trunk/Poubelle/archediab.old/archediab.sources/c/menu.c

@@ -18 +18 @@
 #include "dilution.h"
 #include "senseur_stellaire.h"
+#include "sstbrut.h"
+#include "FindPeri.h" 
+#include "phaseSST.h"
 #include "gyroscope.h"
 
@@ -24 +27 @@
 
 int j,ann;
+
+
 
 void exec_menu_diabolo(int fen,int item,double valeur,...)
@@ -70 +75 @@
                                                                 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 +102 @@
 */
 
-
-
-
-
-
-
-        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;
         }

trunk/Poubelle/archediab.old/archediab.sources/c/mesures_bolo.c

@@ -70 +70 @@
 //                                                                                                      //
 //      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 +80 @@
 //              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 +94 @@
 
 
-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);
 
 

trunk/Poubelle/archediab.old/archediab.sources/c/rafraichis_fenetre.c

@@ -22 +22 @@
         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 +70 @@
                 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);
                 }
 

trunk/Poubelle/archediab.old/archediab.sources/c/senseur_stellaire.c

@@ -1 +1 @@
 #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 +354 @@
 #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.

trunk/Poubelle/archediab.old/archediab.sources/c/tache_PCI.c

@@ -64 +64 @@
                         //                      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;

trunk/Poubelle/archediab.old/archediab.sources/c/tache_archeops.c

@@ -10 +10 @@
 #include "carte_pci.h"
 
+#include "simulmission.h"
 
 //*****************************************************************************************
@@ -87 +88 @@
                 }
         }
-
-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 +157 @@
         }
 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;}
 
 }

trunk/Poubelle/archediab.old/archediab.sources/c/tache_archeops_bit2.c

@@ -12 +12 @@
 
 
+#include "simulmission.h"
 
 
@@ -42 +43 @@
 tt->vi.b=0;
 tt->vi.c=0;
-//init_lit_bit();
 }
 
@@ -48 +48 @@
 #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 +83 @@
 //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 +140 @@
                 }
         }
-
-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 +161 @@
         }
 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;}
 
 }

trunk/Poubelle/archediab.old/archediab.sources/c/tache_diabolo.c

@@ -84 +84 @@
 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 +90 @@
 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 +141 @@
                 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) 
                         {

trunk/Poubelle/archediab.old/archediab.sources/c/tache_regul.c

@@ -79 +79 @@
 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

trunk/Poubelle/archediab.old/archediab.sources/c/tache_transputer.c

@@ -70 +70 @@
 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 +78 @@
 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 +96 @@
         }
 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;}
 }
 

trunk/Poubelle/archediab.old/archediab.sources/c/telecommande.c

@@ -5 +5 @@
 #include "acqui.h"
 #include "tm.h"
+#include "simulmission.h"
+#include "controle.h"
 
 
@@ -135 +137 @@
 {
 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 +152 @@
 int j;
 
+if(!acquisition_avec_telecommande)  return;
+
+
 //*****************************************************************************************
 //                                                                                      ***
@@ -157 +164 @@
 
 #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 +207 @@
                         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 +274 @@
                                 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 +302 @@
 
 //  delai pour separer les télécommandes (archeops, transputer ou non)
-if(tt->PCI_actif==1) delai(1000);
+if(acquisition_PCI) delai(1000);
 
 #endif          //--------------------------------------------------------------------  ***

trunk/Poubelle/archediab.old/archediab.sources/c/trace-DS.c

@@ -142 +142 @@
                 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]); 

trunk/Poubelle/archediab.old/archediab.sources/c/trace_tout.c

@@ -5 +5 @@
 #include "trace_tout.h"
 #include "synchro.h"
-
-
 
 
@@ -38 +36 @@
                                                 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 +50 @@
                                         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 +74 @@
                                         {
                                         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 +93 @@
                                                         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 +103 @@
                                                                 {
                                                                 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 +116 @@
         }
 
-                                                                montracen_tout(fen,nb_max_bolo,x,SS);
+                                                                montracen_tout(fen,nb_max_trace,x,SS);
 
 
@@ -129 +127 @@
                                                                                         }
 
-                                                                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 +142 @@
 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;
         }