Interrupções de comparação do Timer1

No tutorial anterior, o loop consultava a flag de comparação do Timer1 e decidia o que fazer. Agora a comparação pode solicitar um atendimento automático: uma interrupção.

Quando o evento é aceito para atendimento, o processador desvia temporariamente do ponto atual do programa para uma rotina curta chamada ISR (Interrupt Service Routine, ou rotina de serviço de interrupção). Ao terminar essa rotina, ele retorna ao fluxo principal exatamente para continuar o trabalho interrompido.

A comparação do Timer1 é um evento de hardware: ela acontece quando o contador alcança o valor configurado, independentemente da instrução que o programa está executando naquele instante.

O atendimento pela ISR vem depois. Entre o evento e o começo da rotina pode haver um pequeno atraso, pois o processador conclui a instrução em andamento antes de desviar. Portanto, evento de comparação e primeira instrução da ISR não são necessariamente o mesmo instante.

Organize a sequência típica após uma comparação do Timer1.

Nesta etapa, guarde este modelo mental:

• O Timer1 produz uma comparação.
• O processador pode desviar para atendê-la por uma ISR.
• Enquanto a ISR executa, o trecho principal fica suspenso.
• Ao final, a execução principal é retomada.

Nos próximos passos, você verá quais condições permitem esse atendimento e qual rotina corresponde especificamente à comparação A do Timer1.

No step anterior, a comparação do Timer1 foi apresentada como um evento que pode desviar temporariamente o processador para uma ISR. Para esse desvio ocorrer, não basta a comparação acontecer: duas permissões precisam estar ativas.

• Habilitação global de interrupções: permite que o processador aceite interrupções em geral.
• Máscara específica do evento: permite o atendimento daquela fonte, neste caso a comparação A do Timer1.

No núcleo Arduino AVR do Uno R3, a habilitação global já está ativa antes de setup() começar. Mesmo assim, a máscara específica do Timer1 continua desabilitada até o seu programa ativá-la.

Para a comparação do canal A do Timer1, use esta associação no ATmega328P:

• OCF1A, em TIFR1: flag que indica que ocorreu a comparação A.
• OCIE1A, em TIMSK1: máscara que autoriza o atendimento por interrupção desse evento.
• TIMER1_COMPA_vect: vetor que identifica a rotina destinada à comparação A.

A flag responde “o evento aconteceu?”. A máscara responde “este evento pode interromper?”. O vetor responde “qual rotina será executada?”.

Os nomes parecidos ajudam a lembrar a relação: OCF1A é a flag, OCIE1A é a habilitação da interrupção e COMPA identifica o canal A no vetor.

Se OCIE1A estiver desabilitado, a comparação A deixa de acontecer?

A rotina não é chamada pelo seu código

No exemplo anterior, loop() consultava a flag de comparação. Agora, quando a comparação A for atendida, o processador desvia temporariamente para uma rotina de serviço de interrupção (ISR).

A macro ISR(...), disponível em avr/interrupt.h, associa o corpo da rotina diretamente ao vetor TIMER1_COMPA_vect. Portanto, a ISR fica fora de setup() e de loop() e não deve ser chamada como uma função comum.

Nesta aplicação, ela terá uma única responsabilidade: alternar o LED integrado, ligado a PB5 (D13).

Código mínimo da ISR

Inclua os cabeçalhos para os nomes dos registradores, bits e vetores AVR. A declaração ISR(TIMER1_COMPA_vect) define a rotina que o hardware executará no atendimento da comparação A.

A escrita de 1 no bit PB5 de PINB alterna o bit correspondente de PORTB; como PB5 será preparado como saída, isso alterna o LED integrado. Não use delay(), laços de espera ou operações longas aqui.

Também não há variável da aplicação acessada tanto por ISR quanto por loop() neste exemplo. Essa troca de dados exige cuidados próprios e será tratada no próximo tutorial.

A ISR já foi definida; agora importa quando ela pode começar a executar. Durante a inicialização, mantenha o Timer1 parado e sua interrupção de comparação A desabilitada. Assim, o periférico continua reservado à aplicação, mas nenhum atendimento ocorre enquanto registradores e pinos ainda estão sendo preparados.

A ordem segura é: preparar o LED e o Timer1 em CTC, limpar uma possível pendência, iniciar o clock do temporizador e, por último, permitir o atendimento com OCIE1A.

Use a configuração de referência já calculada: clock de 16 MHz, prescaler de 256 e OCR1A = 31249. Em CTC, ela produz uma comparação A a cada 500 ms.

TCCR1A e TCCR1B começam em zero: as saídas de comparação ficam desconectadas e não há clock para o Timer1. A configuração WGM12 seleciona CTC; CS12 inicia o clock com prescaler 256. Como COM1A e COM1B permanecem em zero, o Timer1 não assume o controle de pinos de saída.

