class Timer – contrôle des minuteurs internes¶

Les minuteurs peuvent servir à une grande variété de tâches. Pour l’instant, seul le cas le plus simple est implémenté : appeler une fonction de façon périodique.

Chaque minuteur est constitué d’un compteur qui s’incrémente à un certain rythme. Ce rythme correspond à la fréquence d’horloge du périphérique (en Hz) divisée par le prédiviseur du minuteur. Lorsque le compteur atteint la période du minuteur, il déclenche un événement et le compteur est réinitialisé à zéro. En utilisant la méthode callback, l’événement du minuteur peut appeler une fonction Python.

Exemple d’utilisation pour faire clignoter une LED à une fréquence fixe

tim = pyb.Timer(4)              # create a timer object using timer 4
tim.init(freq=2)                # trigger at 2Hz
tim.callback(lambda t:pyb.LED(1).toggle())

Exemple utilisant une fonction nommée pour la fonction de rappel

def tick(timer):                # we will receive the timer object when being called
    print(timer.counter())      # show current timer's counter value
tim = pyb.Timer(4, freq=1)      # create a timer object using timer 4 - trigger at 1Hz
tim.callback(tick)              # set the callback to our tick function

Autres exemples

tim = pyb.Timer(4, freq=100)    # freq in Hz
tim = pyb.Timer(4, prescaler=0, period=99)
tim.counter()                   # get counter (can also set)
tim.prescaler(2)                # set prescaler (can also get)
tim.period(199)                 # set period (can also get)
tim.callback(lambda t: ...)     # set callback for update interrupt (t=tim instance)
tim.callback(None)              # clear callback

Remarque : Timer(1) est utilisé pour la caméra. De même, Timer(5) commande le pilote de servomoteur, et Timer(6) est utilisé pour la lecture/écriture temporisée de l’ADC/DAC. Il est recommandé d’utiliser les autres minuteurs dans vos programmes.

Remarque : La mémoire ne peut pas être allouée pendant une fonction de rappel (une interruption) et, par conséquent, les exceptions levées dans une fonction de rappel ne donnent pas beaucoup d’informations. Consultez micropython.alloc_emergency_exception_buf() pour savoir comment contourner cette limitation.

Constructeurs¶

class pyb.Timer(id: int, *args, **kwargs)¶

Construit un nouvel objet minuteur avec l’identifiant donné. Si des arguments supplémentaires sont fournis, le minuteur est initialisé par init(...). L’ensemble des valeurs id valides dépend du MCU STM32 de l’OpenMV Cam utilisée ; consultez le manuel de référence STM32 pour connaître les minuteurs polyvalents et de contrôle avancé disponibles.

Méthodes¶

init(*, freq: int | float | None = None, prescaler: int | None = None, period: int | None = None, mode: int = Timer.UP, div: int = 1, callback: Callable[[Timer], None] | None = None, deadtime: int = 0, brk: int = Timer.BRK_OFF, hard: bool = True) → None¶

Initialise le minuteur. L’initialisation doit se faire soit par fréquence (en Hz), soit par prédiviseur et période

tim.init(freq=100)                  # set the timer to trigger at 100Hz
tim.init(prescaler=83, period=999)  # set the prescaler and period directly

Arguments nommés :

freq — spécifie la fréquence périodique du minuteur. Vous pouvez également la voir comme la fréquence à laquelle le minuteur effectue un cycle complet.

prescaler [0-0xffff] - spécifie la valeur à charger dans le registre de prédiviseur (PSC) du minuteur. La source d’horloge du minuteur est divisée par (prescaler + 1) pour obtenir l’horloge du minuteur. La source d’horloge provient du bus APB parent du minuteur et dépend du MCU. Sur STM32, les minuteurs sur APB1 cadencent généralement à 2 * pclk1 et les minuteurs sur APB2 à 2 * pclk2 ; lisez les fréquences de bus actuelles avec pyb.freq() et consultez le manuel de référence STM32 du MCU de votre OpenMV Cam.

period [0-0xffff] pour les minuteurs 1, 3, 4 et 6-15. [0-0x3fffffff] pour les minuteurs 2 et 5. Spécifie la valeur à charger dans le registre de rechargement automatique (ARR) du minuteur. Cela détermine la période du minuteur (c.-à-d. le moment où le compteur recommence un cycle). Le compteur du minuteur effectuera un débordement après period + 1 cycles d’horloge du minuteur.

mode peut être l’un des suivants :

Timer.UP - configure le minuteur pour compter de 0 jusqu’à ARR (par défaut)

Timer.DOWN - configure le minuteur pour compter de ARR jusqu’à 0.

Timer.CENTER - configure le minuteur pour compter de 0 jusqu’à ARR, puis redescendre jusqu’à 0.

