Técnicas de Controle de Eventos

Aprenda Técnicas de Controle de Eventos em Microcontroladores

Explore diferentes abordagens para gerenciar eventos e tarefas no ATmega328P com simulações interativas e exemplos práticos.

⚡

Interrupções

Resposta imediata a eventos com hardware dedicado

Latência: 2-10 μs Complexidade: Alta

🔄

Event Loop

Verificação contínua de eventos em laço principal

Latência: 100 μs - 10 ms Complexidade: Baixa

🧩

Corrotinas

Multitarefa cooperativa com suspensão voluntária

Latência: 10-100 μs Complexidade: Média

⏰

Timer Scheduling

Escalonamento baseado em temporizadores de hardware

Latência: 1-10 ms Complexidade: Média

🔀

Máquina de Estados

Organização em estados com transições controladas

Latência: Variável Complexidade: Baixa

📊

Comparação

Análise comparativa detalhada de todas as técnicas

Análise Completa Recomendações

⚡

Programação Orientada a Interrupções

Utilize hardware dedicado para resposta imediata a eventos externos e internos

Conceitos Fundamentais

ISR (Interrupt Service Routine): Função executada automaticamente
Vetores de Interrupção: Endereços específicos na memória
Prioridades: Sistema hierárquico de tratamento
Contexto: Salvamento automático de registradores

✅ Vantagens

Resposta rápida (2-10 μs)
Eficiente uso de CPU
Ideal para tempo real
Baixo jitter temporal

❌ Desvantagens

Complexidade de implementação
ISRs devem ser curtas
Debugging mais difícil
Compartilhamento de dados complexo

Simulador de Interrupções

Pino INT0:

LOW

Estado LED:

LED: OFF

Contador:

0

Log de Eventos

                    Código de Exemplo - ATmega328P
                    #include <avr/io.h>
#include <avr/interrupt.h>

#define LED_PIN PB0

volatile uint16_t event_counter = 0;

void setup_interrupt() {
    // Configurar LED como saída
    DDRB |= (1 << LED_PIN);
    
    // Configurar INT0 (PD2) como entrada
    DDRD &= ~(1 << PD2);
    PORTD |= (1 << PD2);  // Pull-up interno
    
    // Configurar INT0 para falling edge
    EICRA |= (1 << ISC01);
    EICRA &= ~(1 << ISC00);
    
    // Habilitar INT0
    EIMSK |= (1 << INT0);
    
    // Habilitar interrupções globais
    sei();
}

// ISR para INT0 - deve ser curta e rápida
ISR(INT0_vect) {
    event_counter++;
    PORTB ^= (1 << LED_PIN);  // Toggle LED
}

int main(void) {
    setup_interrupt();
    
    while (1) {
        // Loop principal pode executar outras tarefas
        // A interrupção funciona independentemente
    }
    
    return 0;
}
                

🔄

Laços de Eventos (Event Loop)

Verificação contínua de estados e flags em laço principal do programa

Funcionamento

O Event Loop verifica continuamente o estado de entradas, flags e variáveis, despachando eventos para funções específicas quando condições são atendidas.

1 Verificar Botões

2 Processar Eventos

3 Delay

Características

Simplicidade de implementação
Código sequencial e intuitivo
Baixo uso de memória
Facilidade de debug

Simulador Event Loop

Botão: Released

LED: OFF

                    Código de Exemplo - Event Loop
                    #include <avr/io.h>
#include <util/delay.h>

#define BUTTON_PIN PB1
#define LED_PIN PB0

void handle_button_events(void) {
    static uint8_t button_pressed_last = 0;
    uint8_t button_pressed_now = !(PINB & (1 << BUTTON_PIN));
    
    // Detectar borda de descida (botão pressionado)
    if (button_pressed_now && !button_pressed_last) {
        PORTB ^= (1 << LED_PIN);  // Toggle LED
        _delay_ms(50);  // Debounce simples
    }
    
    button_pressed_last = button_pressed_now;
}

int main(void) {
    // Configurar pinos
    DDRB |= (1 << LED_PIN);    // LED como saída
    DDRB &= ~(1 << BUTTON_PIN); // Botão como entrada
    PORTB |= (1 << BUTTON_PIN); // Pull-up interno
    
    while (1) {
        // Event Loop principal
        handle_button_events();
        
        // Outras tarefas podem ser adicionadas aqui
        
        _delay_ms(10);  // Controla frequência do loop
    }
    
    return 0;
}
                

🧩

Multitarefa Cooperativa - Corrotinas

Funções que podem pausar e retomar execução permitindo multitarefa sem preempção

Conceito de Corrotinas

Corrotinas são funções especiais que podem suspender sua execução em pontos específicos e retomar posteriormente, mantendo seu estado interno.

Características

