Universidad Tecnolgica de Tijuana

INGENIERA EN TECNOLOGAS DE LA INFORMACIN Y COMUNICACIN

MANUAL DE PRCTICAS

OPTATIVA I
M.C. Florencio Lpez Cruz

RESUMEN DE MATERIALES
10 LEDS $30.00

URGENTE

5 RESISTENCIAS DE 270 OHM

$5.05 URGENTE

5 RESISTENCIAS DE 10 KOHM

$5.05 URGENTE

5 RESISTENCIAS DE 330 OHM

$5.05

5 RESISTENCIAS DE 220 OHM

$5.05 URGENTE

10 RESISTENCIAS DE 100 OHM

$5.05

2 MICRO SWITCH PUSH DE 4 TERMINALES $9.01 URGENTE

2 MICRO SWITCH PUSH DE 2 TERMINALES

$12.01URGENTE

2 DISPLAY DE CATODO COMUN DC05

$18.00 URGENTE

2 DISPLAY DE ANODO COMUN DA05

$18.00 URGENTE

1 POTENCIOMETRO DE 5KOHM

$8.00 URGENTE

1 MOTOR CD DE 5 A 6 VOLTS (ELECTRON O MADRIGAL)

1 MOTOR PASO A PASO O STEPPER (ELECTRON O MADRIGAL)
1 SERVOMOTOR (ELECTRON O MADRIGAL)
2 TRANSISTOR BIPOLAR NPN 45VCEO, BC547, 2N2222, 2N3904 $8.00
1 FOTORESISTENCIA (LDR)

$11.99 URGENTE

1 SENSOR DE TEMPERATURA MCP9700 (ELECTRON O MADRIGAL L)

1 BUZZER DE 2.9 KHZ BGD25C TONO CONSTANTE

$26.01

1 PUENTE H SN754410 (ELECTRON O MADRIGAL L)

1 DISPLAY LCD 16 X 2 (ELECTRON O MADRIGAL)
1 RELEVADOR DE 5 A 110 VOLTS

$17.01

1 SENSOR ULTRASONICO HC-SR04 (ELECTRON O MADRIGAL) $60.00 APROX

NOTA: Los materiales que dicen URGENTE, son materiales para las prcticas del martes
14, y los precios son de acuerdo a la STEREN. Los materiales que dicen ELECTRON O
MADRIGAL, son materiales que no encontrara en la STEREN, dado que no maneja
sensores, motores dc, servomotores, y motores paso a paso, estos materiales los
usaremos en las prcticas posteriores.

Practica 1: Programar los pines para entrada y salida

En esta prctica desarrollaremos un pequeo programa para un
circuito que cuenta con 2 botones (switches) y un LED. Un
switch estar programado para encender el LED y el otro
switch estar programado para apagarlo.
LISTA DE MATERIALES:

Protoboard
1 LED
1 Resistencia 270 ohms (rojo, morado, cafe)
2 Botones de push, interruptores
Arduino Uno
Cable USB para el Arduino
Cable

Figura 1: Montaje Virtual del Circuito

INSTRUCCIONES
Como ves hemos conectado 2 botones y 1 LED en el protoboard.
La terminal positiva del LED se conecta a la resistencia y la

resistencia se conecta al pin nmero 10 del Arduino. El otro

extremo del LED se conecta a tierra (-). Los botones tienen 2
extremos o terminales, una de las terminales la conectamos a
tierra (s, la misma que el LED) y ahora conectamos el otro
extremo del botn (switch) en el pin 7 y el otro botn en el
pin 2 del Arduino. La imagen muestra una forma en que pueden
estar conectados los elementos, no importa el orden, solo que
lo hagas de la forma correcta.
CDIGO
//Declaracion de los Pines
int pinLed = 10; // Pin del LED
int boton1 = 2; //Encender
int boton2 = 7;//Apagar</code>
//Aqu hacemos el Setup de los pines, es decir, los configuramos como
entradas y salidas
void setup()
{
pinMode(pinLed, OUTPUT);
pinMode(boton1, INPUT_PULLUP);
pinMode(boton2, INPUT_PULLUP);
}
//Aqu empezamos a hacer nuestro ciclo infinito, programa principal
void loop()
{
if (digitalRead(boton1) == LOW)
{
digitalWrite(pinLed, HIGH);
}
if (digitalRead(boton2) == LOW)
{
digitalWrite(pinLed, LOW);
}
}

Practica I1: Contador con Display de 7 segmentos

En esta prctica de Arduino haremos un pequeo contador que
ir de 0 a 9 y para eso vamos a usar un display de 7
segmentos. Tal vez no tengas mucha experiencia con el display
de 7 segmentos pero te aseguro que ya los conoces, son esas
cosillas que estn en los despertadores, microondas, etc.
MATERIALES

Arduino
Display de 7 segmentos catodo comn modelo DC05
1 Resistencia de 220 Ohms
Cables

INSTRUCCIONES
Un Display de este tipo no es ms que un conjunto de LEDs
como los que hemos estado utilizando, solo que estos estn
conectados en un circuito. Nosotros usaremos el display
modelo DC05, el cual es de catodo comn, es decir,
internamente todos los LEDs comparten la misma tierra (GND).

Figura 2: Display de 7 segmentos catodo comn modelo DC05

El circuito es fcil de armar, las configuraciones pueden

