Timer osztály – belső időzítők vezérlése

Az időzítők rendkívül sokféle feladatra használhatók. Jelenleg csak a legegyszerűbb eset van megvalósítva: egy függvény időszakos meghívása.

Minden időzítő egy számlálóból áll, amely adott ütemben számol felfelé. A számlálás üteme a periféria órajel-frekvenciája (Hz-ben) osztva az időzítő előosztójával. Amikor a számláló eléri az időzítő periódusát, eseményt vált ki, és a számláló visszaáll nullára. A callback metódus használatával az időzítő esemény egy Python függvényt hívhat meg.

Példa egy LED rögzített frekvenciájú kapcsolgatására:

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

Példa elnevezett függvény használatára a visszahíváshoz:

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

További példák:

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

Megjegyzés: A Timer(1) a kamerához van használva. Hasonlóan a Timer(5) vezérli a szervo meghajtót, a Timer(6) pedig az időzített ADC/DAC olvasáshoz/íráshoz használatos. Ajánlott a többi időzítőt használni a programjaidban.

Megjegyzés: A visszahívás (megszakítás) során nem foglalható memória, így a visszahíváson belül kiváltott kivételek nem adnak sok információt. Lásd a micropython.alloc_emergency_exception_buf() függvényt arról, hogyan lehet ezt a korlátozást megkerülni.

Konstruktorok

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

Új időzítő objektum létrehozása a megadott azonosítóval. Ha további argumentumokat is megadsz, akkor az időzítő az init(...) hívással inicializálódik. Az érvényes id értékek halmaza a használt OpenMV Cam STM32 MCU-jától függ; az elérhető általános célú és haladó vezérlésű időzítőkről az STM32 referencia-kézikönyvében tájékozódhatsz.

Metódusok

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

Az időzítő inicializálása. Az inicializálásnak vagy frekvencia (Hz-ben), vagy előosztó és periódus alapján kell történnie:

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

Kulcsszavas argumentumok:

  • freq — megadja az időzítő időszakos frekvenciáját. Ezt úgy is felfoghatod, mint azt a frekvenciát, amellyel az időzítő egy teljes ciklust végigfut.

  • prescaler [0-0xffff] - megadja az időzítő előosztó regiszterébe (PSC) betöltendő értéket. Az időzítő órajelforrása (prescaler + 1) értékkel oszlik el, így adódik az időzítő órajele. Az órajelforrás az időzítő szülő APB buszáról érkezik, és MCU-függő. STM32 esetén az APB1-en lévő időzítők jellemzően 2 * pclk1 órajellel, az APB2-n lévők pedig 2 * pclk2 órajellel működnek; az aktuális buszfrekvenciákat a pyb.freq() függvénnyel olvashatod ki, az OpenMV Cam MCU-járól pedig az STM32 referencia-kézikönyvben tájékozódhatsz.

  • period [0-0xffff] az 1, 3, 4 és 6-15 időzítőknél. [0-0x3fffffff] a 2-es és 5-ös időzítőknél. Megadja az időzítő automatikus újratöltő regiszterébe (ARR) betöltendő értéket. Ez határozza meg az időzítő periódusát (azaz azt, amikor a számláló újrakezdi a ciklust). Az időzítő számlálója period + 1 időzítő-órajelciklus után fordul át.

  • A mode az alábbiak egyike lehet:

    • Timer.UP - úgy konfigurálja az időzítőt, hogy 0-tól ARR-ig számoljon (alapértelmezett)

    • Timer.DOWN - úgy konfigurálja az időzítőt, hogy ARR-tól 0-ig számoljon lefelé.

    • Timer.CENTER - úgy konfigurálja az időzítőt, hogy 0-tól ARR-ig, majd vissza 0-ig számoljon.

  • A div az 1, 2 vagy 4 értékek egyike lehet. Elosztja az időzítő órajelét, hogy meghatározza a digitális szűrők által használt mintavételi órajelet.

  • callback - a Timer.callback() szerint

  • deadtime - megadja a komplementer csatornák átmenetei közötti „holt” vagy inaktív idő mértékét (mindkét csatorna inaktív lesz ez idő alatt). A deadtime egy 0 és 1008 közötti egész szám lehet, az alábbi megkötésekkel: 0-128 között 1-es lépésekben, 128-256 között 2-es lépésekben, 256-512 között 8-as lépésekben, 512-1008 között pedig 16-os lépésekben. A deadtime a source_freq div órajellel osztott órajelütéseit méri. A deadtime csak az 1-es és 8-as időzítőkön érhető el.

  • brk - megadja, hogy a megszakítási (break) mód a PWM kimenet leállítására szolgál-e, amikor a BRK_IN bemenet aktiválódik. Ennek az argumentumnak az értéke határozza meg, hogy a break engedélyezett-e és milyen a polaritása, és lehet a Timer.BRK_OFF, Timer.BRK_LOW vagy Timer.BRK_HIGH egyike. A BRK_IN láb kiválasztásához hozz létre egy Pin objektumot mode=Pin.ALT, alt=Pin.AFn_TIMx paraméterekkel. A láb GPIO bemeneti funkciói alt módban is elérhetők - pull= , value() és irq().

  • A hard az alábbiak egyike lehet:

    • True - A visszahívás kemény megszakítási kontextusban fut le, ami minimalizálja a késleltetést és a jittert, de a Megszakításkezelők írása szakaszban leírt korlátozások vonatkoznak rá, beleértve azt is, hogy nem foglalhat a heapen.

    • False - A visszahívás lágy megszakításként ütemeződik, ami lehetővé teszi a foglalást, de szemétgyűjtési késleltetéseket és jittert is okozhat.

    Ennek az opciónak az alapértelmezett értéke True.

