clase Timer – controla los temporizadores internos¶

Los temporizadores se pueden usar para una gran variedad de tareas. Por el momento, solo está implementado el caso más simple: el de llamar a una función periódicamente.

Cada temporizador consta de un contador que cuenta hacia arriba a una determinada velocidad. La velocidad a la que cuenta es la frecuencia del reloj del periférico (en Hz) dividida por el preescalador del temporizador. Cuando el contador alcanza el período del temporizador, se dispara un evento y el contador se reinicia a cero. Mediante el método callback, el evento del temporizador puede llamar a una función de Python.

Ejemplo de uso para conmutar un LED a una frecuencia fija:

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

Ejemplo usando una función con nombre para el 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

Más ejemplos:

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

Nota: Timer(1) se usa para la cámara. De forma similar, Timer(5) controla el controlador de servos, y Timer(6) se usa para la lectura/escritura temporizada de ADC/DAC. Se recomienda usar los demás temporizadores en tus programas.

Nota: No se puede asignar memoria durante un callback (una interrupción) y, por lo tanto, las excepciones lanzadas dentro de un callback no proporcionan mucha información. Consulta micropython.alloc_emergency_exception_buf() para saber cómo sortear esta limitación.

Constructores¶

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

Construye un nuevo objeto de temporizador con el id dado. Si se proporcionan argumentos adicionales, entonces el temporizador se inicializa mediante init(...). El conjunto de valores válidos de id depende del MCU STM32 de la OpenMV Cam que se esté usando; consulta el manual de referencia del STM32 para conocer los temporizadores de propósito general y de control avanzado disponibles.

Métodos¶

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¶

Inicializa el temporizador. La inicialización debe hacerse o bien por frecuencia (en Hz) o bien por preescalador y período:

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

Argumentos de palabra clave:

freq — especifica la frecuencia periódica del temporizador. También puedes verlo como la frecuencia con la que el temporizador completa un ciclo entero.

prescaler [0-0xffff] - especifica el valor que se cargará en el Registro de Preescalador (PSC) del temporizador. La fuente de reloj del temporizador se divide por (prescaler + 1) para derivar el reloj del temporizador. La fuente de reloj proviene del bus APB padre del temporizador y es dependiente del MCU. En STM32, los temporizadores en APB1 normalmente funcionan a 2 * pclk1 y los temporizadores en APB2 a 2 * pclk2; lee las frecuencias actuales de los buses con pyb.freq() y consulta el manual de referencia del STM32 para el MCU de tu OpenMV Cam.

period [0-0xffff] para los temporizadores 1, 3, 4 y 6-15. [0-0x3fffffff] para los temporizadores 2 y 5. Especifica el valor que se cargará en el Registro de Autorecarga (ARR) del temporizador. Esto determina el período del temporizador (es decir, cuándo el contador completa un ciclo). El contador del temporizador desbordará después de period + 1 ciclos de reloj del temporizador.

mode puede ser uno de:

Timer.UP - configura el temporizador para contar de 0 a ARR (predeterminado)

Timer.DOWN - configura el temporizador para contar de ARR hacia abajo hasta 0.

Timer.CENTER - configura el temporizador para contar de 0 a ARR y luego de vuelta hasta 0.

div puede ser 1, 2 o 4. Divide el reloj del temporizador para determinar el reloj de muestreo usado por los filtros digitales.

callback - según Timer.callback()

deadtime - especifica la cantidad de tiempo «muerto» o inactivo entre transiciones en canales complementarios (ambos canales estarán inactivos durante este tiempo). deadtime puede ser un entero entre 0 y 1008, con las siguientes restricciones: 0-128 en pasos de 1. 128-256 en pasos de 2, 256-512 en pasos de 8, y 512-1008 en pasos de 16. deadtime mide ticks de source_freq divididos por div ticks de reloj. deadtime solo está disponible en los temporizadores 1 y 8.

