class Timer – styr interna timrar¶

Timrar kan användas för en mängd olika uppgifter. För närvarande är endast det enklaste fallet implementerat: att anropa en funktion periodiskt.

Varje timer består av en räknare som räknar uppåt med en viss hastighet. Hastigheten som den räknar med är kringutrustningens klockfrekvens (i Hz) dividerad med timerns förskalare. När räknaren når timerns period utlöser den en händelse, och räknaren nollställs. Genom att använda callback-metoden kan timerhändelsen anropa en Python-funktion.

Exempel på användning för att växla en LED med en fast frekvens:

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

Exempel med en namngiven funktion för återanropet:

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

Ytterligare exempel:

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

Obs: Timer(1) används för kameran. På samma sätt styr Timer(5) servodrivrutinen, och Timer(6) används för tidsstyrd ADC/DAC-läsning/-skrivning. Det rekommenderas att använda de andra timrarna i dina program.

Obs: Minne kan inte allokeras under ett återanrop (ett avbrott), och därför ger undantag som uppstår inom ett återanrop inte mycket information. Se micropython.alloc_emergency_exception_buf() för hur du kan kringgå denna begränsning.

Konstruktorer¶

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

Konstruerar ett nytt timerobjekt med det angivna id:t. Om ytterligare argument anges, så initieras timern med init(...). Mängden giltiga id-värden beror på vilken STM32-MCU som finns på den OpenMV Cam som används; se STM32-referensmanualen för tillgängliga generella och avancerade styrtimrar.

Metoder¶

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¶

Initierar timern. Initieringen måste göras antingen med frekvens (i Hz) eller med förskalare och period:

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

Nyckelordsargument:

freq — anger timerns periodiska frekvens. Du kan också se detta som frekvensen med vilken timern går igenom en fullständig cykel.

prescaler [0-0xffff] - anger värdet som ska laddas in i timerns förskalarregister (PSC). Timerns klockkälla divideras med (prescaler + 1) för att härleda timerklockan. Klockkällan kommer från timerns överordnade APB-buss och är MCU-beroende. På STM32 klockas timrar på APB1 vanligtvis med 2 * pclk1 och timrar på APB2 med 2 * pclk2; läs av de aktuella bussfrekvenserna med pyb.freq() och se STM32-referensmanualen för din OpenMV Cams MCU.

period [0-0xffff] för timrarna 1, 3, 4 och 6-15. [0-0x3fffffff] för timrarna 2 och 5. Anger värdet som ska laddas in i timerns autoreload-register (ARR). Detta bestämmer timerns period (dvs. när räknaren cyklar). Timerräknaren rullar över efter period + 1 timerklockcykler.

mode kan vara en av:

Timer.UP - konfigurerar timern att räkna från 0 till ARR (standard)

Timer.DOWN - konfigurerar timern att räkna från ARR ner till 0.

Timer.CENTER - konfigurerar timern att räkna från 0 till ARR och sedan tillbaka ner till 0.

div kan vara 1, 2 eller 4. Dividerar timerklockan för att bestämma samplingsklockan som används av de digitala filtren.

callback - enligt Timer.callback()

deadtime - anger mängden ”död” eller inaktiv tid mellan övergångar på komplementära kanaler (båda kanalerna kommer att vara inaktiva under denna tid). deadtime kan vara ett heltal mellan 0 och 1008, med följande begränsningar: 0-128 i steg om 1. 128-256 i steg om 2, 256-512 i steg om 8, och 512-1008 i steg om 16. deadtime mäter tick av source_freq dividerat med div klocktick. deadtime är endast tillgängligt på timrarna 1 och 8.

brk - anger om brytläget används för att stänga av PWM-utgången när BRK_IN-ingången är aktiverad. Värdet på detta argument bestämmer om bryt är aktiverat och vilken polaritet det har, och kan vara ett av Timer.BRK_OFF, Timer.BRK_LOW eller Timer.BRK_HIGH. För att välja BRK_IN-stiftet, konstruera ett Pin-objekt med mode=Pin.ALT, alt=Pin.AFn_TIMx. Stiftets GPIO-ingångsfunktioner är tillgängliga i alt-läge - pull= , value() och irq().

hard kan vara en av:

True - Återanropet kommer att utföras i hårt avbrottskontext, vilket minimerar fördröjning och jitter men är föremål för de begränsningar som beskrivs i Skriva avbrottshanterare, inklusive att inte kunna allokera på heapen.

False - Återanropet kommer att schemaläggas som ett mjukt avbrott, vilket tillåter det att allokera men möjligen också introducerar fördröjningar och jitter från skräpinsamling.

Standardvärdet för detta alternativ är True.

Du måste antingen ange freq eller både period och prescaler.

deinit() → None¶

Avinitierar timern.

Inaktiverar återanropet (och det tillhörande irq:t).

Inaktiverar alla kanalåteranrop (och de tillhörande irq:erna). Stoppar timern och inaktiverar timerkringutrustningen.

callback(fun: Callable[[Timer], None] | None) → None¶: Ställer in funktionen som ska anropas när timern utlöses. fun skickas 1 argument, timerobjektet. Om fun är None kommer återanropet att inaktiveras.

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

Om endast ett kanalnummer skickas, returneras ett tidigare initierat kanalobjekt (eller None om det inte finns någon tidigare kanal).

Annars initieras och returneras ett TimerChannel-objekt.

Varje kanal kan konfigureras för att utföra pwm, output compare eller input capture. Alla kanaler delar samma underliggande timer, vilket innebär att de delar samma timerklocka.

Nyckelordsargument:

mode kan vara en av:

Timer.PWM — konfigurerar timern i PWM-läge (aktiv hög).

