Interrupciones en Arduino con attachInterrupt()
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Una interrupción ejecuta una función tuya en el instante en que un pin cambia, sin importar qué esté haciendo loop() en ese momento. En un Uno solo los pines 2 y 3 pueden hacerlo. Escribe attachInterrupt(digitalPinToInterrupt(2), onPress, FALLING); en setup() y onPress() se ejecuta cada vez que el pin 2 baja de HIGH a LOW. Marca como volatile toda variable que la función modifique.
El circuito de arriba tiene un botón en el pin 2 y un LED en el pin 13, y el sketch cuenta las pulsaciones con una interrupción. Presiona Ejecutar y presiona el botón una vez. El monitor serie imprime "presses: 2", y al soltarlo, "presses: 4". La interrupción es tan rápida que atrapa cada rebote de los contactos del botón, al presionar y otra vez al soltar.
Abajo explicamos cómo funciona attachInterrupt(), los cuatro modos, por qué el contador necesita volatile, cómo eliminar los rebotes de un botón dentro de una interrupción, y para qué sirven de verdad las interrupciones: contar pulsos demasiado rápidos para sondearlos.
¿Quieres la versión paso a paso? La lección "Leer un botón y el rebote" recorre esto con puntos de control.
Abrir la lecciónattachInterrupt(), pieza por pieza
attachInterrupt() toma tres cosas. El número de interrupción, que en un Uno es 0 para el pin 2 y 1 para el pin 3; obtenlo siempre con digitalPinToInterrupt(pin) en lugar de escribir el número. La función a ejecutar, llamada el manejador o ISR, que no recibe nada y no devuelve nada. Y el modo, que indica a qué cambio del pin reaccionar.
El sketch de abajo es el más pequeño que sirve de algo. Cuenta flancos de bajada en el pin 2 e imprime el conteo una vez por segundo. Con un botón ideal que no rebota, una pulsación imprimió 0 y luego 1. Con el botón normal con rebotes del simulador, la misma secuencia de presionar y soltar imprimió 0 y luego 4.
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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
FALLING, RISING, CHANGE y LOW
FALLING ejecuta el manejador cuando el pin pasa de HIGH a LOW, que para un botón en INPUT_PULLUP es la pulsación. RISING es de LOW a HIGH, la suelta. CHANGE es ambos. LOW lo ejecuta una y otra vez mientras el pin esté en bajo.
Una pulsación y suelta del botón con rebotes contó 4 con FALLING, 4 con RISING y 8 con CHANGE, ya que cada rebote es una bajada y una subida. LOW ejecutó el manejador 16042 veces durante una presión de un décimo de segundo. LOW es para chips que mantienen una línea de alarma en bajo hasta que los atiendes, no para botones.
Por qué la variable debe ser volatile
El compilador no sabe que un manejador puede ejecutarse entre dos líneas cualesquiera de loop(). En el sketch de abajo, setup() espera en un bucle a que pressed se vuelva true. Sin volatile, el compilador lee pressed una vez, ve que nada en el bucle la cambia, y se queda en el bucle para siempre. Presionamos el botón: imprimió "waiting for the button" y nada más, nunca.
Cambia la primera línea a volatile bool pressed = false; y la misma pulsación imprimió "pressed!". volatile le dice al compilador que lea la variable fresca cada vez. Toda variable que un manejador comparta con el resto del sketch la necesita.
Una variable de más de un byte, como un int o un unsigned long, necesita un paso más. El Uno mueve un byte a la vez, así que el manejador puede cambiarla a mitad de que loop() la esté leyendo. Cópiala con las interrupciones apagadas, como lo hace el contador de pulsos más abajo: noInterrupts(); copy = count; interrupts();.
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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Eliminar rebotes de un botón con una interrupción
Un manejador no puede esperar a que un rebote se asiente, porque nada más se ejecuta mientras espera. Así que que anote la hora, y que loop() decida. El manejador de abajo solo registra que hubo un flanco y cuándo. loop() espera 50 ms de quietud y luego verifica si el botón sigue presionado.
Tres pulsaciones imprimieron "press 1", "press 2" y "press 3" y nada más, incluso con el botón en su peor rebote. El contador simple de arriba contó 14 para las mismas tres pulsaciones.
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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Para qué son las interrupciones: pulsos rápidos
Un botón es lo bastante lento para sondearlo. Las interrupciones se ganan su lugar con señales demasiado rápidas para vigilarlas desde loop(): un sensor de flujo, un encoder rotatorio, la salida de velocidad de un ventilador. Aquí el pin 9 genera una señal de prueba de 490 Hz con analogWrite(), conectada al pin 2. La interrupción atrapó cada flanco: imprimió "490 pulses in the last second", luego 490 otra vez, luego 491, según los flancos cayeran a cada lado de cada segundo.
Un bucle que revisa el pin 2 con digitalRead() y luego llama delay(5) contó 92 pulsos por segundo con el mismo cable, porque el pin subió y bajó varias veces durante cada delay. A la interrupción no le importa qué esté haciendo loop().
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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Mantén corto el manejador
Mientras un manejador se ejecuta, otras interrupciones esperan, incluido el temporizador que hace avanzar millis(). Este manejador lee millis(), espera 5 ms observando micros() y vuelve a leer millis(). Imprimió "millis() antes: 299" y "millis() 5 ms después: 299": el reloj se quedó quieto todo ese tiempo.
Así que dentro de un manejador, no llames a delay(), no esperes nada y evita Serial.print(). Un print en un manejador funciona para una línea corta, pero con un botón que rebota, una sola pulsación imprimió "presionado" cuatro veces. Pon una bandera o suma a un contador, y haz el resto en loop().
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 en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Errores comunes
Escribir el número de pin como el número de interrupción. attachInterrupt(2, onPress, FALLING) pide la interrupción 2, que un Uno no tiene, así que no hace nada: el nuestro contó 0. Escribe digitalPinToInterrupt(2).
Usar un pin que no tiene interrupción. En un Uno solo funcionan los pines 2 y 3; digitalPinToInterrupt(4) es -1, y un botón en el pin 4 contó 0. El pin 3 contó los mismos 4 que el pin 2.
Omitir volatile. El loop que espera la bandera nunca ve que cambie.
Contar un botón sin antirrebote. Cada rebote es un flanco, y una pulsación puede contar 4.
Hacer demasiado en el manejador. Nada de delay(), nada de impresiones largas, nada de esperar.
Abre este circuito en el editor. Arduino Uno: conteo de pulsaciones de un botón con una interrupción, cableado como se ejecuta arriba en esta página. Cambia un componente o un valor y vuelve a ejecutarlo.
Preguntas
¿Qué pines pueden usar interrupciones en un Arduino Uno?
Solo los pines 2 y 3, que son la interrupción 0 y la interrupción 1. Usa digitalPinToInterrupt(pin) para obtener el número. Un Mega tiene seis (2, 3, 18, 19, 20 y 21), y la mayoría de los pines del ESP32 pueden usar una.
¿Por qué usar volatile con interrupciones?
Sin ella, el compilador puede mantener la variable en un registro y nunca leer el nuevo valor que escribió el manejador. Aquí un loop esperando una bandera sin volatile nunca terminó.
¿Puedo usar delay() dentro de una interrupción?
No. Mientras el manejador se ejecuta, la interrupción del temporizador que hace avanzar millis() queda en espera: millis() se quedó quieto durante 5 ms dentro de una aquí. Pon una bandera en el manejador y espera en loop().
¿Por qué mi interrupción cuenta una pulsación de botón muchas veces?
Los contactos del botón rebotan, y la interrupción es lo bastante rápida para ver cada rebote: una pulsación y liberación contó 4 aquí. Deja que el controlador registre el tiempo y aplica el antirrebote en loop().
¿Cuál es la diferencia entre RISING, FALLING y CHANGE?
FALLING reacciona cuando el pin pasa de HIGH a LOW, RISING de LOW a HIGH, y CHANGE a ambos. Para un botón en INPUT_PULLUP, FALLING es la pulsación.
Sigue así
De dónde vienen los datos de esta página
Á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.