MicroPython-Hack-timers

De MCHobby - Wiki
Aller à : navigation, rechercher

MCHobby investit du temps et de l'argent dans la réalisation de traduction et/ou documentation. C'est un travail long et fastidieux réalisé dans l'esprit Open-Source... donc gratuit et librement accessible.
SI vous aimez nos traductions et documentations ALORS aidez nous à en produire plus en achetant vos produits chez MCHobby.

Qu'est-ce qu'un Timer?

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 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

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 le n° 3 est réservé pour usage interne et 5 & 6 utilisés pour les Servo moteurs et contrôle ADC/DAC.. Eviter d'utiliser ces timers si cela est possible.

Utiliser un Timer

Commecons par créer un objet timer:

>>> tim = pyb.Timer(4)

Voyons maintenant l'objet que nous venons juste de créer:

>>> tim
Timer(4)

La carte PyBoard nous informe que 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):

>>> tim.init(freq=10)

Analysons maintenant ce que nous pouvons vois dans les informations du timer:

>>> tim
Timer(4, prescaler=624, period=13439, mode=UP, div=1)

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 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:

>>> tim.counter()
21504

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 (Glossaire lettre C)) de sorte que le timer l'exécute à chaque déclenchement (voyez notre tutoriel sur sur les boutons pour un introduction sur les fonction callback (de rappel):

>>> tim.callback(lambda t:pyb.LED(1).toggle())

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:

>>> tim.init(freq=20)

Vous pouvez désactiver le callback (fonction de rappel) en passant la valeur None:

>>> tim.callback(None)

La fonction que vous passez à 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:

>>> 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())

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:

>>> micros = pyb.Timer(2, prescaler=83, period=0x3fffffff)

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 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 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:

>>> micros.counter(0)

puis d'effectuer notre mesure de temps:

>>> start_micros = micros.counter()

... executer du code ici ...

>>> end_micros = micros.counter()

Ensuite, une simple soustraction end_micros - start_micros permet d'évaluer le temps écoulé.

Dans notre cas, nous avons end_micros - start_micros = 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 ;-)



Source: The timers écrit par/written by Damien P.George

Traduit par Meurisse D. pour MCHobby.be - Translated by Meurisse D. for MCHobby.be

Traduit avec l'autorisation de micropython.org - Translated with the authorisation of micropython.org

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.