class Timer – controllo dei timer interni

I timer possono essere utilizzati per un’ampia varietà di compiti. Al momento è implementato solo il caso più semplice: quello della chiamata periodica di una funzione.

Ogni timer è composto da un contatore che conta in avanti a una certa velocità. La velocità con cui conta è la frequenza di clock della periferica (in Hz) divisa per il prescaler del timer. Quando il contatore raggiunge il periodo del timer, viene generato un evento e il contatore viene riportato a zero. Utilizzando il metodo callback, l’evento del timer può chiamare una funzione Python.

Esempio di utilizzo per far lampeggiare un LED a una frequenza fissa:

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

Esempio che utilizza una funzione con nome per la callback:

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

Ulteriori esempi:

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

Nota: Timer(1) è utilizzato per la camera. Analogamente, Timer(5) controlla il driver del servo e Timer(6) è utilizzato per la lettura/scrittura temporizzata di ADC/DAC. Si consiglia di utilizzare gli altri timer nei propri programmi.

Nota: la memoria non può essere allocata durante una callback (un interrupt) e quindi le eccezioni sollevate all’interno di una callback non forniscono molte informazioni. Vedere micropython.alloc_emergency_exception_buf() per sapere come aggirare questa limitazione.

Costruttori

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

Costruisce un nuovo oggetto timer con l’id specificato. Se vengono forniti argomenti aggiuntivi, il timer viene inizializzato tramite init(...). L’insieme dei valori id validi dipende dal MCU STM32 della OpenMV Cam in uso; consultare il manuale di riferimento STM32 per i timer general-purpose e advanced-control disponibili.

Metodi

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

Inizializza il timer. L’inizializzazione deve avvenire o tramite frequenza (in Hz) oppure tramite prescaler e periodo:

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

Argomenti keyword:

  • freq — specifica la frequenza periodica del timer. Si può anche considerare come la frequenza con cui il timer completa un ciclo completo.

  • prescaler [0-0xffff] - specifica il valore da caricare nel registro Prescaler (PSC) del timer. La sorgente di clock del timer viene divisa per (prescaler + 1) per ricavare il clock del timer. La sorgente di clock proviene dal bus APB genitore del timer ed è dipendente dal MCU. Su STM32, i timer su APB1 hanno tipicamente un clock pari a 2 * pclk1 e i timer su APB2 pari a 2 * pclk2; leggere le frequenze di bus correnti con pyb.freq() e consultare il manuale di riferimento STM32 per il MCU della propria OpenMV Cam.

  • period [0-0xffff] per i timer 1, 3, 4 e 6-15. [0-0x3fffffff] per i timer 2 e 5. Specifica il valore da caricare nel registro AutoReload (ARR) del timer. Questo determina il periodo del timer (cioè quando il contatore completa il ciclo). Il contatore del timer effettuerà il roll-over dopo period + 1 cicli di clock del timer.

  • mode può essere uno tra:

    • Timer.UP - configura il timer per contare da 0 fino ad ARR (predefinito)

    • Timer.DOWN - configura il timer per contare da ARR fino a 0.

    • Timer.CENTER - configura il timer per contare da 0 fino ad ARR e poi di nuovo fino a 0.

  • div può essere 1, 2 o 4. Divide il clock del timer per determinare il clock di campionamento utilizzato dai filtri digitali.

  • callback - come per Timer.callback()

  • deadtime - specifica la quantità di tempo «morto» o inattivo tra le transizioni sui canali complementari (entrambi i canali saranno inattivi per questo tempo). deadtime può essere un intero compreso tra 0 e 1008, con le seguenti restrizioni: 0-128 a passi di 1, 128-256 a passi di 2, 256-512 a passi di 8 e 512-1008 a passi di 16. deadtime misura i tick di source_freq divisi per i tick di clock di div. deadtime è disponibile solo sui timer 1 e 8.

  • brk - specifica se la modalità break viene utilizzata per disattivare l’uscita del PWM quando l’ingresso BRK_IN viene asserito. Il valore di questo argomento determina se il break è abilitato e quale ne è la polarità, e può essere uno tra Timer.BRK_OFF, Timer.BRK_LOW o Timer.BRK_HIGH. Per selezionare il pin BRK_IN costruire un oggetto Pin con mode=Pin.ALT, alt=Pin.AFn_TIMx. Le funzionalità di ingresso GPIO del pin sono disponibili in modalità alt - pull= , value() e irq().

  • hard può essere uno tra:

    • True - La callback verrà eseguita in contesto di hard interrupt, il che minimizza ritardo e jitter ma è soggetto alle limitazioni descritte in Scrittura dei gestori di interrupt, tra cui l’impossibilità di allocare sull’heap.

    • False - La callback verrà schedulata come soft interrupt, consentendole di allocare ma introducendo possibilmente anche ritardi e jitter dovuti al garbage collection.

    Il valore predefinito di questa opzione è True.

È necessario specificare freq oppure entrambi period e prescaler.

deinit() → None

Deinizializza il timer.

Disabilita la callback (e l’irq associato).

Disabilita eventuali callback dei canali (e gli irq associati). Arresta il timer e disabilita la periferica del timer.

callback(fun: Callable[[Timer], None] | None) → None

Imposta la funzione da chiamare quando il timer si attiva. A fun viene passato 1 argomento, l’oggetto timer. Se fun è None allora la callback verrà disabilitata.

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

Se viene passato solo un numero di canale, viene restituito un oggetto canale precedentemente inizializzato (oppure None se non esiste un canale precedente).

Altrimenti, viene inizializzato e restituito un oggetto TimerChannel.

Ogni canale può essere configurato per eseguire pwm, output compare o input capture. Tutti i canali condividono lo stesso timer sottostante, il che significa che condividono lo stesso clock del timer.

