Discussion :

[Pat42]

Rebonjour,
J'ai pu avec l'aide de Jpbbricole faire fonctionner mon fréquencemètre.
Celui-ci affiche l'exacte fréquence, mais en clignotant à la cadence à laquelle je fais ma mesure de fréquence, ici toute les 100ms.


Je n'arrive pas à trouver la solution pour faire fonctionner mon multiplexage dans une boucle tout en ayant pas un arrêt du multiplexage quand je vais chercher mon information.

Plus simplement , comment faire fonctionner mon multiplexage sans l'interrompre tout en récupérant la valeur de la fréquence pour l'introduire dans le multiplexage ?

Merci

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
  int variable;
  int Compteur;
  const int Affich_A = 4;      //  Cinq afficheurs multiplexés par un 4028 //port D Arduino
  const int Affich_B = 6;   
  const int Affich_C = 7;
 
  const int Seg_A = 8;        //  Sept segments commandés par un 4513 // Port B  Arduino
  const int Seg_B = 9;
  const int Seg_C = 10;
  const int Seg_D = 11;
 
         #define Entree_Compteur 5 // Entrée D5 pour mesurer les fréquences.
         unsigned long VALEUR, Ancienne_valeur;  // Fréquence mesurée.
         int Temps_de_mesure, Affine; // temps de mesure
 
 
 
void setup() 
{ 
         Temps_de_mesure = 99; Affine = 800; 
         Ancienne_valeur = 0;
         TCCR1A = 0;   
         TCCR1B = (1<<CS12) | (1<<CS11) | (1<<CS10);
 
   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);
 
}
 
void loop() {
Mesurer_la_frequence();
multiplexage(); 
}
 
void Mesurer_la_frequence(){ 
   TCNT1 = 0x0000; 
   delay(Temps_de_mesure); 
   delayMicroseconds(Affine);
   VALEUR = TCNT1; }
 
 
void multiplexage(){
 
    byte varUnit = VALEUR % 10; //on transfert la "variable" dans une autre variable " byte varUnit" par ex.pour travailler toujours avec la variable non modifiée et l'écrire en binaire.
PORTD &= B00000000;  //  reset afficheur dizaine de millier   equivaut  à l' allumage afficheur unité
PORTB =  varUnit;  //  affichage unité
delay(4);
PORTB &= B00000000;   //reset affichage
 
 
 byte varDizaine = VALEUR /10 %10;// pas besoin de resetter l'afficheur unité car deja a 0
PORTD |= B00010000;   //  allumage afficheur dizaine
PORTB = varDizaine;  //  affichage dizaine
delay(4);
PORTB &= B00000000;      //reset affichage
 
 
 byte varCentaine = VALEUR /100 %10;
PORTD &= B00000000;   // reset afficheur dizaine
PORTD |= B01000000;   // allumage afficheur centaine
PORTB = varCentaine;  // affichage centaine
delay(4);
PORTB &= B00000000;   // reset affichage
 
 
 byte varMillier = VALEUR /1000 %10;
PORTD &= B00000000;   // reset afficheur centaine
PORTD |= B01010000;   // allumage afficheur millier
PORTB = varMillier; //  affichage millier
delay(4);
PORTB &= B00000000;   // reset affichage
 
 byte varDizaine_Millier = VALEUR /10000;
PORTD &= B00000000;   //  reset afficheur centaine
PORTD |= B10000000;   // allumage afficheur dizaine de millier
PORTB = varDizaine_Millier;  //affichage dizaine de millier
delay(4);
PORTB &= B00000000;   // reset affichage
}

[jpbbricole]

Bonjour Pat42

Un petit calcul, 5x delay(4); + Temps_de_mesure = 99; + Affine = 800; = ~ 120 Millisecondes = 8,33 Herz. La persistance rétinienne qui permet de "mémoriser" l'affichage est de ~25 Hz.

On est assez loin du compte d'où le clignotement.
Je doute, qu'avec ce programme et ce hardware tu puisses corriger le défaut, il faudrait introduire des composants supplémentaires comme des registres à décalages ou autres.

Au delà du problème technique, c'est bien, une fois, d'essayer le multiplexage d'un affichage ne serait-ce que pour en comprendre les mécanismes. Mais, après, il y a tellement d'affichages "tout prêts" et pas chères, qui otent tout ces problèmes et permettent de se consacrer à la tâche principale, dans ton cas le fréquencemètre.