variar, solo recuerda declarar bien los pines dentro del
cdigo de Arduino.

Como puedes
manera:

apreciar

las

conexiones

quedaron

de

la

siguiente

Pin A del Display al pin 2 del Arduino

Pin B del Display al pin 3 del Arduino
Pin G del Display al pin 0 del Arduino
Pin F del Display al pin 1 del Arduino
Pin E del Display al pin 4 del Arduino
Pin D del Display al pin 5 del Arduino
Pin C del Display al pin 6 del Arduino
La tierra del display va conectada a un extremo de la
resistencia y el otro extremo de la resistencia va conectado
a tierra del Arduino (GND)

Cdigo
Versin 1: en esta versin utilizamos un delay(1000), lo que significa
que se detiene el programa por 1000 milisegundos = 1 segundo, esto con el
fin de dejar prendido el estado del display por 1 segundo. Despus
podemos ver cmo es que vamos prendiendo cada uno de los nmeros en el
Display.

//Declaramos los pines de salida,

//en el el proyecto asi lo tenemos cableado
int a = 2;
int b = 3;
int c = 6;
int d = 5;
int e = 4;
int f = 1;
int g = 0;//Hacemos que todas nuestras variables sean salidas
void setup(){
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);}
void loop(){
//Cero
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,LOW);
delay(1000);
//Uno
digitalWrite(a,LOW);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(1000);
//Uno
digitalWrite(a,LOW);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(1000);
//Dos
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,LOW);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);

digitalWrite(f,LOW);
digitalWrite(g,HIGH);
delay(1000);
//Tres
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,HIGH);
delay(1000);
//Cuatro
digitalWrite(a,LOW);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
delay(1000);
//Cinco
digitalWrite(a,HIGH);
digitalWrite(b,LOW);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
delay(1000);
//Seis
digitalWrite(a,HIGH);
digitalWrite(b,LOW);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
delay(1000);
//Siete
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);

delay(1000);
//Ocho
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
delay(1000);
//Nueve
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
delay(1000);
}
Versin 2: La verdad es que esta versin del programa es igual al
anterior
solo
que
aqu
hacemos
uso
de
una
funcin
(escribirEnElDisplay()). La funcin recibe como parmetros los valores de
cada uno de los segmentos del display, un 1 equivale a encendido y 0
equivale a apagado.
//Declaramos los pines de salida,
//en el el proyecto asi lo tenemos cableado
int a = 2;
int b = 3;
int c = 6;
int d = 5;
int e = 4;
int f = 1;
int g = 0;
void setup(){
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);}
void escribirEnElDisplay(int va, int vb, int vc, int vd, int ve, int vf,
int vg){
digitalWrite(a,va);
digitalWrite(b,vb);

digitalWrite(c,vc);
digitalWrite(d,vd);
digitalWrite(e,ve);
digitalWrite(f,vf);
digitalWrite(g,vg);
}
void loop(){
//Cero
escribirEnElDisplay(1,1,1,1,1,1,0);
delay(1000);
//Uno
escribirEnElDisplay(0,1,1,0,0,0,0);
delay(1000);
//Dos
escribirEnElDisplay(1,1,0,1,1,0,1);
delay(1000);
//Tres
escribirEnElDisplay(1,1,1,1,0,0,1);
delay(1000);
//Cuatro
escribirEnElDisplay(0,1,1,0,0,1,1);
delay(1000);
//Cinco
escribirEnElDisplay(1,0,1,1,0,1,1);
delay(1000);
//Seis
escribirEnElDisplay(1,0,1,1,1,1,1);
delay(1000);
//Siete
escribirEnElDisplay(1,1,1,0,0,0,0);
delay(1000);
//Ocho
escribirEnElDisplay(1,1,1,1,1,1,1);
delay(1000);
//Nueve
escribirEnElDisplay(1,1,1,1,0,1,1);
delay(1000);
}

Practica I1I: Entradas y salidas anlogas

En esta ocasin vamos a trabajar con un LED y un
potencimetro, tal vez no sepas que es un potencimetro pero
aqu te lo explicare de manera simple. Se trata de una
resistencia variable, s, una resistencia que puede cambiar
su valor, bueno un potencimetro es lo mismo solo que podemos
variar su valor ya que cuenta con una perilla. Podemos
aumentar o disminuir su resistencia, es decir, si aumentamos
su resistencia la cantidad de corriente que pase por el
circuito ser menos, pero si la disminuimos, la cantidad de
corriente elctrica que pase por el circuito ser mayor.

Bueno, ahora pasemos a explicar la leccin de entradas y

salidas analogas. El Arduino cuenta con entradas y salidas
analogas, con las entradas analogas podemos podemos hacer una
lectura de una variacin de voltaje, y con las salidas
anlogas tambin podemos hacer una variacin de voltaje solo
que usando PWM.
MATERIALES

Arduino
Potenciometro (en el ejemplo usamos uno de 5KOhms pero
puedes usar uno de 1KOhm u otro)
LED
Resistencia de 220 Ohms
Cables
Protoboard

INSTRUCCIONES
En el circuito, la resistencia se conecta a tierra y al pin
11 del Arduino. Mientras que el potencimetro tiene 3

patitas, las dos de los extremos van ir conectada a voltaje,

