Laboratorio 11-ELECTRONICA DIGITAL-2020-I

Vista previa del material en texto

Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
1 
 
 
 
 
 
 
 
 
UNIVERSIDAD 
 
 NACIONAL DE LA 
 
 AMAZONIA PERUANA 
 
 
 
 
FACULTAD DE INGENIERIA 
 
DE SISTEMAS E INFORMATICA 
 
LABORATORIO DE ELECTRONICA DIGITAL 
 
 
GUIA - INFORME Nº11 
CURSO : ELECTRONICA DIGITAL 
 TEMA : Las Entradas y Salidas Digitales y 
 Transmisión en Serie 
 PROFESOR : 
 GRUPO : 
 ALUMNO : 
 CODIGO : 
 
 NOTA: 
 
 FECHA EXPE.: SEMEST. ACADÉ. 2020 - I 
 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
2 
 
 
 
11avo LABORATORIO 
Tema: Las Entradas y Salidas Digitales y Transmisión en Serie 
Objetivo: Explicar, analizar y aplicar en la simulación de circuitos, las entradas y salidas 
digitales y la transmisión en serie de la placa Arduino Uno. 
Material y Equipo: 
 Diodos LED 
 Resistencias 
 Un Protoboard 
 Cablecitos de Conexión 
 Una Tarjeta Arduino Uno 
 Cable USB 
EXPERIENCIA No 1: Encendiendo y Apagando LED 
En esta primera experiencia vamos a simular el juego de luces del famoso auto fantástico de la 
serie de televisión que se hizo popular en los años ochenta. 
El algoritmo que se implementará es el que se muestra en la Figura 1. 
Se trata de apagar y encender los LED con esperas de tiempo intercaladas para producir un efecto 
de movimiento de la luz que recorre estos diodos emisores de luz. 
 
 
 
 
 
 
 
 
 
Figura 1.- Algoritmo del auto fantástico 
 
Encender LED 1
Esperar ½ seg
Apagar LED 1
Encender LED 2
Esperar ½ seg
Apagar LED 2
Encender LED 3
Apagar 1/2 seg
Apagar LED 3
Encender LED 4
Esperar ½ seg
Apagar LED 4
Encender LED 5
Esperar ½ seg
Apagar LED 5
Encender LED 6
Apagar 1/2 seg
Apagar LED 6
Encender LED 5
Esperar ½ seg
Apagar LED 5
Encender LED 4
Apagar 1/2 seg
Apagar LED 4
Encender LED 3
Apagar 1/2 seg
Apagar LED 3
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
3 
 
 
 
 
Conectamos los cinco diodos LED a los pines digitales (2 al 6) a través de las cinco resistencias 
limitadoras. Examinemos ahora el sketch que debemos escribir, guardar y subir a nuestro Arduino 
para comprobar su funcionamiento. 
Programa Auto Fantástico: 
void setup() 
 // put your setup code here, to run once: 
{ 
 pinMode(2,OUTPUT); 
 pinMode(3,OUTPUT); 
 pinMode(4,OUTPUT); 
 pinMode(5,OUTPUT); 
 pinMode(6,OUTPUT); 
} 
void loop() 
// put your main code here, to run repeatedly: 
{ 
 digitalWrite(2,HIGH); 
 delay(500); 
 digitalWrite(2,LOW); 
 digitalWrite(3,HIGH); 
 delay(500); 
 digitalWrite(3,LOW); 
 digitalWrite(4,HIGH); 
 delay(500); 
 digitalWrite(4,LOW); 
 digitalWrite(5,HIGH); 
 delay(500); 
 digitalWrite(5,LOW); 
 digitalWrite(6,HIGH); 
 delay(500); 
 digitalWrite(6,LOW); 
 digitalWrite(5,HIGH); 
 delay(500); 
 digitalWrite(5,LOW); 
 digitalWrite(4,HIGH); 
 delay(500); 
 digitalWrite(4,LOW); 
 digitalWrite(3,HIGH); 
 delay(500); 
 digitalWrite(3,LOW); 
} 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
4 
 
 
TIP 1: 
• pinMode (pin, mode): Esta instrucción es utilizada en la parte de configuración setup() y 
sirve para configurar el modo de trabajo de un pin, pudiendo ser el parámetro mode como 
INPUT (entrada) u OUTPUT (SALIDA). 
• Los terminales de Arduino, por defecto, están configurados como entradas por lo tanto, no 
es necesario definirlos en el caso de que vayan a trabajar como entradas. 
• Los pines configurados como entrada quedan, bajo el punto de vista eléctrico, como 
entradas en estado de alta impedancia. 
• Estos pines tienen a nivel interno una resistencia de 20 KΏ a las que se puede acceder 
mediante software. A estas resistencias se accede de la siguiente manera. 
pinMode (pin, INPUT); // configura el ‘pin’ como entrada 
digitalWrite (pin, HIGH): // activa las resistencias internas 
• Los pines configurados como OUTPUT (Salida) se dice que están en un estado de baja 
impedancia y pueden proporcionar 40 mA de corriente a otros dispositivos. 
• Esta corriente es suficiente para alimentar un diodo LED, pero no es lo suficientemente 
grande como para alimentar cargas de mayor consumo como relés, solenoides o motores. 
• digitalWrite (pin, mode): Envía al pin definido previamente como OUTPUT el valor 
HIGH o LOW (poniendo en 1 o 0 LA SALIDA). Por ejemplo: 
 digitalWrite (pin, HIGH); // Saca por el pin un valor HIGH (alto o 1) 
 digitalWrite ( 3, LOW); // Saca por la patilla 3 un valor LOW (bajo o 0) 
• Delay (milisegundos): Detiene la ejecución del programa la cantidad de tiempo en 
milisegundos que se3 indica en la propia función, de tal manera que 1000 equivale a 1 
segundo. 
 delay (2000 ): // Espera 2 segundos 
