Discussion :

[Pat42]

Bonjour,
Comme je l'ai dit dans un précédent poste, je suis débutant.

Mon projet est le suivant: Remplacer des fréquencemètres( en logique cablée) 5 digits, 7 segments que j'ai intégré sur des récepteurs de radio
ancien, par une carte arduino nano pilotant ces mêmes afficheurs (multiplexage).
En effet ces fréquencemètres qui fonctionnent parfaitement prennent beaucoup de place, nbr de CI oblige sans parler du cablage vers les afficheurs.

Malheureusement, je fouille, je cherche, et je n' ai trouvé que des débuts de réponse sur les timers et le comptage de fronts montants,
mais rien pour compter ces impulsions pendant un temps bien précis , par exemple avec un autre timer générant une interruption.


Voici le projet: afficher sur un afficheur 5 digits, 7 segments, la fréquence écoutée.

Pour cela,

1° partie
Mise en mémoire des fronts montants comptés pendant 100ms

Ce que je sais faire :

1) Récupérer et mettre en forme la fréquence de l'oscillateur local
2) Diviser cette fréqence par 100
3) Utiliser le timer 1 pour compter les fronts montants et compter (j'ai récupéré ce programme sur un site de vulgarisation).

Ce que je ne sais pas faire:


3) compter cette fréquence pendant exactement 100ms
4) Soustraire la fréquence intermédiare (ici 464) mais elle est très souvent de 455khz
5) mettre le résultat en mémoire pour l'utiliser sur l'affichage multiplexé.

EX: Fréquence écoutée: 216 kh soit: 216000 hz/s (RMC Grandes Ondes)

la fréquence de l' oscillateur local est égal à la fréquence synthonisée + la fréquence intermédiaire
soit: 216000hz + 464000hz = 680000hz = 680 khz
On divise cette fréquence par 100 soit: 6800 hz/s
On compte pendant un dixième de seconde soit: 680hz
On soustrait 464 à cettre fréquence soit: 680 - 464 = 216 qui est la valeur à mettre en mémoire et à afficher en khz

2° partie
Pendant 100ms :affichage du résultat par multipexage
Le traitement du comptage + affichage dure au total dure 200ms
mais la 2° partie est pour plus tard...


Voici le code qui me permet de compter avec le timer1 sur 2 octets … ( j'ai testé et compris ce code, mais il n'est pas de moi).
Et ma première question qui en comporte plusieurs...
Comment compter les fronts montants pendant 100ms précisément puis retrancher 464 et mettre le résultat en mémoire
en attendant la nouvelle mesure ?


Pouvez vous me donner des pistes ?

Code C :

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
/* Programme élémentaire de comptage sans prise en compte des débordements.
   Dans cette version le compteur recycle sans fin de 65535 à zéro. */
 
#define Entree_Compteur 5 // Entrée D5  servira  pour mesurer les fréquences.
 
// Variable du programme.
unsigned long COMPTEUR, Ancienne_Valeur;
 
void setup() {
  Serial.begin(115200); pinMode(Entree_Compteur, INPUT);}
 
void loop() {Serial.println(); Serial.println("FONCTION COMPTEUR.");
  RAZ_COMPT();
  TCCR1A = 0;   // Le Timer 1 est configuré en simple compteur.
  // 111 pour Source externe sur D5 et comptage sur le front montant :
  TCCR1B = (1<<CS12) | (1<<CS11) | (1<<CS10);
  INFINI:
  //========================= Traiter le COMPTEUR ===============================
  // Ci-dessous une première lecture fait passer TCNT1H dans le TAMPON.
  COMPTEUR = TCNT1L;
  // Lecture des 16 bits dans la variable COMPTEUR.
  COMPTEUR = TCNT1;
  // ============================================================================
  if(COMPTEUR != Ancienne_Valeur) {
  Serial.print(" CMPT = "); Serial.println(COMPTEUR); Ancienne_Valeur = COMPTEUR;}
  goto INFINI; }
 
void RAZ_COMPT() {
  COMPTEUR = 0; Ancienne_Valeur = 1; // Pour forcer l'affichage; 
  // Replacer le compteur à zéro pour une nouvelle mesure.
  // Attention en écriture il faut commencer par les poids forts pour charger le TAMPON.
  TCNT1H = 0; TCNT1L = 0;}

[Vincent PETIT]

Salut,
Je pense qu'il y a trop (beaucoup trop) de questions dans ton message Par exemple, je sais ce qu'est un mélangeur et comment il fonctionne (signal reçu (RF), oscillateur local (LO), les fréquences intermédiaire (IF) + la fréquence image etc...) et pour autant je ne comprends pas ce que tu essayes de faire ? Un fréquencemètre ça compte simplement les périodes.


Comment faire un fréquencemètre avec un microcontrôleur ? (Certain micro ont des choses internes qui facilitent la vie mais comme je ne les connais pas tous, je vais rester générique).

1) Régler l'horloge interne de son micro. Idéalement sur un quartz externe (car très précis) si le hardware le prévoit puis configurer tous les diviseurs (ou autres prescaler internes) afin de connaître exactement la fréquence interne du micro.

2) Régler un Timer sur la fréquence interne du micro par exemple, ou sur un multiple de cette fréquence interne en réglant des diviseurs.

A partir de là, tu as un Timer qui va s'incrémenter de 0 à 65535 (2 octets) de manière très très précise puis qui va déborder, en repassant à 0, de manière extrêmement régulière et indéfiniment.