Timer.PWM_INVERTED — konfigurerar timern i PWM-läge (aktiv låg).

Timer.OC_TIMING — anger att inget stift drivs.

Timer.OC_ACTIVE — stiftet görs aktivt när en jämförelseträff inträffar (aktiv bestäms av polaritet)

Timer.OC_INACTIVE — stiftet görs inaktivt när en jämförelseträff inträffar.

Timer.OC_TOGGLE — stiftet växlas när en jämförelseträff inträffar.

Timer.OC_FORCED_ACTIVE — stiftet tvingas aktivt (jämförelseträff ignoreras).

Timer.OC_FORCED_INACTIVE — stiftet tvingas inaktivt (jämförelseträff ignoreras).

Timer.IC — konfigurerar timern i input capture-läge.

Timer.ENC_A — konfigurerar timern i encoder-läge. Räknaren ändras endast när CH1 ändras.

Timer.ENC_B — konfigurerar timern i encoder-läge. Räknaren ändras endast när CH2 ändras.

Timer.ENC_AB — konfigurerar timern i encoder-läge. Räknaren ändras när CH1 eller CH2 ändras.

callback - enligt TimerChannel.callback()

pin None (standard) eller ett Pin-objekt. Om angivet (och inte None) kommer detta att orsaka att den alternativa funktionen för det angivna stiftet konfigureras för denna timerkanal. Ett fel uppstår om stiftet inte stöder några alternativa funktioner för denna timerkanal.

Nyckelordsargument för Timer.PWM-lägen:

pulse_width - bestämmer det initiala pulsbreddsvärdet som ska användas.

pulse_width_percent - bestämmer den initiala pulsbreddsprocenten som ska användas.

Nyckelordsargument för Timer.OC-lägen:

compare - bestämmer det initiala värdet på jämförelseregistret.

polarity kan vara en av:

Timer.HIGH - utgången är aktiv hög

Timer.LOW - utgången är aktiv låg

Valfria nyckelordsargument för Timer.IC-lägen:

polarity kan vara en av:

Timer.RISING - fångar på stigande kant.

Timer.FALLING - fångar på fallande kant.

Timer.BOTH - fångar på båda kanterna.

Observera att capture endast fungerar på primärkanalen, och inte på de komplementära kanalerna.

Anmärkningar för Timer.ENC-lägen:

Kräver 2 stift, så ett eller båda stiften behöver konfigureras för att använda lämplig timer-AF med Pin-API:t.

Läs av encoder-värdet med metoden timer.counter().

Fungerar endast på CH1 och CH2 (och inte på CH1N eller CH2N)

Kanalnumret ignoreras när encoder-läget ställs in.

PWM-exempel – på varje STM32 OpenMV Cam är TIM4-kanalerna 1 och 2 dragna till headerstiften P7 respektive 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¶: Hämtar eller ställer in timerräknaren.

freq(value: int | float | None = None) → int | float | None¶: Hämtar eller ställer in frekvensen för timern (ändrar förskalare och period om den ställs in).

period(value: int | None = None) → int | None¶: Hämtar eller ställer in timerns period.

prescaler(value: int | None = None) → int | None¶: Hämtar eller ställer in förskalaren för timern.

source_freq() → int¶: Hämtar frekvensen för timerns källa.

Konstanter¶

Räknarlägeskonstanter (mode-argumentet för init()):

UP: int¶: Räkna från 0 upp till ARR (standardläget).

DOWN: int¶: Räkna från ARR ner till 0.

CENTER: int¶: Räkna från 0 upp till ARR och sedan tillbaka ner till 0.

Brytlägeskonstanter (brk-argumentet för init()):

BRK_OFF: int¶: Brytingången är inaktiverad.

BRK_LOW: int¶: Brytingången är aktiv-låg.

BRK_HIGH: int¶: Brytingången är aktiv-hög.

Kanallägeskonstanter (mode-argumentet för channel()):

PWM: int¶: Konfigurerar kanalen för PWM-utgång (aktiv hög).

PWM_INVERTED: int¶: Konfigurerar kanalen för PWM-utgång (aktiv låg).

OC_TIMING: int¶: Output-compare timing-läge; inget stift drivs.

OC_ACTIVE: int¶: Output-compare aktivt läge; stiftet görs aktivt vid jämförelseträff.

OC_INACTIVE: int¶: Output-compare inaktivt läge; stiftet görs inaktivt vid jämförelseträff.

OC_TOGGLE: int¶: Output-compare växlingsläge; stiftet växlar vid jämförelseträff.

OC_FORCED_ACTIVE: int¶: Output-compare tvingat-aktivt läge; stiftet tvingas aktivt och jämförelseträffen ignoreras.

OC_FORCED_INACTIVE: int¶: Output-compare tvingat-inaktivt läge; stiftet tvingas inaktivt och jämförelseträffen ignoreras.

IC: int¶: Konfigurerar kanalen för input-capture-läge.

ENC_A: int¶: Encoder-läge: räknaren ändras endast när CH1 ändras.

ENC_B: int¶: Encoder-läge: räknaren ändras endast när CH2 ändras.

ENC_AB: int¶: Encoder-läge: räknaren ändras närhelst CH1 eller CH2 ändras.

Output-compare-polaritet (polarity-argumentet för channel() i OC-lägen):

HIGH: int¶: Utgången är aktiv-hög.

LOW: int¶: Utgången är aktiv-låg.

Input-capture-polaritet (polarity-argumentet för channel() i IC-läge):

RISING: int¶: Fångar på den stigande kanten.

FALLING: int¶: Fångar på den fallande kanten.

BOTH: int¶: Fångar på vilken kant som helst.