Practicas Arduino Muy Bueno

Centro de Bachillerato
MóduloTecnológico
V: PLC y Microcontroladores CBTis 4
industrial y de servicios No. 4
Manual de Prácticas
Módulo V
Por:
Ing. José Guillermo Palacios Mauricio
Ing. José Guillermo Palacios Mauricio Página 1
ElElectrónica Febrero – Julio 2012

Módulo V: PLC y Microcontroladores CBTis 4
Índice de contenido
Submódulo II............................................................................................................................................................ 3
Práctica No. 1. Configuración básica............................................................................................................. 4
Práctica No. 2. Lectura de Entradas............................................................................................................... 7
Práctica No. 3. Operaciones Lógicas........................................................................................................... 13
Práctica No. 4. Ciclos...................................................................................................................................... 16
Práctica No. 5. E/S Análogas....................................................................................................................... 18
Práctica No. 6. Motor de CD......................................................................................................................... 25
Práctica No. 7. Motor de CD Puente H....................................................................................................... 27
Práctica No. 8. Manejo LCD.......................................................................................................................... 31
Práctica No. 9. Motores a Pasos................................................................................................................... 38
Práctica No. 10. Servomotores RC............................................................................................................... 44
Práctica No. 11. Display 7 Segmentos........................................................................................................ 46
Práctica No. 12. Matriz de LEDs................................................................................................................... 50
Práctica No. 13. Comunicación Serial.......................................................................................................... 53


Prácticas
Submódulo II

Práctica No. 1. Configuración básica
 Objetivo
Conocer la configuración básica de conexión del Arduino a través del uso de los puertos de Salida, así
como la simulación de dichos circuitos en el software Proteus.
 Material
1. Arduino Uno®
2. PC (Arduino 1.0, Proteus)
3. Protoboard y cables para conexiones
4. Leds y botones pulsadores.
 Desarrollo
A) Realizar el programa y el circuito que permita encender un led conectado a pin D13 del
Arduino (Ilustración 2). Realizar la simulación correspondiente en Proteus.
Ilustración 2: Circuito físico

Ilustración 1: Diagrama esquemático
B) Para el mismo circuito mostrado en la Ilustración 2, realizar un programa que permita que el
led encienda y apague con una frecuencia de 2 Hz. Realizar además la simulación
correspondiente en Proteus.
C) Diseñar un programa que permita encender y apagar 4 led de manera intermitente y de

manera alternada, es decir: 0101 ... 1010 ... 0101... 1010. La frecuencia es a su elección.

 Estructura básica de un programa en Arduino
void setup()
{
// Se utiliza doble diagonal para indicar algun comentario
// En esta estructura va el código que sólo se ejecutará una sóla vez.
// Es el área de configuración de las entradas y salidas, variables, constante, entre otras cosas.
}
void loop()
{
// El código dentro de esta estructura se repetirá indefinidamente.
// Usualmente es el programa principal

}
El programa para el caso del inciso A, sería el siguiente:

void setup(){
// Se inicializa el pin 13 como salida.
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);// Enciende el LED
}
El programa para el caso del inciso B, sería el siguiente:

void setup(){
// Se inicializa el pin 13 como salida.
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);// Enciende el LED
delay(1000); // Pausa en el programa de 1 seg.
digitalWrite(13, LOW); // Apaga el LED
delay(1000); // Pausa en el programa de 1 seg.
}

 Simulación en Proteus
Para la simulación en Proteus armar el circuito mostrado en la Ilustración 3, así mismo modificar las
propiedades como se indican en la Ilustración 4.
XTAL1
22pF
CRYSTAL
XTAL2
22pF
U1
D13
2 14
D0 PD0/RXD/PCINT16 PB0/ICP1/CLKO/PCINT0 D8
3 15
D1 PD1/TXD/PCINT17 PB1/OC1A/PCINT1 D9
4 16
D2 PD2/INT0/PCINT18 PB2/SS/OC1B/PCINT2 D10
5 17
D3 PD3/INT1/OC2B/PCINT19 PB3/MOSI/OC2A/PCINT3 D11
6 18
D4 PD4/T0/XCK/PCINT20 PB4/MISO/PCINT4 D12
11 19
D5 PD5/T1/OC0B/PCINT21 PB5/SCK/PCINT5 D13
220
12 9
D6 PD6/AIN0/OC0A/PCINT22 PB6/TOSC1/XTAL1/PCINT6 XTAL1
13 10
D7 PD7/AIN1/PCINT23 PB7/TOSC2/XTAL2/PCINT7 XTAL2
21 23
AREF PC0/ADC0/PCINT8 A0
20 24
VCC AVCC PC1/ADC1/PCINT9 A1
25
PC2/ADC2/PCINT10 A2
26
PC3/ADC3/PCINT11 A3
27
PC4/ADC4/SDA/PCINT12 A4
28
PC5/ADC5/SCL/PCINT13 A5
1
PC6/RESET/PCINT14 VCC
ATMEGA328P
Ilustración 3: Circuito para proteus
Ilustración 4: Propiedades del microcontrolador

Práctica No. 2. Lectura de Entradas
 Objetivo
Emplear técnicas para la lectura y manipulación de datos de entrada digitales en Arduino y simulación
con Proteus.
 Material
1. Arduino Uno®
2. PC (Arduino 1.0, Proteus)
3. Protoboard y cables para conexiones
4. 2 leds rojos, 2 leds verdes, 2 leds amarillos y 2 botones pulsadores.
5. 6 Resistencias de 330Ω y 2 de 10 kΩ
 Funciones a utilizar
• pinMode(), digitalRead(); delay(); if(), variables.
 Desarrollo
A) Realizar el programa y el circuito que permita encender un led conectado a pin D10 al momento que
se presiona un botón conectado al pin D2, tal como lo muestran la Ilustración 5 y la Ilustración 6.
Realizar la simulación correspondiente en Proteus.
Ilustración 5: Esquemático