es decir, una pata va a los 5 volts del Arduino y la otra
pata va a tierra (GND) del Arduino. La pata de en medio del
potencimetro lo vamos a conectar a la entrada anloga 0 es
decir a A0.

Lecturas anlogas
En en esta practicas vamos a trabajar con lecturas analogas
es decir, vamos a leer la cantidad de voltaje que entra por
uno de los pines del Arduino. El voltaje que se lea tiene que
estar entre 0 y 5 volts, por eso vamos a usar el voltaje que
nos proporciona el Arduino en uno de sus pines. Despus de
que se lee el voltaje, este se convierte en un valor numerico
que cabe en 10 bits, es decir entre 0 y 1023. Qu significa
esto?, bueno, significa que 0 volts equivaldrn a un 0 para
el Arduino y 5 volts equivaldr a 1023 y podemos hacer reglas
de 3 para encontrar los dems valores, por ejemplo 2.5 volts
equivalen a 511.
Para hacer lecturas anlogas vamos a usar la funcin
analogRead(A0) y guardarlo en una variable entera. Por
ejemplo:

int valorPotenciometro = analogRead(A0);

La variable valorPotenciometro guardara el valor del voltaje
que se lea en el pin A0.
Salidas Anlogas
En
algunas
ocasiones
las
salidas
digitales
no
son
suficientes, hemos estado usando salidas digitales para
prender y apagar LEDs, recuerdas el HIGH y LOW, este tipo de
seal es excelente para prender y apagar un LED, pero Qu
pasa si lo que queremos es controlar su intensidad?, bueno,
para eso vamos a usar salidas anlogas. Para usar las salidas
anlogas
el
Arduino
hace
uso
de
la
funcin
analogWrite(pin), la salida anloga usa PWM (Modulacin por
ancho de pulsos), ms delante hablaremos detenidamente de el
PWM. El Arduino tiene diferentes salidas anlogas, las
podemos identificar ya que tienen impreso un ~ en el pin.
Para escribir un valor anlogo utilizaremos valores entre 0 y
255, igual que en la entrada anloga estos valores tienen una
equivalencia en voltaje, 0 es igual a 0 volts y 255 equivale
a 5 volts.
Cdigo
int ledPin = 11;
void setup(){
pinMode(ledPin, OUTPUT);
}
void loop(){
int valorPotenciometro = analogRead(A0);
int intensidadLED =
(int)((((double)valorPotenciometro)/1023)*255.0);
analogWrite(ledPin, intensidadLED);
delay (20);
}

Como podemos ver en el cdigo hacemos la lectura de la seal

anloga
A0
y
lo
guardamos
en
una
variable
llamada
valorPotenciometro, despus esta variable la dividimos entre
1023 y luego la multiplicamos por 255 para tener su
equivalente en la salida anloga y guardamos el valor en la
variable intensidadLED. Despus intensidadLED lo escribimos
en ledPin para poder sacar el voltaje en la luminosidad del
LED.

Practica IV: Comunicacin Serial Arduino-PC

MATERIALES

1 Computadora
1 Arduino

INSTRUCCIN
Vamos a hacer un primer ejercicio para poder utilizar la
comunicacin serial. Para este primer ejercicio solo vamos a
necesitar nuestra placa de Arduino y nuestro cable USB. As
que procederemos a conectarlo a nuestra computadora y
ejecutar el siguiente cdigo:
CODIGO
//Hacemos nuestro setup, solo se hace una vez al inicar el programa
void setup()
{
//Establecemos la velocidad de comunicacion serial
Serial.begin(9600);//Imprimimos nuestro "Hello World!" en monitor
serial
Serial.println("Hello world!");
}//El loop se corre siempre
void loop()
{
//No hacemos nada al entrar al loop o ciclo infinito
}

MARCO TEORICO
En esta nueva practica vamos a ver comunicacin serial entre
el Arduino y nuestra computadora. El objetivo es poder
imprimir valores, resultados, etc., de lo que sucede con
nuestra placa Arduino en una ventana de nuestra computadora.
Por ejemplo, si estamos trabajando con un LED podemos
imprimir en pantalla el valor de la intensidad de ese LED, o
si estamos haciendo lecturas anlogas nos ayudar a saber el
valor de la lectura e imprimirlo en una ventana de nuestra
computadora. Primero que nada vamos a hablar un poco acerca
de que trata la comunicacin serial.

COMUNICACIN SERIAL

La comunicacin serial es un protocolo de envio de

informacin a traves de computadoras. El protocolo consiste
en enviar y recibir una secuencia de bits, es decir, enviar o
recibir un bit a la vez a un ritmo o frecuencia acordada
entre las dos computadoras. Actualmente la comunicacin
serial ya no es muy usada entre computadoras personales/de
escritorio ya que ha sido reemplazado por protocolos ms
avanzados como el puerto USB.
Nuestra tarjeta Arduino posee comunicacin serial para poder
hacer intercambio de informacin con el PC u otros
dispositivos. La comunicacin serial puede hacerse a travs
de los pines digitales 0 (RX) y 1 (TX) as como con el PC
mediante USB (es el que utilizaremos en esta leccin).

SEGUNDO EJERCICIO (MONITOREANDO UNA SEAL ANALOGA)

MATERIALES

1 Computadora
1 Arduino
Potenciometro de 5K

