class Timer – interne timers besturen¶

Timers kunnen voor een grote verscheidenheid aan taken worden gebruikt. Op dit moment is alleen het eenvoudigste geval geïmplementeerd: het periodiek aanroepen van een functie.

Elke timer bestaat uit een teller die met een bepaalde snelheid omhoog telt. De snelheid waarmee hij telt is de klokfrequentie van het randapparaat (in Hz) gedeeld door de timer-prescaler. Wanneer de teller de timerperiode bereikt, wordt er een gebeurtenis geactiveerd en wordt de teller weer op nul gezet. Door de callback-methode te gebruiken kan de timergebeurtenis een Python-functie aanroepen.

Voorbeeldgebruik om een LED met een vaste frequentie te laten knipperen:

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

Voorbeeld met een benoemde functie voor de 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

Verdere voorbeelden:

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

Opmerking: Timer(1) wordt gebruikt voor de camera. Op vergelijkbare wijze bestuurt Timer(5) de servo-driver, en Timer(6) wordt gebruikt voor getimed lezen/schrijven van ADC/DAC. Het wordt aanbevolen om de overige timers in uw programma’s te gebruiken.

Opmerking: Tijdens een callback (een interrupt) kan er geen geheugen worden gealloceerd, waardoor uitzonderingen die binnen een callback worden opgeworpen weinig informatie geven. Zie micropython.alloc_emergency_exception_buf() voor hoe u deze beperking kunt omzeilen.

Constructors¶

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

Maak een nieuw timerobject aan met het opgegeven id. Als er aanvullende argumenten worden meegegeven, wordt de timer geïnitialiseerd met init(...). De verzameling geldige id-waarden hangt af van de STM32-MCU op de gebruikte OpenMV Cam; raadpleeg de STM32-referentiehandleiding voor de beschikbare general-purpose en advanced-control timers.

Methods¶

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¶

Initialiseer de timer. Initialisatie moet ofwel via de frequentie (in Hz) ofwel via prescaler en periode gebeuren:

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

Sleutelwoordargumenten:

freq — specificeert de periodieke frequentie van de timer. U kunt dit ook zien als de frequentie waarmee de timer één volledige cyclus doorloopt.

prescaler [0-0xffff] - specificeert de waarde die in het Prescaler Register (PSC) van de timer wordt geladen. De timerklokbron wordt gedeeld door (prescaler + 1) om de timerklok af te leiden. De klokbron komt van de bovenliggende APB-bus van de timer en is MCU-afhankelijk. Op STM32 klokken timers op APB1 doorgaans op 2 * pclk1 en timers op APB2 op 2 * pclk2; lees de huidige busfrequenties met pyb.freq() en raadpleeg de STM32-referentiehandleiding voor de MCU van uw OpenMV Cam.

period [0-0xffff] voor timers 1, 3, 4 en 6-15. [0-0x3fffffff] voor timers 2 en 5. Specificeert de waarde die in het AutoReload Register (ARR) van de timer wordt geladen. Dit bepaalt de periode van de timer (d.w.z. wanneer de teller een cyclus voltooit). De timerteller loopt over na period + 1 timerklokcycli.

mode kan één van de volgende zijn:

Timer.UP - configureert de timer om van 0 tot ARR te tellen (standaard)

Timer.DOWN - configureert de timer om van ARR omlaag tot 0 te tellen.

Timer.CENTER - configureert de timer om van 0 tot ARR te tellen en daarna weer terug omlaag tot 0.

div kan 1, 2 of 4 zijn. Deelt de timerklok om de bemonsteringsklok te bepalen die door de digitale filters wordt gebruikt.

callback - zoals bij Timer.callback()

deadtime - specificeert de hoeveelheid “dode” of inactieve tijd tussen overgangen op complementaire kanalen (beide kanalen zijn gedurende deze tijd inactief). deadtime mag een geheel getal tussen 0 en 1008 zijn, met de volgende beperkingen: 0-128 in stappen van 1. 128-256 in stappen van 2, 256-512 in stappen van 8, en 512-1008 in stappen van 16. deadtime meet ticks van source_freq gedeeld door div klokticks. deadtime is alleen beschikbaar op timers 1 en 8.

