Interrupções do ESP32 com attachInterrupt
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
An interrupt lets an ESP32 notice a pin change the moment it happens, whatever loop() is busy with. You write a short function, mark it IRAM_ATTR, and hand it to attachInterrupt() with the pin and the edge to watch. Every GPIO on an ESP32 can trigger one. The two things that go wrong are the button, which bounces, and the variable the handler shares with loop(), which has to be volatile.
O circuito acima é um ESP32 DevKit com um botão do GPIO 15 ao terra. Abaixo, um contador nesse pino apertado três vezes, com o bounce do botão desligado, depois na configuração típica, depois no pior caso, e o debounce que trouxe todos os três de volta a 3.
attachInterrupt, IRAM_ATTR e volatile
pinMode(15, INPUT_PULLUP) mantém o pino em nível alto até o botão puxá-lo para baixo, e attachInterrupt(digitalPinToInterrupt(15), onPress, FALLING) executa onPress() a cada borda de descida. O handler apenas soma um a um contador; loop() faz a impressão. Em um ESP32, digitalPinToInterrupt(15) é simplesmente 15, mas escrevê-lo mantém o sketch portátil para um Uno.
IRAM_ATTR coloca o handler na RAM interna. Em um ESP32 real a maior parte do código roda da flash por um cache, e o cache é desligado enquanto a flash está sendo gravada, por exemplo pelo Preferences ou pelo WiFi. Um handler deixado na flash que dispare nesse momento trava a placa. No Mokxi todo código já roda da RAM, então a marca não muda nada aqui, mas escreva-a sempre.
volatile avisa o compilador que a variável pode mudar sem que ele saiba. Um loop que esperasse com while (presses == 0) { } em um int comum nunca terminou aqui, mesmo com três apertos: o compilador leu a variável uma vez e guardou a cópia. Com volatile int presses o mesmo loop imprimiu "pressed" no primeiro aperto.
volatile int presses = 0;
void IRAM_ATTR onPress() {
presses++;
}
void setup() {
Serial.begin(115200);
pinMode(15, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(15), onPress, FALLING);
}
void loop() {
static int shown = 0;
if (presses != shown) {
shown = presses;
Serial.print("presses: ");
Serial.println(shown);
}
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Por que um aperto conta mais de uma vez
Um botão de pressão não fecha uma única vez. Seus contatos bounceiam por alguns milissegundos quando se tocam e de novo quando se separam, e uma interrupção é rápida o bastante para capturar cada bounce. O botão do Mokxi bounceia como um real, com uma configuração para o quão mal. Apertado três vezes, o sketch acima contou 3 com o bounce desligado, 14 na configuração típica e 46 no pior caso.
The usual fix in tutorials is a time check: ignore a FALLING edge within 50 milliseconds of the last one counted. It counted 6 for 3 presses, at both settings. The press is counted once, but the release bounces too, and some of its edges fall. They come 200 milliseconds after the press, long after the 50 are up.
Um debounce que conta um por aperto
The handler below watches both edges with CHANGE and reads the pin each time. When it reads HIGH it notes the time; when it reads LOW it counts a press only if the pin had been high for more than 30 milliseconds. A bounce during the press or the release never stays high that long, and a real press always follows a long high. It counted 3 for 3 presses with bounce off, typical and worst.
Mantenha o handler assim curto. Sem Serial.print(), sem delay() e nada que espere: num ESP32 real, um handler que roda por tempo demais derruba o interrupt watchdog e a placa reinicia. Defina uma flag ou um contador e deixe o loop() fazer a parte lenta. detachInterrupt(15) para de observar o pino; um sketch que o chamou quando o contador chegou a 2 ficou em 2 no terceiro aperto.
volatile int presses = 0;
volatile unsigned long highSince = 0;
void IRAM_ATTR onEdge() {
unsigned long now = millis();
if (digitalRead(15) == HIGH) {
highSince = now;
} else if (now - highSince > 30) {
presses++;
}
}
void setup() {
Serial.begin(115200);
pinMode(15, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(15), onEdge, CHANGE);
}
void loop() {
static int shown = 0;
if (presses != shown) {
shown = presses;
Serial.print("presses: ");
Serial.println(shown);
}
}Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.
Pinos de interrupção do ESP32 e os que precisam de resistor
Todo GPIO pode gerar interrupção, mas um pino sem nada que o mantenha alto ou baixo fica flutuando, e um pino flutuando gera interrupções por ruído. Com pinMode(15, INPUT) em vez de INPUT_PULLUP e o botão solto, o pino leu 0 e o contador chegou a 141 em dois segundos, com três apertos reais no meio deles.
GPIO 34 a 39 são só de entrada e não têm pull-up interno nenhum, então INPUT_PULLUP neles não faz nada. O mesmo botão no GPIO 34 com INPUT_PULLUP contou 142. Com um resistor de 10 k do GPIO 34 para 3,3 V, o pino leu 1 em repouso e contou os três apertos, 3. Use esses pinos para interrupções só com um resistor, ou com um sensor que leve a saída aos dois níveis.
For several buttons with one handler, attachInterruptArg(pin, handler, &data, FALLING) passes a pointer to the handler; with a struct for the button it counted 3 for 3 presses. Avoid GPIO 6 to 11, which are the flash, and the strapping pins 0, 2, 5, 12 and 15 for anything held low at power on. GPIO 15 is fine for a button that is open at boot.
Abra este circuito no editor. ESP32 DevKit: um botão no GPIO 15, ligado como no circuito que roda no topo desta página. Troque um componente ou um valor e rode de novo.
Perguntas
Quais pinos do ESP32 podem ser usados para interrupções?
Todos os GPIO. GPIO 34 a 39 não têm pull-up interno, então precisam de um resistor ou de um sensor que leve o pino ao nível definido, e GPIO 6 a 11 são a flash.
Por que meu attachInterrupt no ESP32 não funciona?
Na maioria das vezes o pino está flutuando (sem INPUT_PULLUP nem resistor), a variável compartilhada não é volatile, o pino é de 34 a 39 sem pull-up, ou o handler imprime ou faz delay.
O que o IRAM_ATTR faz num ESP32?
Ele coloca o handler na RAM interna, para que ele possa rodar enquanto o cache da flash está desligado durante uma gravação na flash. Sem ele, um handler que dispara nesse momento trava a placa.
Como fazer debounce de um botão com interrupção no ESP32?
Observe CHANGE, anote quando o pino vai para alto e conte um nível baixo só depois de ele ter ficado alto por cerca de 30 ms. Um simples intervalo de 50 ms após FALLING ainda conta o bounce da soltura.
Posso usar Serial.print numa interrupção do ESP32?
Não. Imprimir espera pela UART, e um handler lento pode disparar o interrupt watchdog. Defina uma variável no handler e imprima a partir do loop().
Continuar
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.