• Ahora vamos a construir el circuito, Figura 2 
• El Hardware que necesitamos es lo siguiente: 
Cinco Dios LED Cinco Resistencias de 220 Ω. 
Un Protoboard Cablecitos de Conexión 
Una Tarjeta Arduino Uno Cable USB 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
5 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 2.- Circuito del programa el auto fantástico 
Cuando analizamos el sketch anterior nos daremos cuenta que tanto el algoritmo como el 
programa propiamente dicho, tienen partes que se repiten continuamente y aunque utilice la 
opción «copiar y pegar» dentro del lDE, la verdad es que no es muy flexible. Por ello vamos a 
cambiar un par de cosas. 
Primero introduciremos una variable de tipo int para poder variar el tiempo de espera en la 
función delay(ms). Después reemplazaremos el código principal por otro más corto que use la 
potencia de la estructura for. A esto, los programadores experimentados lo llaman: optimizar el 
código. 
 
EXPERIENCIA N° 1.1. Mejorando el Código: 
Programa Mejorado 
int d = 100; 
 void setup() { 
 // put your setup code here, to run once: 
pinMode(2,OUTPUT); 
 pinMode(3,OUTPUT); 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
6 
 
 
 pinMode(4,OUTPUT); 
 pinMode(5,OUTPUT); 
 pinMode(6,OUTPUT); 
void loop() 
{ 
 // put your main code here, to run repeatedly: 
for (int a = 2; a < 7; a++) 
 { 
 digitalWrite (a, HIGH); 
 delay (d); 
 digitalWrite(a, LOW); 
 } 
for ( int a = 5; a > 2; a--) 
 { 
 digitalWrite ( a, HIGH); 
 delay (d); 
 digitalWrite ( a, LOW); 
 delay (d); 
 } 
} 
EXPERIENCIA N° 2: Controlando el Encendido de un LED Mediante un Pulsador 
El propósito de esta experiencia es encender un LED mediante un pulsador, el cual permanecerá 
prendido durante 2 segundos, luego del cual se apagará hasta que volvamos a presionar el pulsador. 
El algoritmo es el siguiente 
 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
7 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 3.- Algoritmo de encendido de un LED usando un pulsador 
El hardware que necesitamos es el siguiente: 
Un diodo LED Una resistencia de 220 Ω 
Una resistencia de 10 KΩ Un pulsador de tipo mini 
Un Protoboard Cablecitos de conexión 
Un Arduino Uno Un cable USB 
Conectaremos el pulsador al pin digital 7 a través de una resistencia pull-up de 10 kΏ. 
Esta resistencia se lleva por el otro terminal a 5 voltios. 
El diodo LED se conecta al pin 2 a través de una resistencia de220 Ώ 
 
 
 
 
 
 
Figura 4.- Configuración pull up y pull down 
 
Pulsador
?
Encender LED
Esperar 2 seg
Apagar LED
SI Presionado
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
8 
 
 
TIP 2: 
• Código de Colores de las Resistencias Eléctricas 
 
 
 
 
 
 
 
 
 
 
 
 
a) Código de Colores 
 
 
 
 
b) Colores en la Resistencia 
 
 
 
 
c) Explicación de Código de Colores 
Figura 5.- Código de Colores en las Resistencias Eléctricas 
 
 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
9 
 
 
Programa de Encendiendo un LED con un Pulsador 
/*Encendiendo un led durante dos segundos con un pulsador*/ 
#define LED 12 
#define BUTTON 7 
void setup() 
{ 
 // put your setup code here, to run once: 
 pinMode(LED,OUTPUT); 
 pinMode(BUTTON,INPUT); 
} 
void loop() { 
 // put your main code here, to run repeatedly: 
 if(digitalRead(BUTTON)== HIGH) 
 { 
 digitalWrite(LED,HIGH); 
 delay(2000); 
 digitalWrite(LED,LOW); 
 } 
} 
La dinámica del programa es simple. Testeamos continuamente el estado del pulsador cuyo estado 
en reposo produce un 0 en el pin de entrada 7 del Arduino. Si no activamos el pulsador testeamos 
el if indefinidamente. En cuanto pulsemos, el estado de la patilla 7 cambia a voltaje positivo y 
entonces se ejecuta las acciones que van comprendidas entre llaves, es decir, el encendido del 
LED, la espera de 2 segundos y el apagado del diodo. Tras esto, volvemos al principio del 
void(loop), ejecutando de nuevo el testeo del pulsador con la estructura if. 
TIP 3: 
• # define: Es un comando del Lenguaje C muy útil que permite al programador dar un 
nombre a un valor constante antes de que se compile el programa. 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
10 
 
 
• Las constantes definidas en Arduino no aumentan el tamaño que el programa ocupa en el 
chip. 
• El compilador reemplaza las referencias a estas constantes con el valor definido en 
tiempo de compilación. 
• Básicamente utilizaremos “# define” para etiquetar los pines digitales y de esta manera 
cada vez que en el programa se haga referencia a esa etiqueta se apuntara a su valor. 
• Por ejemplo, en nuestro ejemplo, en nuestro sketch cada vez que utilizamos la palabra 
LED hacemos referencia al pin 12 del Arduino 
• digitalRead(pin). Lee el valor de un pin (definido como digital) dando un resultado 
HIGH (alto) o LOW (bajo) y pudiendo depositar este valor en una variable. Por ejemplo: 
 valor = digitalRead(4); 
Implementemos el circuito: 
 
 
 
 
 
 
 
 
 
 
 
 Figura 6.- Diagrama del circuito de encendido de un LED con un pulsador (Button) 