CODIGO
//Hacemos nuestro setup, solo se hace una vez al inicar el programa
void setup()
{
//Establecemos la velocidad de comunicacion serial
Serial.begin(9600);//Imprimimos nuestro "Hello World!" en monitor
serial
Serial.println("Hello world!");
}//El loop se corre siempre
void loop()
{
int valorPotenciometro = analogRead(A0);
Serial.println("El valor del potenciometro es:");
Serial.println(valorPotenciometro);
delay(1000);
}

INSTRUCCIONES
Primero que nada armamos el circuito con el potencimetro de
la siguiente manera, es muy similar a la leccin de entradas
y salidas anlogas y teclee el siguiente cdigo:
Como podemos ver en el cdigo hacemos lo mismo que en el
anterior, solo que en el loop() hacemos una lectura a la
entrada
analoga
A0
y
guardamos
el
valor
en
valorPotenciometro despus imprimimos este valor en el
monitor serial, y hacemos un delay de 1000 ms. Con este
cdigo podemos monitorear el cambio en una entrada anloga y
desplegar el valor obtenido.

SEGUNDO EJERCICIO (MONITOREANDO UNA SEAL DIGITAL)

MONITOREO DE SEAL DIGITAL
A veces tambin ser til monitorear una seal digital, como
un interruptor. En esta prctica trabajamos con uno de los
botones/switches para desplegar en nuestro monitor serial una
entrada digital. Para eso vamos a conectar a nuestro Arduino
un switch a una de las entradas digitales. Vamos a trabajar
con un cdigo similar al de la leccin de entradas y salidas
digitales.
MATERIALES

1 Computadora
1 Arduino
1 Micro Switch

Ejecutamos y corremos nuestro monitor serial y podremos

observar que cada vez que presionemos el swicht se mostrar
en el monitor serial un mensaje de que el botn fue
presionado.
CODIGO
int boton = 7;
//Hacemos nuestro setup, solo se hace una vez al inicar el programa
void setup()
{
//Establecemos la velocidad de comunicacion serial
Serial.begin(9600);//Imprimimos nuestro "Hello World!" en monitor
serial
Serial.println("Hello world!");
pinMode(boton, INPUT_PULLUP);
}//El loop se corre siempre
void loop()
{
if (digitalRead(boton) == LOW){
Serial.println("Bonton presionado");
}
delay(1000);
}

Practica V:

LEDS Y POTENCIOMETRO (SEALES

ANLOGAS Y DIGITALES)
En esta prctica vamos a trabajar con algunos componentes ya
bien
conocidos
para
nosotros:
unos
cuantos
LEDs
y
Potencimetro. El objetivo es prender los LEDs con el
potencimetro dependiendo el valor de este, es decir, si el
valor aumenta los LEDs se van encendiendo.
Para
esto
necesitaremos
combinar
seales
anlogas
y
digitales. La lectura del potencimetro ser anloga mientras
que el encendido de los LEDs ser digital. Si bien
recordamos nuestro potencimetro nos puede dar seales
anlogas con valores entre 0 y 1023. En esta leccin vamos a
utilizar 6 LEDs por lo tanto vamos a dividir el rango del
potencimetro entre 6 para que los LEDs vayan encendiendo de
manera secuencial. Es decir si el potencimetro tiene un
valor de 0 ninguno de los LEDs estar prendido pero conforme
vaya
aumentando
el
valor
del
potencimetro
se
irn
encendiendo los LEDs uno por uno.
El rango de valores del potencimetro va de 0 a
Dividiendo 1024/6 nos da aproximado 170, por lo
nuestros rangos sern de 170.

1023.
tanto

MATERIALES

Arduino
Protoboard
6 Resistencias de 100 Ohms
Potenciometro 1KOhm o 5 KOhms
6 LEDs
Cables

CIRCUITO

CODIGO
En el cdigo lo que hacemos es leer el valor del potencimetro como
entrada anloga en A0. Dependiendo de este valor vamos a ir encendiendo
los LEDs.
//Declaramos los leds y los pines en los cuales hay que conectar
int led1 = 12;
int led2 = 11;
int led3 = 10;
int led4 = 9;

int led5 = 8;
int led6 = 7;
void setup(){
//configuramos todos los pines como salidas
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
pinMode(led6, OUTPUT);}
void loop(){//Hacemos la lectura analoga del potenciometro
int valorPotenciometro = analogRead(A0);//Apagamos todos los LED's
digitalWrite(led1,
digitalWrite(led2,
digitalWrite(led3,
digitalWrite(led4,
digitalWrite(led5,
digitalWrite(led6,

LOW);
LOW);
LOW);
LOW);
LOW);
LOW);

//En este codigo vamos revisando el valor del pot para

//ir prendiendo poco a poco los LED's
if(valorPotenciometro > 0){
digitalWrite(led1, HIGH);
}
if(valorPotenciometro > 170){
digitalWrite(led2, HIGH);
}
if(valorPotenciometro > 340){
digitalWrite(led3, HIGH);
}
if(valorPotenciometro > 510){
digitalWrite(led4, HIGH);
}
if(valorPotenciometro > 680){
digitalWrite(led5, HIGH);
}
if(valorPotenciometro > 850){
digitalWrite(led6, HIGH);
}
}

PRACTICA INTEGRADORA
Practica VI: Lectura y Entrada Anloga (Potencimetro)
En esta prctica el objetivo es controlar la velocidad con la
que va transcurriendo la secuencia, es decir, que acelere o
disminuya la velocidad con la que cambian los leds.