brk - especifica si el modo de corte (break) se usa para anular la salida del PWM cuando se activa la entrada BRK_IN. El valor de este argumento determina si el corte está habilitado y cuál es la polaridad, y puede ser uno de Timer.BRK_OFF, Timer.BRK_LOW o Timer.BRK_HIGH. Para seleccionar el pin BRK_IN, construye un objeto Pin con mode=Pin.ALT, alt=Pin.AFn_TIMx. Las características de entrada GPIO del pin están disponibles en modo alternativo - pull= , value() e irq().

hard puede ser uno de:

True - El callback se ejecutará en contexto de interrupción dura (hard interrupt), lo que minimiza el retardo y el jitter, pero está sujeto a las limitaciones descritas en Escritura de gestores de interrupciones, incluida la imposibilidad de asignar memoria en el heap.

False - El callback se programará como una interrupción suave (soft interrupt), lo que le permite asignar memoria, pero posiblemente también introduce retardos de recolección de basura y jitter.

El valor predeterminado de esta opción es True.

Debes especificar o bien freq, o bien tanto period como prescaler.

deinit() → None¶

Desinicializa el temporizador.

Deshabilita el callback (y la irq asociada).

Deshabilita cualquier callback de canal (y la irq asociada). Detiene el temporizador y deshabilita el periférico del temporizador.

callback(fun: Callable[[Timer], None] | None) → None¶: Establece la función que se llamará cuando el temporizador se dispare. A fun se le pasa 1 argumento, el objeto temporizador. Si fun es None entonces el callback se deshabilitará.

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

Si solo se pasa un número de canal, entonces se devuelve un objeto de canal previamente inicializado (o None si no hay ningún canal previo).

De lo contrario, se inicializa y devuelve un objeto TimerChannel.

Cada canal se puede configurar para realizar pwm, comparación de salida (output compare) o captura de entrada (input capture). Todos los canales comparten el mismo temporizador subyacente, lo que significa que comparten el mismo reloj de temporizador.

Argumentos de palabra clave:

mode puede ser uno de:

Timer.PWM — configura el temporizador en modo PWM (activo alto).

Timer.PWM_INVERTED — configura el temporizador en modo PWM (activo bajo).

Timer.OC_TIMING — indica que no se controla ningún pin.

Timer.OC_ACTIVE — el pin se activará cuando ocurra una coincidencia de comparación (lo que es activo se determina por la polaridad)

Timer.OC_INACTIVE — el pin se desactivará cuando ocurra una coincidencia de comparación.

Timer.OC_TOGGLE — el pin se conmutará cuando ocurra una coincidencia de comparación.

Timer.OC_FORCED_ACTIVE — el pin se fuerza a activo (se ignora la coincidencia de comparación).

Timer.OC_FORCED_INACTIVE — el pin se fuerza a inactivo (se ignora la coincidencia de comparación).

Timer.IC — configura el temporizador en modo de captura de entrada (Input Capture).

Timer.ENC_A — configura el temporizador en modo codificador (Encoder). El contador solo cambia cuando cambia CH1.

Timer.ENC_B — configura el temporizador en modo codificador (Encoder). El contador solo cambia cuando cambia CH2.

Timer.ENC_AB — configura el temporizador en modo codificador (Encoder). El contador cambia cuando cambia CH1 o CH2.

callback - según TimerChannel.callback()

pin None (el predeterminado) o un objeto Pin. Si se especifica (y no es None), esto hará que la función alternativa del pin indicado se configure para este canal del temporizador. Se generará un error si el pin no admite ninguna función alternativa para este canal del temporizador.

Argumentos de palabra clave para los modos Timer.PWM:

pulse_width - determina el valor inicial de ancho de pulso a usar.

pulse_width_percent - determina el porcentaje inicial de ancho de pulso a usar.

Argumentos de palabra clave para los modos Timer.OC:

compare - determina el valor inicial del registro de comparación.

