Controlando um LED com um AVR - Parte II

Nesta parte vamos ver o software do nosso projeto.

Como ambiente de desenvolvimento vou usar o avr-gcc toolchain que já vimos por aqui (partes 1, 2 e 3).

Existem, é claro, várias maneiras de estruturar o nossa programa. Optei por programar o timer para gerar interrupções a cada aproximadamente 16 milisegundos e colocar toda a lógica dentro do tratamento desta interrupção. Desta forma, na maior parte do tempo o processador estará parado em modo de economia de energia (sleep mode).



Para controlar o botão usei uma variável de tipo unsigned char (byte), onde 1 bit indica o estado do botão na leitura anterior e outro o estado após o debounce. Este segundo bit só é alterado após duas leituras consecutivas iguais.

Uma segunda variável do tipo usnigned char armazena o estado do LED: apagado, aceso continuamente ou piscando. A cada pressionamento do botão o estado muda ciclicamente.

Sem mais delongas, eis o código em C:

view plaincopy to clipboardprint?

1. #include <inttypes.h>  
2. #include <avr/io.h>  
3. #include <avr/interrupt.h>  
4. #include <avr/sleep.h>  
5.   
6. // Bits correspondentes aos pinos de E/S  
7. #define BOTAO   _BV(PD2)  
8. #define LED     _BV(PB0)  
9.   
10. // Valor para contar (aproximadamente) 50ms  
11. #define TEMPO_50MS  3  
12.   
13. // Controle do LED  
14. static enum { APAGADO, ACESO, PISCANDO } ModoLed;  
15.   
16. // Controles do estado do botão  
17. #define BOTAO_ANTERIOR 0x01 // este bit indica o estado anterior  
18. #define BOTAO_APERTADO 0x02 // este bit tem o valor c/ "debounce"  
19. static unsigned char ModoBotao;  
20.   
21. // Programa Principal  
22. int main (void)  
23. {  
24.     // Pino do LED é saída  
25.     DDRB |= LED;  
26.     PORTB = 0;  
27.       
28.     // Pino do Botão é entrada com pullup  
29.     DDRD &= ~BOTAO;  
30.     PORTD |= BOTAO;  
31.   
32.     // Configura o timer 0  
33.     TCCR0A = 0;                       // Modo normal: overflow a cada 256 contagens  
34.     TCCR0B = _BV(CS01) | _BV(CS00);   // Usar clkIO/64: int a cada 64*256/1000 ms  
35.                                       //   = 16,384 ms  
36.     TIMSK = _BV(TOIE0);               // Interromper no overflow  
37.   
38.     // Inicia os nossos controles  
39.     ModoBotao = 0;  
40.     ModoLed = PISCANDO;  
41.       
42.     // Permite interrupções  
43.     sei ();  
44.       
45.     // Loop infinito  
46.     for (;;)  
47.     {  
48.         set_sleep_mode(SLEEP_MODE_IDLE);  
49.         sleep_mode();  
50.     }  
51. }  
52.   
53. // Tratamento da interrupção do timer 0  
54. ISR (TIMER0_OVF_vect)  
55. {  
56.     static unsigned char cnt = TEMPO_50MS;  
57.       
58.     // Aguarda 50 ms  
59.     if (--cnt != 0)  
60.         return;  
61.     cnt = TEMPO_50MS;  
62.       
63.     // Trata o LED  
64.     if (ModoLed == PISCANDO)  
65.         PORTB ^= LED;  
66.       
67.     // Trata o botão  
68.     if ((PIND & BOTAO) == 0)  
69.     {  
70.         // Botao está apertado  
71.         if (ModoBotao & BOTAO_ANTERIOR)  
72.         {  
73.             if ((ModoBotao & BOTAO_APERTADO) == 0)  
74.             {  
75.                 // Acabamos de detectar o aperto  
76.                 ModoBotao |= BOTAO_APERTADO;  
77.                 switch (ModoLed)  
78.                 {  
79.                     case APAGADO:  
80.                         ModoLed = ACESO;  
81.                         PORTB |= LED;  
82.                         break;  
83.                     case ACESO:  
84.                         ModoLed = PISCANDO;  
85.                         break;  
86.                     case PISCANDO:  
87.                         ModoLed = APAGADO;  
88.                         PORTB &= ~LED;  
89.                         break;  
90.                 }  
91.             }  
92.         }  
93.         else  
94.         {  
95.             // Vamos aguardar a confirmação  
96.             ModoBotao |= BOTAO_ANTERIOR;  
97.         }  
98.     }  
99.     else  
100.     {  
101.         if (ModoBotao & BOTAO_ANTERIOR)  
102.             ModoBotao &= ~BOTAO_ANTERIOR;   // aguarda confirmar  
103.         else  
104.             ModoBotao &= ~BOTAO_APERTADO;   // confirmado  
105.     }  
106. }  

