Sistemas Embarcados

CONTROLE DE INTERRUPÇÕES
COM ATMEGA328

Luis Claudio
 Definição
● Em nível de hardware, uma interrupção é um sinal de algum
dispositivo ou software que indica à CPU quando interromper o
processo que está executando e passe a executar um outro
processo.

● Por exemplo, isso ocorre quando uma tecla é acionada , o

programa que está em execução (processo) no processador é
interrompido e um novo processo é executado para tratar a tecla
pressionada.
 Interrupções no Arduino
● Nos Atmega’s, não são todos os pinos que podem receber
uma interrupção; no Arduino Uno, por exemplo, são
permitidos interrupções apenas nos pinos 2 e 3.
 Interrupt Service Routines - ISR
● Os ISRs são tipos especiais de funções que possuem algumas limitações únicas que a maioria das outras funções não
possuem. Um ISR não pode ter parâmetros, e eles não devem retornar nada.

● Geralmente, um ISR deve ser tão curto e rápido quanto possível. Se um programa tem vários ISRs , apenas um
pode ser executado de cada vez, outras interrupções serão executadas depois que o atual terminar em uma ordem que
depende da prioridade que eles possuem.

● Variáveis tipicamente globais são usadas para passar dados entre um ISR e o programa principal. Para garantir que as
variáveis compartilhadas entre um ISR e o programa principal sejam atualizadas corretamente, declare-as como
volatile (diretiva de compilação que instrui o compilador a carregar a variável direto da RAM, ao invés de um
registrador; é usada quando o seu valor pode ser mudado por algo além do controle da seção de código na qual ela
pertence, como uma thread paralela - https://www.arduino.cc/en/pmwiki.php?n=Reference/Volatile).

● Obs:
– Em Ansi C, uma variável volatile pode ter seu conteúdo alterado (via ponteiro) por comandos que fazem parte de
outros programas, sem otimização do compilador; esta diretiva pode ser usada para definir endereços de memória
associados a periféricos físicos, cujo valor pode mudar independente do programa (um teclado ou porta serial, por
exemplo)
– Dentro da função que será chamada na interrupção, a função delay() não funcionará (pois depende de interrupções)
e a função millis() não será incrementada
– delayMicroseconds() não usa nenhum contador, portanto ela funcionará normalmente durante uma interrupçao
– (https://www.arduino.cc/reference/pt/language/functions/external-interrupts/attachinterrupt/)
 Sintaxe
attachInterrupt (digitalPinToInterrupt (pino), ISR, modo); // recomendado

attachInterrupt (interrupção, ISR, modo); // não recomendado

attachInterrupt (pino, ISR, modo); // Não recomendado para Arduino

// Due, Zero, MKR1000, 101

● pino: o número do pino conectado (no Arduino Uno só poderá ser os pinos 2 e 3);
● ISR: o ISR para ligar quando ocorrer a interrupção; Esta função não deve ter
parâmetros e não devolve nada (void).
● modo: define quando a interrupção deve ser acionada. Quatro constantes são
predefinidas como valores válidos: LOW, HIGH, CHANGE, RISING, FALLING.
 Modos (triggers)
● LOW: dispara a interrupção sempre que o pino tiver nível baixo;
● HIGH: dispara a interrupção sempre que o pino tiver nível alto;
● CHANGE: dispara a interrupção quando houver mudança no estado do
pino;
● RISING: dispara a interrupção quando o pino tiver uma mudança do estado
LOW para HIGH, apenas;
● FALLING: dispara a interrupção quando o pino tiver uma mudança do
estado HIGH para LOW, apenas;
Exemplo:
Implementar um projeto que
acione em sequência 3 leds e
espere 1 segundo entre cada
acionamento.

Um botão deverá parar a

sequência imediatamente e
acionar os três leds
simultâneamente.
CÓDIGO SEM INTERRUPÇÃO
const int ledVermelho = 13;
const int ledAmarelo = 12;
const int ledVerde = 11;
const int chave = 2;
void setup() {
pinMode(chave, INPUT);
pinMode(ledVermelho, OUTPUT);
pinMode(ledAmarelo, OUTPUT);
pinMode(ledVerde, OUTPUT);
} digitalWrite(ledAmarelo,HIGH);
void loop() {
digitalWrite(ledVermelho,HIGH);
digitalWrite(ledAmarelo,LOW);
digitalWrite(ledVerde,LOW);
delay(1000);
digitalWrite(ledVermelho,LOW);
digitalWrite(ledAmarelo,HIGH);
digitalWrite(ledVerde,LOW);
delay(1000);
digitalWrite(ledVermelho,LOW);
digitalWrite(ledAmarelo,LOW);
digitalWrite(ledVerde,HIGH);
delay(1000);
if (digitalRead(chave)==HIGH) {
digitalWrite(ledVermelho,HIGH);
digitalWrite(ledVerde,HIGH);
delay(1000);
}
}
 CÓDIGO COM INTERRUPÇÃO

volatile const int ledVermelho = 13; digitalWrite(ledVermelho,LOW);

volatile const int ledAmarelo = 12; digitalWrite(ledAmarelo,HIGH);
volatile const int ledVerde = 11; digitalWrite(ledVerde,LOW);
delay(1000);
const int chave = 2; digitalWrite(ledVermelho,LOW);
digitalWrite(ledAmarelo,LOW);
void setup() { digitalWrite(ledVerde,HIGH);
pinMode(chave, INPUT); delay(1000);
pinMode(ledVermelho, OUTPUT); }
pinMode(ledAmarelo, OUTPUT);
pinMode(ledVerde, OUTPUT); void leds() {
digitalWrite(ledVermelho,HIGH);
attachInterrupt(digitalPinToInterrupt(chave), leds, digitalWrite(ledAmarelo,HIGH);
HIGH); digitalWrite(ledVerde,HIGH);
} delayMicroseconds(1000);
}
void loop() {
digitalWrite(ledVermelho,HIGH);
digitalWrite(ledAmarelo,LOW);
digitalWrite(ledVerde,LOW);
delay(1000);