class Timer – controlul temporizatoarelor interne¶

Temporizatoarele pot fi folosite pentru o mare varietate de sarcini. În prezent, este implementat doar cazul cel mai simplu: acela al apelării periodice a unei funcții.

Fiecare temporizator constă într-un contor care numără în sus la o anumită rată. Rata la care numără este frecvența ceasului periferic (în Hz) împărțită la prescalerul temporizatorului. Când contorul atinge perioada temporizatorului, declanșează un eveniment, iar contorul se resetează la zero. Folosind metoda callback, evenimentul temporizatorului poate apela o funcție Python.

Exemplu de utilizare pentru a comuta un LED la o frecvență fixă:

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

Exemplu folosind o funcție denumită pentru funcția de retroapelare (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

Exemple suplimentare:

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

Notă: Timer(1) este folosit pentru cameră. În mod similar, Timer(5) controlează driverul de servo, iar Timer(6) este folosit pentru citirea/scrierea ADC/DAC temporizată. Se recomandă folosirea celorlalte temporizatoare în programele dumneavoastră.

Notă: Memoria nu poate fi alocată în timpul unei funcții de retroapelare (o întrerupere), astfel încât excepțiile generate într-o funcție de retroapelare nu oferă prea multe informații. Consultați micropython.alloc_emergency_exception_buf() pentru a vedea cum puteți depăși această limitare.

Constructori¶

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

Construiește un nou obiect temporizator cu id-ul dat. Dacă sunt furnizate argumente suplimentare, atunci temporizatorul este inițializat prin init(...). Setul de valori id valide depinde de microcontrolerul STM32 de pe OpenMV Cam în uz; consultați manualul de referință STM32 pentru temporizatoarele de uz general și de control avansat disponibile.

Metode¶

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¶

Inițializează temporizatorul. Inițializarea trebuie făcută fie prin frecvență (în Hz), fie prin prescaler și perioadă:

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

Argumente cu cuvinte-cheie:

freq — specifică frecvența periodică a temporizatorului. Puteți de asemenea să o priviți ca pe frecvența cu care temporizatorul parcurge un ciclu complet.

prescaler [0-0xffff] - specifică valoarea care urmează să fie încărcată în registrul Prescaler (PSC) al temporizatorului. Sursa de ceas a temporizatorului este împărțită la (prescaler + 1) pentru a deriva ceasul temporizatorului. Sursa de ceas provine de la magistrala APB părinte a temporizatorului și este dependentă de microcontroler. Pe STM32, temporizatoarele de pe APB1 funcționează de obicei la 2 * pclk1, iar cele de pe APB2 la 2 * pclk2; citiți frecvențele curente ale magistralelor cu pyb.freq() și consultați manualul de referință STM32 pentru microcontrolerul OpenMV Cam-ului dumneavoastră.

period [0-0xffff] pentru temporizatoarele 1, 3, 4 și 6-15. [0-0x3fffffff] pentru temporizatoarele 2 și 5. Specifică valoarea care urmează să fie încărcată în registrul AutoReload (ARR) al temporizatorului. Aceasta determină perioada temporizatorului (adică momentul în care contorul reia ciclul). Contorul temporizatorului se va reseta după period + 1 cicluri de ceas ale temporizatorului.

mode poate fi una dintre:

Timer.UP - configurează temporizatorul să numere de la 0 la ARR (implicit)

Timer.DOWN - configurează temporizatorul să numere de la ARR în jos până la 0.

Timer.CENTER - configurează temporizatorul să numere de la 0 la ARR și apoi înapoi până la 0.

div poate fi 1, 2 sau 4. Împarte ceasul temporizatorului pentru a determina ceasul de eșantionare folosit de filtrele digitale.

callback - conform Timer.callback()

deadtime - specifică durata de timp „mort” sau inactiv între tranzițiile de pe canalele complementare (ambele canale vor fi inactive în acest interval). deadtime poate fi un număr întreg între 0 și 1008, cu următoarele restricții: 0-128 în pași de 1, 128-256 în pași de 2, 256-512 în pași de 8 și 512-1008 în pași de 16. deadtime măsoară impulsuri de ceas ale source_freq împărțit la div. deadtime este disponibil doar pe temporizatoarele 1 și 8.

brk - specifică dacă modul break este folosit pentru a opri ieșirea PWM-ului atunci când intrarea BRK_IN este activată. Valoarea acestui argument determină dacă break este activat și care îi este polaritatea și poate fi una dintre Timer.BRK_OFF, Timer.BRK_LOW sau Timer.BRK_HIGH. Pentru a selecta pinul BRK_IN, construiți un obiect Pin cu mode=Pin.ALT, alt=Pin.AFn_TIMx. Caracteristicile de intrare GPIO ale pinului sunt disponibile în modul alt - pull= , value() și irq().

hard poate fi una dintre:

True - Funcția de retroapelare va fi executată în context de întrerupere hardware, ceea ce minimizează întârzierea și jitterul, dar este supusă limitărilor descrise în Scrierea handlerelor de întrerupere, inclusiv imposibilitatea de a aloca pe heap.

False - Funcția de retroapelare va fi programată ca o întrerupere software, permițându-i să aloce, dar introducând posibil și întârzieri și jitter cauzate de colectarea gunoiului (garbage collection).

Valoarea implicită a acestei opțiuni este True.

Trebuie să specificați fie freq, fie atât period cât și prescaler.

deinit() → None¶

Dezinițializează temporizatorul.

Dezactivează funcția de retroapelare (și irq-ul asociat).

Dezactivează orice funcții de retroapelare ale canalelor (și irq-ul asociat). Oprește temporizatorul și dezactivează periferia temporizatorului.

callback(fun: Callable[[Timer], None] | None) → None¶: Setează funcția care urmează să fie apelată când temporizatorul se declanșează. Lui fun îi este transmis 1 argument, obiectul temporizator. Dacă fun este None, atunci funcția de retroapelare va fi dezactivată.

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

Dacă este transmis doar un număr de canal, atunci este returnat un obiect canal inițializat anterior (sau None dacă nu există un canal anterior).

În caz contrar, un obiect TimerChannel este inițializat și returnat.

Fiecare canal poate fi configurat pentru a realiza pwm, comparare de ieșire (output compare) sau captură de intrare (input capture). Toate canalele partajează același temporizator subiacent, ceea ce înseamnă că partajează același ceas al temporizatorului.

Argumente cu cuvinte-cheie:

mode poate fi una dintre:

Timer.PWM — configurează temporizatorul în modul PWM (activ pe nivel înalt).

Timer.PWM_INVERTED — configurează temporizatorul în modul PWM (activ pe nivel jos).

Timer.OC_TIMING — indică faptul că niciun pin nu este acționat.

Timer.OC_ACTIVE — pinul va fi făcut activ atunci când apare o potrivire de comparare (activul este determinat de polaritate)

Timer.OC_INACTIVE — pinul va fi făcut inactiv atunci când apare o potrivire de comparare.

Timer.OC_TOGGLE — pinul va fi comutat atunci când apare o potrivire de comparare.

Timer.OC_FORCED_ACTIVE — pinul este forțat activ (potrivirea de comparare este ignorată).

Timer.OC_FORCED_INACTIVE — pinul este forțat inactiv (potrivirea de comparare este ignorată).

Timer.IC — configurează temporizatorul în modul Input Capture.

Timer.ENC_A — configurează temporizatorul în modul Encoder. Contorul se schimbă doar când CH1 se schimbă.

Timer.ENC_B — configurează temporizatorul în modul Encoder. Contorul se schimbă doar când CH2 se schimbă.

Timer.ENC_AB — configurează temporizatorul în modul Encoder. Contorul se schimbă când CH1 sau CH2 se schimbă.

callback - conform TimerChannel.callback()

pin None (implicit) sau un obiect Pin. Dacă este specificat (și nu None), acest lucru va determina configurarea funcției alternative a pinului indicat pentru acest canal al temporizatorului. Va fi generată o eroare dacă pinul nu suportă nicio funcție alternativă pentru acest canal al temporizatorului.

Argumente cu cuvinte-cheie pentru modurile Timer.PWM:

pulse_width - determină valoarea inițială a lățimii impulsului care va fi folosită.

pulse_width_percent - determină procentajul inițial al lățimii impulsului care va fi folosit.

Argumente cu cuvinte-cheie pentru modurile Timer.OC:

compare - determină valoarea inițială a registrului de comparare.

polarity poate fi una dintre:

Timer.HIGH - ieșirea este activă pe nivel înalt

Timer.LOW - ieșirea este activă pe nivel jos

Argumente opționale cu cuvinte-cheie pentru modurile Timer.IC:

polarity poate fi una dintre:

Timer.RISING - captează pe muchia ascendentă.

Timer.FALLING - captează pe muchia descendentă.

Timer.BOTH - captează pe ambele muchii.

Rețineți că captura funcționează doar pe canalul primar și nu pe canalele complementare.

Note pentru modurile Timer.ENC:

Necesită 2 pini, așa că unul sau ambii pini vor trebui configurați pentru a folosi AF-ul corespunzător al temporizatorului folosind API-ul Pin.

Citiți valoarea encoderului folosind metoda timer.counter().

Funcționează doar pe CH1 și CH2 (și nu pe CH1N sau CH2N)

Numărul canalului este ignorat la setarea modului encoder.

Exemplu PWM – pe fiecare OpenMV Cam STM32, canalele 1 și 2 ale TIM4 sunt rutate către pinii de antet P7 și respectiv 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¶: Obține sau setează contorul temporizatorului.

freq(value: int | float | None = None) → int | float | None¶: Obține sau setează frecvența temporizatorului (modifică prescalerul și perioada dacă este setată).

period(value: int | None = None) → int | None¶: Obține sau setează perioada temporizatorului.

prescaler(value: int | None = None) → int | None¶: Obține sau setează prescalerul temporizatorului.

source_freq() → int¶: Obține frecvența sursei temporizatorului.

Constante¶

Constante de mod-contor (argumentul mode al init()):

UP: int¶: Numără de la 0 în sus până la ARR (modul implicit).

DOWN: int¶: Numără de la ARR în jos până la 0.

CENTER: int¶: Numără de la 0 în sus până la ARR și apoi înapoi până la 0.

Constante de mod-break (argumentul brk al init()):

BRK_OFF: int¶: Intrarea break este dezactivată.

BRK_LOW: int¶: Intrarea break este activă pe nivel jos.

BRK_HIGH: int¶: Intrarea break este activă pe nivel înalt.

Constante de mod-canal (argumentul mode al channel()):

PWM: int¶: Configurează canalul pentru ieșire PWM (activ pe nivel înalt).

PWM_INVERTED: int¶: Configurează canalul pentru ieșire PWM (activ pe nivel jos).

OC_TIMING: int¶: Mod de temporizare cu comparare de ieșire; niciun pin nu este acționat.

OC_ACTIVE: int¶: Mod activ cu comparare de ieșire; pinul este făcut activ la potrivirea de comparare.

OC_INACTIVE: int¶: Mod inactiv cu comparare de ieșire; pinul este făcut inactiv la potrivirea de comparare.

OC_TOGGLE: int¶: Mod de comutare cu comparare de ieșire; pinul comută la potrivirea de comparare.

OC_FORCED_ACTIVE: int¶: Mod forțat-activ cu comparare de ieșire; pinul este forțat activ, iar potrivirea de comparare este ignorată.

OC_FORCED_INACTIVE: int¶: Mod forțat-inactiv cu comparare de ieșire; pinul este forțat inactiv, iar potrivirea de comparare este ignorată.

IC: int¶: Configurează canalul pentru modul de captură de intrare.

ENC_A: int¶: Mod encoder: contorul se schimbă doar când CH1 se schimbă.

ENC_B: int¶: Mod encoder: contorul se schimbă doar când CH2 se schimbă.

ENC_AB: int¶: Mod encoder: contorul se schimbă ori de câte ori CH1 sau CH2 se schimbă.

Polaritate de comparare de ieșire (argumentul polarity al channel() în modurile OC):

HIGH: int¶: Ieșirea este activă pe nivel înalt.

LOW: int¶: Ieșirea este activă pe nivel jos.

Polaritate de captură de intrare (argumentul polarity al channel() în modul IC):

RISING: int¶: Captează pe muchia ascendentă.

FALLING: int¶: Captează pe muchia descendentă.

BOTH: int¶: Captează pe oricare muchie.