MATERIALES

Potencimetro de 10Khoms.
8 Leds
9 Resistencias 220homs
Boton

CODIGO
int
int
int
int
int

botonPin = 13; //Pin del boton

Cont = 0; //Contador para llevar el control de tareas
botonEstado = 0; //Variable para guardar cuando se presione el boton
PotVal = 0; //Tiempo para observar los cambios
PotPin = 2;

void setup() { //Se configuran los puertos, todos los leds como salida y
el pin del boton como entrada
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);

pinMode(botonPin, INPUT);
}
//Metodo para prender 8 leds incluyendo el tiempo de espera
void PrenderLeds(int ld1, int ld2, int ld3, int ld4, int ld5, int ld6,
int ld7, int ld8, int tiempo){
digitalWrite(ld1, HIGH);
delay(tiempo);
digitalWrite(ld2, HIGH);
delay(tiempo);
digitalWrite(ld3, HIGH);
delay(tiempo);
digitalWrite(ld4, HIGH);
delay(tiempo);
digitalWrite(ld5, HIGH);
delay(tiempo);
digitalWrite(ld6, HIGH);
delay(tiempo);
digitalWrite(ld7, HIGH);
delay(tiempo);
digitalWrite(ld8, HIGH);
delay(tiempo);
}
//Metodo para apagar 8 leds incluyendo el tiempo de espera
void ApagarLeds(int ld1, int ld2, int ld3, int ld4, int ld5, int ld6, int
ld7, int ld8, int tiempo){
digitalWrite(ld1, LOW);
delay(tiempo);
digitalWrite(ld2, LOW);
delay(tiempo);
digitalWrite(ld3, LOW);
delay(tiempo);
digitalWrite(ld4, LOW);
delay(tiempo);
digitalWrite(ld5, LOW);
delay(tiempo);
digitalWrite(ld6, LOW);
delay(tiempo);
digitalWrite(ld7, LOW);
delay(tiempo);
digitalWrite(ld8, LOW);
delay(tiempo);
}
void loop(){
PotVal = analogRead(PotPin);
botonEstado = digitalRead(botonPin); //Lee si el boton se presiona o no
if (botonEstado == HIGH) { //Si el boton se presiono entrada a la
condicion
Cont += 1; //Aumenta contador cada vez que se presiona
if(Cont > 4) //Resetea el contador cuando es mayor a 4 y vuelve a la
primera opcion
{
Cont = 0;
}
}

if (Cont == 0){ //Opcion por default, todos los leds prendidos

PrenderLeds(5,6,7,8,9,10,11,12,0);
delay(150);
}
if (Cont==1){ //Primera opcion, prende los leds empezando del 1 hasta
el 9 uno por uno
PrenderLeds(5,6,7,8,9,10,11,12,PotVal);
delay(PotVal);
ApagarLeds(5,6,7,8,9,10,11,12,0);
delay(PotVal);
}
if (Cont==2){ //Segunda opcion, prende los leds empezando del 9 hasta
el 1 uno por uno
ApagarLeds(12,11,10,9,8,7,6,5,0);
delay(PotVal);
PrenderLeds(12,11,10,9,8,7,6,5,PotVal);
delay(PotVal);
}
if (Cont==3){ //Tercera opcion, apaga los leds del 1 al 9 uno por uno
PrenderLeds(5,6,7,8,9,10,11,12,0);
delay(PotVal);
ApagarLeds(5,6,7,8,9,10,11,12,PotVal);
delay(PotVal);
}
if (Cont==4){ //Cuarta opcion, apaga los leds del 9 al 1 uno por uno
PrenderLeds(5,6,7,8,9,10,11,12,0);
delay(PotVal);
ApagarLeds(12,11,10,9,8,7,6,5,PotVal);
delay(PotVal);
}
}

Practica VII: Lectura y Entrada Anloga (Potencimetro) 2

En esta prctica el objetivo es utilizar el potencimetro
para prender o apagar los leds, el potencimetro tiene un
rango de valor de 0 a 1023, utilizando 8 leds prender el
primero si el rango del potencimetro esta entre el 1 y el
100, el segundo de 100 a 200, y asi hasta llegar el led
nmero 8 donde ser de 700 a 800, si el valor es mayor a 800
que todos los leds parpadeen, si el valor del potencimetro
es 0 apagar todos los leds. Mostrar en el "Monitor serial" el
valor del potencimetro.
MATERIALES

Potenciometro de 10Khoms.
8 Leds
9 Resistencias 220homs

CIRCUITO