En esta sentencia se lee el estado del pin 7 y se deposita su estado alto o bajo, en la variable valor 
que se supone que se ha definido previamente como de tipo booleano o entero. Evidentemente, 
esto es útil para evaluar el estado abierto o cerrado de un pulsador o interruptor. Por ello, cuando 
en el sketch anterior tenemos las expresión: /lif (digitaIRead(BUTTON) == HIGH)" lo que 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
11 
 
 
estamos haciendo es evaluar si el pin 7 definido con el nombre BUTTON, está HIGH o LOW. Es 
decir, testeamos el estado del pulsador y en función de su estado ejecutamos lo que está dentro de 
las llaves del if o no lo hacemos. 
EXPERIENCIA N° 3: Control de dos Semáforos. Un Proyecto Completo con LED y 
Pulsadores: 
En una primera instancia vamos a resolver el diseño solo considerando la sincronización de los 
dos semáforos: el de entrada al túnel y el de salida. De nosotros depende que no se encuentren dos 
autos en medio del mismo, ya que como observamos en la foto, la carretera solo tiene un carril. 
Para simular los dos semáforos utilizaremos 6 diodos LEO:2 de color rojo, 2 de color verde y 2 de 
color amarillo (a falta del color ámbar). Esto se puede observar en la Figura 8, cuyo esquema se 
ha realizado con Proteus. Vemos el diagrama de flujo (Figura 9) en el que observamos cómo se 
cumple la secuencia típica de un cruce de semáforos normal. Mientras que un semáforo está en 
rojo, el otro luce en verde, y viceversa. Los cambios de un color a otro se producen tras una espera 
determinada que, en nuestro caso, suponemos de varios segundos. El tiempo de cambio de cada 
semáforo podemos establecerlo en 2 minutos ya por esta carretera no existe demasiado tráfico. 
 
 
 
 
 
 
 
 
 Figura 7.- Entrada al túnel 
 En cuanto al hardware que necesitamos: 
6 diodos LED de varios colores. 6 resistencias de 220 Ω 
Un Protoboard Cablecitos de conexión. 
Un Arduino un cable USB 
 
 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
12 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 FIGURA 8.- Diagrama del circuito del túnel con dos semáforos 
 
 
 
 
 
 
 
 
 
 
 Figura 9.- Algoritmo del programa 
Este es el esquema de semáforos: 
 
 
Semáforo 1: ROJO
Semáforo 2: VERDE
Espera...
Semáforo 1: ROJO
Semáforo 2: Amarillo
Semáforo 1: VERDE
Semáforo 2: ROJO
Espera...
Semáforo 1: AMARILLO
Semáforo 2: ROJO
Semáforo 1: ROJO
Semáforo 2: VERDE
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
13 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Figura 10.- Esquema de semáforos 
Programa de Control de dos Semáforos: 
 
 
 
 
 
 
 
 
 
 
 
 
 
• Color ROJO asociado al pin 7
• Color AMARILLO asociado al pin 6
• Color VERDE asociado al pin 5
Semáforo 1 (Situado a la entrada del 
túnel)
• Color ROJO asociado al pin 4
• Color AMARILLO asociado al pin 3
• Color VERDE asociado al pin 2
• Semáforo 2 (situado a la salida del 
túnel)
 
Inicializa los pines 2-6 
del Arduino utilizando 
el bucle for 
Parpadeo del Verde 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
14 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
digitalWrite(5,HIGH);
delay(500);
digitalWrite(5,LOW);
delay(500);
digitalWrite(5,HIGH);
delay(500);
digitalWrite(5,LOW);
delay(500);
digitalWrite(6,HIGH);
delay(3000);
digitalWrite(6,LOW);
digitalWrite(7,LOW);
digitalWrite(4,LOW);
semaforo_1();
} 
 
Luz Amarilla se enciende 
durante 3 segundos 
Cambia el Semáforo 2 a Rojo 
Parpadeo del 
 
Luz Amarilla se Enciende 
durante 3 Segundos. 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
15 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Ahora tenemos un nuevo concepto que es el de función. Una función es un trozo de código que 
se va a utilizar varias veces dentro del mismo programa. Una función es, por tanto, un bloque de 
código que tiene un nombre y un conjunto de sentencias. Las funciones se declaran asociadas a un 
tipo de valor: type. Este valor será el que devolverá la función, por ejemplo, int se utilizará cuando 
la función devuelva un dato numérico de tipo entero. Si la función no devuelve ningún valor, 
entonces se colocará delante la palabra void, que significa “función vacía”. Después de declarar el 
tipo de dato que devuelve la función se debe escribir el nombre de la función y entre paréntesis se 
pondrán, si es necesario, los parámetros que se deben pasar a la función para que se ejecute. Su 
formato específico es el siguiente: 
 type nombreFunción(parámetros) 
 { 
 Sentencias que se ejecutan al llamar a esta función; 
 } 
En el ejemplo tenemos dos funciones diferenciadas: la función semáforo_1() y la función 
semáforo_2(). Son de tipo void porque no devuelven nada; solo ejecutan una serie de acciones para 
 
void loop() 
{
for(int pin = 2 ; pin <= 
7; pin++)
{
digitalWrite(pin,LOW);
}
digitalWrite(2,HIGH);
digitalWrite(7,HIGH);
semaforo_1();
}
Inicializamos todas las luces 
con el Estado de Apagado. 
Luz Verde en un Semáforo y 
roja en el otro para comenzar 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
16 
 
 
gobernar las luces de las que consta cada semáforo. Además, como vemos, las hemos definido 
antes de la estructura loop(). 
EXPERIENCIA 3.1.- Control de Circulación del túnel Completo 
Ahora nos toca prestar un poco de atención a los peatones que deseen atravesar el túnel, sin miedo 
a ser atropellados. Para ello dotamos al diseño de dos pulsadores que, cuando se sean activados, 
deben cambiar el flujo normal de funcionamiento de los dos semáforos. La idea es que cuando 
cualquiera de los dos pulsadores, tanto en una boca u otra del túnel, sea presionado y, tras una 
espera de tiempo razonable, se actúe sobre los dos semáforos poniéndolos en luz ROJA para 
permitir que los peatones circulen sin peligro. 
Para ello vamos a testear los dos pulsadores de los peatones durante la secuencia de 
funcionamiento de los dos semáforos; exactamente, después del parpadeo de la luz amarilla. Si 
cualquiera de los pulsadores ha sido activado se deben poner en rojo los dos semáforos de los 
coches y en verde los dos indicadores de paso de peatones. 
Se han utilizado cuatro pines más para el control del paso de peatones. Por otra parte, se han 
añadido cuatro luces: una roja y otra verde para el control de paso del peatón posible en la entrada 
del túnel. Una más para el peatón de la salida del túnel. 
 
 
 
 
 
 
 
 
 
 
 
 
 Figura 11.- Primer Diagrama 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
