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 14 : |
Ligne 12 : |
| | | |
| == Timers sur la PyBoard == | | == 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. | + | {{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. | | 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 == | | == Utiliser un Timer == |
Ligne 49 : |
Ligne 48 : |
| 21504</nowiki> | | 21504</nowiki> |
| | | |
− | La valeur du compteur change continuellement, et il compte sans arrêt. | + | La valeur du compteur change continuellement, il compte sans arrêt. |
| | | |
| == Le callback du Timer == | | == Le callback du Timer == |
− | The next thing we can do is register a callback function <small>([[Glossaire#C|Glossaire lettre C]])</small> for the timer to execute when it triggers (see the [switch tutorial](tut-switch) for an introduction to callback functions):
| + | 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> | | <nowiki>>>> tim.callback(lambda t:pyb.LED(1).toggle())</nowiki> |
| | | |
− | This should start the red LED flashing right away. It will be flashing at 5 Hz (2 toggle’s are needed for 1 flash, so toggling at 10 Hz makes it flash at 5 Hz). You can change the frequency by re-initialising the timer:
| + | 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> | | <nowiki>>>> tim.init(freq=20)</nowiki> |
| | | |
− | You can disable the callback by passing it the value {{fname|None}}:
| + | Vous pouvez désactiver le ''callback'' (fonction de rappel) en passant la valeur {{fname|None}}: |
| | | |
| <nowiki>>>> tim.callback(None)</nowiki> | | <nowiki>>>> tim.callback(None)</nowiki> |
| | | |
− | The function that you pass to callback must take 1 argument, which is the timer object that triggered. This allows you to control the timer from within the callback function.
| + | 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''. |
| | | |
− | We can create 2 timers and run them independently:
| + | 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) | | <nowiki>>>> tim4 = pyb.Timer(4, freq=10) |
Ligne 73 : |
Ligne 76 : |
| >>> tim7.callback(lambda t: pyb.LED(2).toggle())</nowiki> | | >>> tim7.callback(lambda t: pyb.LED(2).toggle())</nowiki> |
| | | |
− | Because the callbacks are proper hardware interrupts, we can continue to use the pyboard for other things while these timers are running.
| + | 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 == | | == Créer un compteur de microsecondes == |
− | You can use a timer to create a microsecond counter, which might be useful when you are doing something which requires accurate timing. We will use timer 2 for this, since timer 2 has a 32-bit counter (so does timer 5, but if you use timer 5 then you can’t use the Servo driver at the same time).
| + | 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). |
| | | |
− | We set up timer 2 as follows:
| + | Nous assignons le ''timer'' 2 comme suit: |
| | | |
| <nowiki>>>> micros = pyb.Timer(2, prescaler=83, period=0x3fffffff)</nowiki> | | <nowiki>>>> micros = pyb.Timer(2, prescaler=83, period=0x3fffffff)</nowiki> |
| | | |
− | The prescaler is set at 83, which makes this timer count at 1 MHz. This is because the CPU clock, running at 168 MHz, is divided by 2 and then by prescaler+1, giving a freqency of 168 MHz/2/(83+1)=1 MHz for timer 2. The period is set to a large number so that the timer can count up to a large number before wrapping back around to zero. In this case it will take about 17 minutes before it cycles back to zero.
| + | 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. |
| | | |
− | To use this timer, it’s best to first reset it to 0:
| + | Pour utiliser ce ''timer'', le mieux est de commencer par le réinitialiser à 0: |
| | | |
| <nowiki>>>> micros.counter(0)</nowiki> | | <nowiki>>>> micros.counter(0)</nowiki> |
| | | |
− | and then perform your timing:
| + | puis d'effectuer notre mesure de temps: |
| | | |
| <nowiki>>>> start_micros = micros.counter() | | <nowiki>>>> start_micros = micros.counter() |
| | | |
− | ... do some stuff ... | + | ... executer du code ici ... |
| | | |
| >>> end_micros = micros.counter()</nowiki> | | >>> 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}} |