#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>

// Bits correspondentes aos pinos de E/S
#define BOTAO   _BV(PD2)
#define LED     _BV(PB0)

// Valor para contar (aproximadamente) 50ms
#define TEMPO_50MS  3

// Controle do LED
static enum { APAGADO, ACESO, PISCANDO } ModoLed;

// Controles do estado do botão
#define BOTAO_ANTERIOR 0x01 // este bit indica o estado anterior
#define BOTAO_APERTADO 0x02 // este bit tem o valor c/ "debounce"
static unsigned char ModoBotao;

// Programa Principal
int main (void)
{
    // Pino do LED é saída
    DDRB |= LED;
    PORTB = 0;
    
    // Pino do Botão é entrada com pullup
    DDRD &= ~BOTAO;
    PORTD |= BOTAO;

    // Configura o timer 0
    TCCR0A = 0;                       // Modo normal: overflow a cada 256 contagens
    TCCR0B = _BV(CS01) | _BV(CS00);   // Usar clkIO/64: int a cada 64*256/1000 ms
                                      //   = 16,384 ms
    TIMSK = _BV(TOIE0);               // Interromper no overflow

    // Inicia os nossos controles
    ModoBotao = 0;
    ModoLed = PISCANDO;
    
    // Permite interrupções
    sei ();
    
    // Loop infinito
    for (;;)
    {
        set_sleep_mode(SLEEP_MODE_IDLE);
        sleep_mode();
    }
}

// Tratamento da interrupção do timer 0
ISR (TIMER0_OVF_vect)
{
    static unsigned char cnt = TEMPO_50MS;
    
    // Aguarda 50 ms
    if (--cnt != 0)
        return;
    cnt = TEMPO_50MS;
    
    // Trata o LED
    if (ModoLed == PISCANDO)
        PORTB ^= LED;
    
    // Trata o botão
    if ((PIND & BOTAO) == 0)
    {
        // Botao está apertado
        if (ModoBotao & BOTAO_ANTERIOR)
        {
            if ((ModoBotao & BOTAO_APERTADO) == 0)
            {
                // Acabamos de detectar o aperto
                ModoBotao |= BOTAO_APERTADO;
                switch (ModoLed)
                {
                    case APAGADO:
                        ModoLed = ACESO;
                        PORTB |= LED;
                        break;
                    case ACESO:
                        ModoLed = PISCANDO;
                        break;
                    case PISCANDO:
                        ModoLed = APAGADO;
                        PORTB &= ~LED;
                        break;
                }
            }
        }
        else
        {
            // Vamos aguardar a confirmação
            ModoBotao |= BOTAO_ANTERIOR;
        }
    }
    else
    {
        if (ModoBotao & BOTAO_ANTERIOR)
            ModoBotao &= ~BOTAO_ANTERIOR;   // aguarda confirmar
        else
            ModoBotao &= ~BOTAO_APERTADO;   // confirmado
    }
}

Alguns comentários sobre o código:

• O include avr/io.h define as constantes relativas ao microcontrolador. O modelo específico é definido nos parâmetros de execução do gcc.
• A iniciação das portas de entrada e saída digital é minimalista, deixando os pinos não usados da forma como eles ficam após um reset.
• Para ligar o pullup interno no pino onde está conectado o botão é necessário colocar em 1 o bit correspondente no registrador PORTx.
• O timer é usado de forma bem simplista. Como a temporização não é crítica, deixei o microcontrolador operando no modo padrão de fábrica, com um clock de 1MHz (oscilador de 8MHz dividido por 8). Este clock é dividido por 64 para gerar uma interrupção a cada 16,384ms. A base de tempo de aproximadamente 50ms corresponde a três interrupções. Uma precisão melhor poderia ser obtida dividindo o clock por um valor menor e contando mais interrupções.
• Durante a maior parte do tempo o processador está no modo IDLE, que para a CPU mas deixa contadores e interrupções funcionando.

 No próximo post vamos ver o circuito montado na protoboard, como compilar o programa e como gravá-lo na Flash.