Meg kell adnod vagy a freq értéket, vagy a period és a prescaler értéket is.

deinit() → None

Megszünteti az időzítő inicializálását.

Letiltja a visszahívást (és a hozzá tartozó irq-t).

Letiltja az összes csatorna-visszahívást (és a hozzájuk tartozó irq-t). Leállítja az időzítőt, és letiltja az időzítő perifériát.

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

Beállítja az időzítő kiváltásakor meghívandó függvényt. A fun 1 argumentumot kap, az időzítő objektumot. Ha a fun értéke None, akkor a visszahívás letiltódik.

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

Ha csak egy csatornaszámot adsz át, akkor egy korábban inicializált csatorna objektum kerül visszaadásra (vagy None, ha nincs korábbi csatorna).

Egyébként egy TimerChannel objektum inicializálódik és kerül visszaadásra.

Minden csatorna konfigurálható pwm, kimeneti összehasonlítás (output compare) vagy bemeneti rögzítés (input capture) végzésére. Az összes csatorna ugyanazt az alapul szolgáló időzítőt osztja meg, ami azt jelenti, hogy ugyanazt az időzítő órajelet használják.

Kulcsszavas argumentumok:

  • A mode az alábbiak egyike lehet:

    • Timer.PWM — az időzítő PWM módba konfigurálása (aktív magas).

    • Timer.PWM_INVERTED — az időzítő PWM módba konfigurálása (aktív alacsony).

    • Timer.OC_TIMING — jelzi, hogy egyetlen lábat sem hajt meg.

    • Timer.OC_ACTIVE — a láb aktívvá válik, amikor összehasonlítási egyezés történik (az aktív állapotot a polaritás határozza meg)

    • Timer.OC_INACTIVE — a láb inaktívvá válik, amikor összehasonlítási egyezés történik.

    • Timer.OC_TOGGLE — a láb állapota átkapcsol, amikor összehasonlítási egyezés történik.

    • Timer.OC_FORCED_ACTIVE — a láb kényszerítetten aktív (az összehasonlítási egyezés figyelmen kívül marad).

    • Timer.OC_FORCED_INACTIVE — a láb kényszerítetten inaktív (az összehasonlítási egyezés figyelmen kívül marad).

    • Timer.IC — az időzítő bemeneti rögzítés (Input Capture) módba konfigurálása.

    • Timer.ENC_A — az időzítő enkóder módba konfigurálása. A számláló csak akkor változik, amikor a CH1 változik.

    • Timer.ENC_B — az időzítő enkóder módba konfigurálása. A számláló csak akkor változik, amikor a CH2 változik.

    • Timer.ENC_AB — az időzítő enkóder módba konfigurálása. A számláló akkor változik, amikor a CH1 vagy a CH2 változik.

  • callback - a TimerChannel.callback() szerint

  • pin None (az alapértelmezett) vagy egy Pin objektum. Ha meg van adva (és nem None), akkor a megjelölt láb alternatív funkciója ehhez az időzítő-csatornához lesz konfigurálva. Hiba keletkezik, ha a láb nem támogat egyetlen alternatív funkciót sem ehhez az időzítő-csatornához.

Kulcsszavas argumentumok a Timer.PWM módokhoz:

  • pulse_width - meghatározza a használandó kezdeti impulzusszélesség-értéket.

  • pulse_width_percent - meghatározza a használandó kezdeti impulzusszélesség-százalékot.