brk - specificeert of de break-modus wordt gebruikt om de uitvoer van de PWM te onderbreken wanneer de BRK_IN-ingang wordt geactiveerd. De waarde van dit argument bepaalt of break is ingeschakeld en wat de polariteit is, en kan Timer.BRK_OFF, Timer.BRK_LOW of Timer.BRK_HIGH zijn. Om de BRK_IN-pin te selecteren maakt u een Pin-object aan met mode=Pin.ALT, alt=Pin.AFn_TIMx. De GPIO-ingangsfuncties van de pin zijn beschikbaar in alt-modus - pull= , value() en irq().

hard kan één van de volgende zijn:

True - De callback wordt uitgevoerd in hard interrupt-context, wat vertraging en jitter minimaliseert maar onderhevig is aan de beperkingen beschreven in Interrupt-handlers schrijven, waaronder dat er niet op de heap kan worden gealloceerd.

False - De callback wordt ingepland als een soft interrupt, waardoor deze kan alloceren maar mogelijk ook garbage-collection-vertragingen en jitter introduceert.

De standaardwaarde van deze optie is True.

U moet ofwel freq specificeren ofwel zowel period als prescaler.

deinit() → None¶

De-initialiseert de timer.

Schakelt de callback (en de bijbehorende irq) uit.

Schakelt alle kanaal-callbacks (en de bijbehorende irq) uit. Stopt de timer en schakelt het timer-randapparaat uit.

callback(fun: Callable[[Timer], None] | None) → None¶: Stel de functie in die wordt aangeroepen wanneer de timer activeert. Aan fun wordt 1 argument doorgegeven, het timerobject. Als fun None is, wordt de callback uitgeschakeld.

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

Als alleen een kanaalnummer wordt doorgegeven, wordt een eerder geïnitialiseerd kanaalobject geretourneerd (of None als er geen eerder kanaal is).

Anders wordt een TimerChannel-object geïnitialiseerd en geretourneerd.

Elk kanaal kan worden geconfigureerd voor pwm, output compare of input capture. Alle kanalen delen dezelfde onderliggende timer, wat betekent dat ze dezelfde timerklok delen.

Sleutelwoordargumenten:

mode kan één van de volgende zijn:

Timer.PWM — configureert de timer in PWM-modus (actief hoog).

Timer.PWM_INVERTED — configureert de timer in PWM-modus (actief laag).

Timer.OC_TIMING — geeft aan dat er geen pin wordt aangestuurd.

Timer.OC_ACTIVE — de pin wordt actief gemaakt wanneer een compare match optreedt (actief wordt bepaald door de polariteit)

Timer.OC_INACTIVE — de pin wordt inactief gemaakt wanneer een compare match optreedt.

Timer.OC_TOGGLE — de pin wordt omgeschakeld wanneer een compare match optreedt.

Timer.OC_FORCED_ACTIVE — de pin wordt geforceerd actief gemaakt (compare match wordt genegeerd).

Timer.OC_FORCED_INACTIVE — de pin wordt geforceerd inactief gemaakt (compare match wordt genegeerd).

Timer.IC — configureert de timer in Input Capture-modus.

Timer.ENC_A — configureert de timer in Encoder-modus. De teller verandert alleen wanneer CH1 verandert.

Timer.ENC_B — configureert de timer in Encoder-modus. De teller verandert alleen wanneer CH2 verandert.

Timer.ENC_AB — configureert de timer in Encoder-modus. De teller verandert wanneer CH1 of CH2 verandert.

callback - zoals bij TimerChannel.callback()

pin None (de standaard) of een Pin-object. Indien gespecificeerd (en niet None) zorgt dit ervoor dat de alternatieve functie van de aangegeven pin voor dit timerkanaal wordt geconfigureerd. Er wordt een fout opgeworpen als de pin geen alternatieve functies voor dit timerkanaal ondersteunt.

Sleutelwoordargumenten voor Timer.PWM-modi:

pulse_width - bepaalt de initiële pulsbreedtewaarde die gebruikt moet worden.

pulse_width_percent - bepaalt het initiële pulsbreedtepercentage dat gebruikt moet worden.

