Arduino interrumpe el tutorial

Las interrupciones son una característica poderosa de los microcontroladores que le permiten manejar los eventos de manera asincrónica. A diferencia de la encuesta, que verifica continuamente los eventos, las interrupciones responden inmediatamente cuando ocurre un evento específico, como un botón de presión o un desbordamiento del temporizador. Este tutorial lo guiará a través de la comprensión y el uso de interrupciones con Arduino.

Lo que necesitarás

Arduino Uno (o una placa compatible)
Botón de presentación
Resistencia de 10k-ohmios (para configuración desplegable)
LED y resistencia de 220 ohmios (opcional)
Cables de placa y jersey
Arduino IDE instalado en su computadora

Paso 1: ¿Qué son las interrupciones?

Una interrupción detiene temporalmente la ejecución del programa principal para manejar un evento específico. Una vez que se procesa el evento, el programa se reanuda donde lo dejó. Las interrupciones se gestionan utilizando funciones especiales llamadas Rutinas de servicio de interrupción (ISRS).

Tipos de interrupciones en Arduino

Interrupciones externas: Activado por eventos en pines específicos (por ejemplo, pin 2 o 3 en Arduino Uno).
El cambio de pin de interrupción: Activado por un cambio en cualquier pin digital.
Interrupciones del temporizador: Activado por desbordamientos del temporizador o comparar coincidencias.

Paso 2: Uso de interrupciones externas

El Arduino Uno admite interrupciones externas en los pines 2 y 3. Puede configurar estas interrupciones para activar:

CRECIENTE: La señal va de baja a alta.
DESCENDENTE: La señal va de alta a baja.
CAMBIAR: Cambios de señal de estado (bajo a alto o alto a bajo).
BAJO: La señal sigue siendo baja.

Código de ejemplo: Detección de un botón Presione

Este ejemplo alterna un LED cuando se presiona un botón conectado al PIN 2.

#define buttonPin 2 // Interrupt pin
#define ledPin 13   // Built-in LED

volatile bool ledState = false; // Shared variable between ISR and main code

void handleInterrupt() {
  ledState = !ledState; // Toggle LED state
  digitalWrite(ledPin, ledState);
}

void setup() {
  pinMode(buttonPin, INPUT_PULLUP); // Enable internal pull-up resistor
  pinMode(ledPin, OUTPUT);

  attachInterrupt(digitalPinToInterrupt(buttonPin), handleInterrupt, FALLING); // Trigger on button press
}

void loop() {
  // Main loop does nothing; interrupt handles the LED
}

Explicación

attachInterrupt(digitalPinToInterrupt(pin), ISR, mode): Configura la interrupción.
- pin: El pin de interrupción (por ejemplo, pin 2 o 3 en Arduino Uno).
- ISR: La rutina de servicio de interrupción para ejecutar.
- mode: La condición de activación (RISING, FALLING, CHANGE, o LOW).
digitalPinToInterrupt(pin): Convierte un número PIN en su número de interrupción.

Paso 3: El uso de interrupciones de cambio de pines

Las interrupciones de cambio de PIN le permiten detectar cambios en cualquier PIN digital. Esto requiere bibliotecas adicionales, como Habilitarinterruption.

Código de ejemplo: interrupción del cambio de pin

#include <EnableInterrupt.h>
#define pin 4 // Pin to monitor

void handlePinChange() {
  Serial.println("Pin state changed!");
}

void setup() {
  Serial.begin(9600);
  enableInterrupt(pin, handlePinChange, CHANGE); // Trigger on any state change
}

void loop() {
  // Main loop does nothing; interrupt handles the event
}

Instalación de la biblioteca

Para usar interrupciones de cambio de pin, instale el Habilitarinterruption Biblioteca a través del Gerente de la Biblioteca Arduino.

Paso 4: las interrupciones del temporizador

Las interrupciones del temporizador son útiles para programar tareas a intervalos precisos. Consulte el Tutorial de temporizador Arduino Para obtener detalles sobre la configuración de interrupciones del temporizador.

Ejemplo: parpadear un LED con Trimer1 Interruption

#define ledPin 13

void setup() {
  pinMode(ledPin, OUTPUT);

  // Configure Timer1
  noInterrupts(); // Disable interrupts during setup
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1 = 0;

  OCR1A = 15624; // Compare match value for 1Hz (1-second interval)
  TCCR1B |= (1 << WGM12); // CTC mode
  TCCR1B |= (1 << CS12) | (1 << CS10); // 1024 prescaler
  TIMSK1 |= (1 << OCIE1A); // Enable Timer1 compare interrupt

  interrupts(); // Enable interrupts
}

ISR(TIMER1_COMPA_vect) {
  digitalWrite(ledPin, !digitalRead(ledPin)); // Toggle LED
}

void loop() {
  // Main loop does nothing; Timer1 handles the LED
}

Paso 5: Mejores prácticas para usar interrupciones

Mantenga a ISRS corto: Evite demoras o cálculos complejos en ISR para garantizar una respuesta rápida.
Evite la comunicación en serie en ISR: Las funciones en serie pueden no funcionar de manera confiable dentro de un ISR.
Usar volatile Para variables compartidas: Marcas variables compartidas entre ISRS y el programa principal como volatile Para evitar problemas de optimización del compilador.
Entradas de desbloqueo: Manejar la lógica de desbloqueo en software o hardware para señales ruidosas como presiones de botones.
Deshabilitar interrupciones durante las secciones críticas: Usar noInterrupts() y interrupts() para proteger las secciones de código crítico.

Aplicaciones de interrupciones

Manejo del botón Presiones sin sondeo
Lectura de codificadores rotativos
Eventos críticos de sincronización (por ejemplo, control de motor preciso)
Programación de tareas periódicas
Reaccionar a señales externas (por ejemplo, sensores, eventos de comunicación)

Solución de problemas

Interrumpir no activar: Asegúrese de configurar el PIN y el modo correctos.
Comportamiento inestable: Desbloquear señales ruidosas y evitar largos ISR.
Conflictos con bibliotecas: Algunas bibliotecas usan interrupciones internamente (por ejemplo, servo, PWM). Asegúrese de que no haya conflicto con su código.

Conclusión

Las interrupciones permiten el manejo receptivo y eficiente de los eventos en proyectos de Arduino. Al aprender a usar interrupciones externas, de cambio de pin e temporizador, puede crear aplicaciones robustas y precisas. ¡Experimente con diferentes tipos de interrupciones para mejorar sus proyectos y optimizar el rendimiento!