Ligne 1 : |
Ligne 1 : |
| {{MicroPython-Hack-Prepare-NAV}} | | {{MicroPython-Hack-Prepare-NAV}} |
− |
| |
− | {{traduction}}
| |
| | | |
| == Qu'est-ce qu'un Timer? == | | == Qu'est-ce qu'un Timer? == |
Ligne 13 : |
Ligne 11 : |
| }} | | }} |
| | | |
− | == Ensuite == | + | == 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}} |