Suspensão voluntária: A função decide quando pausar
Estado preservado: Variáveis locais mantidas
Múltiplas instâncias: Várias corrotinas simultâneas
Código sequencial: Lógica natural e legível

Casos de Uso

Protocolos de comunicação
Sequências complexas
Tarefas com delays
State machines elaboradas

Simulador de Corrotinas

LED Blink Coroutine

Idle

ADC Read Coroutine

Idle

Valor ADC: 0

                    Implementação de Corrotinas - ATmega328P
                    // Macros para implementar corrotinas simples
#define crBegin static int state = 0; switch(state) { case 0:
#define crReturn(x) do { state = __LINE__; return x; case __LINE__:; } while (0)
#define crFinish }

// Corrotina para piscar LED
int led_blink_coroutine(void) {
    crBegin;
    
    while (1) {
        PORTB |= (1 << PB0);     // LED ON
        crReturn(1);              // Suspende aqui
        
        _delay_ms(500);
        
        PORTB &= ~(1 << PB0);    // LED OFF
        crReturn(1);              // Suspende aqui
        
        _delay_ms(500);
    }
    
    crFinish;
    return 0;
}

// Corrotina para leitura ADC
int adc_read_coroutine(void) {
    static uint16_t adc_value;
    
    crBegin;
    
    while (1) {
        // Iniciar conversão ADC
        ADCSRA |= (1 << ADSC);
        crReturn(1);
        
        // Aguardar conversão
        while (ADCSRA & (1 << ADSC)) {
            crReturn(1);
        }
        
        adc_value = ADC;
        
        // Processar valor
        if (adc_value > 512) {
            // Ação para valor alto
        }
        
        crReturn(1);
    }
    
    crFinish;
    return 0;
}

int main(void) {
    DDRB |= (1 << PB0);  // LED
    // Configurar ADC...
    
    while (1) {
        led_blink_coroutine();
        adc_read_coroutine();
        _delay_ms(10);
    }
}
                

⏰

Escalonamento Baseado em Temporizadores

Execute tarefas em intervalos precisos usando temporizadores de hardware

Timer Scheduling

Utiliza temporizadores de hardware para gerar interrupções em intervalos regulares, permitindo execução determinística de tarefas.

Benefícios

Precisão temporal alta
Execução determinística
Múltiplas frequências
Ideal para controle

Configuração Típica

TIMER1: 16-bit, alta precisão
CTC Mode: Clear Timer on Compare
Prescaler: Divisão de clock
OCR1A: Valor de comparação

Simulador Timer Scheduling

LED Task (1Hz):

ADC Task (100Hz):

                    Código Timer Scheduling - ATmega328P
                    #include <avr/io.h>
#include <avr/interrupt.h>

volatile uint8_t task_flags = 0;
volatile uint16_t system_ticks = 0;

#define TASK_LED_FLAG    0x01
#define TASK_ADC_FLAG    0x02

// ISR executada a cada 1ms (1kHz)
ISR(TIMER1_COMPA_vect) {
    static uint16_t led_counter = 0;
    static uint8_t adc_counter = 0;
    
    system_ticks++;
    
    // LED Task - 1Hz (a cada 1000ms)
    led_counter++;
    if (led_counter >= 1000) {
        task_flags |= TASK_LED_FLAG;
        led_counter = 0;
    }
    
    // ADC Task - 100Hz (a cada 10ms)
    adc_counter++;
    if (adc_counter >= 10) {
        task_flags |= TASK_ADC_FLAG;
        adc_counter = 0;
    }
}

void setup_timer_scheduler(void) {
    // Configurar Timer1 para CTC mode, 1ms
    TCCR1B |= (1 << WGM12);           // CTC mode
    OCR1A = 1999;                     // Para 1ms com prescaler 8
    TCCR1B |= (1 << CS11);            // Prescaler 8
    TIMSK1 |= (1 << OCIE1A);          // Habilitar interrupção
    sei();                            // Interrupções globais
}

void led_task(void) {
    PORTB ^= (1 << PB0);  // Toggle LED
}

void adc_task(void) {
    // Iniciar conversão ADC
    ADCSRA |= (1 << ADSC);
    while (ADCSRA & (1 << ADSC));  // Aguardar
    
    uint16_t adc_value = ADC;
    // Processar valor...
}

int main(void) {
    DDRB |= (1 << PB0);  // LED output
    setup_timer_scheduler();
    
    while (1) {
        // Verificar e executar tarefas agendadas
        if (task_flags & TASK_LED_FLAG) {
            task_flags &= ~TASK_LED_FLAG;
            led_task();
        }
        
        if (task_flags & TASK_ADC_FLAG) {
            task_flags &= ~TASK_ADC_FLAG;
            adc_task();
        }
        
        // CPU pode entrar em sleep mode aqui
    }
}
                

🔀

Máquinas de Estados

Organize o sistema em estados bem definidos com transições controladas

Conceitos Fundamentais