Argomenti keyword:

  • mode può essere uno tra:

    • Timer.PWM — configura il timer in modalità PWM (attivo alto).

    • Timer.PWM_INVERTED — configura il timer in modalità PWM (attivo basso).

    • Timer.OC_TIMING — indica che nessun pin viene pilotato.

    • Timer.OC_ACTIVE — il pin verrà reso attivo quando si verifica una corrispondenza di compare (lo stato attivo è determinato dalla polarità)

    • Timer.OC_INACTIVE — il pin verrà reso inattivo quando si verifica una corrispondenza di compare.

    • Timer.OC_TOGGLE — il pin verrà commutato quando si verifica una corrispondenza di compare.

    • Timer.OC_FORCED_ACTIVE — il pin viene forzato attivo (la corrispondenza di compare viene ignorata).

    • Timer.OC_FORCED_INACTIVE — il pin viene forzato inattivo (la corrispondenza di compare viene ignorata).

    • Timer.IC — configura il timer in modalità Input Capture.

    • Timer.ENC_A — configura il timer in modalità Encoder. Il contatore cambia solo quando cambia CH1.

    • Timer.ENC_B — configura il timer in modalità Encoder. Il contatore cambia solo quando cambia CH2.

    • Timer.ENC_AB — configura il timer in modalità Encoder. Il contatore cambia quando cambia CH1 o CH2.

  • callback - come per TimerChannel.callback()

  • pin None (il valore predefinito) oppure un oggetto Pin. Se specificato (e non None) questo farà sì che la funzione alternativa del pin indicato venga configurata per questo canale del timer. Verrà sollevato un errore se il pin non supporta alcuna funzione alternativa per questo canale del timer.

Argomenti keyword per le modalità Timer.PWM:

  • pulse_width - determina il valore iniziale della larghezza di impulso da utilizzare.

  • pulse_width_percent - determina la percentuale iniziale della larghezza di impulso da utilizzare.

Argomenti keyword per le modalità Timer.OC:

  • compare - determina il valore iniziale del registro di compare.

  • polarity può essere uno tra:

    • Timer.HIGH - l’uscita è attiva alta

    • Timer.LOW - l’uscita è attiva bassa

Argomenti keyword opzionali per le modalità Timer.IC:

  • polarity può essere uno tra:

    • Timer.RISING - cattura sul fronte di salita.

    • Timer.FALLING - cattura sul fronte di discesa.

    • Timer.BOTH - cattura su entrambi i fronti.

Si noti che la cattura funziona solo sul canale primario e non sui canali complementari.

Note per le modalità Timer.ENC:

  • Richiede 2 pin, quindi uno o entrambi i pin dovranno essere configurati per utilizzare l’AF del timer appropriata tramite l’API Pin.

  • Leggere il valore dell’encoder utilizzando il metodo timer.counter().

  • Funziona solo su CH1 e CH2 (e non su CH1N o CH2N)

  • Il numero del canale viene ignorato quando si imposta la modalità encoder.

Esempio PWM – su ogni OpenMV Cam STM32 i canali 1 e 2 di TIM4 sono instradati rispettivamente ai pin di header P7 e 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

Legge o imposta il contatore del timer.

freq(value: int | float | None = None) → int | float | None

Legge o imposta la frequenza del timer (se impostata, modifica prescaler e periodo).

period(value: int | None = None) → int | None

Legge o imposta il periodo del timer.

prescaler(value: int | None = None) → int | None

Legge o imposta il prescaler del timer.

source_freq() → int

Legge la frequenza della sorgente del timer.

Costanti

Costanti della modalità di conteggio (argomento mode di init()):

UP: int

Conta da 0 fino ad ARR (la modalità predefinita).

DOWN: int

Conta da ARR fino a 0.

CENTER: int

Conta da 0 fino ad ARR e poi di nuovo fino a 0.

Costanti della modalità break (argomento brk di init()):

BRK_OFF: int

L’ingresso break è disabilitato.

BRK_LOW: int

L’ingresso break è attivo basso.

BRK_HIGH: int

L’ingresso break è attivo alto.

Costanti della modalità del canale (argomento mode di channel()):

PWM: int

Configura il canale per l’uscita PWM (attivo alto).

PWM_INVERTED: int

Configura il canale per l’uscita PWM (attivo basso).

OC_TIMING: int

Modalità output-compare timing; nessun pin viene pilotato.

OC_ACTIVE: int

Modalità output-compare active; il pin viene reso attivo alla corrispondenza di compare.

OC_INACTIVE: int

Modalità output-compare inactive; il pin viene reso inattivo alla corrispondenza di compare.

OC_TOGGLE: int

Modalità output-compare toggle; il pin commuta alla corrispondenza di compare.

OC_FORCED_ACTIVE: int

Modalità output-compare forced-active; il pin viene forzato attivo e la corrispondenza di compare viene ignorata.

OC_FORCED_INACTIVE: int

Modalità output-compare forced-inactive; il pin viene forzato inattivo e la corrispondenza di compare viene ignorata.

IC: int

Configura il canale per la modalità input-capture.

ENC_A: int

Modalità Encoder: il contatore cambia solo quando cambia CH1.

ENC_B: int

Modalità Encoder: il contatore cambia solo quando cambia CH2.

ENC_AB: int

Modalità Encoder: il contatore cambia ogni volta che cambia CH1 o CH2.

Polarità di output-compare (argomento polarity di channel() nelle modalità OC):

HIGH: int

L’uscita è attiva alta.

LOW: int

L’uscita è attiva bassa.

Polarità di input-capture (argomento polarity di channel() nella modalità IC):

RISING: int

Cattura sul fronte di salita.

FALLING: int

Cattura sul fronte di discesa.

BOTH: int

Cattura su entrambi i fronti.