As interrupções internas são habilitadas por eventos inerentes ao funcionamento do microcontrolador. No caso do ATMega 328P, as interrupções por estouro dos timers são as mais comuns e fáceis de programar. Considere o TIMER0, que é um contador de 8 bits. Programe uma rotina de interrupção pelo TIMER0 que forneça uma base de tempo de 1 segundo.

Passo 1

Beleza, vamos lá! O exercício pede para programar uma rotina de interrupção usando o TIMER0 do microcontrolador ATMega328P, de forma que ele gere um intervalo de 1 segundo. A matéria envolvida aqui é a manipulação de interrupções e timers em microcontroladores. Para resolver isso, vamos precisar entender como configurar o TIMER0, calcular os valores certos para o temporizador e programar a rotina de interrupção.

Passo 2

Primeiro, precisamos saber que o TIMER0 no ATMega328P é um contador de 8 bits, o que significa que ele pode contar de 0 até 255. Também precisamos considerar a frequência do relógio do microcontrolador, que geralmente é de 16 MHz no Arduino Uno. Com essa informação, podemos calcular quanto tempo leva para o TIMER0 estourar (ou overflowar).

Passo 3

A fórmula para calcular o tempo de overflow é:
Tempo de Overflow = Presca<=r times (Valor Máximo + 1)Frequência do Clock áê
Onde:
  • Prescaler é o divisor de frequência aplicado ao timer.
  • Valor Máximo é 255, já que o TIMER0 é de 8 bits.
  • Frequência do Clock é 16 MHz.

Passo 4

Queremos que o tempo total chegue a 1 segundo. Para isso, podemos usar o prescaler para ajustar nosso cálculo. Com valores comuns de prescaler como 64, 256 ou 1024, vamos escolher 1024 para facilitar o cálculo:
Tempo de Overflow = 1024 times (255 + 1)16,000,000 = 1024 times 25616,000,000 = 26214416,000,000 = 0,016384, segundos
Isso significa que o TIMER0 estoura a cada aproximadamente 16,384 milissegundos.

Passo 5

Para chegar a 1 segundo, precisamos que o overflow aconteça várias vezes. Calculamos quantas vezes isso ocorre em 1 segundo:
10,016384 approx 61, vezes
Então, precisamos contar 61 interrupções para chegar a aproximadamente 1 segundo.

Passo 6

Agora, vamos programar a configuração do TIMER0 com o prescaler de 1024 e habilitar a interrupção de overflow. Também precisamos criar uma variável para contar o número de interrupções e executar a ação desejada quando chegar a 61.

Passo 7

Segue um exemplo de código em C para o ATMega328P:
#include <avr/io.h>
#include <avr/interrupt.h>

volatile unsigned int contador = 0;

int main(void) {
    // Configura o TIMER0 para o modo normal
    TCCR0A = 0x00;
    
    // Define o prescaler para 1024
    TCCR0B |= (1 << CS02) | (1 << CS00);
    
    // Habilita a interrupção de overflow do TIMER0
    TIMSK0 |= (1 << TOIE0);
    
    // Habilita as interrupções globais
    sei();
    
    while(1) {
        // Loop principal vazio
    }
}

ISR(TIMER0_OVF_vect) {
    contador++;
    if (contador >= 61) {
        contador = 0;
        // Aqui coloca o que você quer que aconteça a cada 1 segundo
    }
}

Resposta

Prontinho! Com esse código, o TIMER0 do ATMega328P está configurado para gerar uma interrupção a cada 1 segundo. Sempre que o contador chegar a 61 interrupções, ele reinicia e você pode colocar qualquer ação que desejar dentro da condição if. Assim, você consegue uma base de tempo precisa de 1 segundo usando as interrupções internas do microcontrolador.

Exercícios relacionados