Interrupciones externas con Arduino

Las interrupciones externas con Arduino es un mecanismo por el cual podemos suspender o interrumpir en forma temporal la ejecución de un proceso de Arduino para ejecutar una subrutina realizando una tarea definida y posteriormente reanudar el proceso en el momento que se produjo la interrupción.

Estas interrupciones externas o de hardware son muy útiles cuando deseamos implementar alguna subrutina para modificar de forma parcial alguna variable de manera externa.

Generalmente cuando realizamos nuestros proyectos con Arduino lo hacemos pensando en realizar un secuencia de instrucciones que van realizándose una tarea tras otra en una línea de tiempo, pero cuando necesitamos recoger una señal en cualquier momento en la línea de tiempo de nuestro programa no podemos realizarlo porque estamos sujetos al tiempo del delay() que le demos.

Al iniciar en la programación de Arduino nuestros primeros proyectos son relativamente sencillos como el típico encendido de una serie de led de forma secuencial con un tiempo predefinido, pero si quisiéramos aumentar o disminuir la velocidad de encendido de esta secuencia de LED en cualquier instante de nuestro programa no podríamos realizarlo con la forma en que estamos programando en Arduino hasta el momento, para solucionar estos inconvenientes Arduino tiene funciones para trabajar con interrupciones con las cuales podríamos resolver este ejercicio sencillo de la secuencia de led aumentando un botón para aumentar la velocidad y otra para disminuir la velocidad de la secuencia de led en cualquier momento, de esta manera podemos ya a empezar a realizar proyectos cada vez más grandes y complejos.

¿Cómo trabajar con interrupciones con Arduino?

La respuesta es otra vez muy sencilla, en lo que se caracteriza Arduino es hacernos lo más sencillo posible realizar proyectos electrónicos, por lo cual Arduino ya tiene funciones preparadas para trabajar con interrupciones, al igual que las placas de desarrollo de Arduino ya tienes entradas digitales preparadas para trabajar con interrupciones, estas entradas no son iguales en todas las placas de desarrollo de Arduino por lo cual debemos averiguar que pines y cuantos están habilitadas para trabajar con interrupciones, a continuación se nuestra una pequeña tabla para saber que entradas podemos utilizar.

Función para trabajar con interrupciones externas con Arduino

Esta función nos permite trabajar con interrupciones externas o de hardware en Arduino de manera sencilla.  

Función attachInterrupt(interrupción, ISR, mode)

Tiene tres paramentos, el primer parámetro es el número de interrupción que deseamos usar, como ya vimos anteriormente cada placa de Arduino presenta un número determinado de pines que podemos usar como interrupciones por lo cual debemos ser precavidos al momento de escoger el pin que usaremos para trabajar con interrupciones.

Este parámetro debe ser del tipo entero y colocar el número de interrupción a usar por ejemplo la placa de Arduino UNO solo posee dos pines habilitados para trabajar con interrupciones el pin 2 y 3, pero no podemos colocar directamente el número de pin habilitado para trabajar con interrupciones en la función attachInterrupt() por qué ocurriría un error grave ya que en realidad los números de interrupciones habilitados son 0 y 1 donde el pin 2 representaría a la interrupción 0 y el pin 3 a la interrupción 1.

Esto para muchos es confuso si bien se puede trabajar directamente de esta manera, la documentación de Arduino nos sugiere trabajar con la función digitalPinToInterrupt([pin habilitado para trabajar con interrupciones]) que tiene un solo parámetro y es el pin habilitado para trabajar con interrupciones, es decir que podemos colocar directamente el número de pin y no así el número de la interrupción, y con esto podemos trabajar sin muchas complicaciones, la función quedaría así attachInterrupt(digitalPinToInterrupt(pin), ISR, mode).

El segundo parámetro es un ISR (Interrupt Service Routine – Rutina de servicio de interrupción)  que no es más que una función con algunas restricciones como por ejemplo que no tiene ningún parámetro y además no debe devolver nada y debe ser lo más corto posible para que su tiempo ejecución sea lo más veloz posible, en caso de usar varios ISR la ejecución de las mismas se hará de forma secuencial una después de otra.

El tercer parámetro es el modo de cuando se debe activar nuestra interrupción y funcionar nuestra rutina de servicio de interrupción (ISR), Arduino nos provee cuatro constantes válidas para trabajar y son: LOW, CHANGE, RISING, FALLING, en el caso de las placas de Arduino Due, Zero y MKR1000 nos ofrece una constante extra que es el HIGH.