Máquinas de estados organizam o comportamento do sistema em estados discretos, com transições bem definidas entre eles.

Vantagens

Organização clara do código
Facilidade de manutenção
Fluxo de execução definido
Debug simplificado

Componentes

Estados: Condições do sistema
Transições: Mudanças entre estados
Eventos: Gatilhos para transições
Ações: Executadas em estados

Diagrama de Estados

IDLE Sistema em repouso

→ Botão pressionado

LED_ON LED aceso

→ Timeout ou botão

LED_OFF LED apagado

                    Implementação - Máquina de Estados
                    #include <avr/io.h>
#include <util/delay.h>

// Definição dos estados
typedef enum {
    STATE_IDLE,
    STATE_LED_ON,
    STATE_LED_OFF,
    STATE_BLINK_FAST,
    STATE_BLINK_SLOW
} system_state_t;

// Função para ler botão (com debounce)
uint8_t read_button(void) {
    static uint8_t button_state = 0;
    static uint8_t last_reading = 0;
    static uint16_t debounce_counter = 0;
    
    uint8_t reading = !(PINB & (1 << PB1));
    
    if (reading != last_reading) {
        debounce_counter = 0;
    } else if (debounce_counter < 50) {
        debounce_counter++;
    } else {
        button_state = reading;
    }
    
    last_reading = reading;
    return button_state;
}

int main(void) {
    // Configurar pinos
    DDRB |= (1 << PB0);     // LED como saída
    DDRB &= ~(1 << PB1);    // Botão como entrada
    PORTB |= (1 << PB1);    // Pull-up interno
    
    system_state_t current_state = STATE_IDLE;
    static uint16_t state_timer = 0;
    
    while (1) {
        uint8_t button_pressed = read_button();
        
        switch (current_state) {
            case STATE_IDLE:
                PORTB &= ~(1 << PB0);  // LED OFF
                
                if (button_pressed) {
                    current_state = STATE_LED_ON;
                    state_timer = 0;
                }
                break;
                
            case STATE_LED_ON:
                PORTB |= (1 << PB0);   // LED ON
                state_timer++;
                
                if (button_pressed) {
                    current_state = STATE_BLINK_FAST;
                    state_timer = 0;
                } else if (state_timer > 3000) {  // 3 segundos
                    current_state = STATE_LED_OFF;
                    state_timer = 0;
                }
                break;
                
            case STATE_LED_OFF:
                PORTB &= ~(1 << PB0);  // LED OFF
                state_timer++;
                
                if (button_pressed) {
                    current_state = STATE_BLINK_SLOW;
                    state_timer = 0;
                } else if (state_timer > 2000) {  // 2 segundos
                    current_state = STATE_IDLE;
                }
                break;
                
            case STATE_BLINK_FAST:
                if (state_timer % 200 < 100) {    // 200ms período, 50% duty
                    PORTB |= (1 << PB0);
                } else {
                    PORTB &= ~(1 << PB0);
                }
                
                state_timer++;
                
                if (!button_pressed && state_timer > 100) {
                    current_state = STATE_IDLE;
                }
                break;
                
            case STATE_BLINK_SLOW:
                if (state_timer % 1000 < 500) {   // 1000ms período, 50% duty
                    PORTB |= (1 << PB0);
                } else {
                    PORTB &= ~(1 << PB0);
                }
                
                state_timer++;
                
                if (!button_pressed && state_timer > 500) {
                    current_state = STATE_IDLE;
                }
                break;
        }
        
        _delay_ms(1);  // Base de tempo de 1ms
    }
    
    return 0;
}
                

📊

Análise Comparativa

Compare as diferentes técnicas de controle de eventos e escolha a melhor para seu projeto

Técnica	Latência	Uso CPU	Complexidade	Determinismo	Aplicação Ideal
⚡ Interrupções	2-10 μs	Baixo	Alta	Excelente	Sistemas tempo real crítico
🔄 Event Loop	100 μs - 10 ms	Variável	Baixa	Médio	Interfaces simples
🧩 Corrotinas	10-100 μs	Baixo	Média	Bom	Sistemas complexos multi-tarefa
⏰ Timer	1-10 ms	Baixo	Média	Excelente	Tarefas periódicas precisas
🔀 Estados	Variável	Baixo	Baixa	Bom	Fluxos bem definidos

🎯 Mecanismo de Recomendação

Selecione o tipo de aplicação para receber uma recomendação personalizada:

Matriz de Decisão

📈 Performance Crítica

Escolha: Interrupções

Quando cada microssegundo conta

🎯 Simplicidade

Escolha: Event Loop ou Estados

Prototipagem rápida e debug fácil

🧩 Flexibilidade

Escolha: Corrotinas

Código complexo bem estruturado

⏱️ Precisão Temporal

Escolha: Timer Scheduling

Tarefas periódicas determinísticas