El programa quedaría de la siguiente manera:
//Se definen el lugar de cada elemento según su conexión al Arduino
// #define palabra valor ---- Sintaxis #define

#define LR1 10 //Pin 10, Luz Roja 1
#define BP1 2 //Pin 2, Botón Pulsador 1
void setup()
{
pinMode(LR1,OUTPUT);
pinMode(BP1,INPUT);
}
void loop()
{
if(digitalRead(BP1)==1)
{
digitalWrite(LR1,HIGH);
}
else
{
digitalWrite(LR1,LOW);
}
}
Compilar, cargar el programa en el Arduino y simular.
Ilustración 6: Conexión física

B) Cambie el programa del inciso anterior de tal manera que ahora se asigne el valor de la lectura del
botón a una variable y sea esta última la que se compare.
El programa quedaría de la siguiente manera:
//Se definen el lugar de cada elemento según su conexión al Arduino
// #define palabra valor ---- Sintaxis #define

#define LR1 10 //Pin 10, Luz Roja 1
#define BP1 2 //Pin 2, Botón Pulsador 1
#define Presionado 1
boolean edoBP1=0; //Variable para guardar el estado del botón 1

//Probar con: int edoBP1=0;
void setup()
{
pinMode(LR1,OUTPUT);
pinMode(BP1,INPUT);
}
void loop()
{
edoBP1=digitalRead(BP1);
if(edoBP1==Presionado)
{
digitalWrite(LR1,HIGH);
}
else
{
digitalWrite(LR1,LOW);
}
}
Compilar, cargar el programa en el Arduino y simular.

C) Diseñe un programa y circuito que permita el control de dos semáforos los cuales tendrán la siguiente
secuencia:
Tiempo 5 Seg 1 Seg. 5 Seg. 1 Seg. 5 Seg. 1 Seg.

Lámpara Norte/Sur Verde Amarillo Rojo Verde Amarillo
Lámpara Este/Oeste Rojo Verde Amarillo Rojo
La siguiente ilustración muestra el esquema a utilizar en Poteus:


TRAFFIC LIGHTS
Ilustración 7: Simulación de semáforos
D) Diseñe un programa que permita controlar los semáforos para el cruce de un peatón en una calle de
doble sentido. La Ilustración 8 muestra el esquema a controlar.
Al no haber un peatón que quiera cruzar la calle, tanto la luz de color roja del peatón como la luz de
color verde para los vehículos, deberán de estar encendidas.
Cuando el peatón presiona el botón pulsador, inicia la secuencia, la luz verde del semáforo
permanece encendida por 3 segundos más, después de los cuales la señal del vehículo cambia a
amarillo. Después de 1 segundo, la señal del vehículo cambia a rojo, y la señal del peatón cambia a
verde en el mismo tiempo.

Después de 5 segundos la señal del peatón, que ha estado en verde, cambia a color rojo y después
de 2 segundos, la señal de los vehículos regresa a la condición previa de presionar cualquiera de los
dos botones. La secuencia se repite cuando se presiona de nueva cuenta cualquiera de los botones
pulsadores.
Semáforo peatonal
Alto
Siga
Ilustración 8: Semáforo para peatón
Notas:
• Utilizar operadores relacionales.
• La disposición de cuales salidas y entradas usar, queda a elección del programador.

 Puntos extra
• En el ejercicio C. Hacer que la luz de color verde parpadee una o dos veces antes de cambiar
a color amarillo.
• En el ejercicio D. Animar la imagen de SIGA del peatón. Simular en Proteus.

Práctica No. 3. Operaciones Lógicas
 Objetivo
Emplear técnicas para la lectura y manipulación de datos de entrada, así como la utilización de
operadores lógicos a nivel bit y a nivel relacional.
 Material
• Arduino Uno® • 1 buzzer 5V
• PC (Arduino 1.0, Proteus) • 1 Resistencia de 330Ω
• Protoboard y cables para conexiones • 5 Botones pulsadores
• 1 LED • 5 Resistencias de 10 kΩ
• pinMode(), digitalRead(); delay(); if(), Operadores lógicos, variables.
 Desarrollo
A) Diseñe y simule un programa que permita encender de una manera intermitente un buzzer utilizando
operadores lógicos a nivel bit. La Ilustración 9 muestra el circuito necesario.

Donde el programa quedaría de la siguiente manera:
#define Buzzer 13 //Pin 13
boolean edoBuzzer=0;
void setup()
{
pinMode(Buzzer,OUTPUT);
}
void loop()
{
edoBuzzer=edoBuzzer^1; //Operador XOR
digitalWrite(Buzzer, edoBuzzer);
delay(500);
}
B) Realizar el programa y el circuito que permita encender una alarma, mostrado en la Ilustración 11,
según las siguientes condiciones:
Ilustración 11: Circuito para alarma

1. Cuando se abra cualquiera de los 5 interruptores la alarma deberá de sonar de manera

intermitente, hasta que se vuelvan a cerrar todos los interruptores.
2. La alarma deberá de encenderce sólo cuando el SW1 y el SW5 se abran, los otros interrptores
deberán de estar cerrados. Una lampára deberá conmutar al mismo tiempo que la alarma se
activa, es decir, cuando la alarma se enciende, la lámpara se apaga y cuando la lámpara se
apaga, la lámpara se enciende.
3. La alarma deberá de activarse cuando cualquiera de los interruptores SW1, SW2, SW3 o SW4
se abran y deberá apagarse exclusivamente hasta que se abra el interruptor SW5, es decir, este
último será la llave para activar o desactivar la alarma.
4. Diseñar un circuito que permita la acitvación en secuencia de una alarma o una carga, esto es, que
sólo se deberá de encender la carga, cuando se hayan cerrado los interruptores en la siguiente
secuencia: SW1 » SW2 » SW3
Ilustración 12: Teoría de conjuntos para operaciones lógicas