17 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Figura 12.- Diagrama de Conexiones del Semáforo del Peatón 
Los peatones pueden pulsar el botón de solicitud de paso en cualquier momento. 
Por ello, debemos “enclavar” o retener esa petición hasta que la ejecución del programa pase 
después de hacer parpadear la luz amarilla en cualquiera de los dos semáforos. 
La retención de la solicitud a través de los pulsadores se realiza con dos biestables asíncronos 
RS. 
Cuando algún peatón presione cualquiera de los dos pulsadores, la salida de su correspondiente 
biestable se pondrá en estado alto, y permanecerá así hasta que obliguemos a pasar su salida a un 
estado bajo mediante la patilla del Arduino: REINICIO_BIESTABLE. 
La parte del diseño correspondiente a los pulsadores de los peatones y sus correspondientes 
biestables RS se puede observar en la figura 13. 
El listado de código se muestra a continuación: 
Como observamos, el listado es bastante largo, pero muy sencillo de seguir. 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
18 
 
 
Lo que hemos añadido es una función llamada semáforo_peatones() que actúa sobre los 
indicadores de los mismos cuando alguno de los pulsadores de peatones se han activado. 
El testeo de dichos pulsadores se hace siempre después de parpadear la luz amarilla de los dos 
semáforos. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Figura 13.- Diagrama de los dos pulsadores para los peatones 
Programa de Control de Circulación del 
Tunel Completo 
void setup() 
{ 
 // put your setup code here, to run once: 
 for(int pin=2; pin<=7; pin++) 
 { 
 pinMode(pin,OUTPUT); 
 } 
 pinMode(8,INPUT); 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
19 
 
 
 pinMode(9,OUTPUT); 
 pinMode(12,OUTPUT); 
 pinMode(13,OUTPUT); 
} 
void semaforo_peatones() 
 { 
 digitalWrite(2,LOW); 
 digitalWrite(3,LOW); 
 digitalWrite(5,LOW); 
 digitalWrite(6,LOW); 
 digitalWrite(4,HIGH); 
 digitalWrite(7,HIGH); 
 digitalWrite(13,LOW); 
 digitalWrite(12,HIGH); 
 delay(3000); 
 digitalWrite(12,LOW); 
 digitalWrite(13,HIGH); 
 digitalWrite(9,HIGH); 
 delay(10); 
 digitalWrite(9,LOW); 
 } 
void semaforo_1() 
 { 
 digitalWrite(2,HIGH); 
 delay(3000); 
 digitalWrite(2,LOW); 
 digitalWrite(3,HIGH); 
 delay(500); 
 digitalWrite(3,LOW); 
 delay(500); 
 digitalWrite(3,HIGH); 
 delay(500); 
 digitalWrite(3,LOW); 
delay(500); digitalWrite(3,HIGH); 
 delay(500); 
 digitalWrite(3,LOW); 
if(digitalRead(8)== HIGH) 
 { semaforo_peatones(); 
 } 
 digitalWrite(7,LOW); 
 digitalWrite(4,HIGH); 
 semaforo_2(); 
 } 
void semaforo_2() 
 { 
 digitalWrite(5,HIGH); 
 delay(3000); 
 digitalWrite(5,LOW); 
 digitalWrite(6,HIGH); 
 delay(500); 
digitalWrite(6,LOW); 
 delay(500); 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
20 
 
 
 digitalWrite(6,HIGH); 
 delay(500); 
 digitalWrite(6,LOW); 
 delay(500); 
 digitalWrite(6,HIGH); 
 delay(500); 
 digitalWrite(6,LOW); 
 if(digitalRead(8)== HIGH) 
 { 
semaforo_peatones(); 
 } 
 digitalWrite(7,HIGH); 
 digitalWrite(4,LOW); 
 semaforo_1(); 
 } 
void loop() 
 { 
 // put your main code here, to run 
repeatedly: 
 for(int pin = 2 ; pin <= 7; pin++) 
 { 
 digitalWrite(pin,LOW); 
 } 
 digitalWrite(2,HIGH); 
 digitalWrite(7,HIGH); 
 digitalWrite(13,HIGH); 
 digitalWrite(9,HIGH); 
 delay(10); 
 digitalWrite(9,LOW); 
 semaforo_1(); 
 } 
 
En la figura 14 vemos el circuito completo diseñado y simulado en Proteus. 
 
 
 
 
 
 
 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
