Interrupciones
Las interrupciones en el ESP32 son una excelente manera de responder rápidamente a eventos externos sin
tener que depender de un bucle de control continuo. A diferencia del uso de millis() o delay(), una
interrupción es un mecanismo que permite al microcontrolador reaccionar inmediatamente ante eventos,
como la activación de un botón, sin importar en qué parte del código se encuentre.
Aquí te dejo un ejemplo básico de cómo implementar una interrupción con el ESP32 utilizando la placa
NodeMCU 32S.
Ejemplo: Interrupción por botón que controla un LED
Supongamos que queremos encender y apagar un LED cuando se presione un botón conectado a un pin del
ESP32. Para ello, configuraremos una interrupción que detecte el cambio de estado en el botón y cambie el
estado del LED.
Conexiones:
Botón conectado al pin GPIO 0 (con pull-up interno habilitado).
LED conectado al pin GPIO 2.
Código:
const int botonPin = 0; // Pin del botón
const int ledPin = 2; // Pin del LED
volatile bool estadoLed = LOW; // Estado del LED (variable volátil para la ISR)
// Función de interrupción
void IRAM_ATTR manejarInterrupcion() {
estadoLed = !estadoLed; // Cambia el estado del LED
digitalWrite(ledPin, estadoLed); // Actualiza el LED
}
void setup() {
pinMode(ledPin, OUTPUT); // Configura el pin del LED como salida
pinMode(botonPin, INPUT_PULLUP); // Configura el pin del botón como entrada con
pull-up
// Asigna la interrupción al pin del botón (se activa cuando cambia de estado,
FALLING)
attachInterrupt(digitalPinToInterrupt(botonPin), manejarInterrupcion, FALLING);
}
void loop() {
// Aquí no necesitamos hacer nada, el control lo toma la interrupción
}
Explicación:
1. Declaración de pines:
o botonPin: GPIO 0 está configurado como entrada con una resistencia de pull-up interna, lo
que significa que el pin estará en estado HIGH mientras el botón no se presione.
o ledPin: GPIO 2 está configurado como salida para controlar el LED.
2. Interrupción (IRAM_ATTR):
o La función de interrupción debe tener el atributo IRAM_ATTR, que le indica al compilador que
esta función se debe ejecutar desde la RAM en lugar de la flash, asegurando una respuesta
rápida y evitando problemas con el acceso a la memoria flash.
o La función manejarInterrupcion() se ejecutará cada vez que se detecte un borde
descendente (cuando el botón pasa de HIGH a LOW, es decir, cuando se presiona).
3. attachInterrupt():
o Asocia una interrupción al pin botonPin usando attachInterrupt().
o El tercer argumento (FALLING) especifica que la interrupción se activará cuando el pin
cambie de HIGH a LOW (cuando se presiona el botón).
4. Variable volátil (volatile):
o La variable estadoLed está marcada como volatile porque su valor puede cambiar en la
función de interrupción. Esto le indica al compilador que no debe optimizar el acceso a esta
variable, ya que puede ser modificada en cualquier momento por la interrupción.
Detalles importantes sobre las interrupciones:
Tiempo de ejecución: La función que maneja la interrupción debe ejecutarse rápidamente, evitando
retardos o el uso de funciones que dependan de interrupciones, como delay() o [Link](),
ya que esto puede causar problemas.
Prioridades: En el ESP32, puedes asignar prioridades a las interrupciones, aunque para casos
simples como este, no es necesario.
Alternativas de activación de la interrupción:
RISING: La interrupción se activa cuando el pin cambia de LOW a HIGH.
CHANGE: Se activa con cualquier cambio de estado, tanto de LOW a HIGH como de HIGH a LOW.
FALLING: Se activa cuando el pin cambia de HIGH a LOW.
Pines GPIO que pueden usarse con INPUT_PULLUP:
En general, la mayoría de los pines GPIO del ESP32 se pueden configurar como INPUT_PULLUP, pero hay
ciertas consideraciones a tener en cuenta con algunos pines especiales.
Lista de GPIO disponibles para INPUT_PULLUP:
GPIO Uso o restricción especial ¿Se puede usar con INPUT_PULLUP?
0 A veces usado como modo BOOT (dependiendo de la placa) Sí, pero con precaución
1 UART0 (TX), usado para la comunicación serie No recomendado
2 Usado para algunos LEDs internos en ciertas placas Sí
3 UART0 (RX), usado para la comunicación serie No recomendado
4 GPIO general Sí
5 GPIO general Sí
12 Conectado a la señal MTDI durante el arranque Sí, pero con precaución
13 GPIO general Sí
14 GPIO general Sí
15 GPIO general Sí
16 GPIO general Sí
17 GPIO general Sí
18 GPIO general, SPI MOSI Sí
19 GPIO general, SPI MISO Sí
21 GPIO general Sí
22 GPIO general Sí
23 GPIO general Sí
25 GPIO general Sí
26 GPIO general Sí
GPIO Uso o restricción especial ¿Se puede usar con INPUT_PULLUP?
27 GPIO general Sí
32 GPIO general Sí
33 GPIO general Sí
34 GPIO de solo entrada No, no admite salida ni pull-up
35 GPIO de solo entrada No, no admite salida ni pull-up
36 GPIO de solo entrada (sensor VP) No, no admite salida ni pull-up
39 GPIO de solo entrada (sensor VN) No, no admite salida ni pull-up
Pines de solo entrada (GPIO 34-39):
Estos pines no tienen capacidad de salida y no pueden configurarse con pull-up interno, ya que están
diseñados solo para leer señales, generalmente usadas como entradas analógicas o para sensores.
Pines con restricciones adicionales:
GPIO 0: Es un pin especial relacionado con el modo de arranque del ESP32, ya que determina el
modo BOOT. Puede usarse como entrada con pull-up, pero ten cuidado si lo usas durante el
arranque.
GPIO 12: También relacionado con el modo de arranque. Si se mantiene en el nivel incorrecto al
encender el dispositivo, puede provocar problemas en el arranque.
GPIO 1 y GPIO 3: Son los pines TX y RX de la UART0, que se usan para la comunicación serie
con el ordenador. No es recomendable usarlos para otras funciones si estás usando la consola serie.
Ejemplo básico de INPUT_PULLUP:
const int botonPin = 4; // Usaremos el GPIO 4 para este ejemplo
void setup() {
pinMode(botonPin, INPUT_PULLUP); // Configura el pin con resistencia pull-up interna
[Link](115200);
}
void loop() {
int estadoBoton = digitalRead(botonPin); // Lee el estado del pin
if (estadoBoton == LOW) { // El botón está presionado
[Link]("Botón presionado");
} else {
[Link]("Botón no presionado");
}
delay(500); // Espera medio segundo entre lecturas
}
En este ejemplo:
El GPIO 4 se configura con INPUT_PULLUP, lo que significa que, si no hay conexión externa, el pin
estará en estado HIGH debido a la resistencia pull-up interna. Cuando el botón está presionado, el pin
se conecta a tierra (LOW).
Resumen:
La mayoría de los GPIO del ESP32 pueden configurarse como INPUT_PULLUP.
Los pines especiales como GPIO 0, GPIO 12, GPIO 1 y GPIO 3 deben usarse con precaución
debido a su función en el arranque o la comunicación serie.
Los pines GPIO 34-39 no tienen pull-up ni pull-down interno, ya que son solo de entrada.
Ejemplo: Contador usando interrupción
Cada vez que se presiona un botón, el contador se incrementará. Usaremos una interrupción para detectar la
pulsación del botón.
Conexiones:
Botón conectado al pin GPIO 14 (configurado con INPUT_PULLUP).
El contador se incrementará y se mostrará en el monitor serie.
Código:
const int botonPin = 14; // Pin del botón
volatile int contador = 0; // Variable del contador (debe ser volatile)
void IRAM_ATTR manejarInterrupcion() {
contador++; // Incrementa el contador cada vez que se presiona el botón
}
void setup() {
[Link](115200); // Inicializa la comunicación serie
pinMode(botonPin, INPUT_PULLUP); // Configura el pin del botón con resistencia pull-
up interna
// Asigna la interrupción al pin del botón (se activa con un borde descendente,
FALLING)
attachInterrupt(digitalPinToInterrupt(botonPin), manejarInterrupcion, FALLING);
[Link]("Presiona el botón para incrementar el contador.");
}
void loop() {
// Muestra el valor del contador en el monitor serie
[Link]("Contador: ");
[Link](contador);
delay(500); // Pequeño retraso para evitar saturar el monitor serie
}
Explicación del código:
1. Pin del botón: El botón está conectado al GPIO 14, que se configura como INPUT_PULLUP. Esto
significa que el pin estará en estado HIGH mientras no se presione el botón, y en LOW cuando se
presiona, debido a la resistencia pull-up interna.
2. Interrupción (IRAM_ATTR):
o La función manejarInterrupcion() se ejecuta cada vez que se detecta un borde
descendente en el pin del botón, lo que indica que el botón ha sido presionado.
o contador++ incrementa la variable contador cada vez que se llama la interrupción.
3. volatile:
o La variable contador está declarada como volatile porque puede ser modificada tanto en
la función de interrupción como en el código principal. Esto le indica al compilador que debe
evitar optimizaciones que puedan ignorar los cambios hechos en la función de interrupción.
4. attachInterrupt():
o Usa attachInterrupt() para asociar la función manejarInterrupcion() con el pin del
botón y se activa cuando el botón pasa de HIGH a LOW (cuando se presiona el botón).
5. Monitor serie:
o El valor de la variable contador se imprime en el monitor serie para que puedas ver cómo se
incrementa cada vez que presionas el botón.
Configuración de la interrupción:
FALLING: La interrupción se activa cuando el pin cambia de HIGH a LOW (cuando se presiona el
botón).
Puedes cambiar FALLING a RISING o CHANGE si quieres detectar otros eventos:
o RISING: Se activa cuando el pin cambia de LOW a HIGH (cuando se suelta el botón).
o CHANGE: Se activa en cualquier cambio de estado, tanto de HIGH a LOW como de LOW a
HIGH.
Conclusión:
Este es un ejemplo sencillo donde usamos una interrupción para incrementar un contador cada vez que se
presiona un botón. La ventaja de usar una interrupción es que no necesitas estar verificando constantemente
el estado del botón en el loop(), ya que la interrupción se ejecuta de forma inmediata cuando ocurre el
evento.
