Interrupciones en ESP32 con attachInterrupt
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las 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.
El circuito de arriba es un ESP32 DevKit con un botón del GPIO 15 a tierra. Abajo, un contador en ese pin con tres pulsaciones, con el rebote del botón desactivado, luego con el ajuste típico, luego en el peor caso, y el debounce que devolvió las tres a 3.
attachInterrupt, IRAM_ATTR y volatile
pinMode(15, INPUT_PULLUP) mantiene el pin en alto hasta que el botón lo lleva a bajo, y attachInterrupt(digitalPinToInterrupt(15), onPress, FALLING) ejecuta onPress() en cada flanco de alto a bajo. El controlador solo suma uno a un contador; loop() se encarga de imprimir. En un ESP32, digitalPinToInterrupt(15) es simplemente 15, pero escribirlo así mantiene el sketch portable a un Uno.
IRAM_ATTR coloca el controlador en la RAM interna. En un ESP32 real la mayoría del código se ejecuta desde la flash a través de una caché, y la caché se desactiva mientras se escribe la flash, por ejemplo con Preferences o WiFi. Un controlador que se queda en la flash y se ejecuta en ese momento hace que la placa se cuelgue. En Mokxi todo el código ya se ejecuta desde la RAM, así que la marca aquí no cambia nada, pero escríbela siempre.
volatile le dice al compilador que la variable puede cambiar a sus espaldas. Un bucle que esperara con while (presses == 0) { } sobre un int común nunca terminó aquí, ni con tres pulsaciones: el compilador leyó la variable una vez y conservó la copia. Con volatile int presses el mismo bucle imprimió "pressed" en la primera pulsación.
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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Por qué una pulsación cuenta más de una vez
Un botón pulsador no cierra una sola vez. Sus contactos rebotan durante unos milisegundos cuando se tocan y también cuando se separan, y una interrupción es lo bastante rápida para atrapar cada rebote. El botón de Mokxi rebota como uno real, con un ajuste para qué tan mal lo hace. Con tres pulsaciones, el sketch de arriba contó 3 con el rebote desactivado, 14 con el ajuste típico y 46 en el peor 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.
Un debounce que cuenta una por pulsación
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.
Mantén el manejador así de corto. Sin Serial.print(), sin delay() y nada que espere: en un ESP32 real un manejador que corre demasiado tiempo activa el perro guardián de interrupciones y la placa se reinicia. Establece una bandera o un contador, y deja que loop() haga la parte lenta. detachInterrupt(15) deja de vigilar el pin; un sketch que lo llamó cuando el contador llegó a 2 se quedó en 2 durante la tercera pulsación.
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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Pines de interrupción del ESP32 y los que necesitan una resistencia
Todos los GPIO pueden interrumpir, pero un pin sin nada que lo mantenga en alto o en bajo queda flotando, y un pin flotante interrumpe por ruido. Con pinMode(15, INPUT) en lugar de INPUT_PULLUP y el botón liberado, el pin leyó 0 y el contador llegó a 141 en dos segundos, con tres pulsaciones reales entre ellas.
Los GPIO 34 a 39 son solo de entrada y no tienen ninguna resistencia pull-up interna, así que INPUT_PULLUP en ellos no hace nada. El mismo botón en el GPIO 34 con INPUT_PULLUP contó 142. Con una resistencia de 10 k del GPIO 34 a 3.3 V el pin leyó 1 en reposo y contó las tres pulsaciones, 3. Usa esos pines para interrupciones solo con una resistencia, o con un sensor que maneje su salida en ambos sentidos.
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.
Abre este circuito en el editor. ESP32 DevKit: un botón en el GPIO 15, cableado como el que funciona arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Preguntas
¿Qué pines del ESP32 se pueden usar para interrupciones?
Todos los GPIO. Los GPIO 34 a 39 no tienen pull-up interna, así que necesitan una resistencia o un sensor que maneje el pin, y los GPIO 6 a 11 son de la flash.
¿Por qué no funciona mi attachInterrupt del ESP32?
La mayoría de las veces el pin queda flotando (sin INPUT_PULLUP ni resistencia), la variable compartida no es volatile, el pin es del 34 al 39 sin pull-up, o el controlador imprime o hace delays.
¿Qué hace IRAM_ATTR en un ESP32?
Coloca el controlador en la RAM interna, para que pueda ejecutarse mientras la caché de flash está desactivada durante una escritura en la flash. Sin esto, un controlador que se dispara en ese momento hace que la placa se cuelgue.
¿Cómo elimino el rebote de una interrupción de botón en un ESP32?
Observa CHANGE, registra cuándo el pin pasa a alto, y cuenta un nivel bajo solo después de que haya estado alto unos 30 ms. Un simple intervalo de 50 ms después de FALLING sigue contando el rebote al soltar.
¿Puedo usar Serial.print en una interrupción de ESP32?
No. Imprimir espera al UART, y un controlador lento puede activar el watchdog de interrupciones. Asigna una variable en el controlador e imprímela desde loop().
Sigue así
Ármalo en la vida real
Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.