ACTIVIDAD PRÁCTICA Nº 2

ARQUITECTURA DE COMPUTADORAS 1

TEMA: Manejo de puertos de E/S, interrupciones y funciones del

sistema de la placa Galileo.

PROFESOR: Ing. José María Ducloux.

ALUMNOS:

 Alf. Irupé Arguello.

 Alf. Daniel Sztuka.
INDICE

1. INTRODUCCION ---------------------------------------------------------------- Pág. 3.

2. DESARROLLO ------------------------------------------------------------------- Pág. 4.
2.1. RESOLUCION DEL ENUNCAIDO Nº 1 --------------------------------
Pág. 4.
2.1.1. Código en IDE Arduino --------------------------------------------- Pág. 4.
2.1.2. Esquema circuital ---------------------------------------------------- Pág. 5.
2.1.3. Explicación ----------------------------------------------------------- Pág. 5.
2.2. RESOLUCION DEL ENUNCAIDO Nº 2 --------------------------------
Pág. 7.
2.2.1. Código en IDE Arduino --------------------------------------------- Pág. 7.
2.2.2. Esquema circuital ---------------------------------------------------- Pág. 7.
2.2.3. Explicación ----------------------------------------------------------- Pág.
8.
2.3. RESOLUCION DEL ENUNCAIDO Nº 3 --------------------------------
Pág. 9.
2.3.1. Código en IDE Arduino --------------------------------------------- Pág. 9.
2.3.2. Esquema circuital --------------------------------------------------- Pág.
11.
2.3.3. Explicación ---------------------------------------------------------- Pág. 11.

2
 1. INTRODUCCION

En este informe se mostrara como se utilizó una nueva metodología que permite
encender y apagar el LED sin usar “delay”.

Las consignas que se siguieron en este informe son las siguientes:

1) Codificar un programa que configure un puerto E/S como salida y que cambie su
estado cada un segundo. Conectar un LED externo o utilizar el disponible para
propósito general en la placa Galileo. El LED externo debe conectarse al puerto
a través de una resistencia de 1 KΩ. No usar la función delay(), utilizar
funciones del sistema para la temporización. Ver ejemplo “BlinkWithoutDelay”
del IDE de Arduino. Explicar el funcionamiento del código y las diferencias con
la utilización de la función delay().
2) Ídem al caso anterior pero utilizando interrupciones para la temporización. Ver
el ejemplo “ISRBlink” para Galileo del IDE de Arduino. Explicar el
funcionamiento del código y las diferencias con la utilización de la función
delay() y el ejercicio 1.
3) Mejorar el desempeño del ejercicio n.º 4 de la “Actividad Práctica n.º 1”
utilizando funciones del sistema o interrupciones según considere.

3
 2. DESARROLLO

2.1. RESOLUCION DEL ENUNCIADO Nº 1

2.1.1. Código en IDE Arduino:

const int ledPin = 2; // Numero de pin para el LED

int ledState = LOW; // Estado del LED al inicio

unsigned long previousMillis = 0; // Este renglón se usa para guardar la última

actualización del estado del LED

const long interval = 1000; // Se coloca en milisegundos el intervalo de encendido y

apagado

