Arduino - Interrupciones

Las interrupciones detienen el trabajo actual de Arduino de modo que se puede realizar algún otro trabajo.

Suponga que está sentado en su casa, charlando con alguien. De repente suena el teléfono. Dejas de charlar y levantas el teléfono para hablar con la persona que llama. Cuando haya terminado su conversación telefónica, vuelva a charlar con la persona antes de que sonara el teléfono.

Del mismo modo, puede pensar en la rutina principal como charlar con alguien, el teléfono que suena hace que deje de charlar. La rutina del servicio de interrupción es el proceso de hablar por teléfono. Cuando finaliza la conversación telefónica, vuelve a su rutina principal de charlar. Este ejemplo explica exactamente cómo una interrupción hace que actúe un procesador.

El programa principal se ejecuta y realiza alguna función en un circuito. Sin embargo, cuando ocurre una interrupción, el programa principal se detiene mientras se lleva a cabo otra rutina. Cuando finaliza esta rutina, el procesador vuelve a la rutina principal.

Características importantes

Aquí hay algunas características importantes sobre las interrupciones:

  • Las interrupciones pueden provenir de varias fuentes. En este caso, estamos utilizando una interrupción de hardware que se activa por un cambio de estado en uno de los pines digitales.

  • La mayoría de los diseños de Arduino tienen dos interrupciones de hardware (denominadas "interrupt0" e "interrupt1") cableadas a los pines 2 y 3 de E / S digitales, respectivamente.

  • El Arduino Mega tiene seis interrupciones de hardware, incluidas las interrupciones adicionales ("interrupt2" a "interrupt5") en los pines 21, 20, 19 y 18.

  • Puede definir una rutina utilizando una función especial denominada "Rutina de servicio de interrupción" (generalmente conocida como ISR).

  • Puede definir la rutina y especificar condiciones en el flanco ascendente, descendente o en ambos. En estas condiciones específicas, la interrupción sería reparada.

  • Es posible que esa función se ejecute automáticamente, cada vez que ocurre un evento en un pin de entrada.

Tipos de interrupciones

Hay dos tipos de interrupciones:

  • Hardware Interrupts - Ocurren en respuesta a un evento externo, como un pin de interrupción externo que sube o baja.

  • Software Interrupts- Ocurren en respuesta a una instrucción enviada en software. El único tipo de interrupción que admite el "lenguaje Arduino" es la función attachInterrupt ().

Usando interrupciones en Arduino

Las interrupciones son muy útiles en los programas Arduino, ya que ayudan a resolver problemas de sincronización. Una buena aplicación de una interrupción es leer un codificador rotatorio u observar una entrada de usuario. Generalmente, un ISR debe ser lo más corto y rápido posible. Si su boceto utiliza varios ISR, solo se puede ejecutar uno a la vez. Otras interrupciones se ejecutarán después de que finalice la actual en un orden que depende de la prioridad que tengan.

Normalmente, las variables globales se utilizan para pasar datos entre un ISR y el programa principal. Para asegurarse de que las variables compartidas entre un ISR y el programa principal se actualicen correctamente, declararlas como volátiles.

attachInterrupt Sintaxis de la instrucción

attachInterrupt(digitalPinToInterrupt(pin),ISR,mode);//recommended for arduino board
attachInterrupt(pin, ISR, mode) ; //recommended Arduino Due, Zero only
//argument pin: the pin number
//argument ISR: the ISR to call when the interrupt occurs; 
   //this function must take no parameters and return nothing. 
   //This function is sometimes referred to as an interrupt service routine.
//argument mode: defines when the interrupt should be triggered.

Las siguientes tres constantes están predefinidas como valores válidos:

  • LOW para activar la interrupción siempre que el pin esté bajo.

  • CHANGE para activar la interrupción siempre que el pin cambie de valor.

  • FALLING siempre que el pin pase de mayor a menor.

Example

int pin = 2; //define interrupt pin to 2
volatile int state = LOW; // To make sure variables shared between an ISR
//the main program are updated correctly,declare them as volatile.

void setup() {
   pinMode(13, OUTPUT); //set pin 13 as output
   attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);
   //interrupt at pin 2 blink ISR when pin to change the value
} 
void loop() { 
   digitalWrite(13, state); //pin 13 equal the state value
} 

void blink() { 
   //ISR function
   state = !state; //toggle the state when the interrupt occurs
}