Affichage 7 segments (chaînables)

Arduino


Affichage LCD avec bus i2C

Arduino

Cordialement
jpbbricole

[Pat42]

Oui, il y a des afficheurs tout prêt qui me faciliterait le travail, mais cela ne m'intéresse pas. J' utilise des mini afficheurs sept segments vintage qui ont leur place dans certain de mes récepteurs radios eux aussi très vintage.
Pour le reste mon pb ne vient pas du multiplexage en lui même qui fonctionne impeccablement ( il suffit que je supprime l'appelle à la fonction multiplexage dans la fonction loop pour que de beaux zéro s' affichent s'en sintillement.
Mon pb vient du fait que je dois aller chercher une information dans la fonction loop ( valeur de la frequence) et que pendant ce temps là, mon multiplexage s'arrête de fonctionner.
En fait j'ai mon multiplexage qui fonctionne cadencé par des arrêts dû au temps que prend mon bout de code pour aller chercher la valeur de la fréquence.
Je vais essayer une autre méthode en utilisant une interruption généré par le timer 2 toutes les 100ms.

De ce fait il me semble que je m affranchirais des "delay" et que je pourrais rendre autonome le comptage de la fréquence.
J'aurais sans aucun doute besoin d'aide pour mettre au point mon petit fréquencemètre.
Cordialement
Pat42

[jpbbricole]

Bonjour Pat42

J' utilise des mini afficheurs sept segments vintage qui ont leur place dans certain de mes récepteurs radios eux aussi très vintage.

Voilà qui est plus claire, je comprends mieux, joli projet.

Je pense qu'il est préférable de travailler le problème du côté de l'affichage, qui est très gourmand en temps. Une solution à base de MAX7221 est assez adaptée à ton problème.

Cordialement
jpbbricole

[Pat42]

Effectivement, avec ce genre de CI, je n'aurais même plus besoin de l'Arduino. Quelques CI suffiraient au bon fonctionnement d'un simple fréquencemètre.
Dans mon projet, cela n'est pas aussi simple, car je dois soustraire différentes valeurs (FI) dépendant directement des récepteurs et de plus, je voudrais une commutation automatique et l'affichage et du point quand je passe sur des fréquences dépassant une certaine limite.
c'est pour cela que je vais continuer mon petit projet avec du code.

Merci beaucoup pout ton aide et de mon côté je vais éplucher internet.


Très bonne journée


Pat42

[Vincent PETIT]

Salut,
On pourrait voir ton schéma ? Tu ne peux pas mettre des Latch derrière ton CD4028 ?

Dans le code je ne comprends pas bien où tu fais une mesure de fréquence, à moins que tu ne sois entrain de mettre au point ?

[Pat42]

Bonjour Vincent,

SI si, il ya bien tout et l'affichage de la fréquence sur mes afficheurs est exact comme je l'ai écrit dans le post précédent.

1) Appel de la routine Mesurer_la_frequence();

Code :

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

1
2
3
void loop() {
Mesurer_la_frequence();
multiplexage();

2) mesure de la fréquence

Code :

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

1
2
3
4
5
void Mesurer_la_frequence(){ 
   TCNT1 = 0x0000; 
   delay(Temps_de_mesure); 
   delayMicroseconds(Affine);
   VALEUR = TCNT1; }

3) appel de la routine multiplexage();

Code :

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

1
2
3
void loop() {
Mesurer_la_frequence();
multiplexage();

Un latch ne servira à rien dans mon cas, je n'ai pas un pb de mise en tampon de mes données mais un pb de multiplexage.
J' ai bien compris mon pb qui est le suivant , j'utilise la fonction "delay" qui est une fonction bloquante.
La séquence est la suivante:

on allume l'afficheur unit puis on attends 4ms
on allume l'afficheur dizaine puis on attends 4 ms ect…
Arriver au dernier afficheur on attends 4ms puis on appelle la routine de mesure qui dure 100ms et à ce moment, les afficheurs ne sont plus alimentés.

Ce qui donne "afficheurs alimentés pendant environ 20ms puis arrêt pendant 100ms et on recommence".

Je suis en tarin d'écrire( avec ce que j'ai appris ) un bout de code faisant intervenir les intérupt.
Ce morceau de code fonctionne super bien pour le mutiplexage, mais j'ai un pb d'exactitude à l'affichage.


Cordialement
Pat42