CODIGO
int pinPot = 2; //Puerto analogo donde esta conectado el potenciometro
int valPot = 0; //Variable que guardara el valor del potenciometro
void setup()
{
pinMode(pinPot, INPUT); //Se pone como input el pin analogo del
potenciometro
for (int i = 5; i <= 12; i++){ //Ciclo para poner los pines de los leds
como output
pinMode(i, OUTPUT);
}
Serial.begin(9600);
}
//Metodo para controlar los leds, se envia un 0 para apagarlo y un 1 para
prenderlo
void Leds(boolean A,boolean B,boolean C,boolean D,boolean E,boolean
F,boolean G,boolean H)
{
digitalWrite(5, A);
digitalWrite(6, B);
digitalWrite(7, C);
digitalWrite(8, D);
digitalWrite(9, E);
digitalWrite(10, F);
digitalWrite(11, G);
digitalWrite(12, H);
}
//Metodo que hace parpadear los leds, se usara cuando el valor sea mayor
a 800
void Blink(){

Leds(1,1,1,1,1,1,1,1);
delay(50);
Leds(0,0,0,0,0,0,0,0);
delay(50);
}
void loop()
{
valPot = analogRead(pinPot); //Lee el valor del potenciometro
Serial.println(valPot, DEC); //Lo muestra en el "monitor serial"
delay(100);
if (valPot == 0){ //Apaga los leds
Leds(0,0,0,0,0,0,0,0);
}
if (valPot >= 1 && valPot < 100){ //Prende el primer led
Leds(1,0,0,0,0,0,0,0);
}
if (valPot >= 100 && valPot < 200){ //Prende el segundo led
Leds(1,1,0,0,0,0,0,0);
}
if (valPot >= 200 && valPot < 300){
Leds(1,1,1,0,0,0,0,0);
}
if (valPot >= 300 && valPot < 400){
Leds(1,1,1,1,0,0,0,0);
}
if (valPot >= 400 && valPot < 500){
Leds(1,1,1,1,1,0,0,0);
}
if (valPot >= 500 && valPot < 600){
Leds(1,1,1,1,1,1,0,0);
}
if (valPot >= 600 && valPot < 700){
Leds(1,1,1,1,1,1,1,0);
}
if (valPot >= 700 && valPot < 800){
Leds(1,1,1,1,1,1,1,1);
}
if (valPot >= 800){ //Parpadea todos los leds
Blink();
}
}
.

Practica VIII: ARDUINO FOTORRESISTENCIA Y LED

En esta prctica trabajaremos con una fotorresistencia
utilizaremos la entrada de la seal anloga de una
fotorresistencia para prender un LED y mostrar su valor en la
terminal serial. Como sabemos, dependiendo de la cantidad de
luz en el ambiente podremos controlar nuestro LED, lo malo es
que una fotorresistencia es muy sensible.

Una fotorresistencia es una resistencia que tiene la

capacidad de aumentar o disminuir el valor de su resistencia
de acuerdo a la intensidad de luz que pueda captar. El valor
de resistencia de una fotorresistencias es bajo cuando hay
luz incidiendo en l (puede descender hasta 50 ohms) y muy
alto cuando est a oscuras (varios megaohms). Estos
componentes pueden ser utilizados como sensores de luz.
MATERIALES

Arduino
Protoboard
Fotorresistencia
LED
1 resistencia de 220 ohms
1 resistencia de 10 kohms
cables

CODIGO
int led = 11;
void setup(){
Serial.begin(9600); //Crea la velocidad de comunicacin seria
pinMode( led, OUTPUT ); //configura como salida el led
}
void loop(){
int valorFotorresistencia;
//Declaramos la variable de la
fotorresistencia
valorFotorresistencia = analogRead(A0); //leemos el valor de la
fotorresistencia
Serial.println(valorFotorresistencia); //Imprimimos en la consola
serial el valor de la fotorresistencia
analogWrite(led, valorFotorresistencia/4); //prendemos el valor del LED
dependiendo del valor de la fotorresistencia
delay(500);
//Esperamos 500ms
}

CIRCUITO

En el cdigo podemos ver que declaramos una variable para

leer el valor de la fotorresistencia y lo imprimimos en la
consola serial. Adems de eso hacemos prender el LED
dependiendo el valor de la fotorresistencia. Recuerda que en
la leccin de comunicacin serial hacemos uso de la terminal
serial si es que no lo recuerdas. Para poder ver el
funcionamiento de la fotorresistencia es necesario taparlo
por completo para ver verdaderos resultados, o si prefieres
necesitaras estar a obscuras para ver como es que funciona.

Practica 1X:

Contador con Display de 7 Segmentos de ANODO COMUN

En esta prctica de Arduino haremos un pequeo contador que

ir de 0 a 9 y para eso vamos a usar un display de 7
segmentos de anodo comn DA05.

Verificar que las conexiones que se van a hacer desde el

puerto 0 hasta el 6 sean las correctas, ya que para que logre
funcionar el display cada puerto enviara un 1 o un 0 segn
corresponda el caso, y dependiendo del resultado se prender
o se apagara la parte del segmento del display.
MATERIALES

Arduino
Display Anodo Comun DA05.
Resistencias de 220 homs.

CODIGO
//Se declaran los pines de acuerdo a las letras del diagrama del display
int a = 2;
int b = 3;
int c = 6;
int d = 5;
int e = 4;
int f = 1;
int g = 0;

int tiempo = 500;

void setup(){ //Se configuran todos los pin como salidas
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);}
void loop(){ //Empezara a contar desde el 0
//Cero
//Aqui es donde cada segmento se gestiona y de acuerdo a como se indique
en esta parte es lo que
//se vera reflejado en el display, solo bastara con dibujar cada numero u
no por uno
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,HIGH);
delay(tiempo);
//Uno
digitalWrite(a,HIGH);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
delay(tiempo);
//Dos
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,HIGH);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,HIGH);
digitalWrite(g,LOW);
delay(tiempo);
//Tres
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,LOW);
delay(tiempo);
//Cuatro

