29 917
modifications
Modifications
Sauter à la navigation
Sauter à la recherche
Ligne 1 :
Ligne 1 : − − {{traduction}} Ligne 14 :
Ligne 12 : + − The pyboard has 14 timers which each consist of an independent counter running at a user-defined frequency. They can be set up to run a function at specific intervals. The 14 timers are numbered 1 through 14, but 3 is reserved for internal use, and 5 and 6 are used for servo and ADC/DAC control. Avoid using these timers if possible.+ + − Let’s create a timer object:+ − Now let’s see what we just created:+ − The pyboard is telling us that {{fname|tim}} is attached to timer number 4, but it’s not yet initialised. So let’s initialise it to trigger at 10 Hz (that’s 10 times per second):+ − Now that it’s initialised, we can see some information about the timer:+ − The information means that this timer is set to run at the peripheral clock speed divided by 624+1, and it will count from 0 up to 13439, at which point it triggers an interrupt, and then starts counting again from 0. These numbers are set to make the timer trigger at 10 Hz: the source frequency of the timer is 84MHz (found by running {{fname|tim.source_freq()}}) so we get 84MHz / 625 / 13440 = 10Hz.+ + + − So what can we do with our timer? The most basic thing is to get the current value of its counter:+ + + − This counter will continuously change, and counts up.+ − The next thing we can do is register a callback function for the timer to execute when it triggers (see the [switch tutorial](tut-switch) for an introduction to callback functions):+ − 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:+ + + − You can disable the callback by passing it the value {{fname|None}}:+ − 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.+ − We can create 2 timers and run them independently:+ + + Ligne 68 :
Ligne 76 : − Because the callbacks are proper hardware interrupts, we can continue to use the pyboard for other things while these timers are running.+ − 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).+ − We set up timer 2 as follows:+ − 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.+ + + − To use this timer, it’s best to first reset it to 0:+ − and then perform your timing:+ − + + +
→Timers sur la PyBoard
{{MicroPython-Hack-Prepare-NAV}}
{{MicroPython-Hack-Prepare-NAV}}
== Qu'est-ce qu'un Timer? ==
== Qu'est-ce qu'un Timer? ==
== Timers sur la PyBoard ==
== 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 ==
== Utiliser un Timer ==
Commecons par créer un objet timer:
<nowiki>>>> tim = pyb.Timer(4)</nowiki>
<nowiki>>>> tim = pyb.Timer(4)</nowiki>
Voyons maintenant l'objet que nous venons juste de créer:
<nowiki>>>> tim
<nowiki>>>> tim
Timer(4)</nowiki>
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>
<nowiki>>>> tim.init(freq=10)</nowiki>
Analysons maintenant ce que nous pouvons vois dans les informations du ''timer'':
<nowiki>>>> tim
<nowiki>>>> tim
Timer(4, prescaler=624, period=13439, mode=UP, div=1)</nowiki>
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 ==
== 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()
<nowiki>>>> tim.counter()
21504</nowiki>
21504</nowiki>
La valeur du compteur change continuellement, il compte sans arrêt.
== Le callback du Timer ==
== 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>
<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>
<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>
<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)
<nowiki>>>> tim4 = pyb.Timer(4, freq=10)
>>> tim7.callback(lambda t: pyb.LED(2).toggle())</nowiki>
>>> 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 ==
== 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>
<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>
<nowiki>>>> micros.counter(0)</nowiki>
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}}