Práctica No. 4. Ciclos
 Objetivo
Emplear el uso de la estructura de repetitiva “for” para la creación de ciclos controlados.
 Material
• Arduino Uno® • 1 Resistencia de 10 kΩ
• PC (Arduino 1.0, Proteus) • 1 Botón pulsador
• Protoboard y cables para conexiones • 8 Resistencias de 330Ω
• 8 LED
• pinMode(), digitalWrite(), digitalRead(); delay(); if(), for(), Operadores lógicos, variables.
 Desarrollo
A) Arme el circuito mostrado tanto en la Ilustración 13 como en la Ilustración 14, tanto físicamento como
en Proteus.

B) Realizar los programas correspondientes según las siguientes condiciones:

1. Realizar un programa que permita crear un efecto de animación de encender un LED conectado al
pin D6, después de cierto tiempo apagarlo y encender el siguiente pin (D7), realizar esta acción
hasta llegar al LED conectado al pin D13. Repetir la secuencia al terminar de encender el último
LED.
2. Modificar el programa para hacer el mismo ciclo, pero ahora en sentido contrario, es decir, ir del
LED conectado al pin D13 al LED conectado al pin D6.
3. Realizar un programa que permita crear un efecto de animación que permita ir encendiendo uno
a uno los leds conectados a los pines D6-D13, uno a uno con cierta frecuencia e ir apagándolos en
la dirección contraria, uno a uno también, hasta apagarlos todos.
Es decir:
00000000
10000000
11000000
11100000
…
11111100
11111110
11111111
11111110
11111100
…
11100000
11000000
10000000
00000000
 Puntos extra
• Para cualquiera de los problemas anteriores. Agregar un botón pulsador y modificar el
programa, para que sólo mientras el botón sea presionado la secuencia siga su curso normal.
Cuando se deje de presionar el botón se detendrá la secuencia.
Una pista: utilizar if().
• Igualmente, para cualquiera de los problemas anteriores, modificar el programa para que el
botón pueda ser utilizado para controlar la frecuencia de la secuencia.
Una pista: Utilizar un contador y un tipo de variable que no utilice valores negativos y pueda
contener la cantidad de tiempo para la pausa deseada.

Práctica No. 5. E/S Análogas
 Objetivo
Utilizar tanto el convertidor ADC como la señal PWM que provee el microcontrolador para
interacturar con sensores que tienen un rango en su señal de sensado, así como con la conversión de un valor
en una magnitud de voltaje.
 Material
• Arduino Uno® • 10 LEDs con
• PC (Arduino 1.0, Proteus) • 10 Resistencias de 330Ω
• Protoboard y cables para conexiones • 2 Potenciómetros 10kΩ
• analogRead(), analogWrite(), for(), corrimiento (<<), Serial.
 Desarrollo
Arme el circuito mostrado tanto en la Ilustración 15, tanto físicamento como en Proteus. El
elemento virtual terminal físicamente será utilizar el puerto usb para monitorear el canal A0.
Ilustración 15: Circuito para entradas análogas

A) Cargar el siguiente programa en el Arduino:
#define LED 13
int valorA0=0;
void setup()
{
pinMode(LED,OUTPUT);
}
void loop()
{
valorA0=analogRead(A0);
digitalWrite(LED,HIGH);
delay(valorA0);
digitalWrite(LED,LOW);
delay(valorA0);
}
Describa el funcionamiento de este programa. Asigne comentarios a cada línea del programa.
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
B) Carga ahora el siguiente programa:
int valorA0=0;
void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.println(valorA0);
delay(200);
}
Al simular el programa será necesario visualizar el contenido de “VIRTUAL TERMINAL”, el cual,

aparecerá automáticamente al empezar la simulación. La Ilustración 16 muestra un ejemplo de lo que
se visualizará. En caso de que no aparezca el contenido del “VIRTUAL TERMINAL”, mientras se esté
simulando, dar click en el menú “Debug” y posteriormente en “Virtual Terminal..”

Ilustración 16: Lectura del canal A0 en el puerto serie
Al correr el programa en el Arduino, será necesario visualizar el puerto serial, para lo cual se
utilizará la herramienta de la IDE Arduino, la cual se encuentra en el menú “Tools” y se llama “Serial
Monitor”. La Ilustración 17 muestra dicha herramienta.

Ilustración 17: Monitor serial en el IDE Arduino

Comparar la simulación con el valor físico.

Describa el funcionamiento del programa. Asigne comentarios a cada línea del programa.
Anote al menos 4 valores de voltaje y su correspondiente valor en el Arduino.
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
C) Ahora cargue el siguiente programa en el Arduino y simulelo.
unsigned int valorA0=0;

unsigned int aux;
void setup()
{
Serial.begin(9600); //Habilita comunicación serial a 9600 bps
for(int pin=4; pin<=13; pin++)
{
pinMode(pin,OUTPUT);
}
}
void loop()
{
aux=1;
{
if((valorA0&aux)>0)
{
digitalWrite(pin,HIGH);
}
else
{
digitalWrite(pin,LOW);
}
aux=aux<<1;
}
Serial.println(valorA0);
delay(100);
}
Compare los valores en los LEDs y en el puerto serie.
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________

D) Para probar ahora la salida análgo, tipo PWM, que contiene el Arduino, arme el circuito mostrado en
Ilustración 18 y cargue el sigiente progama:
#define pwm 3
void setup()
{
}
void loop()
{
for(int i=0; i<=255; i++)
{
analogWrite(pwm,i);
delay(100);
}
}
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________





Ilustración 18: Esquema ver señal PWM

