classe Timer – controla os timers internos¶

Os timers podem ser usados para uma grande variedade de tarefas. No momento, apenas o caso mais simples está implementado: o de chamar uma função periodicamente.

Cada timer consiste em um contador que conta de forma crescente a uma determinada taxa. A taxa na qual ele conta é a frequência do clock do periférico (em Hz) dividida pelo prescaler do timer. Quando o contador alcança o período do timer, ele dispara um evento e o contador retorna a zero. Usando o método callback, o evento do timer pode chamar uma função Python.

Exemplo de uso para alternar um LED a uma frequência fixa:

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

Exemplo usando uma função nomeada para o 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

Outros exemplos:

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: O Timer(1) é usado pela câmera. De forma semelhante, o Timer(5) controla o driver do servo, e o Timer(6) é usado para leitura/escrita temporizada do ADC/DAC. Recomenda-se usar os demais timers em seus programas.

Nota: Não é possível alocar memória durante um callback (uma interrupção) e, portanto, as exceções levantadas dentro de um callback não fornecem muitas informações. Veja micropython.alloc_emergency_exception_buf() para saber como contornar essa limitação.

Construtores¶

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

Constrói um novo objeto timer com o id fornecido. Se argumentos adicionais forem fornecidos, então o timer é inicializado por init(...). O conjunto de valores válidos para id depende do MCU STM32 da OpenMV Cam em uso; consulte o manual de referência do STM32 para conhecer os timers de propósito geral e de controle avançado disponíveis.

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 o timer. A inicialização deve ser feita por frequência (em Hz) ou por prescaler e 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 nomeados:

freq — especifica a frequência periódica do timer. Você também pode encarar isso como a frequência com que o timer percorre um ciclo completo.

prescaler [0-0xffff] - especifica o valor a ser carregado no Registrador de Prescaler (PSC) do timer. A fonte de clock do timer é dividida por (prescaler + 1) para derivar o clock do timer. A fonte de clock provém do barramento APB pai do timer e é dependente do MCU. No STM32, os timers no APB1 normalmente operam a 2 * pclk1 e os timers no APB2 a 2 * pclk2; leia as frequências atuais dos barramentos com pyb.freq() e consulte o manual de referência do STM32 para o MCU da sua OpenMV Cam.

period [0-0xffff] para os timers 1, 3, 4 e 6-15. [0-0x3fffffff] para os timers 2 e 5. Especifica o valor a ser carregado no Registrador de AutoReload (ARR) do timer. Isso determina o período do timer (ou seja, quando o contador completa o ciclo). O contador do timer fará o roll-over após period + 1 ciclos de clock do timer.

mode pode ser um dos seguintes:

Timer.UP - configura o timer para contar de 0 até ARR (padrão)

Timer.DOWN - configura o timer para contar de ARR de forma decrescente até 0.

Timer.CENTER - configura o timer para contar de 0 até ARR e então de volta até 0.

div pode ser 1, 2 ou 4. Divide o clock do timer para determinar o clock de amostragem usado pelos filtros digitais.

callback - conforme Timer.callback()

deadtime - especifica a quantidade de tempo “morto” ou inativo entre transições em canais complementares (ambos os canais ficarão inativos durante esse tempo). deadtime pode ser um inteiro entre 0 e 1008, com as seguintes restrições: 0-128 em passos de 1, 128-256 em passos de 2, 256-512 em passos de 8 e 512-1008 em passos de 16. deadtime mede ticks de source_freq divididos por div ticks de clock. deadtime está disponível apenas nos timers 1 e 8.

brk - especifica se o modo de break é usado para anular a saída do PWM quando a entrada BRK_IN é acionada. O valor desse argumento determina se o break está habilitado e qual é a polaridade, podendo ser Timer.BRK_OFF, Timer.BRK_LOW ou Timer.BRK_HIGH. Para selecionar o pino BRK_IN, construa um objeto Pin com mode=Pin.ALT, alt=Pin.AFn_TIMx. Os recursos de entrada GPIO do pino ficam disponíveis no modo alt - pull= , value() e irq().

hard pode ser um dos seguintes:

True - O callback será executado em contexto de interrupção de hardware (hard interrupt), o que minimiza atraso e jitter, mas está sujeito às limitações descritas em Escrevendo manipuladores de interrupção, incluindo a impossibilidade de alocar no heap.

False - O callback será agendado como uma interrupção de software (soft interrupt), permitindo que ele aloque, mas possivelmente introduzindo também atrasos e jitter da coleta de lixo.

O valor padrão dessa opção é True.

Você deve especificar freq ou ambos period e prescaler.

deinit() → None¶

Desinicializa o timer.

Desabilita o callback (e a irq associada).

Desabilita quaisquer callbacks de canal (e a irq associada). Para o timer e desabilita o periférico do timer.

callback(fun: Callable[[Timer], None] | None) → None¶: Define a função a ser chamada quando o timer disparar. fun recebe 1 argumento, o objeto timer. Se fun for None então o callback será desabilitado.

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

Se apenas um número de canal for passado, então um objeto de canal previamente inicializado é retornado (ou None se não houver canal anterior).

Caso contrário, um objeto TimerChannel é inicializado e retornado.

Cada canal pode ser configurado para executar pwm, comparação de saída (output compare) ou captura de entrada (input capture). Todos os canais compartilham o mesmo timer subjacente, o que significa que compartilham o mesmo clock do timer.

Argumentos nomeados:

mode pode ser um dos seguintes:

Timer.PWM — configura o timer no modo PWM (ativo em nível alto).

Timer.PWM_INVERTED — configura o timer no modo PWM (ativo em nível baixo).

Timer.OC_TIMING — indica que nenhum pino é acionado.

Timer.OC_ACTIVE — o pino se tornará ativo quando ocorrer uma correspondência de comparação (o estado ativo é determinado pela polaridade)

Timer.OC_INACTIVE — o pino se tornará inativo quando ocorrer uma correspondência de comparação.

Timer.OC_TOGGLE — o pino será alternado quando ocorrer uma correspondência de comparação.

Timer.OC_FORCED_ACTIVE — o pino é forçado a ativo (a correspondência de comparação é ignorada).

Timer.OC_FORCED_INACTIVE — o pino é forçado a inativo (a correspondência de comparação é ignorada).

Timer.IC — configura o timer no modo de captura de entrada (Input Capture).

Timer.ENC_A — configura o timer no modo Encoder. O contador só muda quando CH1 muda.

Timer.ENC_B — configura o timer no modo Encoder. O contador só muda quando CH2 muda.

Timer.ENC_AB — configura o timer no modo Encoder. O contador muda quando CH1 ou CH2 muda.

callback - conforme TimerChannel.callback()

pin None (o padrão) ou um objeto Pin. Se especificado (e não None), isso fará com que a função alternativa do pino indicado seja configurada para este canal do timer. Um erro será levantado se o pino não suportar nenhuma função alternativa para este canal do timer.

Argumentos nomeados para os modos Timer.PWM:

pulse_width - determina o valor inicial de largura de pulso a ser usado.

pulse_width_percent - determina a porcentagem inicial de largura de pulso a ser usada.

Argumentos nomeados para os modos Timer.OC:

compare - determina o valor inicial do registrador de comparação.

polarity pode ser um dos seguintes:

Timer.HIGH - a saída é ativa em nível alto

Timer.LOW - a saída é ativa em nível baixo

Argumentos nomeados opcionais para os modos Timer.IC:

polarity pode ser um dos seguintes:

Timer.RISING - captura na borda de subida.

Timer.FALLING - captura na borda de descida.

Timer.BOTH - captura em ambas as bordas.

Observe que a captura só funciona no canal primário, e não nos canais complementares.

Notas para os modos Timer.ENC:

Requer 2 pinos, de modo que um ou ambos os pinos precisarão ser configurados para usar a AF apropriada do timer por meio da API Pin.

Leia o valor do encoder usando o método timer.counter().

Funciona apenas em CH1 e CH2 (e não em CH1N ou CH2N)

O número do canal é ignorado ao definir o modo encoder.

Exemplo de PWM – em toda OpenMV Cam STM32, os canais 1 e 2 do TIM4 são roteados para os pinos de header P7 e 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¶: Obtém ou define o contador do timer.

freq(value: int | float | None = None) → int | float | None¶: Obtém ou define a frequência do timer (altera o prescaler e o período se definida).

period(value: int | None = None) → int | None¶: Obtém ou define o período do timer.

prescaler(value: int | None = None) → int | None¶: Obtém ou define o prescaler do timer.

source_freq() → int¶: Obtém a frequência da fonte do timer.

Constantes¶

Constantes do modo de contagem (argumento mode de init()):

UP: int¶: Conta de 0 até ARR (o modo padrão).

DOWN: int¶: Conta de ARR de forma decrescente até 0.

CENTER: int¶: Conta de 0 até ARR e então de volta até 0.

Constantes do modo de break (argumento brk de init()):

BRK_OFF: int¶: A entrada de break está desabilitada.

BRK_LOW: int¶: A entrada de break é ativa em nível baixo.

BRK_HIGH: int¶: A entrada de break é ativa em nível alto.

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

PWM: int¶: Configura o canal para saída PWM (ativo em nível alto).

PWM_INVERTED: int¶: Configura o canal para saída PWM (ativo em nível baixo).

OC_TIMING: int¶: Modo de temporização de comparação de saída; nenhum pino é acionado.

OC_ACTIVE: int¶: Modo ativo de comparação de saída; o pino se torna ativo na correspondência de comparação.

OC_INACTIVE: int¶: Modo inativo de comparação de saída; o pino se torna inativo na correspondência de comparação.

OC_TOGGLE: int¶: Modo de alternância de comparação de saída; o pino alterna na correspondência de comparação.

OC_FORCED_ACTIVE: int¶: Modo de comparação de saída forçado-ativo; o pino é forçado a ativo e a correspondência de comparação é ignorada.

OC_FORCED_INACTIVE: int¶: Modo de comparação de saída forçado-inativo; o pino é forçado a inativo e a correspondência de comparação é ignorada.

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

ENC_A: int¶: Modo encoder: o contador só muda quando CH1 muda.

ENC_B: int¶: Modo encoder: o contador só muda quando CH2 muda.

ENC_AB: int¶: Modo encoder: o contador muda sempre que CH1 ou CH2 muda.

Polaridade da comparação de saída (argumento polarity de channel() nos modos OC):

HIGH: int¶: A saída é ativa em nível alto.

LOW: int¶: A saída é ativa em nível baixo.

Polaridade da captura de entrada (argumento polarity de channel() no modo IC):

RISING: int¶: Captura na borda de subida.

FALLING: int¶: Captura na borda de descida.

BOTH: int¶: Captura em qualquer uma das bordas.