void setup() {

pinMode(ledPin, (OUTPUT); // Configura como salida el pin 2

void loop() {

unsigned long currentMillis = millis(); // La función millis devuelve el número de mseg

que transcurrieron

if (currentMillis - previousMillis >= interval) { // Compara si el tiempo actual menos el

tiempo que el LED cambio de estado es mayor que el intervalo

previousMillis = currentMillis; // Si se cumple se guarda el nuevo tiempo que el LED

cambia de estado

4
// Un nuevo IF que cambia el estado del LED. Lo pone alto si estaba bajo y viceversa

if (ledState == LOW) {

ledState = HIGH;

} else {

ledState = LOW;

digitalWrite(ledPin, ledState); // Da la orden al LED para que prenda o apague según

corresponda

2.1.2. Esquema Circuital:

5
 2.1.3. Explicación:

Mediante este código se logra lo mismo que utilizando la función “delay”. La

diferencia entre ambos es que utilizando “delay” el procesador se dedica pura y
exclusivamente a contar los milisegundos para asi poder apagar o encender el LED
según corresponda; Con este código en cambio el microprocesador se puede dedicar a
otra tarea.

En el mismo además de declarar las constantes y las variables al principio,

también se le suma una nueva variable que va a almacenar la última actualización del
estado del LED; A la misma dentro del loop se le asigna el valor de la función “millis”,
que da el tiempo actual transcurrido desde que comenzó a ejecutarse el código.

A continuación se encuentra un IF, que realiza una comparación entre el tiempo

actual menos el tiempo previo y el intervalo establecido; En caso que dicha resta sea
mayor o igual al intervalo asigna como tiempo previo el tiempo actual (para que en el
próximo loop este valor sea mayor y se pueda restar al tiempo actual que también va a
ser mayor ya que vuelve a adoptar como valor el tiempo transcurrido). Continuando
dentro del IF hay otro condicional que se encarga de asignarle un valor bajo al estado
del LED si su valor es alto o viceversa. Por último, el “digitalWrite” le da la orden que
se apague o prenda según corresponda.

6
 2.2. RESOLUCION DEL ENUNCIADO Nº 2

2.2.1. Código en IDE Arduino:

#include <TimerOne.h> // Esta biblioteca se utiliza para el temporizador. Crea un objeto

llamado Timer1

void setup() {

pinMode(12, OUTPUT); // Pin de salida conectado al LED

Timer1.initialize(1000000); // Inicia el temp. Duración 1000000 microseg (1 seg)

Timer1.attachInterrupt(timerIsr); // Interrumpe el temp e inicia la función entre

paréntesis

void loop() {

void timerIsr() { // Función de encendido/ apagado del LED

7
digitalWrite( 12, digitalRead( 12 ) ^ 1 ); // Enciende y apaga el LED

2.2.2. Esquema Circuital:

8
 2.2.3. Explicación:

Con este código se utiliza una interrupción. Al igual que el código del enunciado
1, se utiliza para que el procesador pueda ejecutar otras tareas; Pasado determinado
tiempo el loop se interrumpe para cambiar el estado del LED.

Al principio se llama a la librería “TimerOne”, que posee el temporizador para

que funcione la interrupción; Incluyéndola se crea un objeto llamado “Timer1”, que va a
ser el encargado de interrumpir la secuencia cuando pase un intervalo preestablecido.

Dentro del setup además de configurar el pin de salida para el LED se utiliza el
objeto mencionado anteriormente; acompañado del comando “initialize” se coloca entre
paréntesis el tiempo en el cual se quiere activar la interrupción (debe estar en
microsegundos).

Inmediatamente debajo se coloca el comando “attachInterrupt” que una vez

pasado el intervalo llama a la función encargada de cambiar el estado del LED (de
nombre “timerlsr”).

Luego del setup va el bucle y por último la función “timerlsr” que como se ve en
el código cambia el estado del LED utilizando un XOR binario, apagándolo si esta
encendido o viceversa.

9
 2.3. RESOLUCION DEL ENUMCIADO Nº 3

2.3.1. Código en IDE Arduino:

const int ledPin = 2; // Pin del LED

const int buttonPin = 8; // Pin del pulsador

int ledState = LOW; // Estado inicial del LED

int buttonState = 0; // Estado inicial del pulsador

unsigned long previousMillis = 0; // Guardara la última actualización del estado del

LED

long interval = 500; // Intervalo de parpadeo en mseg

long intervalo_off = 500; // Tiempo de apagado; es fijo

long intervalo_on = 500; // Tiempo de encendido inicial; es variable

byte bandera = 0; // Bandera para indicar cambio de estado del pulsador

void setup() {

Serial.begin(9600); // Habilita y configura el monitor serie

pinMode(ledPin, OUTPUT); // Configura el puerto E/S como salida; LED de propósito

general

pinMode(buttonPin, INPUT); // Configura el puerto E/S como entrada; pulsador

void loop() {

unsigned long currentMillis = millis();

if (currentMillis - previousMillis >= interval) {

10
previousMillis = currentMillis; // Si se cumple se guarda el nuevo tiempo que el LED
cambia de est.

// Un nuevo IF que cambia el estado del LED. Lo prende si estaba apagado y viceversa

if (ledState == LOW) {

ledState = HIGH;

interval = intervalo_on; // Asigna el tiempo de encendido actual

else {

ledState = LOW;

interval = intervalo_off; // Asigna el tiempo de apagado

digitalWrite(ledPin, ledState); // Da la orden al LED para prenda o apague según

corresponda

buttonState = digitalRead(buttonPin); // Lee el estado del pulsador

// Activa la bandera si el pulsador fue presionado

if (buttonState == LOW) {

bandera = 1;

// Si el pulsador regresa a su estado de no presionado y si la bandera fue activada

if ((buttonState == HIGH) && (bandera == 1)) {

bandera = 0;

intervalo_on += 100; // Incrementa el valor del tiempo de encendido

11
if (intervalo_on > 1500) intervalo_on = 500; // Si se superan los 1500 ms, se reinicia a
500 ms

Serial.println("El tiempo de encendido es:");

Serial.println(intervalo_on);

2.3.2. Esquema circuital:

2.3.3. Explicación:

En este código se utiliza la función “millis” para apagar y prender el LED.

Primero se asignan los pines al pulsador y al LED, luego los estados iniciales de ambos
y por ultimo una variable que guardara el tiempo que haya transcurrido según millis.

Además se declaran los intervalos de apagado, encendido y una bandera que se

utilizara para indicar el cambio de estado del pulsador (adopta el valor de 1 si se
presionó); Dentro del setup se configuran los pines y se habilita el monitor serie.

Ya dentro del bucle se le asigna a la variable de tiempo actual (“currentMillis”)

el valor de la función millis, dando el tiempo actual transcurrido desde que comenzó a
ejecutarse el código.

12
 A continuación se encuentra un IF, que realiza una comparación entre el tiempo
actual menos el tiempo previo y el intervalo establecido; En caso que dicha resta sea
mayor o igual al intervalo asigna como tiempo previo el tiempo actual (para que en el
próximo loop este valor sea mayor y se pueda restar al tiempo actual que también va a
ser mayor ya que vuelve a adoptar como valor el tiempo transcurrido).

Continuando dentro del IF, hay otro condicional encargado de asignarle un valor
bajo al estado del LED si su valor es alto o viceversa, asi como también el valor del
“intervalo_on” si esta alto o “intervalo_off” si está bajo; Según corresponda el
“digitalWrite” le da la orden que se apague o prenda al LED.

Luego de esta línea continua un IF que cambia el valor de la bandera a 1 si se

presiona el pulsador.

Por último, sigue otro IF que será el encargado de agregarle los 100
milisegundos al intervalo de encendido cuando el botón este arriba y la bandera es 1 (lo
que quiere decir que se presionó el pulsador para agregar tiempo). Esto lo va a hacer
siempre y cuando el “intervalo_on” sea menor a 1500, si no se cumple dicha condición
el valor de “intervalo_on” vuelve a 500 mseg. Cabe aclarar que antes de realizar una
adición o reseteo del intervalo se coloca nuevamente el valor de la bandera en 0.

Asimismo, también se encuentra el mensaje que muestra en el monitor serie el

tiempo de encendido.

13