Significado de estas constantes para trabajar con interrupciones con Arduino

LOW.- Utilizado cunado necesitamos activar nuestra interrupción mientras el pin habilitado este en bajo.

HIGH.- Similar al anterior pero es habilitada cuando este siempre nuestro pin de interrupción en alto.

CHANGE.- Muy útil cuando requerimos detectar algún cambio en el pin que estemos utilizando como interrupción externa o de hardware.

RISING.- Este modo nos permite detectar el cambio del valor de nuestro pin de bajo a alto y activar de esta manera nuestra interrupción.

FALLING.- Este modo es muy similar al anterior con la diferencia que se activa cuando cambia el valor del pin de alto a bajo.

Variable global volatile utilizada para trabajar con interrupciones

Las variables globales son generalmente utilizadas en cualquier lugar de nuestro programa, pero al tratar de interrupciones, Arduino nos sugiere declararlo con la palabra reservada volatile porque al pasar datos desde el ISR al nuestro código principal debemos asegurarnos que estas variables se actualicen de forma correcta cada vez que se lo necesite.

Ejemplo de Interrupciones con Arduino (Efectos de luces LED accionados por un pulsador)

Este ejemplo consiste en hacer un circuito de 4 Leds donde se pueda cambiar 3 efectos de luces con un pulsador, el primer efecto consiste en encender progresivamente los leds y apagarlos también progresivamente, el segundo efecto es más simple solo enciende y apaga todos los led y el tercer efecto es el típico luces del auto fantástico.

Nota.- Para aprender siempre es necesario practicar por lo cual te reto a modificar este código para que el primer y tercer efecto, se ejecute de manera instantánea cuando accionemos el pulsador, la solución es más simple de lo que crees.  

Materiales necesarios para nuestro proyecto de Arduino

• 4 Leds
• 4 Resistencias de 220 o 330 ohmios
• 1 Resistencia de 10K
• 1 Pulsador
• Varios cables para conectar nuestro circuito
• Arduino UNO

Conexión de nuestro circuito para trabajar con interrupciones con Arduino

Código para ser utilizado en nuestro proyecto de interrupciones

/* AUTOR: CREATIVIDAD CODIFICADADA
 *  www.creatividadcodificada.com
 *  NOMBRE DEL PROYECTO: JUEGO DE LUCES CON 4 LEDS
*/
// variable global volatil para cambiar el efecto de luces
volatile int efectoLed = 0;
// matriz o array para controlar todos los led 
// de mejor forma 
int led[4] = {8,9,10,11};
void setup() {
// Inicamos nuestro pines de salida y que esten apagados 
  for(int i = 0; i<=3; i++)
  {
    // Iniciamos todos los pines 8,9,10,11 como salidas
    pinMode(led[i],OUTPUT);
    //Iniciamos todos los led apagados
    digitalWrite(led[i], LOW);
    }
    //Activamos nuestra interrupcion 
    attachInterrupt(digitalPinToInterrupt(2),cambioEfecto,RISING);
  }

void loop() {
  switch(efectoLed)
  {
    //Primer efecto - Secuencia de Led
    case 0:     
          for(int j=0;j<=3; j++)
          {
            //Encendemos los led
            digitalWrite(led[j],HIGH);
            delay(200);  
            }
           for(int j=3;j>=0; j--)
          {
            //Apagamos lo led
            digitalWrite(led[j],LOW);  
            delay(200);
            }
            break;
      //Segundo Efecto - Enciende y apaga todos los led
      case 1:
            for(int j=0;j<=3; j++)digitalWrite(led[j],HIGH);
            delay(200);
            for(int j=0;j<=3;j++)digitalWrite(led[j],LOW);
            delay(200);
            break;
        //Tercer efecto - Auto fantastico
        case 2:
              for(int i=0;i<=3;i++)
              {
                // Enciende un led
                digitalWrite(led[i],HIGH);
                if(i>0)
                {
                  //Apaga el Led anterior
                  digitalWrite(led[i-1],LOW);
                  }
                delay(200);
                }
              for(int i=3;i>=0;i--)
              {
                digitalWrite(led[i],HIGH);
                if(i<3)
                {
                  digitalWrite(led[i+1],LOW);
                  }
                delay(200);
                }
               break; 
      default: 
              for(int k = 0; k<=3; k++)digitalWrite(led[k], LOW);
              break; 
    }
}
// Nuestra Funcion ISR
void cambioEfecto()
{
  efectoLed++;
  if(efectoLed >2) efectoLed=0;
  }