La Ilustración 19 muestra la señal PWM en el osciloscopio del Proteus.
E) Y por último, simule y pruebe físicamente el siguiente programa.
#define pwm 3
int valA0;
int aux;
void setup()
{
Serial.begin(9600);
}
void loop()
{
valA0=analogRead(A0);
aux=map(valA0,0,1023,0,255);
analogWrite(pwm,aux);
Serial.println(aux);
delay(10);
}
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
Ilustración 19: Osciloscopio de Proteus

 Observaciones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
 Conclusiones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________

Práctica No. 6. Motor de CD
 Objetivo
Concer el funcionamiento básico de un motor CD, así como concer el arranque, paro y control de
velocidad, por medio de una serie ejercicios y la aplicación de los conceptos aprendidos en las prácticas
anteriores.
 Material
• Arduino Uno® • 1 MOSFET IRFI9Z34
• PC (Arduino 1.0, Proteus) • 1 Resistencia 1kΩ
• Protoboard y cables para conexiones • 1 Diodos 1N4001(G)
• Motor de CD < 2Amp. • 2 LEDs Verde y Rojo
• 1 Transistor TIP120 • 2 Resistencias 330 Ω
• #define, digitalRead(), digitalWrite(), analogRead(), analogWrite(), variables.
 Desarrollo
Arme el circuito mostrado en la Ilustración 20, tanto físicamento(según transistor o MOSFET) como
en Proteus.



Ilustración 20: Motor de CD
A) Diseñar un programa que permita controlar el arranque de un motor de CD, por medio de un botón
pulsador. Mientras esté presionado el botón, el motor deberá de estar encendido también. Al soltar el
botón, se apagará el motor.
B) Diseñar un programa que permita el arranque y paro de un motor con un sólo botón, es decir, al
presionar el botón, y si el motor esta apagado, el motor deberá de encender. Al soltar el botón se
quedará encendido el motor. Si se presiona nuevamente el botón, y si el motor está encendido, este
deberá de apagarse. Al soltar el botón se mandentrá apagado.
C) Diseñe un programa que permita controlar la velocidad del motor por medio de dos botones
pulsadores, es decir, el botón S2 incrementa la velocidad hasta llegar al 100% y el botón S3
decrementa la velocidad hasta llegar a 0%. Utilizar un osciloscopio para corroborar la señal de
control aplicada al MOSFET o al Transistor.
D) Modifique el programa del inciso anterior, pero ahora controle la velocidad por medio de un
potenciómetro.
E) Diseño un circuito y un programa que permita lo siguiente:

• Controlar el arranque de un motor de CD por medio de un botón.
• Indicar con dos LEDs el estado del motor, color Verde=Encendido, color
Rojo=Apagado.
• Con un potenciómetro se controlará la velocidad del motor, en caso de

estar apagado el motor, el potenciómetro no tendrá efecto en el motor.
 Punto extra
• Realizar el inciso E, pero para dos motores con control independiente de Arranque, Paro y Velocidad.
 Observaciones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
 Conclusiones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________

Práctica No. 7. Motor de CD Puente H
 Objetivo
Controlar el giro de un motor de CD, por medio de un puente H, diseñado con transistores y/o
MOSFETs, así como con ayuda del uso de un circuito integrado LM298.
 Material
• Arduino Uno® • 1 LM298
• PC (Arduino 1.0, Proteus) • 2 LEDs
• Protoboard y cables para conexiones • 2 Resistencias 330 Ω
• Motor de CD < 2Amp.
• #define, digitalRead(), digitalWrite(), analogRead(), analogWrite(), variables.
 Desarrollo
Arme el circuito mostrado en la Ilustración 21 en Proteus.
Ilustración 21: Puente H con transistores

A) Para el circuito mostrado en Ilustración 21, diseñe un programa que permita la siguiente secuencia del
motor:
• Encender el motor con giro CW  (ClockWise - Sentido horario)

• Pausa de 1 segundo (motor continua con su estado anterior)
• Encender el motor con el giro en CCW (Counter ClockWise - Sentido anti horario)
• Apagar el motor
B) Diseñe un programa que permita el control del circuito mostrado en Ilustración 21mediante 3 botónes,
los cuales harán lo que indica la Ilustración 22.



Botón Botón Botón
Encendido-Apagado Giro CW Giro CCW
Ilustración 22: Botonera para cambio de giro
Agregue los leds que sean necesarios para indicar el sentido de giro, los cuales, al estár encendidos,
harán notar que esta encendido el motor.
El giro inicial, al encender el motor, quedará definido por el programador. Si el motor está apagado,
los botones de cambio de giro, no deberán de encender el motor.

C) Arme físicamente y en Proteus el siguiente circuito, considere las terminales provenientes del Arduino.
Ilustración 23: Dual Puente H con L298
La Ilustración 24 muestra la configuración básica para el control de un motor, es decir, utiliza sólo la
mitad de la capacidad del L298.
Ilustración 24: Configuración básica del L298

D) Diseñe un programa que permita el control del MOTOR 1 con la siguiente secuencia:
• Encender el motor con giro CW  (ClockWise - Sentido horario)

• Encender el motor con el giro en CCW (Counter ClockWise - Sentido anti horario)
• Apagar el motor
E) Modificar el programa para que ahora se controle el MOTOR 2.
F) Diseñe un programa que permita el control de ambos motores, según las siguientes condiciones:
SW3 SW2 SW1 Motor 1 Motor 2

0 0 0 CW  OFF
0 0 1 CCW  OFF
0 1 0 OFF CW 
0 1 1 OFF CCW 
1 0 0 CW  CW 
1 0 1 CCW  CCW 
1 1 0 CW  CCW 
1 1 1 CCW  CW 
Utilizar LEDs para indicar la dirección de giro de cada motor.
 Punto extra
Probar sobre alguno de los tanques que se encuentran en el taller.
 Observaciones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
 Conclusiones
_________________________________________________________________________________
_________________________________________________________________________________

Práctica No. 8. Manejo LCD
 Objetivo