Sleutelwoordargumenten voor Timer.OC-modi:

compare - bepaalt de initiële waarde van het compare-register.

polarity kan één van de volgende zijn:

Timer.HIGH - uitvoer is actief hoog

Timer.LOW - uitvoer is actief laag

Optionele sleutelwoordargumenten voor Timer.IC-modi:

polarity kan één van de volgende zijn:

Timer.RISING - legt vast op de stijgende rand.

Timer.FALLING - legt vast op de dalende rand.

Timer.BOTH - legt vast op beide randen.

Merk op dat capture alleen werkt op het primaire kanaal, en niet op de complementaire kanalen.

Opmerkingen voor Timer.ENC-modi:

Vereist 2 pinnen, dus één of beide pinnen moeten worden geconfigureerd om de juiste timer-AF te gebruiken via de Pin API.

Lees de encoderwaarde met de methode timer.counter().

Werkt alleen op CH1 en CH2 (en niet op CH1N of CH2N)

Het kanaalnummer wordt genegeerd bij het instellen van de encoder-modus.

PWM-voorbeeld – op elke STM32 OpenMV Cam zijn de kanalen 1 en 2 van TIM4 respectievelijk naar de header-pinnen P7 en P8 gerouteerd:

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¶: Verkrijg of stel de timerteller in.

freq(value: int | float | None = None) → int | float | None¶: Verkrijg of stel de frequentie voor de timer in (wijzigt indien ingesteld de prescaler en periode).

period(value: int | None = None) → int | None¶: Verkrijg of stel de periode van de timer in.

prescaler(value: int | None = None) → int | None¶: Verkrijg of stel de prescaler voor de timer in.

source_freq() → int¶: Verkrijg de frequentie van de bron van de timer.

Constants¶

Counter-modus-constanten (mode-argument van init()):

UP: int¶: Tel van 0 omhoog tot ARR (de standaardmodus).

DOWN: int¶: Tel van ARR omlaag tot 0.

CENTER: int¶: Tel van 0 omhoog tot ARR en daarna weer terug omlaag tot 0.

Break-modus-constanten (brk-argument van init()):

BRK_OFF: int¶: Break-ingang is uitgeschakeld.

BRK_LOW: int¶: Break-ingang is actief-laag.

BRK_HIGH: int¶: Break-ingang is actief-hoog.

Kanaal-modus-constanten (mode-argument van channel()):

PWM: int¶: Configureer het kanaal voor PWM-uitvoer (actief hoog).

PWM_INVERTED: int¶: Configureer het kanaal voor PWM-uitvoer (actief laag).

OC_TIMING: int¶: Output-compare timing-modus; er wordt geen pin aangestuurd.

OC_ACTIVE: int¶: Output-compare actieve modus; de pin wordt actief gemaakt bij een compare match.

OC_INACTIVE: int¶: Output-compare inactieve modus; de pin wordt inactief gemaakt bij een compare match.

OC_TOGGLE: int¶: Output-compare toggle-modus; de pin schakelt om bij een compare match.

OC_FORCED_ACTIVE: int¶: Output-compare geforceerd-actieve modus; de pin wordt geforceerd actief gemaakt en de compare match wordt genegeerd.

OC_FORCED_INACTIVE: int¶: Output-compare geforceerd-inactieve modus; de pin wordt geforceerd inactief gemaakt en de compare match wordt genegeerd.

IC: int¶: Configureer het kanaal voor input-capture-modus.

ENC_A: int¶: Encoder-modus: de teller verandert alleen wanneer CH1 verandert.

ENC_B: int¶: Encoder-modus: de teller verandert alleen wanneer CH2 verandert.

ENC_AB: int¶: Encoder-modus: de teller verandert telkens wanneer CH1 of CH2 verandert.

Output-compare-polariteit (polarity-argument van channel() in OC-modi):

HIGH: int¶: Uitvoer is actief-hoog.

LOW: int¶: Uitvoer is actief-laag.

Input-capture-polariteit (polarity-argument van channel() in IC-modus):

RISING: int¶: Leg vast op de stijgende rand.

FALLING: int¶: Leg vast op de dalende rand.

BOTH: int¶: Leg vast op beide randen.