3) Régler son Timer pour qu'il déclenche une interruption à chaque débordement car c'est super important de savoir qu'il a fait un tour complet. On incrémentera une variable.

Maintenant, tu as un compteur autonome et précis qui tourne dans ton micro et il compte aussi le nombre de fois où il déborde. Pour fixer les idées, imaginons un quartz de 20MHz, un micro qui ne divise pas l'horloge interne donc 20MHz aussi et un Timer réglé sur le bus interne sans aucune division non plus, donc qui s'incrémente à 20MHz aussi. Ce Timer va démarrer à 0 puis s'incrémenter de 1 toutes les 50ns et arrivé à 65535 il se sera écoulé précisément 3,27675ms puis on recommence à 0 en ayant, juste avant, déclenché une interruption dans la quelle on incrémentera une variable pour compter les débordement.

Si d'un coup le programme principal prend un photographie du Timer et de cette variable et qu'il lit respectivement 705 et 3 voici ce qu'il faut comprendre ; 705 * 50ns = 35.25µs mais la variable qui compte les débordements est à 3 ce qui implique qu'il s'est déjà passé 3 * 3,27675ms = 9,83025ms. Donc au moment de la photo je sais qu'il s'est passé 9,83025ms + 35.25µs = 9,8655ms depuis le tout premier démarrage du Timer.

4) Régler un Timer en mode capture sur front montant et lui demander de déclencher une interruption pour être sur de ne louper aucun front.

Et c'est pour ainsi dire fini...Voici l'idée.
Au premier front montant, le programme va sauter dans une interruption qui aura pour rôle de prendre une photo du timer (qui tourne tout seul, indépendamment et de manière hyper précise) on dira photo 1. Au second front montant le programme va sauter à nouveau dans l'interruption qui prend une photo du timer, appelons là photo 2. Reste plus qu'a faire photo 2 - photo 1 et on connait quasi exactement le temps entre les deux fronts montant. Ce temps est la période et il suffit de faire 1 / par ce temps pour avoir la fréquence.

Après il peut y avoir plein de variante de fonctionnement. Est il utile de compter les débordements ? Si on connait à peu prés l'ordre de grandeur de la fréquence a mesurer, n'est il pas plus judicieux ici de régler plus finement le Timer pour pouvoir faire quelques chose de bien plus efficace : premier front montant = un RESET timer et second front montant = photo du Timer (on a la période) ainsi de suite. Si le Timer est bien réglé on a plus besoin de soustraction.

[Pat42]

Merci pour la réponse que je vais relire attentivement.

En réalité ce que je veux faire est très simple et basic, en logique cablée.

Mais avec l'arduino Aïe... dur pour moi

Pour simplifier...

Je me sers du timer1 (parcequ'il est autonome) pour compter les fronts montants sur la pin D5 et cela fonctionne apparemment très bien ( ce qui équivaut à compter les périodes) .

Il faudrait simplement compter ces fronts montants pendant un créneaux de 100ms.
Mettre la valeur comptée dans une variable (pour l'utiliser et l'afficher les 100ms suivantes) et remettre le timer1 à 0 si cela est possible.

L'idée effectivement serais de régler un autre timer et de compter les débordement pour avoir 100ms et là, déclencher une interruption... pour faire la suite du boulot: remettre le timer1 à 0, afficher le comptage...

Je vais creuser

[Vincent PETIT]

Je me sers du timer1 (parcequ'il est autonome) pour compter les fronts montants sur la pin D5 et cela fonctionne apparemment très bien ( ce qui équivaut à compter les périodes) .

Il faudrait simplement compter ces fronts montants pendant un créneaux de 100ms.

Je t'invite à te poser la question de l'utilité de compter les fronts montants pour déterminer une période. Moi je n'ai besoin de compter que le temps qui sépare 2 fronts montant et de faire (1 / ce temps) pour connaître la fréquence. Qu'il y ait 4 ou 50 fronts montant, je calculerai toujours le temps qui s'est écoulé entre le front montant et celui d'avant.

remettre le timer1 à 0 si cela est possible.

En effet, on peut aussi envisager de créer un chronomètre avec le timer. Front montant = start Timer, Front montant suivant = stop Timer et on connaît le temps entre 2 fronts (sans les avoir compter )

L'idée effectivement serais de régler un autre timer et de compter les débordement pour avoir 100ms et là, déclencher une interruption... pour faire la suite du boulot: remettre le timer1 à 0, afficher le comptage...

Pourquoi chercher a déclencher une interruption toutes les 100ms ? Mieux vaut déclencher l'interruption sur un front montant pour faire un reset timer ? Puis au front montant suivant, lire la valeur dans le Timer et peut être en prenant soin de savoir si il a débordé ou pas.

[Pat42]

Bonjour,

J'ai lu dans plusieurs tuto cette façon de faire qui est de mesurer un temps entre deux fronts montant.
C'est une façon de faire courante en électronique pour avoir une mesure précise dans les TBF.
Il me paraissait plus simple et plus rapide de compter" bêtement" les fronts montants puis de les mettre en mémoire dans une variable d'autant plus que le timer1 travaille seul… et donc , "ne prend pas du temp au reste du programme".


Cela est sans doute dû à mon manque d'expérience dans le domaine de la micro et mes nbrx années à bosser avec des CI.

Pour en revenir au fréquencemètre:

La période max à mesurée sera de 645 micros seconde
La période min de 3.33 micros seconde


Je vais jeter un oeil sur différent tuto pour tenter d'écrire un bout de code


Bonne soirée