Aprender

Interrupções no Arduino com attachInterrupt()

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: contando apertos de botão com uma interrupçãoao vivo0.000 s 0.00x
Aperte Rodar, depois aperte e solte o botão
A interrupção do pino 2 conta toda borda de descida, incluindo os bounces. Aperte e solte o botão.

Uma interrupção roda uma função sua no instante em que um pino muda, seja lá o que loop() estiver fazendo. Em um Uno, só os pinos 2 e 3 podem fazer isso. Escreva attachInterrupt(digitalPinToInterrupt(2), onPress, FALLING); em setup() e onPress() roda toda vez que o pino 2 cai de HIGH para LOW. Marque como volatile qualquer variável que a função altera.

O circuito acima é um botão no pino 2 e um LED no pino 13, e o sketch conta apertos com uma interrupção. Aperte Rodar e aperte o botão uma vez. O monitor serial imprime "presses: 2", e quando você solta, "presses: 4". A interrupção é tão rápida que pega todos os bounces dos contatos do botão, no aperto e de novo na soltura.

Abaixo está como o attachInterrupt() funciona, os quatro modos, por que o contador precisa de volatile, como debouncar um botão dentro de uma interrupção, e para que as interrupções realmente servem: contar pulsos rápidos demais para consultar por polling.

Quer a versão passo a passo? A aula "Reading a button, and the bounce" percorre isso com checkpoints.

Abrir a aula

attachInterrupt(), parte por parte

attachInterrupt() recebe três coisas. O número da interrupção, que em um Uno é 0 para o pino 2 e 1 para o pino 3; sempre obtenha com digitalPinToInterrupt(pino) em vez de escrever o número. A função a rodar, chamada de handler ou ISR, que não recebe nada e não retorna nada. E o modo, que diz a qual mudança do pino reagir.

O sketch abaixo é o menor exemplo útil. Ele conta bordas de descida no pino 2 e imprime a contagem uma vez por segundo. Com um botão ideal que não sofre bounce, um aperto imprimiu 0 e depois 1. Com o botão comum do simulador, que sofre bounce, o mesmo aperto e soltura imprimiu 0 e depois 4.

Conte bordas de descida no pino 2
const int BUTTON = 2;

volatile int presses = 0;

void onPress() {
  presses++;
}

void setup() {
  Serial.begin(9600);
  pinMode(BUTTON, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(BUTTON), onPress, FALLING);
}