21 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Figura 14.- Diagrama del circuito de Control de Circulación Completo del Túnel 
EXPERIENCIA 4: Contador de Pulsaciones 
El programa debe mostrar en pantalla del ordenador el número de veces que un pulsador ha sido 
presionado. 
Se realiza un proceso que, de acuerdo al número de pulsaciones, encienda o apague un LED. 
Para hacernos una idea, en la figura 15 se muestra el esquema realizado en Proteus. 
El LED se encenderá cuando se pulse cinco veces consecutivas y se apagará cuando el número 
de pulsaciones sea de ocho. 
El condensador de 100 nf produce una pequeña espera que amortigua el rebote del pulsador. 
El hardware que se necesitará es el siguiente: 
1 diodo LED de cualquier color. Condensador de 100 nF, 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
22 
 
 
Resistencia1 de 220 Ω 1 pulsador tipo mini 
Cablecitos de conexión. Un Arduino y un cable USB. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Figura 15.- Diagrama del Circuito del Contador de Pulsaciones 
Programa Contador de Pulsaciones 
//Contando Pulsaciones 
int conta=0; 
void setup() { 
 // put your setup code here, to run once:Serial.begin(9600); 
 pinMode(2,INPUT); 
 pinMode(13,OUTPUT); 
} 
void loop() { 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
23 
 
 
 // put your main code here, to run repeatedly: 
 if(digitalRead(2)==LOW) 
 { 
 if(digitalRead(2)==HIGH) 
 { 
 conta++; 
 Serial.println(conta); 
 delay(100); 
 } 
 } 
if(conta == 5) 
 { 
 digitalWrite(13,HIGH); 
 } 
 if(conta==8) 
 { 
 digitalWrite(13,LOW); 
 conta=0; 
 } 
} 
EXPERIENCIA 5: Haciendo Variar el brillo de un LED 
En esta práctica vamos a variar la luminosidad de un LED conectado en la patilla 5 de nuestro 
Arduino. Para ello le inyectaremos una señal PWM con diferentes valores de ciclo de trabajo. 
En lugar de encender y apagar continua y rápidamente el LED utilizamos la función: analogWrite() 
para dar la sensación de que se enciende levemente. El ojo humano percibe un parpadeo rápido 
como un cierto nivel de brillo y podemos utilizar la modulación de ancho de pulso (PWM) para 
especificar la cantidad de tiempo que el pin digital “ ~” esta alto (HIGH) en comparación con el 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
24 
 
 
tiempo que permanece bajo (LOW). Variando esta proporción ( duty cycle, DC ) entre los dos 
estados a lo largo del tiempo, obtenemos diferentes brillos o luminosidades del LED. 
Para crear una señal PWM se utiliza la función analogWriter() donde especificamos el pin 
digital implicado y el valor entre 0 (0%) y 255 (100%) que deseamos para su ciclo de trabajo. 
analogWrite(pin,value). Esta función sirve para escribir un valor proporcional de trabajo (DC) 
utilizando la técnica PWM. El parámetro pin indica la patilla digital implicada. El parámetro value 
contiene un número entre 0 y 255. Por ejemplo: “analogWrite(5,128)” enviará por el pin 5 una 
salida cuadrada (128 es la mitad de 256). Un LED conectado a esta patilla brillará con una luz que 
será la mitad de su máxima luminosidad. 
El hardware que necesitaremos es el siguiente: 
1diodo LEO. 1 resistencia de 220 O. 
Un Protoboard Cablecitos de conexión. 
Un Arduino Un cable USB 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Figura 16.- Diagrama del circuito que Varia el Brillo de un LED 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
25 
 
 
Programa que Hace Variar el Brillo de un LED 
int aumento = 5; 
void setup() 
 // put your setup code here, to run once: 
{ 
 pinMode(led, OUTPUT); 
} 
void loop() 
 // put your main code here, to run repeatedly: 
{ 
 analogWrite (led,brillo); 
 brillo = brillo + aumento; 
 if (brillo == 0 || brillo == 255) 
 { 
 aumento = -aumento; 
 } 
 delay(30); 
} 
En este sketch establecemos la cantidad de aumento de luminosidad mediante la variable aumento 
que posee un valor de 5 y se ira sumando a la variable brillo que es la que determina 
definitivamente el brillo de LED a través de la función analogWrite(). Cuando la variable aumento 
llega a 255 o a 0, invertimos su signo para decrecer su valor. La función delay() es utilizada para 
que podamos visualizar el efecto sobre el LED. 
TIP 4: ¿Qué es el PWM? 
• Las siglas PWM provienen de Pulse Wide Modulation, o lo que es lo mismo, modulación 
por amplitud de pulsos. 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
26 
 
 
• Mediante una señal PWM, que es una señal digital en la que se envían ceros o unos más o 
menos largos, podemos simular una salida analógica y hacer creer al receptor (LED, motor, 
etc.) que tengamos conectado a esa salida, que lo que está recibiendo es una variación 
“suave” de voltaje. 
• La primera particularidad de esta función es que no puede utilizarse con cualquier pin, solo 
con los que tienen dibujado a su lado este símbolo “ ~ ”. 
• Ver la figura 17 para ver que pines tienen esta característica: 3, 5, 6,9, 10 y 11. 
• La segunda característica curiosa es que solo podemos enviar valores entre 0 y 255 
correspondiendo el “ 0 “ a 0 voltios y “ 255 “ a 5 voltios. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Figura 17.- Se muestra los pines que tienen la característica de simular Salida Análoga 
 
 
 
 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
27 
 
 
 
 
 
 
 
 
 
 
 
EXPERIENCIA 6 Y 7: Haciendo Sonar un Altavoz 
Vamos a probar un altavoz conectado al Arduino utilizando una señal PWM para producir 
sonidos. El esquema (Figura 18) y el sketch son muy sencillos. 
El hardware que necesitaremos es lo siguiente: 
1 altavoz o zumbador piezoeléctrico 1 resistencia de 220 n. 
Un Protoboard Cablecitos de conexión. 
Un Arduino y un cable USB. 
 
 
 
 
 
 
 
 
 Figura 18.- Diagrama del circuito zumbador 
Programa de Haciendo Sonar un Zumbador: 
• La técnica PWM permite generar ondas 
cuadradas con una frecuencia y ciclo de 
actividad determinada. 
• El ciclo de actividad (duty cycle) 
representa la anchura del pulso: cuanto 
tiempo de cada onda cuadrada hay pulso 
(5V) y cuando no lo hay (0V). 
• En la figura 4.24 se observan diferentes 
señales PWM con diferentes ciclos de 
trabajo (DC). 
 
 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