Kulcsszavas argumentumok a Timer.OC módokhoz:

  • compare - meghatározza az összehasonlító regiszter kezdeti értékét.

  • A polarity az alábbiak egyike lehet:

    • Timer.HIGH - a kimenet aktív magas

    • Timer.LOW - a kimenet aktív alacsony

Opcionális kulcsszavas argumentumok a Timer.IC módokhoz:

  • A polarity az alábbiak egyike lehet:

    • Timer.RISING - felfutó élnél rögzít.

    • Timer.FALLING - lefutó élnél rögzít.

    • Timer.BOTH - mindkét élnél rögzít.

Vedd figyelembe, hogy a rögzítés csak az elsődleges csatornán működik, a komplementer csatornákon nem.

Megjegyzések a Timer.ENC módokhoz:

  • 2 lábat igényel, így egy vagy mindkét lábat a megfelelő időzítő AF használatára kell konfigurálni a Pin API segítségével.

  • Olvasd ki az enkóder értékét a timer.counter() metódussal.

  • Csak a CH1-en és a CH2-n működik (a CH1N-en vagy a CH2N-en nem)

  • Az enkóder mód beállításakor a csatornaszám figyelmen kívül marad.

PWM példa – minden STM32 alapú OpenMV Cam esetén a TIM4 1-es és 2-es csatornája a P7 és P8 fejléclábakra van vezetve:

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

Lekérdezi vagy beállítja az időzítő számlálóját.

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

Lekérdezi vagy beállítja az időzítő frekvenciáját (beállításkor megváltoztatja az előosztót és a periódust).

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

Lekérdezi vagy beállítja az időzítő periódusát.

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

Lekérdezi vagy beállítja az időzítő előosztóját.

source_freq() → int

Lekérdezi az időzítő forrásának frekvenciáját.

Konstansok

Számlálási mód konstansai (az init() mode argumentuma):

UP: int

Számolás 0-tól ARR-ig (az alapértelmezett mód).

DOWN: int

Számolás ARR-tól 0-ig.

CENTER: int

Számolás 0-tól ARR-ig, majd vissza 0-ig.

Break mód konstansai (az init() brk argumentuma):

BRK_OFF: int

A break bemenet le van tiltva.

BRK_LOW: int

A break bemenet aktív alacsony.

BRK_HIGH: int

A break bemenet aktív magas.

Csatorna mód konstansai (a channel() mode argumentuma):

PWM: int

A csatorna konfigurálása PWM kimenetre (aktív magas).

PWM_INVERTED: int

A csatorna konfigurálása PWM kimenetre (aktív alacsony).

OC_TIMING: int

Kimeneti összehasonlítás időzítési mód; egyetlen láb sincs meghajtva.

OC_ACTIVE: int

Kimeneti összehasonlítás aktív mód; a láb aktívvá válik összehasonlítási egyezéskor.

OC_INACTIVE: int

Kimeneti összehasonlítás inaktív mód; a láb inaktívvá válik összehasonlítási egyezéskor.

OC_TOGGLE: int

Kimeneti összehasonlítás átkapcsolási mód; a láb állapota átkapcsol összehasonlítási egyezéskor.

OC_FORCED_ACTIVE: int

Kimeneti összehasonlítás kényszerített aktív mód; a láb kényszerítetten aktív, és az összehasonlítási egyezés figyelmen kívül marad.

OC_FORCED_INACTIVE: int

Kimeneti összehasonlítás kényszerített inaktív mód; a láb kényszerítetten inaktív, és az összehasonlítási egyezés figyelmen kívül marad.

IC: int

A csatorna konfigurálása bemeneti rögzítés módba.

ENC_A: int

Enkóder mód: a számláló csak akkor változik, amikor a CH1 változik.

ENC_B: int

Enkóder mód: a számláló csak akkor változik, amikor a CH2 változik.

ENC_AB: int

Enkóder mód: a számláló akkor változik, amikor a CH1 vagy a CH2 változik.

Kimeneti összehasonlítás polaritása (a channel() polarity argumentuma OC módokban):

HIGH: int

A kimenet aktív magas.

LOW: int

A kimenet aktív alacsony.

Bemeneti rögzítés polaritása (a channel() polarity argumentuma IC módban):

RISING: int

Rögzítés a felfutó élnél.

FALLING: int

Rögzítés a lefutó élnél.

BOTH: int

Rögzítés bármelyik élnél.