class Timer – interne Timer steuern¶

Timer können für eine Vielzahl von Aufgaben verwendet werden. Derzeit ist nur der einfachste Fall implementiert: das periodische Aufrufen einer Funktion.

Jeder Timer besteht aus einem Zähler, der mit einer bestimmten Rate hochzählt. Die Rate, mit der er zählt, ist die Taktfrequenz des Peripheriegeräts (in Hz) geteilt durch den Timer-Vorteiler. Wenn der Zähler die Timer-Periode erreicht, löst er ein Ereignis aus und der Zähler wird wieder auf null zurückgesetzt. Mit der Callback-Methode kann das Timer-Ereignis eine Python-Funktion aufrufen.

Beispielanwendung, um eine LED mit fester Frequenz umzuschalten:

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

Beispiel mit einer benannten Funktion für den 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

Weitere Beispiele:

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

Hinweis: Timer(1) wird für die Kamera verwendet. Ebenso steuert Timer(5) den Servo-Treiber und Timer(6) wird für getaktetes ADC/DAC-Lesen/-Schreiben verwendet. Es wird empfohlen, in Ihren Programmen die anderen Timer zu verwenden.

Hinweis: Während eines Callbacks (eines Interrupts) kann kein Speicher zugewiesen werden, und daher liefern innerhalb eines Callbacks ausgelöste Ausnahmen nicht viele Informationen. Siehe micropython.alloc_emergency_exception_buf() für Möglichkeiten, diese Einschränkung zu umgehen.

Konstruktoren¶

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

Erstellt ein neues Timer-Objekt mit der angegebenen ID. Wenn zusätzliche Argumente angegeben werden, wird der Timer durch init(...) initialisiert. Die Menge der gültigen id-Werte hängt vom STM32-MCU der verwendeten OpenMV Cam ab; im STM32-Referenzhandbuch finden Sie die verfügbaren Allzweck- und Advanced-Control-Timer.

Methoden¶

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¶

Initialisiert den Timer. Die Initialisierung muss entweder über die Frequenz (in Hz) oder über Vorteiler und Periode erfolgen:

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

Schlüsselwortargumente:

freq — gibt die periodische Frequenz des Timers an. Sie können dies auch als die Frequenz betrachten, mit der der Timer einen vollständigen Zyklus durchläuft.

prescaler [0-0xffff] - gibt den Wert an, der in das Vorteiler-Register (PSC) des Timers geladen werden soll. Die Timer-Taktquelle wird durch (prescaler + 1) geteilt, um den Timer-Takt abzuleiten. Die Taktquelle stammt vom übergeordneten APB-Bus des Timers und ist MCU-abhängig. Auf STM32 takten Timer auf APB1 typischerweise mit 2 * pclk1 und Timer auf APB2 mit 2 * pclk2; lesen Sie die aktuellen Busfrequenzen mit pyb.freq() aus und konsultieren Sie das STM32-Referenzhandbuch für den MCU Ihrer OpenMV Cam.

period [0-0xffff] für die Timer 1, 3, 4 und 6-15. [0-0x3fffffff] für die Timer 2 & 5. Gibt den Wert an, der in das AutoReload-Register (ARR) des Timers geladen werden soll. Dies bestimmt die Periode des Timers (d. h. wann der Zähler umläuft). Der Timer-Zähler läuft nach period + 1 Timer-Taktzyklen über.

mode kann einer der folgenden sein:

Timer.UP - konfiguriert den Timer so, dass er von 0 bis ARR zählt (Standard)

Timer.DOWN - konfiguriert den Timer so, dass er von ARR herunter bis 0 zählt.

Timer.CENTER - konfiguriert den Timer so, dass er von 0 bis ARR und dann wieder herunter bis 0 zählt.

div kann 1, 2 oder 4 sein. Teilt den Timer-Takt, um den von den digitalen Filtern verwendeten Abtasttakt zu bestimmen.

callback - gemäß Timer.callback()

deadtime - gibt die Menge an „toter“ oder inaktiver Zeit zwischen Übergängen auf komplementären Kanälen an (beide Kanäle sind während dieser Zeit inaktiv). deadtime kann eine ganze Zahl zwischen 0 und 1008 sein, mit den folgenden Einschränkungen: 0-128 in Schritten von 1, 128-256 in Schritten von 2, 256-512 in Schritten von 8 und 512-1008 in Schritten von 16. deadtime misst Ticks von source_freq geteilt durch div Takt-Ticks. deadtime ist nur auf den Timern 1 und 8 verfügbar.