28 
 
 
#define PIEZO 3 
 int del = 15; 
 void setup() 
 // put your setup code here, to run once: 
{ 
 pinMode(PIEZO,OUTPUT); 
} 
void loop() 
 // put your main code here, to run repeatedly: 
{ 
 analogWrite(PIEZO,255); 
 delay(del); 
 analogWrite(PIEZO,0); 
 delay(del); 
} 
En este ejercicio utilizamos una patilla 3 digital con propiedades PWM para inyectar una señal 
cuadrada a un zumbador. La señal cuadrada variara entre 0 y 5 voltios con una cadena o frecuencia 
marcada por el valor de la función delay(). Si variamos dicho valor, escucharemos pitidos distintos. 
TIP 5: 
• Un altavoz piezoeléctrico es un dispositivo pequeño y redondo que puede ser utilizado 
para generar ruidos fuertes y molestos. 
• Son perfectos para las alarmas o para divertirse reproduciendo melodías. 
• Los altavoces contienen una palca muy delgada dentro del soporte que se mueve cuando 
se aplica corriente eléctrica. 
• Cuando se aplica una tensión alterna, la placa vibra y generan ondas de sonido. 
• Los zumbadores piezoeléctricos (Figura 19) están polarizados y no pueden ser 
conectados de cualquier manera. 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
29 
 
 
 
 
 
 
 
 
 
 
 
 Figura 19.- Zumbadores Piezoeléctricos 
EXPERIENCIA 7: Reproduciendo Tonos 
Si quereos escuchar mayor volumen haremos uso de un altavoz piezoeléctrico de más potencia, 2 
W. Pequeño pero fuerte, es de gran calidad y ofrece una mejor reproducción de sonido que el 
zumbador del ejercicio anterior. 
Con la ayuda de un pequeño transistor, se podrá amplificar la señal PWM. El altavoz piezoeléctrico 
lo observamos en la figura 20. 
El transistor nos va a proporcionar una corriente mayor que la que produce el Arduino. Además, 
permite manejar voltajes mayores que 5 Voltios que es el valor con el que trabaja nuestra placa. 
Todo ello se traduce en un aumento del sonido. Un transistor puede activar o desactivar un flujo 
de mayor corrienteque la que puede proporcionar nuestro Arduino. 
Al igual que el LED, los pines del transistor tienen una función única y es imprescindible, antes 
de nada, identificarlos para su correcta conexión. En la figura 21 observamos la disposición que 
tienen las patillas del transistor 2N3904. Todos los transistores poseen tres patillas llamadas: 
Colector (C), Base (B) y Emisor (E). Cuando una pequeña corriente se aplica al terminal de Base, 
procedente, por ejemplo, de un pin del Arduino, se establece una corriente mayor desde el colector 
hacia masa pasando por el Emisor. Es decir, que podemos controlar un flujo de corriente mas o 
menos grande (depende del tipo de transistor) desde el colector al Emisor con una pequeña 
corriente en la Base. En el caso del 2N3904, la máxima corriente que podemos gobernar es de 
unos 200 mA, suficiente para activar el altavoz 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
30 
 
 
 
 
 
 
 
 
 
 
 Figura 20.- Altavoz Piezoeléctrico 
 
 
 
 
 
 
 
 
 Figura 21.- Transistor 2N3904: Disposiciones de las patitas 
En cuanto al hardware que necesitamos: 
1 altavoz 4 Ω 1 resistencia de 220 Ω 
1 resistencia de 1 kΩ 1 transistor típico 2N3904. 
Un Protoboard Cablecitos de conexión. 
Un Arduino un cable USB. 
El esquema del circuito es lo siguiente: 
 
 
 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
