Diseño de sistemas Embebidos de alto nivel, Guía 1

Facultad: Ingeniería
Escuela: Electrónica
Asignatura: Diseño de sistemas Embebidos
de alto nivel

Tema: Manejo de interrupciones

Objetivos Específicos

1. Conocer el uso de la librería para uso de interrupciones programadas

2. Desarrollar aplicaciones mediante interrupciones externas

Material y Equipo

No Cantidad Descripción
1 1 Una computadora con sistema operativo Windows y con el
programa Arduino IDE instalados
2 1 Cable USB (tipo A hacia tipo B)
3 1 Tarjeta Arduino UNO R2 o R3
4 4 Resistencias de 4.7kΩ
5 4 LEDs
6 4 Botones pulsadores
7 1 Breadboard
8 1 Pinza
9 1 Cortadora
10 Varios Cables UTP
11 10 Potenciometros

Introduccion Teórica

Interrupciones programadas
Normalmente asociadas a la librería

#include <TimerOne.h>

Esto nos crea un objeto llamado Timer1 directamente, sin necesidad de instanciarlos. Lo
siguiente es programar el intervalo de disparo en microsegundos:

Timer1.initialize(150000); // 150 ms
2

Lo siguiente es decirle la función que deberá ejecutarse cada vez que pase el tiempo
configurado:

Timer1.attachInterrupt( ISR_Servicio) ;

Luego es necesario incorporar la función de servicio:

Void ISR_Servicio()
{

Interrupciones externas
Para definir una interrupción en Arduino usamos la función:

attachInterrupt(interrupt, ISR, mode);

Donde interrupt es el número de la interrupción que estamos definiendo, ISR la función de

callback asociada, y mode una de las opciones disponibles (Falling, Rising, Change y Low)

No obstante, es más limpio emplear la función digitalPinToInterrupt(), que convierte un Pin a

la interrupción equivalente. De esta forma se favorece el cambio de modelo de placa sin
tener que modificar el código.

attachInterrupt(digitalPinToInterrupt(pin), ISR, mode);

Otras funcionas interesantes para la gestión de interrupciones son:

DetachInterrupt(interrupt ), anula la interrupción.

NoInterrupts(), desactiva la ejecución de interrupciones hasta nueva orden. Equivale a sli()
Interrupts(), reactiva las interrupciones. Equivale a cli()

Procedimiento

Parte I

Ejecute el siguiente código

#include <TimerOne.h>
const int led = 13; // the pin with a LED
int ledState = LOW; // El LED empieza apagado
volatile int segundos=0,conteo;
volatile unsigned long blinkCount = 0; // La definimos como volatile
 Diseño de sistemas Embebidos de alto nivel, Guía 1
3

void setup(void)
{
pinMode(led, OUTPUT);
Timer1.initialize(5000000);
Timer1.attachInterrupt(ISR_Blink); // Activa la interrupcion y la asocia a ISR_Blink
Serial.begin(9600);
}
void ISR_Blink()
{ ledState = !ledState ;
segundos++ ; // Contador veces se enciende el LED

//Serial.print(segundos);

}
void loop(void)
{
unsigned long N; // Haremos copia del blinkCount
digitalWrite(led, ledState); // Asignamos el valor del
// status a la salida
noInterrupts(); // Suspende las interrupciones
N = blinkCount;

interrupts(); // Autoriza las interrupciones

Reto:
Utilizando el timer haga un semáforo de 4 leds que siga la secuencia de 18 segundos
en rojo, 3 segundos en amarillo 10 segundos en verde y 4 segundos en cruceizq.
Los tiempos deben ser modificables para que hagan sus pruebas.

Parte II
Arme el siguiente circuito
4

Figura 1. Diagrama de circuito para la parte 2

1. Con el circuito correctamente armado, proceda a conectar el cable USB al Arduino, y

suba el siguiente sketch:

// Variable global de velocidad

volatile int velocidad = 20;
// Constantes de velocidad máxima, mínima y cuanto aumenta
const int maxima = 1000;
const int minima = 20;
const int aumenta = 20;

// Array con los números de los pines donde están conectados

// los LEDs de las luces
 Diseño de sistemas Embebidos de alto nivel, Guía 1
5

int leds[5] = {8, 9, 10, 11, 12};

void setup() {
// Inicializamos los pines de los LEDs como salida y a estado bajo
for (int i = 0; i < 5; i++)
{
pinMode(leds[i], OUTPUT);
digitalWrite(leds[i], LOW);
}

// Asignamos la velocidad mínima

velocidad = minima;

// Configuramos los pines de interrupciones para que

// detecten un cambio de bajo a alto
attachInterrupt(digitalPinToInterrupt(2), velocidadMenos, RISING);
attachInterrupt(digitalPinToInterrupt(3), velocidadMas, RISING);

void loop() {
// Este primer bucle recorre el array de izquierda a derecha
for (int i = 0; i < 5; i++)
{
// Solo para el segundo pin y consecutivos apagamos el pin anterior
// En el caso de 0 no hace falta ya que por defecto está apagado
// Cuidado que nos salimos del rango del array 0-1=-1 no existe este elemento
if (i > 0)
{
// Apagamos el LED a la izquierda
digitalWrite(leds[i - 1], LOW);
}

// Encendemos en el LED en el que estamos

digitalWrite(leds[i], HIGH);

// Esperamos el tiempo marcado por velocidad

delay(velocidad);
}

// Apagamos el último LED encendido, el elemento 5 del array

digitalWrite(leds[4], LOW);

// Recorremos el array en sentido inverso de derecha a izquierda

for (int i = 4; i >= 0; i--)
{
6

// En el primer caso como ya está apagado el LED no hacemos nada

// Cuidado que nos salimos del rango del array 4+1=5 no existe este elemento
if (i < 4)
{
// Apagamos el LED a la derecha
digitalWrite(leds[i + 1], LOW);
}
// Encendemos en el LED en el que estamos
digitalWrite(leds[i], HIGH);

// Esperamos el tiempo marcado por velocidad

delay(velocidad);
}

// Apagamos el último LED encendido, el elemento 0 del array

digitalWrite(leds[0], LOW);

// ISR pin 2, disminuye la velocidad

void velocidadMenos()
{
// Disminuimos el valor establecido
velocidad = velocidad - aumenta;

// Si hemos llegado a la velocidad mínima no disminuímos más

if (velocidad < minima)
{
velocidad = minima;
}
}

// ISR pin 3, aumenta la velocidad

void velocidadMas()
{
// Aumentamos el valor establecido
velocidad = velocidad + aumenta;

// Si hemos llegado a la velocidad máxima no aumentamos más

if (velocidad > maxima)
{
velocidad = maxima;
}
}
Listado 1. Sketch para la parte 2.
 Diseño de sistemas Embebidos de alto nivel, Guía 1
7

2. Pruebe el programa y explique que hace:

__________________________________________________________________

__________________________________________________________________

RETO: haga un programa que le permita leer datos de una entrada análoga
Y que por medio de las interrupciones se tenga la función de activar o desactivar la
lectura constante de la entrada análoga.

Bibliografía

 Sitio web de los desarrolladores: www.arduino.cc

 Referencia en línea del lenguaje: http://arduino.cc/en/Reference/HomePage
 Massimo Banzi, “Getting started with Arduino” O'Reilly Media / Make Publisher, Marzo
2009, ISBN: 978-0-596-15551-3
8

Hoja de cotejo: 1

Guía : Manejo de interrupciones en Arduino

Alumno: Maquina No:

Docente: GL: Fecha:

EVALUACION

% 1-4 5-7 8-10 Nota

CONOCIMIENTO 25% Conocimiento Conocimiento y Conocimiento

deficiente de los explicación completo y
fundamentos incompleta de los explicación clara
teóricos fundamentos de los
teóricos fundamentos
teóricos

APLICACIÓN DEL 70% No Terminó Terminó Terminó

CONOCIMIENTO completamente el completamente el completamente el
programa y programa pero los programa con sus
comentó mal el comentarios no comentarios
código (30%) estaban del todo correctos
correctos
No realizó el El circuito
circuito El circuito funcionó
correctamente funcionó
(40%)

ACTITUD 2.5 Es un observador Participa Participa

% pasivo. ocasionalmente o propositiva e
lo hace integralmente en
constantemente toda la práctica.
pero sin
coordinarse con su
compañero.

2.5 Es ordenado; pero Hace un uso Hace un manejo

% no hace un uso adecuado de los responsable y
adecuado de los recursos, respeta adecuado de los
recursos las pautas de recursos conforme
seguridad; pero es a pautas de
desordenado. seguridad e
higiene.
 Diseño de sistemas Embebidos de alto nivel, Guía 1
9

TOTAL 100
%