Interrupciones en Arduino: ¿Qué son, para qué sirve y cómo podemos crear una en nuestros proyecto?

Arduino es una de las tecnologías que podemos utilizar para programar y crear grandes innovaciones, sumándole que es totalmente práctico para ser desarrollado por cualquiera de nosotros sin necesidad de algunas certificaciones en programación o electrónica.

Son tantos los detalles de Arduino, que actualmente se pueden implementar interrupciones en su proceso. A lo largo de este artículo te explicaremos de forma clara y detallada, realmente qué son estas interrupciones y su importancia.

También, hablaremos de sus funciones y cómo puedes crear uno de forma rápida y sencilla. Si después esto quieres crear tu propia interrupción, puedes utilizar como base algunos de los proyectos que mencionamos aquí.

¿Qué son las interrupciones en Arduino y para qué sirven al desarrollar un dispositivo?

Cuando hablamos de interrupciones nos referimos a un mecanismo potente que puede ser utilizado para paradas seguras, o detener cualquier equipo o sistema de forma inmediata. Debido que Arduino es un sistema electrónico, también debe hacer uso de este mecanismo.

De una manera más ilustrativa, podemos imaginar que contamos con una tecnología que nos permite controlar una bomba centrifuga desde un PLC, sin embargo necesitamos que este se detenga y no responde por acciones del PLC, allí es donde debemos acudir rápidamente al botón de parada o interrupción, para que este ordene una detención inmediata.

El gran valor de esta parada, no solo radica en un trabajo seguro para un operador, también puede ofrecernos ventajas, como tales:

• Intervención para comprobar el consumo correcto de energía y recursos, el cual se puede consultar por medio del estado de entrada.
• Al contar con un sistema a punto de colisión, que necesite ser intervenido inmediatamente, de forma que se puedan ejecutar acciones de correcciones.
• Comprobar los pulsos que se envían desde los procesadores, debido que por una consulta sistemática, podríamos no darnos cuenta de pulsos recortados de acciones.

Por otro lado estas interrupciones si no son programadas y se accionan pueden ser un problema grave, debido que provoca inestabilidades en el sistema y en el procesador, interrumpiendo eventos que se vienen ejecutando perfectamente. Estos tipos de interrupciones se pueden nombrar ISR por su acrónimo en inglés, “Interruption Service Rutine”.

Desde un punto de vista más técnico, estas interrupciones trabajan mediante un flujo normal de procesador y programa que se interrumpe, cuyas tareas y acciones enviadas no son tomadas en cuenta, ejecutando la única función del ISR.

Efectos de una interrupción en Arduino ¿Cómo influye en el funcionamiento de un proyecto?

Las interrupciones tienen una influencia positiva en todos los proyectos, aunque, esto claramente se debe al adecuado uso del mismo. Un sistema puede contener más una línea de interrupción, su uso depende de las necesidades y prioridades. Si contamos con un sistema y procesador que ejecutan un conjunto de tareas de forma normal y continua, pero deseamos que cumpla con otras actividades cuya valor e importancia es mayor que el anterior, se debe ejecutar el ISR.

El cómo funciona, se puede explicar de manera básica por medio de las siguientes listas:

• Anular todos los comandos de las máquinas que se unen al interruptor.
• Todos los mensajes y valores que se emiten por medio del procesador, se protegen y guardan en un registro de forma que se puedan seguir ejecutando cuando se solicite la acción nuevamente.
• El procesador o CPU obvia todas las direcciones que se almacenan para el seguimiento de la rutina, y se ejecuta una parada con un objetivo único. Esta es una de las paradas más seguras tanto para el sistema como para el operador.
• Una vez terminemos la interrupción, el CPU ejecutará todas las tareas que fueron anteriormente ignoradas, por lo que se retoma desde el punto de uso anterior.

Tipos de Interrupciones

Existen más de un tipo de sistemas y procesadores, por esto, también existen diferentes tipos de interrupciones.

Tales las mencionamos a continuación:

• Interrupciones HW o externas: Son interrupciones asíncronas a las acciones emitidas por el procesador. Dicho de otra forma, son paradas que se pueden ejecutar en cualquier momento sin importar que el CPU esté trabajando en ese momento.
• Interrupciones SW: Estas son las famosas interrupciones por softwares, cuyo proceso se induce por medio de la programación de un código y acción. Arduino actualmente no soporta este tipo de interrupciones.
• Eventos programados o paradas de tiempo: Tal como su nombre lo indica son paradas en factor del tiempo, estos se programan según un tiempo determinado de trabajo.
• Excepciones: Estas son el tipo de paradas que se producen cada vez que un operador desee realizar acciones indebidas o bloqueadas, donde el sistema responde con una parada inmediata.

Función ISR ¿Qué es y cuál es su finalidad en las interrupciones de Arduino?

Podríamos decir a grosso modo que las funciones de una interrupción son denominadas ISR, y se basan con el objetivo de no enviar ni recibir otra función, impidiendo el retorno de algún dato. En la sección anterior mencionamos que existen diferentes tipos de ISR, sin embargo ninguna se puede ejecutar de forma simultánea debido que puede ocasionar un descontrol. La manera correcta para ello es ejecutar una en continuación con otra.

Si te adentras adecuadamente en el mundo de las tecnologías de Arduino notarás que se repite constantemente que una interrupción mientras más corta, mejor. Cuando una ISR tiene el menor tiempo de ejecución posible, le permite al sistema un retorno de sus actividades de manera rápida y efectiva, y la generación de errores es menor.

De otro modo, podemos verlo de una forma ilustrativa; si contamos con un proceso de recolección de objetos con la implementación de un motor, una parada larga puede provocar errores, debido que el motor pierde fuerza y deja de hacer presión para el brazo, provocando que este suelte los objetos.

Variables

Si queremos modificar una variable que pertenezca en la parte externa de la interrupción, siempre debemos tomar en cuenta la importancia de hacer una declaración Volátil, cuyo indicador es el usado para referirse a una variable que puede ser auditada o consultada.

Un indicador de variable es el que compila todos los registros, así mismo desactiva algunas de las características para la optimización que pueden considerarse como fugas de eficiencia. Cuando necesitemos crear variables, solo debemos marcar como volátil, las características que realmente sean necesaria para la creación del bucle principal dentro de las interrupciones.

Aprende paso a paso cómo crear y probar una interrupción en un Arduino fácil y rápido

Si deseas crear tu propia interrupción en una placa Arduino, este es el lugar adecuado para ti. En esta sección te vamos a explicar que debes hacer para aprender a crear y probar una interrupción en Arduino, de la manera más fácil existente.

Vamos a ello:

Crear interrupción

Para crear una interrupción lo primero que debes tomar en cuenta es su lenguaje y sintaxis, en su mayoría se maneja con la siguiente:

attachInterrupt (digitalPinToInterrupt (pin), ISR, modo); //(recomendado)

attachInterrupt (Interrupt, ISR, modo); //(no recomendado)

attachInterrupt (pin, ISR, modo); //Arduino SAMD Boards, One WiFi Rev2, Due y 101

Conociendo lo anterior procedemos a crear nuestra propia ISR, usando los parámetros en lista:

• Interupt: Con este se indica el número de interrupciones que deseamos. La sintaxis que se deben ingresar para hacer referencia a este, es “int”.
• Pin: Así como lo indica su propio nombre solo es el número de pin de Arduino.
• ISR: En esta ocasión cuando hablamos del ISR, solo queremos hacer referencia a la llamada que hace a la interrupción. Es una función completamente libre de parámetros y no devuelve nada, en muchas ocasiones es solo una rutina del servicio.
• Modo: Con esta función se definen cuando se deben activar las interrupciones, y se basan en cuatro constantes de valores permitidos, como:
• Low: Se utiliza si queremos activar la interrupción siempre y cuando el pin está bajo.
• Change: Es utilizado para activa la interrupción cuando el valor del pin cambia.
• Rising: Cuando el pin cambia, de bajo a alto, este pin es utilizado.
• Falling: A diferencia del anterior este es cuando el valor del pin pasa de alto a bajo.

Probar interrupción

No solo debemos crear una interrupción, también, debemos probar de forma que confirmemos que el algoritmo funcione correctamente. Debido que es una prueba, tendremos que valorar el máximo de todo, así también el mínimo, por lo que, debemos ejecutar todas las paradas posibles, tanto largas como cortas, si notamos algo inusual en el sistema, se tendrá que cambiar el ISR, por lo contrario si todo marcha bien, debemos felicitarnos por el buen trabajo.