Concer el funcionamiento básico de una pantalla LCD de 16x2 líneas. Utilizarla tanto para mensajes
como para valores de variables.
 Material
• Arduino Uno® • Sensor temp. LM35
• PC (Arduino 1.0, Proteus) • Pot. 10kΩ
• Protoboard y cables para conexiones • 1 LCD 16x2 Líneas
• #define, digitalRead(), digitalWrite(), analogRead(), variables.
 Información de los LCD
Ilustración 25: LCD 16x2

El diagrama de pines es el siguiente:
Ilustración 26: Pin-out
No. de Pin Función Nombre

1 Tierra (0V) Ground
2 Voltaje de alimentación; 5V (4.7V – 5.3V) Vcc
3 Ajuste de Contraste; a través de una resistencia variable VEE
4 Selecciona un registro de comandos cunado esta un nivel BAJO y uno Register Select
registro de DATOS cuando esta en ALTO
5 Permiso escritura/lectura. BAJO para escribir; ALTO para leer Read/write
6 Envía datos a los pines de datos cuando se produce un cambio de BAJO a Enable
ALTO
7 DB0
8 DB1
9 DB2
10 DB3
8-bit pines de datos
11 DB4
12 DB5
13 DB6
14 DB7
15 Luz trasera VCC(5V) (Ánodo) Led+
16 Luz trasera Ground (0V) (Kátodo) Led-
Para pode hacer uso de esta pantalla en Arduino utilizaremos la librería <LiquidCrystal.h>, que
perimite de una manera fácil poder controlar la escritura de nuestra pantalla. Para mayor información ir
al sitio: http://arduino.cc/es/Reference/LiquidCrystal

Las funciones básicas son las siguientes:
• LiquidCrystal() • noBlink()
• begin() • display()
• clear() • noDisplay()
• home() • scrollDisplayLeft()
• setCursor() • scrollDisplayRight()
• write() • autoscroll()
• print() • noAutoscroll()
• cursor() • leftToRight()
• noCursor() • rightToLeft()
• blink() • createChar()
 Desarrollo
Arme el circuito mostrado en la Ilustración 27, tanto físicamente como en Proteus.



Ilustración 27: LCD simulada en Proteus

A) Esquema básico. Cargue el siguiente programa:
#include <LiquidCrystal.h> //Librerías para control del LCD
// Inicializacion de los pines

// pines del LCD(RS, E, D4, D5, D6, D7)
LiquidCrystal lcd(02, 03, 04, 05, 06, 07);
void setup() {
lcd.begin(16, 2); // Se establece el número de columnas y renglones
lcd.print("Hola CBTis 4"); //Imprime el mensaje de "Hola CBTis 4" en el punto (Col-0 , Renglón-0);
}
void loop() {
// Posicionamos el cursor en la columna 0 y renglón 1
// Nota: la posición 1, es el segundo renglón, empezando la cuenta en 0
lcd.setCursor(0, 1);
// Imprime los segundos que lleva el micro funcionando

lcd.print(millis()/1000);
}
B) Control de Cursor. Cargue ahora el siguiente programa
#include <LiquidCrystal.h> //Librerias para control del LCD

boolean pos=0;
void setup() {
pinMode(8, INPUT);
}
void loop() {
for(int i=0; i<=15; i++)
{
pos=digitalRead(8);
lcd.setCursor(i, pos);
lcd.print("CBtis 4");
delay(200);
lcd.clear();
}
}

C) Voltímetro y Termómetro Cargue ahora el siguiente programa
#include <LiquidCrystal.h> //Librerias para control del LCD

#define POT A0
#define LM35 A1
int val_analog;
float temp, volt;
void setup() {
lcd.print("Voltaje= ");
lcd.print("Temp.= ");
}
void loop() {
val_analog=analogRead(POT);
delay(20);
volt=0.00488*val_analog; // --5/1023--
lcd.print(volt,2); //(variable,base o número de decimales)
lcd.print(" V");
val_analog=analogRead(LM35);
delay(20);
temp=0.488*val_analog; //Factor de conversión 100 C = 1 Volt
lcd.print(temp,1); //(variable,base o número de decimales)
lcd.print(" C");
}
 Punto extra
• Diseñe un control ON-OFF con histéresis con los rangos MAX y MIN ajustables desde el
programa o desde dos potenciómetros. El diagrama requerido lo muestra la Ilustración 28.
• Diseñe un control Proporcional de temperatura. La señal de referencia se dará por medio de
un potenciómetro. En el LCD se desplegarán tanto la señal de referencia como la señal actual
de temperatura del sistema.


Ilustración 28: Horno para control de temperatura

Los parámetros del OVEN son los siguientes (Advanced Properties):
• Ambient temperature (°C) = 10

• Thermal Resistence to Ambient (°C/W) = 0.5
• Oven Time Constant (sec) = 10
• Heater Time Constant (sec) = 2
• Temperature coefficient (V/°C) = 0.1
• Heating Power (W)= 100
 Observaciones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
 Conclusiones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________

Práctica No. 9. Motores a Pasos
 Objetivo
Concer el funcionamiento básico de los motores a pasos, específicamente los motores UNIPOLARES,
utilizando la configuración de 1 Fase y 2 Fases.
 Material
• Arduino Uno® • 2 Motores unipolares paso a paso
• PC (Arduino 1.0, Proteus) • ULN2803
• Protoboard y cables para conexiones
• #define, digitalRead(), digitalWrite(), variables.
 Desarrollo
A) Control con Transistores
Ilustración 29: Control de un motor a pasos con trasistores

• Probar el siguiente programa que permite el control básico de un motor a pasos unipolar:
#define A 8
#define Ap 9
#define B 10
#define Bp 11
int retardo=100;
int paso=A;
void setup()
{
pinMode(A,OUTPUT);
pinMode(Ap,OUTPUT);
pinMode(B,OUTPUT);
pinMode(Bp,OUTPUT);
}
void loop()
{
digitalWrite(paso,HIGH);
delay(retardo);
digitalWrite(paso,LOW);
paso++;
if(paso>Bp)
{
paso=A;
}
}