31 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Figura 22.- Diagrama del Circuito Generador de Tonos 
El lenguaje de programación de Arduino proporciona una interesante función para simplificar la 
generación de sonidos o tonos. Probemos el siguiente sketch. 
Programa del Reproductor de Tonos 
void setup() 
 // put your setup code here, to run once: 
{ 
 int pinOut = 3; 
 int freq = 110; 
 int duracion = 1000; 
 for (int i = 0; i<40 ; i++) 
 { 
 tone(pinOut, freq*i, duracion); 
 int pausaEntreNotas = duracion*1.30; 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
32 
 
 
 delay(pausaEntreNotas); 
 noTone(3); 
 } 
} 
void loop() 
 // put your main code here, to run repeatedly: 
{ 
} 
TIP 6: 
• Tone (pin, frecuencia, duración). Genera una onda cuadrada de la frecuencia 
especificada (y un 50 % de ciclo de trabajo) en un pin. 
• La duración puede ser especificada, en caso contrario, la onda continua hasta que haya 
una llamada a noTone(). 
• Solo puede generarse un tono cada vez. 
• Si un tono está sonando en un pin diferente, la llamada a tone() no tendrá efecto. 
• Si el tono está sonando en el mismo pin, la llamada establecerá la nueva frecuencia. 
• La duración se define en milisegundos y la frecuencia en hertzios. 
• Si se desea reproducir varias notas seguidas, es muy importante esperar un tiempo antes 
de reproducir la próxima nota. 
• Se recomienda dar un tiempo de un 30% de la duración de la nota eso es lo que 
precisamente hace la variable pausaEntreNotas. 
• TIPS 7: Si deseas hacer sonar diferentes tonos en múltiple pines se necesita llamara a 
noTone() en un pin antes de llamar a tone() en el siguiente pin.Las frecuencias audibles 
por el oído humano van de 20 HZ a los 20KHz, por lo que el parámetro “frecuencia” 
debería estar comprendido entre estos dos valores. 
• TIPS 8: El fichero pitches.h contiene todos los valores de las frecuencias de las notas 
típicas. Por ejemplo, NOTE_C4 es una C media. NOTE_FS$ es F aguda y asi 
sucesivamente. Esta tabla de notas fue originalmente escrita por Brett Hagman y esta 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
33 
 
 
basada en la función tone(). La encontraras útil cada vez que tengas que reproducir notas 
musicales. Busca en internet este fichero y utilízalo para componer alguna melodía de tu 
gusto. 
TIP 9: Introducción a las Interrupciones en Arduino 
• Las interrupciones en el Arduino son muy poderosas ya que pueden interrumpir el flujo de 
programa en cualquier momento. Una interrupción es como si alguien toca el timbre de tu 
casa cuando estás a punto de entrar en la ducha y tienes que atenderlo de inmediato. El 
Arduino hace exactamente lo mismo, cuando se activa una interrupción se pasa el control 
a la gestión de la misma, a no ser que, puntualmente, lo hayas deshabilitado. 
• Entendemos por gestión de la interrupción, el hecho de ejecutar una rutina, llamada de 
interrupción (ISR), que contiene un trozo de código de programa. Tras haberse procesado 
dicha rutina, se retorna al programa principal y se continúa ejecutando. 
• El Arduino uno puede utilizar un máximo de dos interrupciones. 
• Los Arduinos basados en los microcontroladores Amtel AVR pueden ejecutar una sola 
secuencia de instrucciones a la vez. El problema de esto es, por ejemplo, que si estamos 
enviando números a un dispositivo cualquiera y, en cualquier momento, un usuario 
presiona un botón para llamar la atención del Arduino, pongamos el caso, para apagar un 
LED, puede suceder que perdamos ese evento y no atendamos al usuario porque nuestro 
ciclo de programa emplea mucho tiempo en ejecutarse y hayamos perdido la lectura del 
estado del botón. Esto es una desventaja de los microcontroladores sencillos y es algo con 
lo que las computadoras han tenido que convivir prácticamente desde que fueron 
inventadas. 
• El micro AVR de cualquier Arduino tiene dos tipos de interrupciones: 
• Externas: El Arduino cuenta con solo dos pines de interrupción externa: INT0 e INT1 y 
están asignadas a los pines 2 y 3. Cuando se produce un cambio en el estado lógico del 
pin_2 o del pin_3 se activa dicha interrupción. Estas interrupciones pueden activarse en 
subidas o bajadas de señal, en bajo o en alto nivel. Las activaciones son interpretadas por 
el hardware y son muy rápidas. 
• Internas: Utilizan los recursos hardware del propio micro. Se utilizan para provocar 
eventos internos como el contaje de un tiempo determinado que interrumpa, 
periódicamente, la ejecución del programa principal. 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
34 
 
 
• Si nos fijamos en las interrupciones externas podemos asociar el código de ese tipo de 
rutina de interrupción, a través de la función attachInterrupt(). Las interrupciones o eventos 
que podemos asociar a los pines implicados mediante esta función son las siguientes: 
 Cuando el nivel lógico de la línea es 0 (LOW). 
 Cuando el nivel lógico de la línea cambia independientemente de su estado lógico 
(CHANGE) 
 Cuando el nivel lógico cambia de 0 a 1 (RISING) 
 Cuando el nivel lógico cambia de 1 a 0 (FALLING) 
EXPERIENCIA 8: Control de un LED Mediante un Pulsador sin Interrupciones 
Consideremos que no sabemos nada de interrupciones y deseamos encender y apagar un LED 
cuando presionemos un pulsador. Así de simple. 
El caso es que el programa principal va a estar ocupado haciendo una tarea repetitiva en el bucle 
loop(). No hay problema, pensamos, hemos hecho algo parecido en la experiencia 2. De hecho, 
el esquema de conexión es muy parecido (Figura 23). 
Ahora el diodo LED está conectado al pin 4 y el pulsador al pin 5 del Arduino. Como puede 
observarse, es un código sencillo. Definimos el pin 5 como entrada y el 4 como salida. Además, 
consideramos una variable para controlar en qué estado está actualmente el botón. Lo interesante 
es que para poder comparar eficientemente el uso de la interrupción con este código, agregamos 
una estructura for que se repite 100 veces, con una delay() de 10 milisegundos cada vez 
Esto causara salidasimpredecibles en el LED debido a que el for (que simula un proceso lento) 
está en un punto indeterminado en relación a cuando el botón es presionado. Algunas veces el 
LED cambia de estado inmediatamente, otras veces nada pasa y otras veces es necesario 
mantener el botón presionado por un mayor tiempo para que el estado cambie y sea reconocido. 
Mucho culpa de esto lo tiene la función delay() que paraliza siempre el micro del Arduino 
impidiendo atender a las pulsaciones del pulsador en tiempo real. 
Programa de Pulsador sin Gestion de Interrupciones 
/*Encendiendo y apagando un LED sin usar interrupciones*/ 
/*Programando a la antigua usanza*/ 
int pulsador = 5; 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
35 
 
 
int led = 4; 
int estado = LOW; 
void setup() 
{ 
 pinMode(pulsador,INPUT); 
 pinMode(led,OUTPUT); 
} 
void loop() 
{ 
 estado = digitalRead(pulsador); 
 digitalWrite (led, estado); 
 for (int i = 0; i<100; i++) 
 { 
 delay(10); 
 } 
} 
 
 
 
 
 
 
 
 
 
 Figura 23.- Diagrama de Circuito del Pulsador sin Gestión de Interrupciones 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
36 
 
 
 