digitalWrite(a,HIGH);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(tiempo);
//Cinco
digitalWrite(a,LOW);
digitalWrite(b,HIGH);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,HIGH);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(tiempo);
//Seis
digitalWrite(a,LOW);
digitalWrite(b,HIGH);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(tiempo);
//Siete
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
delay(tiempo);
//Ocho
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,LOW);
digitalWrite(e,LOW);
digitalWrite(f,LOW);
digitalWrite(g,LOW);
delay(tiempo);
//Nueve
digitalWrite(a,LOW);
digitalWrite(b,LOW);
digitalWrite(c,LOW);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,LOW);
digitalWrite(g,LOW);

delay(tiempo);
}

Practica X: Nmeros binarios y Monitoreo Serial

En esta prctica con los 4 leds representar los nmeros del 1
al 15 en binario, es decir, empezando del 0001 hasta el 1111,
cada led representara una posicin de un espacio del numero
binario empezando de izquierda a derecha, por medio del
Monitor serial se ingresara un numero en decimal entre el 1 y
el 15, el cual el programa leer y prender los leds en
representacin de su forma binaria.
MATERIALES

4 Leds
4 Resistencias

CODIGO
int Numero = 0; //variable donde se guardara el nmero que se escriba
void setup() {
Serial.begin(9600);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
}
//Metodo para prender los leds segun su numero
void PrenderLeds(boolean a, boolean b, boolean c, boolean d){

digitalWrite(5,a); //5, 6, 7 y 8 son los pines que se utilizaran pueden

variar
digitalWrite(6,b); //a, b, c y d sirven para indicar si el valor sera
HIGH o LOW
digitalWrite(7,c);
digitalWrite(8,d);
}
void loop() {
if (Serial.available() > 0) { //Si se detecta algun pulso entrara a la
condicion
Numero = Serial.parseInt(); //Convierte en numero lo que se ingrese
desde el monitor serial
if (Numero == 1){ //Si es 1 realizara los siguientes pasos donde
aplicaran para todos los numeros
Serial.println("Numero uno 1000"); //Se despliega el mensaje
PrenderLeds(1,0,0,0); //Se manda un 1 en la posicion del led a
prender y un 0 para apagarlo
}
if (Numero == 2){
Serial.println("Numero dos 0100");
PrenderLeds(0,1,0,0);
}
if (Numero == 3){
Serial.println("Numero tres 1100");
PrenderLeds(1,1,0,0);
}
if (Numero == 4){
Serial.println("Numero cuatro 0010");
PrenderLeds(0,0,1,0);
}
if (Numero == 5){
Serial.println("Numero cinco 1010");
PrenderLeds(1,0,1,0);
}
if (Numero == 6){
Serial.println("Numero seis 0110");
PrenderLeds(0,1,1,0);
}
if (Numero == 7){
Serial.println("Numero siete 1110");
PrenderLeds(1,1,1,0);
}
if (Numero == 8){
Serial.println("Numero ocho 0001");
PrenderLeds(0,0,0,1);
}
if (Numero == 9){
Serial.println("Numero nueve 1001");
PrenderLeds(1,0,0,1);
}
if (Numero == 10){
Serial.println("Numero diez 0101");
PrenderLeds(0,1,0,1);
}
if (Numero == 11){
Serial.println("Numero once 1101");
PrenderLeds(1,1,0,1);

}
if (Numero == 12){
Serial.println("Numero
PrenderLeds(0,0,1,1);
}
if (Numero == 13){
Serial.println("Numero
PrenderLeds(1,0,1,1);
}
if (Numero == 14){
Serial.println("Numero
PrenderLeds(0,1,1,1);
}
if (Numero == 15){
Serial.println("Numero
PrenderLeds(1,1,1,1);
}
if (Numero > 15){
Serial.println("Numero
PrenderLeds(0,0,0,0);
}

doce 0011");

trece 1011");

catorce 0111");

quince 1111");

fuera de rango");

}
}

Practica XI: Lectura y Entrada Digital ( Micro Switch 2

)
Terminales

En esta prctica el objetivo es usar un botn para controlar

los leds conectados, programando las siguientes secuencias:
1.
2.
3.
4.

Primera secuencia, prender los leds del 1 al 8 uno por uno.

Prender los leds del 8 al 9.
Apagar los leds del 1 al 8.
Apagar los leds del 9 al 8.
5. Opcional, prender todos los leds

MATERIALES

PushButton normalmente abierto

9 Resistencias de 220homs
8 Leds

CIRCUITO

CODIGO
int
int
int
int

botonPin = 13; //Pin del boton

Cont = 0; //Contador para llevar el control de tareas
botonEstado = 0; //Variable para guardar cuando se presione el boton
Pausa = 300; //Tiempo para observar los cambios

void setup() { //Se configuran los puertos, todos los leds como salida y
el pin del boton como entrada
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(botonPin, INPUT);
}
//Metodo para prender 8 leds incluyendo el tiempo de espera
void PrenderLeds(int ld1, int ld2, int ld3, int ld4, int ld5, int ld6,
int ld7, int ld8, int tiempo){
digitalWrite(ld1, HIGH);
delay(tiempo);
digitalWrite(ld2, HIGH);

delay(tiempo);
digitalWrite(ld3,
delay(tiempo);
digitalWrite(ld4,
delay(tiempo);
digitalWrite(ld5,
delay(tiempo);
digitalWrite(ld6,
delay(tiempo);
digitalWrite(ld7,
delay(tiempo);
digitalWrite(ld8,
delay(tiempo);

HIGH);
HIGH);
HIGH);
HIGH);
HIGH);
HIGH);

}
//Metodo para apagar 8 leds incluyendo el tiempo de espera
void ApagarLeds(int ld1, int ld2, int ld3, int ld4, int ld5, int ld6, int
ld7, int ld8, int tiempo){
digitalWrite(ld1, LOW);
delay(tiempo);
digitalWrite(ld2, LOW);
delay(tiempo);
digitalWrite(ld3, LOW);
delay(tiempo);
digitalWrite(ld4, LOW);
delay(tiempo);
digitalWrite(ld5, LOW);
delay(tiempo);
digitalWrite(ld6, LOW);
delay(tiempo);
digitalWrite(ld7, LOW);
delay(tiempo);
digitalWrite(ld8, LOW);
delay(tiempo);
}
void loop(){
botonEstado = digitalRead(botonPin); //Lee si el boton se presiona o no
if (botonEstado == HIGH) { //Si el boton se presiono entrada a la
condicion
Cont += 1; //Aumenta contador cada vez que se presiona
if(Cont > 4) //Resetea el contador cuando es mayor a 4 y vuelve a la
primera opcion
{
Cont = 0;
}
}
if (Cont == 0){ //Opcion por default, todos los leds prendidos
PrenderLeds(5,6,7,8,9,10,11,12,0);
delay(150);
}
if (Cont==1){ //Primera opcion, prende los leds empezando del 1 hasta
el 9 uno por uno
PrenderLeds(5,6,7,8,9,10,11,12,150);
delay(Pausa);
ApagarLeds(5,6,7,8,9,10,11,12,0);
delay(Pausa);

}
if (Cont==2){ //Segunda opcion, prende los leds empezando del 9 hasta
el 1 uno por uno
ApagarLeds(12,11,10,9,8,7,6,5,0);
delay(Pausa);
PrenderLeds(12,11,10,9,8,7,6,5,150);
delay(Pausa);
}
if (Cont==3){ //Tercera opcion, apaga los leds del 1 al 9 uno por uno
PrenderLeds(5,6,7,8,9,10,11,12,0);
delay(Pausa);
ApagarLeds(5,6,7,8,9,10,11,12,150);
delay(Pausa);
}
if (Cont==4){ //Cuarta opcion, apaga los leds del 9 al 1 uno por uno
PrenderLeds(5,6,7,8,9,10,11,12,0);
delay(Pausa);
ApagarLeds(12,11,10,9,8,7,6,5,150);
delay(Pausa);
}
}

Practica XII: Motores CD Parte 1

Un motor de corriente directa (CD) es un componente
electromecnico que permite agregar movimiento a nuestros
proyectos, un ejemplo muy comn, son los juguetes como los
coches a control remoto, quienes requieren de un pequeo
motor CD para poder avanzar o retroceder y uno mas para girar
a la izquierda o a la derecha.

A diferencia de los LEDs, por poner un ejemplo, un motor no

puede ser controlado directamente desde los pines de un
Arduino, ya que requiere mucha ms corriente que la que estos
pueden proveer.
En esta ocasiones veremos como construir una de las
soluciones mas simples para poder controlar estos tiles
dispositivos sin correr el riesgo de quemar nuestro Arduino o
microcontrolador.
MATERIALES

1 Transistor Bipolar NPN de uso general, BC547, 2N2222, 2N3904

1 Diodo de propsito general, 1N4001, 1N4007
1 Resistencia 330 ohm (naranja, naranja, caf)

INSTRUCCIONES
Como vemos en el diagrama, la conexin de los componentes es
muy sencilla, y el trabajo pesado recae solo en el
Transistor, quien hace la funcin de Switch, dejando pasar la
corriente necesaria para poner en marcha nuestro motor.
Dependiendo
de
las
caractersticas
por
fabricante
un
Transistor puede llegar a manejar corrientes bastante altas,
a
partir
de
una
mucho
mas
baja
como
la
de
un
microcontrolador, Arduino en nuestro caso.

Ademas, podemos ver en el diagrama la Resistencia entre el

pin 3 de Arduino y la base del Transistor en este caso solo
para proporcionar la corriente necesaria y activarlo, y el
Diodo conectado a los dos cables extremos del motor, la parte
negativa(franja gris) al positivo, esto a manera de
proteccin, puesto que algunos dispositivos electromecnicos
al cambiar de un estado a otro producen un pico de corriente
en reversa que puede daar nuestros componentes, el
Transistor en nuestro caso.

Cdigo
// Declaramos la variable d3 para referenciar el pin digital 3
int d3 = 3;</code></code>void setup(){
// Iniciamos el pin digital como salida.
pinMode(d3, OUTPUT);
}
void loop(){
digitalWrite(d3, HIGH); // escribimos en el pin un valor de salida
Alto (Digital 1)
delay(1500); // esperamos 1.5 segundos

digitalWrite(d3, LOW); // escribimos en el pin un valor de salida

Bajo (Digital 0)
delay(1000); // esperamos 1.5 segundos
}

COMPRAR MATERIAL PARA LAS PRCTICAS POSTERIORES.