brk - gibt an, ob der Break-Modus verwendet wird, um den Ausgang des PWM zu deaktivieren, wenn der BRK_IN-Eingang aktiviert wird. Der Wert dieses Arguments bestimmt, ob Break aktiviert ist und welche Polarität gilt, und kann Timer.BRK_OFF, Timer.BRK_LOW oder Timer.BRK_HIGH sein. Um den BRK_IN-Pin auszuwählen, konstruieren Sie ein Pin-Objekt mit mode=Pin.ALT, alt=Pin.AFn_TIMx. Die GPIO-Eingangsfunktionen des Pins sind im Alt-Modus verfügbar - pull=, value() und irq().

hard kann einer der folgenden sein:

True - Der Callback wird im Hard-Interrupt-Kontext ausgeführt, was Verzögerung und Jitter minimiert, aber den in Interrupt-Handler schreiben beschriebenen Einschränkungen unterliegt, einschließlich der Unmöglichkeit, auf dem Heap zu allozieren.

False - Der Callback wird als Soft-Interrupt eingeplant, wodurch er allozieren kann, aber möglicherweise auch Garbage-Collection-Verzögerungen und Jitter einführt.

Der Standardwert dieser Option ist True.

Sie müssen entweder freq oder sowohl period als auch prescaler angeben.

deinit() → None¶

Deinitialisiert den Timer.

Deaktiviert den Callback (und den zugehörigen IRQ).

Deaktiviert alle Kanal-Callbacks (und die zugehörigen IRQs). Stoppt den Timer und deaktiviert das Timer-Peripheriegerät.

callback(fun: Callable[[Timer], None] | None) → None¶: Legt die Funktion fest, die aufgerufen wird, wenn der Timer auslöst. fun wird 1 Argument übergeben, das Timer-Objekt. Wenn fun None ist, wird der Callback deaktiviert.

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

Wird nur eine Kanalnummer übergeben, wird ein zuvor initialisiertes Kanalobjekt zurückgegeben (oder None, wenn es keinen vorherigen Kanal gibt).

Andernfalls wird ein TimerChannel-Objekt initialisiert und zurückgegeben.

Jeder Kanal kann so konfiguriert werden, dass er PWM, Output-Compare oder Input-Capture durchführt. Alle Kanäle teilen sich denselben zugrunde liegenden Timer, was bedeutet, dass sie sich denselben Timer-Takt teilen.

Schlüsselwortargumente:

mode kann einer der folgenden sein:

Timer.PWM — konfiguriert den Timer im PWM-Modus (active high).

Timer.PWM_INVERTED — konfiguriert den Timer im PWM-Modus (active low).

Timer.OC_TIMING — gibt an, dass kein Pin angesteuert wird.

Timer.OC_ACTIVE — der Pin wird aktiv gesetzt, wenn ein Compare-Match auftritt (aktiv wird durch die Polarität bestimmt)

Timer.OC_INACTIVE — der Pin wird inaktiv gesetzt, wenn ein Compare-Match auftritt.

Timer.OC_TOGGLE — der Pin wird umgeschaltet, wenn ein Compare-Match auftritt.

Timer.OC_FORCED_ACTIVE — der Pin wird zwangsweise aktiv gesetzt (Compare-Match wird ignoriert).

Timer.OC_FORCED_INACTIVE — der Pin wird zwangsweise inaktiv gesetzt (Compare-Match wird ignoriert).

Timer.IC — konfiguriert den Timer im Input-Capture-Modus.

Timer.ENC_A — konfiguriert den Timer im Encoder-Modus. Der Zähler ändert sich nur, wenn sich CH1 ändert.

Timer.ENC_B — konfiguriert den Timer im Encoder-Modus. Der Zähler ändert sich nur, wenn sich CH2 ändert.

Timer.ENC_AB — konfiguriert den Timer im Encoder-Modus. Der Zähler ändert sich, wenn sich CH1 oder CH2 ändert.

callback - gemäß TimerChannel.callback()

pin None (der Standard) oder ein Pin-Objekt. Wenn angegeben (und nicht None), bewirkt dies, dass die alternative Funktion des angegebenen Pins für diesen Timer-Kanal konfiguriert wird. Ein Fehler wird ausgelöst, wenn der Pin keine alternativen Funktionen für diesen Timer-Kanal unterstützt.

Schlüsselwortargumente für die Timer.PWM-Modi:

pulse_width - bestimmt den anfänglich zu verwendenden Impulsbreitenwert.

pulse_width_percent - bestimmt die anfänglich zu verwendende Impulsbreite in Prozent.

