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
}