• Ahora el siguiente programa permite el control del motor, dándo cierta cantidad de pasos.
Cargar el siguiente programa:
#define A 8
#define Ap 9
#define B 10
#define Bp 11
int bobina=A, np=0;
int retardo=100;
int npasos=10;
void setup()
{
pinMode(A,OUTPUT);
pinMode(Ap,OUTPUT);
pinMode(B,OUTPUT);
pinMode(Bp,OUTPUT);
}
void loop()
{
digitalWrite(bobina,HIGH);
delay(retardo);
digitalWrite(bobina,LOW);
bobina++;
if(bobina>Bp) bobina=A;
np++;
if(np==npasos)
{
np=0;
delay(1000);
}

B) Control con CI
Ilustración 30: Control de 2 motores a pasos con un CI


Probar el siguiente programa, que utiliza una función y permite controlar dos motores a
pasos, mediante el uso de un circuito integrado ULN2803, el cual tiene 8 arreglos que permiten
controlar cargas de hasta 500mA por cada salida.
#define A 8
#define Ap 9
#define B 10
#define Bp 11
const int retardo=100;
unsigned char m1=0x01, m2=0x10;

unsigned char m=0, dir=0;
void setup()
{
for(char i=2; i<=9; i++) pinMode(i,OUTPUT);
for(char i=10; i<=12; i++) pinMode(i,INPUT);
}
// m1<<1 | m1>>3 rotación izquierda

// m1>>1 | m1<<3 rotación derecha
void loop()
{
m=m1|m2;
motores(m);
dir=digitalRead(12)+digitalRead(11)*2+digitalRead(10)*4;
switch (dir){

case 0: m1=m1>>1|m1<<3;
//m2=m2<<1|m2>>3;
break;
case 1: m1=m1<<1|m1>>3;
//m2=m2<<1|m2>>3;
break;
case 2: //m1=m1>>1|m1<<3;
m2=m2>>1|m2<<3;
break;
case 3: //m1=m1>>1|m1<<3;
m2=m2<<1|m2>>3;
break;
case 4: m1=m1>>1|m1<<3;
m2=m2>>1|m2<<3;
break;
case 5: m1=m1<<1|m1>>3;
m2=m2<<1|m2>>3;
break;
case 6: m1=m1>>1|m1<<3;
m2=m2<<1|m2>>3;
break;
case 7: m1=m1<<1|m1>>3;
m2=m2>>1|m2<<3;
break;
}
m1=m1&0x0F;
m2=m2&0xF0;
delay(retardo);
void motores(unsigned char valor)

{
unsigned char aux=1;
{
if((valor&aux)>0)
{
}
else
{
}
aux=aux<<1;
}
}

 Observaciones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
 Conclusiones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________

Práctica No. 10. Servomotores RC
 Objetivo
Concer el funcionamiento básico de los servomotores de radio control o modelismo, por medio de una
sencilla práctica para el control de movimiento del mismo.
 Material
• Arduino Uno® • Protoboard y cables para conexiones
• PC (Arduino 1.0, Proteus) • 1 Servomotor RC
• #define, librería Servo.h
 Desarrollo
Arme el circuito mostrado en la Ilustración 31 , tanto físicamente como en Proteus.
Ilustración 31: Sermotor RC en Proteus
Ilustración 32: Servomotor RC con Arduino

Cargue el siguiente programa en el Arduino y pruebe tanto en la simulación como físicamente.
#include <Servo.h>
Servo miservo; //Maximo 12 servos se pueden controlar
int pos = 0; // variable para posicion
void setup()
{
miservo.attach(9);
}
void loop()
{
for(pos = 0; pos < 180; pos += 1)
{
miservo.write(pos);
delay(15);
}
for(pos = 180; pos>=1; pos-=1)
{
miservo.write(pos);
delay(15);
}
}
 Observaciones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
 Conclusiones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________

Práctica No. 11. Display 7 Segmentos
 Objetivo
Estudiar y aplicar el uso de los display de 7 segmentos tanto para mostrar números de uno o de dos
dígitos.
 Material
• Arduino Uno® • 8 Resistencias de 330Ω
• PC (Arduino 1.0, Proteus) • 2 Resistencias de 1kΩ
• Protoboard y cables para conexiones • 1 Transistor BC547(NPN)
• 2 Display de 7 segmentos de cátodo • 1 Transistor BC557(PNP)
común.
 Desarrollo
A) Arme el circuito mostrado en la Ilustración 33, tanto físicamente como en Proteus.
Ilustración 33: Display de 7 segmentos de cátodo común

El siguiente programa permite mostrar los dígitos del 0 al 9 en el display de 7 segmentos. Probarlo
tanto en Proteus como en el Arduino físicamente:
// 0 1 2 3 4 5 6 7 8 9
int disp[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x27,0x7F,0x6F};
void setup()
{
{
}
}
void loop()
{
for(int i=0;i<=9;i++)
{
imprimir(i);
delay(500);
}
}
void imprimir(int val)

{
int aux=1;
{
if((disp[val]&aux)>0)
{
}
else
{
}
aux=aux<<1;
}
}

B) El siguiente circuito mostrado en la Ilustración 34, muestra la aplicación de dos displays de 7

segmentos, que son multiplexados desde el programa para desplegar números de dos dígitos.
Ilustración 34: Control de dos displays
El siguiente programa, permite el desplegar la temperatura capturadada desde un sensor LM35,