Lista de los mejores proyectos Arduino con Interrupciones que puedes hacer tu mismo para practicar

En esta última sección hablaremos de aquellos proyectos que puedes utilizar para practicar y ejercer todos tus conocimientos adquiridos para la creación de interrupciones.

Los siguientes son proyectos sencillos y adecuados para la programación:

Sensor aparca coches

Para cuidar la integridad del coche cuando aparcamos es conveniente crear un sensor con una placa de Arduino. Con este dispositivo sonará una alarma cada vez que el automóvil se acerca a un objeto en el momento de la maniobra, pero es importante que tenga un mecanismo de interrupción para que paralice el sonido luego de haber ejecutado la tarea.

Conociendo la sintaxis, crear el ISR de este proyecto es muy fácil de programar porque ejecuta tareas sencillas, y por otro lado la interrupción debe ser larga, de forma que anule todas las tareas ejecutadas. Tendrás que usar en este proyecto un modelo UNO de Arduino, tres sensores ultrasónicos, una protoboard, un kit de cables y dos mini pantalla de baterías. Cuando tengas todos estos elementos tendrás que ensamblarlos de acuerdo con la imagen te mostramos.

Luego, vas a tener que abrir IDE y escribir estas instrucciones para la programación:

#include <TM1651.h>

#define CLK 3 // Cableado de la pantalla derecha

#define DIO 2

#define CLK2 5 // Cableado de la pantalla izquierda

#define DIO2 4

#define trigPin 6 // Cableado de los módulos de ultrasonido R = Derecha L = Izquierda el otro es el medio

#define echoPin 7

#define trigPinR 8

#define echoPinR 9

#define trigPinL 10

#define echoPinL 11

#define Maxdistance 20 // Distancia máxima 20cm

larga duración ;

int distancia ;

TM1651 DisplayR ( CLK, DIO ) ;

TM1651 DisplayL ( CLK2, DIO2 ) ;

configuración vacía () {

pinMode ( trigPin, SALIDA ) ; // Pinmodes del HC-SR04 e inicio de las pantallas

pinMode ( echoPin, ENTRADA ) ;

pinMode ( trigPinR, SALIDA ) ;

pinMode ( echoPinR, ENTRADA ) ;

pinMode ( trigPinL, SALIDA ) ;

pinMode ( echoPinL, ENTRADA ) ;

init () ;

set ( MÁS BRILLANTE ) ;

init () ;

set ( MÁS BRILLANTE ) ;

}

bucle vacío () {

int distanciaM = CDistancia ( trigPin, echoPin ) ;       // Calculando todas las distancias llamando a la función de abajo

int distanciaR = CDistancia ( trigPinR, echoPinR ) ;

int distanciaL = CDistancia ( trigPinL, echoPinL ) ;

int R = min ( distancia M , distancia R ) ; // Tenemos dos pantallas R y L, primero tomamos la distancia mínima entre M / R y M / L

int L = min ( distanciaM, distanciaL ) ;

if ( R> 0 && R <Maxdistance ) {

Nivel corto R = mapa ( R, 0, Distancia máxima, 0,7 ) ;

displayLevel ( LevelR ) ;

}

if ( R> Maxdistance )

displayLevel ( 7 ) ;

if ( L> 0 && L <Maxdistance ) {

Nivel corto L = mapa ( L, 0, Distancia máxima, 0,7 ) ;

displayLevel ( LevelL ) ;

}

si ( L> Maxdistance )

displayLevel ( 7 ) ;

retraso ( 50 ) ;

}

int CDistance ( int a, int b ) { // Calculando la función de distancia

digitalWrite ( a, BAJO ) ;

delayMicroseconds ( 2 ) ;

escritura digital ( a, ALTA ) ;

delayMicroseconds ( 10 ) ;

digitalWrite ( a, BAJO ) ;

duración = pulseIn ( b, HIGH ) ;

distancia = duración * ( 0 .034 / 2 ) ;

distancia de regreso ; // Devuelve la distancia calculada

}

Semáforo inteligente

El típico semáforo de Arduino, es el segundo proyecto Arduino más sencillo, sin embargo, el nivel de dificultad radica cuando debemos crear una interrupción que anule una acción y permita la ejecución de otro proceso. Esto genera que se pueda cambiar de color de circulación. Para esto, el tipo de ISR que debe usarse debe ser corto y programado en factor al tiempo.