div peut valoir 1, 2 ou 4. Divise l’horloge du minuteur pour déterminer l’horloge d’échantillonnage utilisée par les filtres numériques.

callback - comme pour Timer.callback()

deadtime - spécifie la durée de temps « mort » ou inactif entre les transitions sur des canaux complémentaires (les deux canaux seront inactifs pendant cette durée). deadtime peut être un entier compris entre 0 et 1008, avec les restrictions suivantes : 0-128 par pas de 1, 128-256 par pas de 2, 256-512 par pas de 8 et 512-1008 par pas de 16. deadtime mesure des tics de source_freq divisé par les tics d’horloge div. deadtime n’est disponible que sur les minuteurs 1 et 8.

brk - spécifie si le mode de coupure (break) est utilisé pour interrompre la sortie du PWM lorsque l’entrée BRK_IN est activée. La valeur de cet argument détermine si la coupure est activée et quelle en est la polarité, et peut valoir Timer.BRK_OFF, Timer.BRK_LOW ou Timer.BRK_HIGH. Pour sélectionner la broche BRK_IN, construisez un objet Pin avec mode=Pin.ALT, alt=Pin.AFn_TIMx. Les fonctionnalités d’entrée GPIO de la broche sont disponibles en mode alterné - pull= , value() et irq().

hard peut être l’un des suivants :

True - La fonction de rappel sera exécutée dans un contexte d’interruption matérielle, ce qui minimise le délai et la gigue mais est soumis aux limitations décrites dans Écriture de gestionnaires d’interruption, notamment l’impossibilité d’allouer sur le tas.

False - La fonction de rappel sera planifiée comme une interruption logicielle, ce qui lui permet d’allouer mais peut aussi introduire des délais de ramasse-miettes et de la gigue.

La valeur par défaut de cette option est True.

Vous devez spécifier soit freq, soit à la fois period et prescaler.

deinit() → None¶

Désinitialise le minuteur.

Désactive la fonction de rappel (et l’irq associée).

Désactive toutes les fonctions de rappel de canal (et les irq associées). Arrête le minuteur et désactive le périphérique minuteur.

callback(fun: Callable[[Timer], None] | None) → None¶: Définit la fonction à appeler lorsque le minuteur se déclenche. fun reçoit 1 argument, l’objet minuteur. Si fun vaut None, alors la fonction de rappel sera désactivée.

channel(channel: int, mode: int | None = None, *args, **kwargs) → TimerChannel | None¶

Si seul un numéro de canal est passé, un objet canal précédemment initialisé est renvoyé (ou None s’il n’y a pas de canal antérieur).

Sinon, un objet TimerChannel est initialisé et renvoyé.

Chaque canal peut être configuré pour effectuer du PWM, de la comparaison de sortie (output compare) ou de la capture d’entrée (input capture). Tous les canaux partagent le même minuteur sous-jacent, ce qui signifie qu’ils partagent la même horloge de minuteur.

Arguments nommés :

mode peut être l’un des suivants :

Timer.PWM — configure le minuteur en mode PWM (actif à l’état haut).

Timer.PWM_INVERTED — configure le minuteur en mode PWM (actif à l’état bas).

Timer.OC_TIMING — indique qu’aucune broche n’est pilotée.

Timer.OC_ACTIVE — la broche sera rendue active lorsqu’une correspondance de comparaison se produit (l’état actif est déterminé par la polarité)

Timer.OC_INACTIVE — la broche sera rendue inactive lorsqu’une correspondance de comparaison se produit.

Timer.OC_TOGGLE — l’état de la broche sera basculé lorsqu’une correspondance de comparaison se produit.

Timer.OC_FORCED_ACTIVE — la broche est forcée à l’état actif (la correspondance de comparaison est ignorée).

Timer.OC_FORCED_INACTIVE — la broche est forcée à l’état inactif (la correspondance de comparaison est ignorée).

Timer.IC — configure le minuteur en mode capture d’entrée (Input Capture).

Timer.ENC_A — configure le minuteur en mode encodeur. Le compteur ne change que lorsque CH1 change.

Timer.ENC_B — configure le minuteur en mode encodeur. Le compteur ne change que lorsque CH2 change.

Timer.ENC_AB — configure le minuteur en mode encodeur. Le compteur change lorsque CH1 ou CH2 change.

callback - comme pour TimerChannel.callback()

pin None (la valeur par défaut) ou un objet Pin. S’il est spécifié (et différent de None), cela configurera la fonction alternative de la broche indiquée pour ce canal de minuteur. Une erreur sera levée si la broche ne prend en charge aucune fonction alternative pour ce canal de minuteur.

Arguments nommés pour les modes Timer.PWM :