utilizando dos cifras.
// 0 1 2 3 4 5 6 7 8 9
int disp[10]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x27,0x7F,0x6F};
int valorA0=0;
float voltaje;
int temp,u,d=0;
void setup()
{
{
}
}
void loop()
{
voltaje=valorA0*0.00488;
temp=voltaje*100;
d=temp/10;
u=temp%10;

imprimir(u); //Unidades
digitalWrite(6,HIGH);
delay(5);
imprimir(d); //Decenas
digitalWrite(6,LOW);
delay(5);
}
void imprimir(int val)

{
int aux=1;
{
if((disp[val]&aux)>0)
{
}
else digitalWrite(pin,LOW);
aux=aux<<1;
}
}
 Observaciones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
 Conclusiones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________

Práctica No. 12. Matriz de LEDs
 Objetivo
Estudiar y aplicar el uso de la matriz de leds 8x8, utilizada para desplegar mensajes alfanuméricos.
 Material
• Arduino Uno® • 1 Matriz de LEDs de 8x8
• PC (Arduino 1.0, Proteus) • 8 Resistencias de 330Ω
• Protoboard y cables para conexiones
 Desarrollo
A) Arme el circuito mostrado en la Ilustración 35, tanto físicamente como en Proteus.
Ilustración 35: Matriz de LEDs 8x8 en Proteus

Cargue el siguiente programa, tanto en Proteus como en el Arduino.
//Declaracion de columnas y filas

const char col[8] = {2,3,4,5,6,7,8,9};
const char row[8] = {10,11,12,13,14,15,16,17};
//Valores individuales
const unsigned char n[10]={0xFE,0xFD,0xFB,0xF7,0xEF,0xDF,0xBF,0x7F,0x00,0xFF};
unsigned char aux=0; //Variables para enmascaramiento
unsigned char valor=0x55;
void setup() {
for (char Pin = 0; Pin < 8; Pin++)
{
pinMode(col[Pin], OUTPUT); // Declaración de salidas
pinMode(row[Pin], OUTPUT);
digitalWrite(row[Pin], LOW); //Poniéndo todas las filas en bajo
}
}
void loop() {
// Filas
for(int i=0;i<8;i++)
{
valor=~valor;
RC(n[i],valor);
delay(100);
}
//Diagonal
{
RC(n[i],~n[i]);
delay(100);
}
//Columnas
{
RC(0x00,~n[i]);
delay(100);
}
}
//Asigna a la filas r, el valor c

void RC(unsigned char r, unsigned char c)
{
valR(r);
valC(c);
}

//Asigna el valor val a los pines que controlan las filas

void valR(unsigned char val)
{
aux=1;
for(int i=0; i<8; i++)
{
digitalWrite(row[i],(val&aux));
aux=aux<<1;
}
}
//Asigna el valor val a los pines que controlan las columnas

void valC(unsigned char val)
{
aux=1;
for(int i=0; i<8; i++)
{
digitalWrite(col[i],(val&aux));
aux=aux<<1;
}
}
 Observaciones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
 Conclusiones
_________________________________________________________________________________
_________________________________________________________________________________

Práctica No. 13. Comunicación Serial
 Objetivo
Estudiar
 Material
• Arduino Uno® • 2 Resistencias de 330Ω
• PC (Arduino 1.0, Proteus) • 1 Motor de CD
• Protoboard y cables para conexiones • 1 Puente H
• 2 LEDs
 Desarrollo
El circuito a utilizar será el siguiente:
Ilustración 36: Circuito para Proteus

A) El siguiente programa permite la impresión de caracteres en distintos formatos (Caracter,

Decimal, Hexadecimal, Octal, Binario).
Cargar el siguiente programa:
char val='0';
void setup()
{
Serial.begin(9600);
Serial.println("(val) (val,DEC) (val,HEX) (val,OCT) (val,BIN)");
}
void loop()
{
Serial.print(" ");
Serial.print(val);
Serial.print(" ");
Serial.print(val,DEC);
Serial.print(" ");
Serial.print(val,HEX);
Serial.print(" ");
Serial.print(val,OCT);
Serial.print(" ");
Serial.println(val,BIN);
delay(250);
val++;
}

Se obtendrá algo como lo muestra la siguiente ilustración:
Ilustración 37: Formatos de impresión en el puerto serie
B) Rediseñe el programa anterior para ahora utilizar “int val=48” en lugar de “char val='0'”.
Observar y comentar el resultado.
En el caso de los números fraccionarios o float, se puede especificar la cantidad de decimales

a mostrar, por ejemplo:
• Serial.println(1.23456, 0) imprimirá "1"
• Serial.println(1.23456, 2) imprimirá "1.23"
• Serial.println(1.23456, 4) imprimirá "1.2346"
• Serial.println(val, 2) imprimirá "val.xx"

C) El siguiente programa permite el controlar el encendido y apagado de un led conectado al pin

D13 del Arduino mediante el puerto serie. Al mandar la letra “H” desde la terminal al
Arduino, el led deberá de encenderse. Al mandar la letra “L”, el led deberá de apagarse.
#define LED 13
void setup()
{
pinMode(LED,OUTPUT);
Serial.begin(9600);
Serial.println("Presione 'H' para encender y 'L' para apagar");

}
void loop()
{
//Revisa que haya al menos se haya recibido un caracter en el puerto serie
if(Serial.available())
{
char ch=Serial.read();
if(ch=='H')
{
digitalWrite(LED,HIGH);
}
else if(ch=='L')
{
digitalWrite(LED,LOW);
}

D) El programa anterior permite el procesar un sólo caracter, el problema se presenta al querer

enviar una cantidad para que la pueda procesar el programa, es decir, en caso de querer
enviar el valor a fijar en una señal PWM, no sería tan sencillo enviar un “150”, puesto que se
recibiría un “1”, un “5” y finalmente un “0”. Una solución a este problema la presenta el
siguiente código (ver Ilustración 38):
int valor;
void setup()
{
Serial.begin(9600);
Serial.print("Introduce valor del PWM(0-255): ");
}
void loop()
{
//Revisa que haya al menos se haya recibido un caracter en el puerto serie
if(Serial.available())
{
char ch=Serial.read();
if(ch >= '0' && ch <= '9')
{
valor=(valor*10) + (ch-'0');
Serial.print(ch);
}
//13 es el valor del caracter que indica retorno de carro o ENTER o que se termino de mandar el numero completo
else if(ch==13)
{
analogWrite(9,valor);
Serial.println(" ");
Serial.print("Introduce valor del PWM(0-255): ");
valor=0; //Se inicializa la variable nuevamenta para esperar otro dato
}
}
}

E) Ejecutar el siguiente código y explicar su funcionamiento. Buscar el funcionamiento de la

