Discussion :

[Pat42]

Bonjour, pour ceux qui se sont intéressé à mon projet de fréquencemètre… , je mets quelques photos de ma réalisation (qui n'est pas encore tout a fait fini).

Ici un récepteur Séléna qui date de B212 non modifié :




Ici un autre récepteur Selena B212 auquel j'avais inséré un fréquencemètre à la place du vu-mètre dans les années 80.





Ici, la grosse logique cablé , dans les années 80, la plus part des montages, même complexe,fonctionnaient avec une myriade de circuits logiques



Et voici la "presque finalité" de mon projet.

Ma carte afficheur pour les essais, qui sera remplacée bien entendu par une petite carte que
je ploguerai sur une carte Arduino Uno
Les résistances de limitations seront remplacées par une source de tension
Il me rest à gérer le changement de gamme (AM FM), le point, et éventuellement l'affichage des zéros.




Et voici le code qui peut être sans aucun doute optimisé ( débutant , je ne connais pas encore toute les ficelles du code Arduino).
Nul doute que je vais avoir quelques pbs pour finaliser mon projet et qu'il me faudra votre aide.

Cdt

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#define Entree_Compteur 5 // Entrée D5 pour mesurer les fréquences
  volatile uint16_t comptage_haut,comptage_bas;
  volatile uint32_t  comptage;   
 
  float precision = 1.00445 ;   // coef présision à régler à 17mhz
  int k = 4640;                // soustraction de la FI à régler à 150 khz
  int nbrInterupt=0;          // compteur d'interruptions  
 
  const int Affich_A = 4;     
  const int Affich_B = 6;    //  Cinq afficheurs multiplexés par un 4028 //port D Arduino
  const int Affich_C = 7;
 
  const int Seg_A = 8;       
  const int Seg_B = 9;      //  Sept segments commandés par un 4513 // Port B  Arduino
  const int Seg_C = 10;
  const int Seg_D = 11;
 
 
 
 void setup(){ cli(); //interdit les interruptions
        //Serial.begin(115200);           
      // Initialise le Timer 2 pour déclencher les interruptions à intervalle régulier,            
                  TCCR2A = 0;           //on peut aussi écrire bitClear (TCCR2A, WGM21); // WGM21 = 0 -----//bitClear (TCCR2A, WGM20); // WGM20 = 0
 
                  TCCR2B = 0b00000110; // clk/256 est incrémenté toutes les 16uS  
                  TIMSK2 = 0b00000001; // TOIE2 Autorise l'interruption quand le compteur déborde
 
      // initialise le Timer 1 en simple compteur avec entrée D5 et déclenchement sur fronts montants         
         TIMSK1 = 1<<TOIE1; // autorise les intérrupt. quand le CTNT1 déborde à 65536 
         TCCR1A = 0b00000000;   
         TCCR1B = (1<<CS12) | (1<<CS11) | (1<<CS10);  //front montant, entrée D5.
 
   pinMode (Affich_A,OUTPUT); 
   pinMode (Affich_B,OUTPUT);
   pinMode (Affich_C,OUTPUT);
 
   pinMode (Seg_A,OUTPUT);        
   pinMode (Seg_B,OUTPUT); 
   pinMode (Seg_C,OUTPUT); 
   pinMode (Seg_D,OUTPUT);
 
   digitalWrite(Affich_A,0); 
   digitalWrite(Affich_B,0); 
   digitalWrite(Affich_C,0); 
 
   digitalWrite(Seg_A,0);
   digitalWrite(Seg_B,0);
   digitalWrite(Seg_C,0);  
   digitalWrite(Seg_D,0);
 
   sei();}  //autorise les interruptions
 
void loop() { multiplexage();
}
 
  ISR(TIMER2_OVF_vect) {              
 
 
 
                         TCNT2 = 6;                                                                   
                     if (nbrInterupt++ == 250){nbrInterupt = 0; comptage_bas = TCNT1; TCNT1 = 0;  
                                                   comptage= ((uint32_t)comptage_haut)<<16 | comptage_bas;
                                                comptage = (comptage/precision)- k ;       //précision  et soustraction FI    
                                               comptage_haut = 0;} //Serial.println( comptage/10 );
 
                       }  
 
ISR(TIMER1_OVF_vect) {
                     comptage_haut++;
                     }
 
 
    void multiplexage(){               //l 'affichage àn été décalé de un digit pour avoir un affichage stable; l'afficheur des dizaines devient l'afficheur des unités,
                                       //l'afficheur des centaines devient l'afficheur des dizaines etc...
 
   byte varUnit = comptage /10 %10;  //comptage % 10; //on transfert la "variable" dans une autre variable " byte varUnit" pour pouvoir utiliser   la variable comptage non modifiée
PORTD &= B00000000;  //  reset afficheur dizaine de millier   equivaut  à l' allumage afficheur unité
PORTB =  varUnit;  //   affichage unité
delay(5);
PORTB &= B00000000;   //reset affichage
 
 
 byte varDizaine = comptage /100 %10; //comptage /10 %10;// pas besoin de resetter l'afficheur unité car deja a 0
PORTD |= B00010000;   //  mise soustension afficheur dizaine  
PORTB = varDizaine;  //  affichage dizaine
delay(5);
PORTB &= B00000000;      //reset affichage
 
 
 byte varCentaine = comptage /1000 %10; //comptage /100 %10;
PORTD &= B00000000;   // reset afficheur dizaine
PORTD |= B01000000;   // mise sous tension afficheur centaine
PORTB = varCentaine;  // affichage centaine
delay(5);
PORTB &= B00000000;   // reset affichage
 
 
 byte varMillier = comptage /10000%10;  //comptage /1000 %10;
PORTD &= B00000000;   // reset afficheur centaine
PORTD |= B01010000;   // mise sous tension afficheur millier
PORTB = varMillier;   // affichage millier
delay(5);
PORTB &= B00000000;   // reset affichage
 
 byte varDizaine_Millier = comptage /100000;  // 10000;
PORTD &= B00000000;   //  reset afficheur centaine
PORTD |= B10000000;   // mise sous tension afficheur dizaine de millier
PORTB = varDizaine_Millier;  //affichage dizaine de millier
delay(5);
PORTB &= B00000000;   // reset affichage
}