Sketch mínimo para observar a ordem de inicialização. A ISR pode ficar acima ou abaixo de setup(), mas não é chamada diretamente.

Uma comparação pode ter ocorrido antes ou durante a preparação. Nesse caso, OCF1A pode estar pendente. Ao escrever 1 nesse bit de TIFR1, a pendência é descartada antes de permitir o atendimento.

Se OCIE1A fosse habilitado cedo demais, com a flag pendente e as interrupções globais já ativas no núcleo Arduino, a ISR poderia iniciar no meio da configuração. Ela poderia alternar PB5 antes de PB5 ser saída ou antes de o Timer1 estar na condição planejada.

Iniciar o clock antes da máscara é seguro: uma comparação futura apenas deixa a flag pendente até que a máscara seja habilitada.

Organize as ações na sequência segura. Considere que preparar o Timer1 inclui zerar TCNT1, carregar OCR1A = 31249 e selecionar CTC sem ainda escolher o clock.

Agora complete as duas ações finais: primeiro o clock com prescaler 256 e depois a máscara da comparação A.

Em uma ISR normal do AVR, o processador atende a rotina e só depois retorna ao ponto em que interrompeu o programa. Enquanto ela executa, as interrupções ficam globalmente desabilitadas nesta aplicação: não há aninhamento.

Um evento de hardware ainda pode acontecer nesse intervalo e sua flag pode ficar pendente, mas o atendimento correspondente espera a ISR atual terminar. Portanto, interrupção não cria execução simultânea: ela apenas troca temporariamente qual trecho o único processador está executando.

Uma ISR não acelera uma tarefa longa nem a executa em paralelo ao loop(). Ela interrompe o fluxo principal, executa uma ação curta e retorna.

Para esta aplicação, a rotina deve apenas alternar PB5. Esperas, laços que aguardam algo e operações demoradas ficam fora dela. Assim, o loop() continua responsável por suas atividades, e os demais atendimentos não ficam bloqueados por uma ISR extensa.

Monte a segunda sinalização com a placa desenergizada: conecte D7 → resistor de 1 kΩ → ânodo do LED; conecte o cátodo (terminal mais curto ou lado achatado) ao GND. Depois, alimente o Uno R3 somente pelo cabo USB de dados conectado ao computador.

O LED integrado em D13 não precisa de montagem externa. Nesta prática, ele será alternado pela ISR do Timer1; o LED externo em D7 será controlado exclusivamente pelo loop() usando millis().

Copie o sketch completo para a IDE Arduino, selecione Arduino Uno e a porta correta, depois grave na sua placa. Não acrescente bibliotecas que usem o Timer1.

A ISR só escreve em PINB para alternar PB5/D13. O loop() mantém seu próprio estado e sua própria marca de tempo para D7. Não há consulta a OCF1A no loop() e não há variável compartilhada entre os dois fluxos.

Sketch completo para o Uno R3

Complete o nome do vetor que liga a ISR ao evento de comparação A do Timer1. A rotina não é chamada pelo loop(); o hardware a atende quando a comparação habilitada ocorre.

Após gravar o sketch, observe os dois LEDs por alguns segundos. O LED integrado D13 deve mudar de estado a cada comparação, aproximadamente a cada 500 ms; por isso, seu ciclo completo fica perto de 1 s. O LED externo em D7 muda de estado aproximadamente a cada 200 ms, com ciclo completo perto de 400 ms.

As duas cadências não significam que o processador executa ISR e loop() simultaneamente: a ISR é breve, termina e o processador retoma o loop().

A cadeia desta aplicação é: a comparação A do Timer1 ocorre, OCF1A indica o evento, a máscara OCIE1A e as interrupções globais permitem o atendimento, e o vetor TIMER1_COMPA_vect leva à ISR. A rotina alterna somente D13 e termina; então o processador retoma o ponto em que o loop() foi interrompido.

Isso não é execução simultânea: é uma troca rápida e temporária de fluxo. Como D7 é controlado apenas pelo loop(), sua cadência pode mudar sem alterar a ISR nem a configuração do Timer1.

Na IDE Arduino do seu computador, abra o sketch da prática anterior. Altere somente o intervalo usado pelo loop() para alternar D7: de 200 ms para 800 ms.

Não modifique OCR1A, os registradores do Timer1, TIMSK1 nem o corpo da ISR. Mantenha a verificação temporal não bloqueante: ela precisa continuar usando a comparação de tempo decorrido, sem delay().

Grave o sketch no seu Uno R3. O LED externo em D7 deve completar um ciclo em aproximadamente 1,6 s, pois alterna a cada 800 ms. O LED integrado em D13 continua alternando a cada 500 ms, com ciclo aproximado de 1 s.

Complete as duas partes que preservam a separação da aplicação: o intervalo de D7 e a máscara que habilita a comparação A do Timer1.