Schlüsselwortargumente für die Timer.OC-Modi:

compare - bestimmt den Anfangswert des Compare-Registers.

polarity kann einer der folgenden sein:

Timer.HIGH - Ausgang ist active high

Timer.LOW - Ausgang ist active low

Optionale Schlüsselwortargumente für die Timer.IC-Modi:

polarity kann einer der folgenden sein:

Timer.RISING - erfasst bei steigender Flanke.

Timer.FALLING - erfasst bei fallender Flanke.

Timer.BOTH - erfasst bei beiden Flanken.

Beachten Sie, dass Capture nur auf dem primären Kanal funktioniert und nicht auf den komplementären Kanälen.

Hinweise für die Timer.ENC-Modi:

Erfordert 2 Pins, sodass einer oder beide Pins so konfiguriert werden müssen, dass sie die entsprechende Timer-AF über die Pin-API verwenden.

Lesen Sie den Encoder-Wert mit der Methode timer.counter().

Funktioniert nur auf CH1 und CH2 (und nicht auf CH1N oder CH2N)

Die Kanalnummer wird beim Festlegen des Encoder-Modus ignoriert.

PWM-Beispiel – auf jeder STM32-OpenMV Cam sind die Kanäle 1 und 2 von TIM4 auf die Header-Pins P7 bzw. P8 geroutet:

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¶: Ruft den Timer-Zähler ab oder setzt ihn.

freq(value: int | float | None = None) → int | float | None¶: Ruft die Frequenz des Timers ab oder setzt sie (ändert beim Setzen Vorteiler und Periode).

period(value: int | None = None) → int | None¶: Ruft die Periode des Timers ab oder setzt sie.

prescaler(value: int | None = None) → int | None¶: Ruft den Vorteiler des Timers ab oder setzt ihn.

source_freq() → int¶: Ruft die Frequenz der Quelle des Timers ab.

Konstanten¶

Zählmodus-Konstanten (mode-Argument von init()):

UP: int¶: Zählt von 0 hoch bis ARR (der Standardmodus).

DOWN: int¶: Zählt von ARR herunter bis 0.

CENTER: int¶: Zählt von 0 hoch bis ARR und dann wieder herunter bis 0.

Break-Modus-Konstanten (brk-Argument von init()):

BRK_OFF: int¶: Break-Eingang ist deaktiviert.

BRK_LOW: int¶: Break-Eingang ist active-low.

BRK_HIGH: int¶: Break-Eingang ist active-high.

Kanalmodus-Konstanten (mode-Argument von channel()):

PWM: int¶: Konfiguriert den Kanal für PWM-Ausgabe (active high).

PWM_INVERTED: int¶: Konfiguriert den Kanal für PWM-Ausgabe (active low).

OC_TIMING: int¶: Output-Compare-Timing-Modus; es wird kein Pin angesteuert.

OC_ACTIVE: int¶: Output-Compare-Active-Modus; der Pin wird bei einem Compare-Match aktiv gesetzt.

OC_INACTIVE: int¶: Output-Compare-Inactive-Modus; der Pin wird bei einem Compare-Match inaktiv gesetzt.

OC_TOGGLE: int¶: Output-Compare-Toggle-Modus; der Pin schaltet bei einem Compare-Match um.

OC_FORCED_ACTIVE: int¶: Output-Compare-Forced-Active-Modus; der Pin wird zwangsweise aktiv gesetzt und der Compare-Match wird ignoriert.

OC_FORCED_INACTIVE: int¶: Output-Compare-Forced-Inactive-Modus; der Pin wird zwangsweise inaktiv gesetzt und der Compare-Match wird ignoriert.

IC: int¶: Konfiguriert den Kanal für den Input-Capture-Modus.

ENC_A: int¶: Encoder-Modus: Der Zähler ändert sich nur, wenn sich CH1 ändert.

ENC_B: int¶: Encoder-Modus: Der Zähler ändert sich nur, wenn sich CH2 ändert.

ENC_AB: int¶: Encoder-Modus: Der Zähler ändert sich, wann immer sich CH1 oder CH2 ändert.

Output-Compare-Polarität (polarity-Argument von channel() in den OC-Modi):

HIGH: int¶: Ausgang ist active-high.

LOW: int¶: Ausgang ist active-low.

Input-Capture-Polarität (polarity-Argument von channel() im IC-Modus):

RISING: int¶: Erfassung bei steigender Flanke.

FALLING: int¶: Erfassung bei fallender Flanke.

BOTH: int¶: Erfassung bei beiden Flanken.