Discussion :

[Pat42]

Bonjour,

J'ai récupéré sur un site,un morceau de code que j'ai modifié pour mon fréquencemètre et qui fonctionne...
Pourriez vous m'expliquer et me décortiquer des lignes de code que je ne comprends pas.

Je sais que ce code n'est pas optimisé , mais je suis en train d'apprendre...


Voici les lignes que je ne comprends pas :

1) deltaT = 1.0*ninter*1024*256/F_CPU; Que veut dire 1.0
2) count = ((uint32_t)count_high)<<16 | count_low; Pourriez vous me l'expliquer
3) TCCR2A |= (1 << WGM21); // CTC mode 'clear timer on compare), top = OCR2A; Je ne comprends pas la barre verticale avant le signe égal

Voici le code complet:

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
int inputPin = 5; // entrée T1 pour Timer1
 
volatile uint32_t count_high,count_low;
volatile uint32_t count;
volatile uint16_t ni; // compteur d'interruptions
uint16_t ninter = 60; // nombre d'interruptions pour un comptage 
float deltaT;
 
 void setup() {
  Serial.begin(115200);
  pinMode(inputPin,INPUT);
  deltaT = 1.0*ninter*1024*256/F_CPU;
  cli();               
 
         //déclenche le Timer1 (pour le comptage en mode capture) et le Timer2 pour les interruptions.
 
       // Timer 2 : génération d'interruptions périodiques
  TCCR2A |= (1 << WGM21); // CTC mode 'clear timer on compare), top = OCR2A
  OCR2A = 0xFF; // fréquence d'interruption 16 MHz /1024/256
  TIMSK2 = 1 << TOIE2; // overflow interrupt enable
  TCNT2 = 0;
  ni = 0;
 
  // Timer 1 : compteur d'impulsions
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1 = 0;
  TIMSK1 = 1<<TOIE1; // overflow interrupt enable
  count = 0;
 
 
  TCCR2B |= (0 << CS12) | (1 << CS11) | (1 << CS10); // prescaler = 8
  TCCR1B |= (1 << CS12) | (1 << CS11) | (1 << CS10); // external clock on rising edge
  sei(); // activation des interruptions
}
 
 
//Voici la fonction appelée lors de l'interruption déclenchée par le débordement du Timer 2. 
//Lorsque le nombre d'interruptions atteint ninter, on enregistre le nombre d'impulsions comptées dans count puis on remet le compteur d'impulsions à zéro.
 
ISR(TIMER2_OVF_vect)
{  
       // Overflow interrupt
   ni++;
   if (ni==6) 
   {
     ni = 0;
     count_low = TCNT1;
     TCNT1 = 0;
     count = ((uint32_t)count_high)<<16 | count_low;
    count_high = 0;
   }
}
 
 
   ISR(TIMER1_OVF_vect) 
  {
    count_high++;
 
  }
 
 
//La fonction loop affiche, toutes les 100 ms. La fréquence divisé par 10
 
void loop() {
  delay(100);
  uint32_t freq = count/deltaT;
 
  Serial.print("Frequence (Hz) = ");
  Serial.println(freq);

[Delias]

Bonsoir Pat

1) deltaT = 1.0*ninter*1024*256/F_CPU; Que veut dire 1.0
1.0 impose l'utilisation du format de nombre à virgule. Sans lui le calcul serait effectué en nombre entier, donc avec une erreur au niveau de la division.

2) count = ((uint32_t)count_high)<<16 | count_low; Pourriez vous me l'expliquer
count est un nombre sur 32 bits, mais initialement stocké dans deux nombres de 16 bits. La partie haute est décalée (<<) des 16 bits puis la partie basse est ajoutée par un "ou" logique pour former le nombre de 32 bits.

3) TCCR2A |= (1 << WGM21); // CTC mode 'clear timer on compare), top = OCR2A; Je ne comprends pas la barre verticale avant le signe égal
C'est équivalent à TCCR2A = TCCR2A | (1 << WGM21); le bit WGM21 de TCCR2A est mis à 1 par le "ou" logique sans que les autres bits ne soient changés. Technique du masquage de bits, voir les tutos du forum.

Bonne suite

Delias

[Pat42]

Bonsoir Delias,

Merci pour les explications

Bonne soirée

Pat42

[Pat42]

Re-bonsoir Delias,

Serait il possible d'avoir une explication concernant ces deux lignes de codes.

1) deltaT = 1.0*ninter*1024*256/F_CPU; le calcul donne 0.98304 puisque ninter = 60.

2) uint32_t freq = count/deltaT;.

Pourquoi cette complication ? Est-ce pour compenser le temps entre deux interruptions qui n'est pas une valeur entière et aussi pour avoir une valeur exacte malgré les différences de fréquence d'un micro à un autre ?



Bonne nuit

Pat42

[Delias]

Bonsoir Pat

Comme c'est des nombres constants c'est le compilateur qui va calculer deltaT ou plus exactement 1/deltaT puis la seule ligne de code qui sera effectuée par le micro c'est freq = count*(le nombre constant 1/deltaT), car la multiplication est bien moins couteuses en temps que la division.

Donc vu que le compilateur fait tout le travail, c'est inutile de vouloir faire le calcul soit même. Ensuite le calcul est facile à comprendre, on calcul la durée des 60 interruptions durant les quelles les impulsions sont comptées, puis le nombre d'impulsions divisé par cette durée donne la fréquence du signal.

Il est d'usage de définir la F_CPU au moyen d'un #define et d'écrire le code en paramétrique avec, car ensuite c'est plus rapide d'adapter le programme en fonction de la fréquence du micro, chose qui est très courante...

Et oui faire la mesure sur 60 interruptions permet d'augmenter la précision de la mesure. Le nombre d'impulsion est compter en chiffre entier.

Bonne suite

Delias

[Pat42]

Merci pour toutes vos explications qui me permettent d'avancer.

Bonne journée

Pat42