polarity puede ser uno de:

Timer.HIGH - la salida es activa alta

Timer.LOW - la salida es activa baja

Argumentos de palabra clave opcionales para los modos Timer.IC:

polarity puede ser uno de:

Timer.RISING - captura en el flanco ascendente.

Timer.FALLING - captura en el flanco descendente.

Timer.BOTH - captura en ambos flancos.

Ten en cuenta que la captura solo funciona en el canal principal, y no en los canales complementarios.

Notas para los modos Timer.ENC:

Requiere 2 pines, por lo que uno o ambos pines deberán configurarse para usar la AF de temporizador apropiada mediante la API de Pin.

Lee el valor del codificador usando el método timer.counter().

Solo funciona en CH1 y CH2 (y no en CH1N o CH2N)

El número de canal se ignora al establecer el modo codificador.

Ejemplo de PWM – en cada OpenMV Cam con STM32, los canales 1 y 2 de TIM4 están enrutados a los pines de cabecera P7 y P8 respectivamente:

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¶: Obtiene o establece el contador del temporizador.

freq(value: int | float | None = None) → int | float | None¶: Obtiene o establece la frecuencia del temporizador (cambia el preescalador y el período si se establece).

period(value: int | None = None) → int | None¶: Obtiene o establece el período del temporizador.

prescaler(value: int | None = None) → int | None¶: Obtiene o establece el preescalador del temporizador.

source_freq() → int¶: Obtiene la frecuencia de la fuente del temporizador.

Constantes¶

Constantes de modo de contador (argumento mode de init()):

UP: int¶: Cuenta desde 0 hasta ARR (el modo predeterminado).

DOWN: int¶: Cuenta desde ARR hasta 0.

CENTER: int¶: Cuenta desde 0 hasta ARR y luego de vuelta hasta 0.

Constantes de modo de corte (argumento brk de init()):

BRK_OFF: int¶: La entrada de corte está deshabilitada.

BRK_LOW: int¶: La entrada de corte es activa baja.

BRK_HIGH: int¶: La entrada de corte es activa alta.

Constantes de modo de canal (argumento mode de channel()):

PWM: int¶: Configura el canal para salida PWM (activo alto).

PWM_INVERTED: int¶: Configura el canal para salida PWM (activo bajo).

OC_TIMING: int¶: Modo de temporización de comparación de salida; no se controla ningún pin.

OC_ACTIVE: int¶: Modo activo de comparación de salida; el pin se activa al producirse una coincidencia de comparación.

OC_INACTIVE: int¶: Modo inactivo de comparación de salida; el pin se desactiva al producirse una coincidencia de comparación.

OC_TOGGLE: int¶: Modo de conmutación de comparación de salida; el pin se conmuta al producirse una coincidencia de comparación.

OC_FORCED_ACTIVE: int¶: Modo de comparación de salida forzado a activo; el pin se fuerza a activo y se ignora la coincidencia de comparación.

OC_FORCED_INACTIVE: int¶: Modo de comparación de salida forzado a inactivo; el pin se fuerza a inactivo y se ignora la coincidencia de comparación.

IC: int¶: Configura el canal para el modo de captura de entrada.

ENC_A: int¶: Modo codificador: el contador solo cambia cuando cambia CH1.

ENC_B: int¶: Modo codificador: el contador solo cambia cuando cambia CH2.

ENC_AB: int¶: Modo codificador: el contador cambia cada vez que cambia CH1 o CH2.

Polaridad de comparación de salida (argumento polarity de channel() en los modos OC):

HIGH: int¶: La salida es activa alta.

LOW: int¶: La salida es activa baja.

Polaridad de captura de entrada (argumento polarity de channel() en el modo IC):

RISING: int¶: Captura en el flanco ascendente.

FALLING: int¶: Captura en el flanco descendente.

BOTH: int¶: Captura en cualquiera de los flancos.