29 917
modifications
Modifications
Sauter à la navigation
Sauter à la recherche
Ligne 1 :
Ligne 1 : + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + − {{MicroPython-Hack-Souris-TRAILER}}
→Timers sur la PyBoard
{{MicroPython-Hack-Prepare-NAV}}
{{MicroPython-Hack-Prepare-NAV}}
== Qu'est-ce qu'un Timer? ==
{{bloc-etroit|text=Un timer est un élément matériel (généralement présent dans les microcontrôleurs) dont la fonction principale est de mesurer des durées.
Il ne faut pas voir un "timer" comme un chronomètre qui mesure le temps entre deux TOPs (à votre initiative)... mais plutôt une horloge très précises qui envoi des "TOP"s à intervalle régulier à ''un morceau'' de votre programme. Cela permet donc d'exécuter du code à intervalle régulier.
Dans les environnements microcontrôleurs, les Timers sont utilisés pour synchroniser des opérations. Par exemple, l'émission d'un signal de télécommande InfraRouge doit se faire par des trains d'impulsions très précis dans le temps... on emploi donc un Timer pour synchroniser l'émission du train d'onde.
Curieux? voyez également le [http://iut-tice.ujf-grenoble.fr/tice-espaces/GEII/EP-od/wupload/File/II2_Cours/Chapitre_3_-_Timers.pdf document "Timers" (pdf)] de l'Université Joseph Fourier de Grenoble. Il introduit la notion de Timer, diviseur et fréquence du timer. Lecture très instructive.
}}
== Timers sur la PyBoard ==
{{bloc-etroit|text=La carte PyBoard dispose de 14 timers. Chaque timer dispose d'un compteur indépendant fonctionnant à la fréquence définie par l'utilisateur. Ces timers peuvent être configuré pour exécuter une fonction à intervalle spécifique.
Les 14 timers sont numérotés de 1 à 14 mais <font color="red">'''le n° 3 est réservé pour usage interne et 5 & 6 utilisés pour les Servo moteurs et contrôle ADC/DAC.'''</font>. Eviter d'utiliser ces timers si cela est possible.
}}
== Utiliser un Timer ==
Commecons par créer un objet timer:
<nowiki>>>> tim = pyb.Timer(4)</nowiki>
Voyons maintenant l'objet que nous venons juste de créer:
<nowiki>>>> tim
Timer(4)</nowiki>
La carte PyBoard nous informe que {{fname|tim}} est attaché au ''timer'' numéro 4 mais il n'est pas encore initialisé. Donc, initialisons le pour un déclenchement (''to trigger'' en anglais) à 10 Hz (soit 10 fois par seconde):
<nowiki>>>> tim.init(freq=10)</nowiki>
Analysons maintenant ce que nous pouvons vois dans les informations du ''timer'':
<nowiki>>>> tim
Timer(4, prescaler=624, period=13439, mode=UP, div=1)</nowiki>
Ces informations signifie que le ''timer'' est configuré pour fonctionner avec l'horloge matérielle divisé par 624+1, et qu'il comptera de 0 à 13439... point auquel il déclenche une interruption puis il recommence à compter depuis 0. Ces nombres sont utilisé pour déclencher le ''timer'' à 10 Hz.
La fréquence source du ''timer'' est de 84MHz (résultat de la commande {{fname|tim.source_freq()}}) par conséquent nous obtenons 84.000.000 Hz / 625 / 13440 = 10 Hz.
== Compteur du Timer ==
Que pouvons nous faire avec notre ''timer''?
La chose la plus élémentaire à faire est d'obtenir la valeur actuelle de son compteur:
<nowiki>>>> tim.counter()
21504</nowiki>
La valeur du compteur change continuellement, il compte sans arrêt.
== Le callback du Timer ==
La prochaine chose à faire est d'enregistrer une fonction de rappel (dite ''callback'' <small>([[Glossaire#C|Glossaire lettre C]])</small>) de sorte que le ''timer'' l'exécute à chaque déclenchement (voyez notre tutoriel sur [[MicroPython-Hack-button|sur les boutons]] pour un introduction sur les fonction ''callback'' (de rappel):
<nowiki>>>> tim.callback(lambda t:pyb.LED(1).toggle())</nowiki>
Cela devrait immédiatement faire clignoter la LED (la rouge). Elle va clignoter à 5 Hz. En effet, il faut deux appels de ''toggle()'' pour 1 clignotement de la LED, donc la LED clignote deux fois moins vite que les appels de fonction ''callback''. Un changement d'état (''toggle'') à 10 Hz signifie un clignotement à 5 Hz.
Vous pouvez modifier la fréquence en ré-initialisant le ''timer'':
<nowiki>>>> tim.init(freq=20)</nowiki>
Vous pouvez désactiver le ''callback'' (fonction de rappel) en passant la valeur {{fname|None}}:
<nowiki>>>> tim.callback(None)</nowiki>
La fonction que vous passez à {{fname|callback()}} doit prendre un argumen qui est l'objet ''timer'' qui déclenche (''to trigger'') l'appel de la fonction ''callback''.
Cela vous permet de contrôler le ''timer'' directement depuis la fonction de ''callback'' (par exemple: suspendre le ''timer'' pendant l'exécution du ''callback'').
Nous pouvons créer 2 ''timers'' et les exécuter de façon indépendante:
<nowiki>>>> tim4 = pyb.Timer(4, freq=10)
>>> tim7 = pyb.Timer(7, freq=20)
>>> tim4.callback(lambda t: pyb.LED(1).toggle())
>>> tim7.callback(lambda t: pyb.LED(2).toggle())</nowiki>
Etant donné que les callback sont des interruptions matérielles, nous pouvons continuer à utiliser notre PuBoard pour d'autres tâches pendant que les ''timers'' sont en cours d'exécution.
== Créer un compteur de microsecondes ==
Vous pouvez utiliser un ''timer'' pour créer un compteur de microsecondes, ce qui peut s'avérer très pratique lorsque vous réalisez quelque-chose qui nécessite un chronométrage préçis. Nous allons utiliser le ''timer'' 2 pour cela étant donné qu'il dispose d'un compteur 32-bit (comme c'est aussi le cas pour le ''timer'' 5, mais si vous utilisez le ''timer'' 5 alors vous ne pourrez pas piloter de Servo moteur en même temps).
Nous assignons le ''timer'' 2 comme suit:
<nowiki>>>> micros = pyb.Timer(2, prescaler=83, period=0x3fffffff)</nowiki>
Le ''prescaler'' (le diviseur d'horloge) est configuré sur 83, ce qui signifie donc que le ''timer' compte à 1 MHz. Comme l'horloge CPU, fonctionnant à 168 MHz, est divisé par 2 (pour faire les 84 Mhz, de {{fname|source_freq()}}) puis divisé par ''prescaler+1'', cela donne une fréquence de 168 MHz/2/(83+1)=1 MHz pour le ''timer'' 2.
La période {{fname|period}} est initialisé à une grande valeur (la valeur hexadécimal 0x3fffffff correspond à 1.073.741.823) de sorte que le ''timer'' est capable de compter jusqu'à une valeur vraiment très grande avant de revenir à à la valeur zéro. Dans notre cas, cela devrait prendre environ 17 minutes pour accomplir un cycle complet et revenir à zéro.
Pour utiliser ce ''timer'', le mieux est de commencer par le réinitialiser à 0:
<nowiki>>>> micros.counter(0)</nowiki>
puis d'effectuer notre mesure de temps:
<nowiki>>>> start_micros = micros.counter()
... executer du code ici ...
>>> end_micros = micros.counter()</nowiki>
Ensuite, une simple soustraction {{fname|end_micros - start_micros}} permet d'évaluer le temps écoulé.
Dans notre cas, nous avons {{fname|end_micros - start_micros}} = {{fname|10551946}} pour une dizaine de seconde. Le chiffre vous parait grand? c'est normal, nous avons un compteur configuré à une fréquence de 1 Mhz, cela signifie 1.000.000 de cycles par seconde, soit 1.000.000 correspond à une seconde. Normal d'avoir une valeur de 10.000.000 pour 10 secondes ;-)
{{MicroPython-Hack-Timers-TRAILER}}
{{MicroPython-Hack-Timers-TRAILER}}