EXPERIENCIA 9: Control de un LED Mediante un Pulsador con Interrupciones 
Reprogramemos el sketch utilizando la técnica de interrupciones. 
Utilizamos el mismo circuito (Figura 23) 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 24.- Diagrama de circuito que Controla un LED mediante un Pulsador con Interrupciones 
Programa de Pulsador con Gestión de Interrupciones 
/*Encendiendo y apagando un LED usando interrupciones*/ 
/*Programandko a la antigua usanza*/ 
int pulsador = 2; 
int led = 4; 
volatile int estado = LOW; 
void setup() 
 // put your setup code here, to run once: 
{ 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
37 
 
 
 pinMode(pulsador,INPUT); 
 pinMode(led,OUTPUT); 
 attachInterrupt (pulsador, cambio_estado, CHANGE); 
} 
void loop() 
 // put your main code here, to run repeatedly: 
{ 
 estado = digitalRead(pulsador); 
 digitalWrite (led, estado); 
 for (int i = 0; i<100; i++) 
 { 
 delay(10); 
 } 
} 
void cambio_estado() 
{ 
 estado =!estado; 
 digitalWrite(led, estado); 
} 
La palabra clave es: volatile. Es agregada a la variable estado. Esto causa que el compilador use 
la RAM en vez de un registro de almacenamiento. Esto es así debido a que el registro de 
almacenamiento puede ser temporalmente impreciso si es modificado por áreas diferentes a las del 
programa principal. Este tipo de variable se caracteriza por que su valor puede ser modificado por 
algo fuera de la sección del código en el que aparece, o sea, por una función externa como una 
interrupción. Si la variable estado no la definimos como volatile, no podría ser modificada por la 
rutina de interrupción. 
En segundo lugar, hay que informar a Arduino que utilizaremos la interrupción. Ello lo hacemos 
dentro de setup() con la instrucción attachInterrupt(). Este mandato especifica la función a 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
38 
 
 
invocar cuando se produce una interrupción externa. La mayoría de las placas Arduino tienen 
dos interrupciones externas: las numero 0 (en el pin digital 2) y la 1 (en el pin digital 3). Arduino 
Mega tiene otras cuatro: las numero 2 (pin 21), 3 (pin 20), 4 (pin 19) y 5 (pin 18). 
attachInterrupt(nint, nfuncion, modo). Avisa al Arduino de que vamos a utilizar una 
interrupción. Sus parámetros son los siguientes: 
 nint: Número de interrupción. 0 si utilizamos el pin 2 y 1 si utilizamos el pin 3. 
 nfuncion: Nombre de la función de interrupción que invocamos. 
 modo: Es el evento que provoca la interrupción. Estan descritos anteriormente. 
Concretando la exposición teórica a nuestro caso, tenemos tres puntos reseñables: 
 volatile int estado = LOW; 
Define la variable estado como volatile para que pueda ser “vista” y modificada por la 
interrupción. Se inicializa en estado bajo. 
 attachInterrupt (pulsador, cambio_estado, CHANGE); 
Define una rutina de interrupción (ISR) en el pin 2 (pulsador) que se activara cuando el estado de 
esta patilla cambie (CHANGE) de estado lógico. Siempre que varie, se ejecutara la rutina de 
interrupción ala que hemos llamado: cambio_estado. 
 void cambio_estado() 
{ 
 estado =! Estado; 
 digitalWrite (led, estado); 
} 
La rutina de interrupción cambio_estado lo único que hace es invertir el valor lógico de la variable 
estado y encender o apagar el LED. 
Compila y suba a su Arduino el código del listado anterior. Juega de nuevo con el pulsador para 
observar si ahora ha mejorado el funcionamiento del circuito. 
Por otra parte, Arduino tiene la habilidad de temporalmente ignorar todas las interrupciones. Esto 
es deseable en el caso en el que se tenga un código sensible que debe ser ejecutado sin interrupción. 
En este caso, se debe realizar un llamado al método noInterrupts(). Cuando termine el código 
sensible, las interrupciones pueden reiniciarse con el método interrupts(). 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
39 
 
 
TRANSMISION EN SERIE EN ARDUINO 
La placa Arduino puede establecer comunicación con la computadora a través de una conexión 
por un cable USB para recibir los programas y que queden grabados en el microcontrolador. 
Solo es necesario indicar el número de puerto USB (figura 25) donde está conectado nuestro 
Arduino y desde el IDE visible en nuestro PC, presionar el botón de enviar o subir 
 
 
 
 
 
 
 
 
 
 
 Figura 25.- Menú de Comunicación con el Arduino Uno 
Además, dentro del interfaz IDE disponemos de la opción “Monitor Serie” que posibilita la 
visualización del Arduino. Es decir, que la comunicación serie es en los dos sentidos. 
Podemos, por tanto monitorizar lo que me pudiera enviar el Arduino y verlo en una ventana del 
IDE. 
Si nuestra placa está captando datos de temperatura o de humedad o de lo que sea del entorno 
ambiental, estos datos se pueden observar en tiempo real en el PC. Pero, no podemos guardarlos, 
solo visualizarlo a medida que van siendo adquiridos por el Arduino 
Las sentencias puestas establecen la velocidad en bits por segundo (baudios) entre la placa de 
Arduino y el PC debe ser igual en ambos dispositivos. 
La segunda sentencia envía al PC el Texto (entre paréntesis y comillas) añadiendo un salto de 
línea. 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
40 
 
 
• Pero, además, podríamos utilizar el programa monitor para enviarle ordenes al Arduino a 
través de texto o códigos ASCII, es decir, se puede gobernar el Arduino desde la 
computadora. 
 
 
 
 
 
 
 
 
 
 Figura 26.- Botón para abrir ventana del Monitor 
Programa que Visualiza un Mensaje por medio del MONITOR SERIE 
void setup() 
 // put your setup code here, to run once: 
{ 
 Serial.begin(9600); //Establece la velocidad de comunicación en baudios 
} 
void loop() 
 // put your main code here, to run repeatedly: 
{ 
 Serial.println("Aprendiendo a Programar con Arduino en mi Casa"); 
} 
El campo que senos abre está lleno de posibilidades, tanto en la visualización de datos como la del 
propio control del Arduino 
 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
41Figura 27.- Monitor Serie 
 
 
 
 
 
 
 
VENTANA DEL 
MONITOR SERIE 
Universidad Nacional de la Facultad de Ingeniería de 
 Amazonia Peruana Sistemas e Informática 
42 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	LABORATORIO DE ELECTRONICA DIGITAL