pulse_width - détermine la valeur initiale de largeur d’impulsion à utiliser.

pulse_width_percent - détermine le pourcentage initial de largeur d’impulsion à utiliser.

Arguments nommés pour les modes Timer.OC :

compare - détermine la valeur initiale du registre de comparaison.

polarity peut être l’un des suivants :

Timer.HIGH - la sortie est active à l’état haut

Timer.LOW - la sortie est active à l’état bas

Arguments nommés optionnels pour les modes Timer.IC :

polarity peut être l’un des suivants :

Timer.RISING - capture sur front montant.

Timer.FALLING - capture sur front descendant.

Timer.BOTH - capture sur les deux fronts.

Notez que la capture ne fonctionne que sur le canal principal, et non sur les canaux complémentaires.

Remarques pour les modes Timer.ENC :

Nécessite 2 broches, donc une ou les deux broches devront être configurées pour utiliser la fonction alternative (AF) appropriée du minuteur à l’aide de l’API Pin.

Lisez la valeur de l’encodeur à l’aide de la méthode timer.counter().

Ne fonctionne que sur CH1 et CH2 (et non sur CH1N ou CH2N)

Le numéro de canal est ignoré lors du réglage du mode encodeur.

Exemple PWM – sur chaque OpenMV Cam STM32, les canaux 1 et 2 de TIM4 sont routés respectivement vers les broches d’en-tête P7 et P8

timer = pyb.Timer(4, freq=1000)
ch1 = timer.channel(1, pyb.Timer.PWM, pin=pyb.Pin.board.P7,
                    pulse_width=8000)
ch2 = timer.channel(2, pyb.Timer.PWM, pin=pyb.Pin.board.P8,
                    pulse_width=16000)

counter(value: int | None = None) → int | None¶: Lit ou définit le compteur du minuteur.

freq(value: int | float | None = None) → int | float | None¶: Lit ou définit la fréquence du minuteur (modifie le prédiviseur et la période si défini).

period(value: int | None = None) → int | None¶: Lit ou définit la période du minuteur.

prescaler(value: int | None = None) → int | None¶: Lit ou définit le prédiviseur du minuteur.

source_freq() → int¶: Lit la fréquence de la source du minuteur.

Constantes¶

Constantes de mode de comptage (argument mode de init()) :

UP: int¶: Compte de 0 jusqu’à ARR (le mode par défaut).

DOWN: int¶: Compte de ARR jusqu’à 0.

CENTER: int¶: Compte de 0 jusqu’à ARR, puis redescend jusqu’à 0.

Constantes de mode de coupure (argument brk de init()) :

BRK_OFF: int¶: L’entrée de coupure est désactivée.

BRK_LOW: int¶: L’entrée de coupure est active à l’état bas.

BRK_HIGH: int¶: L’entrée de coupure est active à l’état haut.

Constantes de mode de canal (argument mode de channel()) :

PWM: int¶: Configure le canal pour une sortie PWM (active à l’état haut).

PWM_INVERTED: int¶: Configure le canal pour une sortie PWM (active à l’état bas).

OC_TIMING: int¶: Mode de temporisation par comparaison de sortie ; aucune broche n’est pilotée.

OC_ACTIVE: int¶: Mode actif par comparaison de sortie ; la broche est rendue active lors d’une correspondance de comparaison.

OC_INACTIVE: int¶: Mode inactif par comparaison de sortie ; la broche est rendue inactive lors d’une correspondance de comparaison.

OC_TOGGLE: int¶: Mode bascule par comparaison de sortie ; l’état de la broche bascule lors d’une correspondance de comparaison.

OC_FORCED_ACTIVE: int¶: Mode actif forcé par comparaison de sortie ; la broche est forcée à l’état actif et la correspondance de comparaison est ignorée.

OC_FORCED_INACTIVE: int¶: Mode inactif forcé par comparaison de sortie ; la broche est forcée à l’état inactif et la correspondance de comparaison est ignorée.

IC: int¶: Configure le canal en mode capture d’entrée.

ENC_A: int¶: Mode encodeur : le compteur ne change que lorsque CH1 change.

ENC_B: int¶: Mode encodeur : le compteur ne change que lorsque CH2 change.

ENC_AB: int¶: Mode encodeur : le compteur change chaque fois que CH1 ou CH2 change.

Polarité de comparaison de sortie (argument polarity de channel() dans les modes OC) :

HIGH: int¶: La sortie est active à l’état haut.

LOW: int¶: La sortie est active à l’état bas.

Polarité de capture d’entrée (argument polarity de channel() dans le mode IC) :

RISING: int¶: Capture sur le front montant.

FALLING: int¶: Capture sur le front descendant.

BOTH: int¶: Capture sur l’un ou l’autre front.