void loop() {
  Serial.println(presses);
  delay(1000);
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

FALLING, RISING, CHANGE e LOW

FALLING roda o handler quando o pino vai de HIGH para LOW, que para um botão em INPUT_PULLUP é o aperto. RISING é LOW para HIGH, a soltura. CHANGE é os dois. LOW roda repetidamente enquanto o pino estiver baixo.

Um aperto e soltura do botão com bounce contou 4 com FALLING, 4 com RISING e 8 com CHANGE, já que cada bounce é uma descida e uma subida. LOW rodou o handler 16042 vezes durante uma pressão de um décimo de segundo. LOW é para chips que mantêm uma linha de alarme baixa até você atendê-los, não para botões.

Por que a variável precisa ser volatile

O compilador não sabe que um handler pode rodar entre duas linhas quaisquer de loop(). No sketch abaixo, setup() espera em um loop até pressed virar true. Sem volatile, o compilador lê pressed uma vez, vê que nada no loop a altera, e repete para sempre. Apertamos o botão: imprimiu "waiting for the button" e nada mais, nunca.

Mude a primeira linha para volatile bool pressed = false; e o mesmo aperto imprimiu "pressed!". volatile diz ao compilador para ler a variável do zero toda vez. Toda variável que um handler compartilha com o resto do sketch precisa disso.

Uma variável maior que um byte, como um int ou um unsigned long, precisa de um passo a mais. O Uno move um byte por vez, então o handler pode alterá-la no meio de uma leitura de loop(). Copie-a com as interrupções desligadas, como o contador de pulsos mais abaixo faz: noInterrupts(); copy = count; interrupts();.

Uma flag sem volatile
const int BUTTON = 2;

bool pressed = false;  // needs to be volatile

void onPress() {
  pressed = true;
}

void setup() {
  Serial.begin(9600);
  pinMode(BUTTON, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(BUTTON), onPress, FALLING);
  Serial.println("waiting for the button");
  while (!pressed) {
  }
  Serial.println("pressed!");
}

void loop() {
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Debounce de um botão com uma interrupção

Um handler não pode esperar um bounce assentar, porque nada mais roda enquanto ele espera. Então deixe ele anotar o momento, e deixe loop() decidir. O handler abaixo só registra que uma borda aconteceu e quando. loop() espera 50 ms de silêncio, depois confere se o botão ainda está pressionado.

Três apertos imprimiram "press 1", "press 2" e "press 3" e nada mais, mesmo com o botão no pior bounce. O contador simples de cima contou 14 para os mesmos três apertos.

Um botão com interrupção, com debounce
const int BUTTON = 2;
const unsigned long QUIET_MS = 50;

volatile bool edge = false;
volatile unsigned long lastEdge = 0;
int presses = 0;

void onEdge() {
  edge = true;
  lastEdge = millis();
}

void setup() {
  Serial.begin(9600);
  pinMode(BUTTON, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(BUTTON), onEdge, FALLING);
}

void loop() {
  noInterrupts();
  bool seen = edge;
  unsigned long when = lastEdge;
  interrupts();
  if (seen && millis() - when > QUIET_MS) {
    edge = false;
    if (digitalRead(BUTTON) == LOW) {
      presses++;
      Serial.print("press ");
      Serial.println(presses);
    }
  }
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Para que servem as interrupções: pulsos rápidos

Um botão é lento o bastante para consultar por polling. As interrupções mostram seu valor em sinais rápidos demais para acompanhar de loop(): um sensor de vazão, um encoder rotativo, a saída de velocidade de uma ventoinha. Aqui o pino 9 gera um sinal de teste de 490 Hz com analogWrite(), ligado ao pino 2. A interrupção pegou todas as bordas: imprimiu "490 pulses in the last second", depois 490 de novo, depois 491, conforme as bordas caíam antes e depois de cada segundo.

Um loop que confere o pino 2 com digitalRead() e depois chama delay(5) contou 92 pulsos por segundo no mesmo fio, porque o pino subiu e desceu várias vezes durante cada delay. A interrupção não se importa com o que loop() está fazendo.

Conte um sinal de 490 Hz
volatile unsigned long pulses = 0;

void onPulse() {
  pulses++;
}

void setup() {
  Serial.begin(9600);
  pinMode(9, OUTPUT);
  analogWrite(9, 128);  // a 490 Hz test signal, wired to pin 2
  attachInterrupt(digitalPinToInterrupt(2), onPulse, RISING);
}

void loop() {
  delay(1000);
  noInterrupts();
  unsigned long counted = pulses;
  pulses = 0;
  interrupts();
  Serial.print(counted);
  Serial.println(" pulses in the last second");
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Mantenha o handler curto

Enquanto um handler roda, outras interrupções esperam, incluindo o timer que faz o millis() avançar. Este handler lê millis(), espera 5 ms ocupado observando o micros() e lê millis() de novo. Ele imprimiu "millis() antes: 299" e "millis() 5 ms depois: 299": o relógio ficou parado o tempo todo.

Então dentro de um handler, não chame delay(), não espere nada e evite Serial.print(). Um print em um handler funciona para uma linha curta, mas com um botão com ruído de contato um aperto imprimiu "pressed" quatro vezes. Defina uma flag ou some a um contador, e faça o resto no loop().

millis() dentro de um handler
volatile unsigned long before = 0;
volatile unsigned long after = 0;
volatile bool done = false;

void onPress() {
  before = millis();
  unsigned long start = micros();
  while (micros() - start < 5000) {
  }
  after = millis();
  done = true;
}

void setup() {
  Serial.begin(9600);
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(2), onPress, FALLING);
  while (!done) {
  }
  Serial.print("millis() before: ");
  Serial.println(before);
  Serial.print("millis() 5 ms later: ");
  Serial.println(after);
}

void loop() {
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Erros comuns

Escrever o número do pino como número da interrupção. attachInterrupt(2, onPress, FALLING) pede a interrupção 2, que um Uno não tem, então não faz nada: o nosso contou 0. Escreva digitalPinToInterrupt(2).

Usar um pino sem interrupção. No Uno só os pinos 2 e 3 funcionam; digitalPinToInterrupt(4) é -1, e um botão no pino 4 contou 0. O pino 3 contou os mesmos 4 que o pino 2.

Esquecer o volatile. O loop que espera a flag nunca vê a mudança dela.

Contar um botão sem debounce. Cada bounce é uma borda, e um aperto pode contar 4.

Fazer demais no handler. Sem delay(), sem prints longos, sem esperar.

Abra este circuito no editor. Arduino Uno: contando apertos de botão com uma interrupção, ligado como ele roda no topo desta página. Troque um componente ou um valor e rode de novo.

Perguntas

Quais pinos podem usar interrupções em um Arduino Uno?

Apenas os pinos 2 e 3, que são a interrupção 0 e a interrupção 1. Use digitalPinToInterrupt(pin) para obter o número. Um Mega tem seis (2, 3, 18, 19, 20 e 21), e a maioria dos pinos do ESP32 pode usar uma.

Por que usar volatile com interrupções?

Sem ele o compilador pode manter a variável em um registrador e nunca ler o novo valor que o handler escreveu. Aqui um loop esperando uma flag sem volatile nunca terminou.

Posso usar delay() dentro de uma interrupção?

Não. Enquanto o handler roda, a interrupção do timer que faz o millis() avançar fica retida: o millis() parou por 5 ms dentro de um aqui. Defina uma flag no handler e faça a espera no loop().

Por que minha interrupção conta um aperto de botão várias vezes?

Os contatos do botão dão bounce, e a interrupção é rápida o bastante para ver cada bounce: um aperto e soltar contou 4 aqui. Deixe o handler registrar o horário e faça o debounce no loop().

Qual a diferença entre RISING, FALLING e CHANGE?

FALLING reage quando o pino vai de HIGH para LOW, RISING de LOW para HIGH, e CHANGE para os dois. Para um botão em INPUT_PULLUP, FALLING é o aperto.

Fontes

De onde vêm as informações desta página

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.