Teniendo en cuenta lo anterior, para crear tu propio semáforo inteligente vas a necesitar un Arduino Nano R3, luces leds genéricas, resistencias fotovoltaicas, cables y una resistencia de 100 Ohm. Cuando termines mira el diagrama que te dejamos para que unas los componentes.

Después abre la plataforma de programación e ingresa estos códigos:

// Elige el pin de entrada para el sensor LDR al lado del led

int ledSensor  =  A1  ;

// Elige el pin de entrada para el sensor LDR en la parte superior de la lámpara que siente la luz del sol

int sunSensor  =  A0  ;

// Elige el pin de entrada para el LED

int led  =  13  ;

int pirSensor  =  2  ;

int ledSensorValue  =  0 ;

// Esta es la variable para almacenar el valor proveniente del censor, en la parte superior de la lámpara que siente la luz solar

int sunSensorValue  =  0  ;

int pirSensorValue  =  0  ;

configuración vacía () {

Serial . comenzar ( 9600 );

pinMode ( led , SALIDA );

pinMode(pirSensor, INPUT);

}

void loop() {

sunSensorValue = analogRead(sunSensor);

if (sunSensorValue > 900 )

{

pirSensorValue = digitalRead (pirSensor);

if (pirSensorValue == 1)

{

digitalWrite(13, HIGH);

print(String(1));

print(",");

print(String(sunSensorValue));

print(",");

ledSensorValue = analogRead(ledSensor);

print(String(ledSensorValue));

print(",");

println(String(pirSensorValue));

}else if (pirSensorValue == 0){

digitalWrite(13, LOW);

print(String(0)); //led is off

print(",");

print(String(sunSensorValue));

print(",");

ledSensorValue = analogRead(ledSensor);

Serial .print(String(ledSensorValue));

print(",");

Serial . println(String(pirSensorValue));

}

}

// Si  (sunSensorValue < 900)

{

escritura digital ( 13, LOW);

Serial . imprimir ( Cadena ( 0));

Serial . impresión(",");

Serial . imprimir ( Cadena (sunSensorValue));

Serial . impresión(",");

ledSensorValue =  analogRead(ledSensor);

Serial . imprimir ( Cadena (ledSensorValue));

Serial . impresión(",");

pirSensorValue =  digitalRead (pirSensor);

Serial . println ( String ( pirSensorValue));

}

retraso ( 10000 ); // Demora 10 segundos y luego vuelve a tomar la lectura. Es aquí en donde se produce la interrupción

}

Sketch luces del coche

Este es uno de los proyectos Arduino más elegidos por los principiantes, debido que no solo nos permite decorar el coche y darle un sentido de lujo, sino también vas a poder practicar el IDE. Su programación es sencilla, por lo que no puedes dejar de lado este trabajo electrónico. Las interrupciones juegan un papel importante, debido que el sentido o flujo del proceso de cada una de las luces debe cambiar según sea nuestro gusto, por lo que el ISR permite el cambio anulando la tarea que se está ejecutando en el momento.

Necesitarás, para llevar adelante el proyecto, un Arduino Nano R3, una tira de led de 120 piezas, sodial de 3 mm, cables macho a macho y tres placas protoboard sin soldaduras de 400 puntos. A estos materiales los vas a poder unir entre sí teniendo en cuenta la imagen de arriba.

Por último, queda la parte de programación de la placa Arduino Nano Rev3, por lo que tendrás que cargar las secuencias que te indicamos a continuación:

byte ledPin[] = {3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

int ledDelay = 300 ;

int direccion = 1;

int LEDActual = 5;

unsigned long TiempoCambio;

void setup() {

for(int x=0; x<10 ; x++){

pinMode(ledPin[x], OUTPUT);

}

TiempoCambio = millis();

}

void loop() {

if ((millis() - TiempoCambio) > ledDelay){

cambioLED();

TiempoCambio = millis();

}

}

void cambioLED() {

for(int x=0; x<10 ; x++){

digitalWrite(ledPin[x],LOW);

}

digitalWrite(ledPin[LEDActual],HIGH);

LEDActual += direccion;

if (LEDActual == 9) {

direccion = -1;

}

if (LEDActual == 0) {

direccion = 1;

}

}