función: Serial.Event().
String inputString = "";

boolean stringComplete = false;
void setup() {
Serial.begin(9600);
inputString.reserve(200);
}
void loop() {
if (stringComplete) {
Serial.println(inputString);
inputString = "";
stringComplete = false;
}
}
void serialEvent() {
while (Serial.available()) {
char inChar = (char)Serial.read();
inputString += inChar;
if (inChar == '\n')
{
stringComplete = true;
}
}
}
F) Diseñe un programa que permita el Arranque, Paro y Cambio de Giro de un motor de CD

desde el puerto serie.
G) Añada al programa anterior que el programa permita controlar la velocidad del motor de la
siguiente forma:
• Al presionar la tecla “+” se ira incrementando la velocidad una magnitud definida por el
programador.
• Al presionar la tecla “-” se reducirá la velocidad una magnitud definida por el
programador.

H) Diseñe un programa que permita el Arranque, Paro, Cambio de Giro de un motor y el control
de su velocidad desde el puerto serie. Las teclas serán las siguientes:
• “A” para Arranque.
• “P” para Paro.
• “D” para giro hacia la derecha o CW.
• “I” para giro hacia la izquierda o CCW.
• Y para el control de la velocidad se introducirá un valor de entre 0 y 100 para fijar la
velocidad. 0 es el motor detenido y el 100 siginificará la velocidad máxima del motor.
Ilustración 38: PWM controlado desde el puerto serie
 Observaciones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
 Conclusiones
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________

Practicas Arduino Muy Bueno

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Practicas Arduino Muy Bueno

Uploaded by

Copyright:

Available Formats

Centro de Bachillerato

industrial y de servicios No. 4

Ing. José Guillermo Palacios Mauricio Página 1

ElElectrónica Febrero – Julio 2012

Ing. José Guillermo Palacios Mauricio Página 2

Ing. José Guillermo Palacios Mauricio Página 3

Ing. José Guillermo Palacios Mauricio Página 4

Práctica No. 1. Configuración básica

Ilustración 2: Circuito físico

C) Diseñar un programa que permita encender y apagar 4 led de manera intermitente y de

Ing. José Guillermo Palacios Mauricio Página 5

 Estructura básica de un programa en Arduino

// En esta estructura va el código que sólo se ejecutará una sóla vez.

// Usualmente es el programa principal

El programa para el caso del inciso A, sería el siguiente:

El programa para el caso del inciso B, sería el siguiente:

Ing. José Guillermo Palacios Mauricio Página 6

Ilustración 3: Circuito para proteus

Ilustración 4: Propiedades del microcontrolador

Ing. José Guillermo Palacios Mauricio Página 7

Práctica No. 2. Lectura de Entradas

Ing. José Guillermo Palacios Mauricio Página 8

El programa quedaría de la siguiente manera:

//Se definen el lugar de cada elemento según su conexión al Arduino

// #define palabra valor ---- Sintaxis #define

Compilar, cargar el programa en el Arduino y simular.

Ilustración 6: Conexión física

Ing. José Guillermo Palacios Mauricio Página 9

El programa quedaría de la siguiente manera:

//Se definen el lugar de cada elemento según su conexión al Arduino

// #define palabra valor ---- Sintaxis #define

boolean edoBP1=0; //Variable para guardar el estado del botón 1

Compilar, cargar el programa en el Arduino y simular.

Ing. José Guillermo Palacios Mauricio Página 10

Tiempo 5 Seg 1 Seg. 5 Seg. 1 Seg. 5 Seg. 1 Seg.

La siguiente ilustración muestra el esquema a utilizar en Poteus:

Ing. José Guillermo Palacios Mauricio Página 11

Ing. José Guillermo Palacios Mauricio Página 12

Ilustración 7: Simulación de semáforos

Ing. José Guillermo Palacios Mauricio Página 13

Ilustración 8: Semáforo para peatón

Ing. José Guillermo Palacios Mauricio Página 14

• En el ejercicio D. Animar la imagen de SIGA del peatón. Simular en Proteus.

Ing. José Guillermo Palacios Mauricio Página 15

Práctica No. 3. Operaciones Lógicas

Ilustración 10: Circuito físico

Ilustración 9: Diagrama esquemático

Ing. José Guillermo Palacios Mauricio Página 16

Donde el programa quedaría de la siguiente manera:

#define Buzzer 13 //Pin 13

Ilustración 11: Circuito para alarma

Ing. José Guillermo Palacios Mauricio Página 17

1. Cuando se abra cualquiera de los 5 interruptores la alarma deberá de sonar de manera

Ilustración 12: Teoría de conjuntos para operaciones lógicas

Ing. José Guillermo Palacios Mauricio Página 18

Práctica No. 4. Ciclos

Ilustración 14: Circuito físico

Ilustración 13: Diagrama esquemático

Ing. José Guillermo Palacios Mauricio Página 19

B) Realizar los programas correspondientes según las siguientes condiciones:

Ing. José Guillermo Palacios Mauricio Página 20

Práctica No. 5. E/S Análogas

Ilustración 15: Circuito para entradas análogas

Ing. José Guillermo Palacios Mauricio Página 21