TUTORIAL ARDUINO #01 E/S DIGITALES: LED INTERMITENTE

QU APRENDO? CONOCIMIENTOS PREVIOS

Activar una salida digital Seal Digital
Encender un LED en ON/OFF Funcin digitalWrite ()
Temporizar una seal de salida Polaridad de un led
Sintaxis de un programa en Arduino Conexin de la placa Arduino al computador.

MATERIALES
Arduino UNO
Led Verde
Cable USB

DISEO

CDIGO

void setup() // Se ejecuta cada vez que el Arduino se inicia

{
pinMode(13,OUTPUT); // Inicializa el pin 13 como una salida
}

//Funcin cclica
void loop() // Esta funcin se mantiene ejecutando
{ // cuando este energizado el Arduino
digitalWrite(13,HIGH); // Enciende el LED
delay(1000); // Temporiza un segundo (1s = 1000ms)
digitalWrite(13,LOW); // Apaga el LED
delay(3000); // Temporiza un segundo (1s = 1000ms)
}
// Fin del programa

EJERCICIO 1

1
Se trata de encender y apagar 4 leds secuencialmente. Los leds deben estar conectados a los pines 5,6,7 y
8. Se deben encender y posteriormente apagar los leds desde el pin 5 al 8, con un tiempo de duracin de
encendido y apagado de 200 milisegundos.

TUTORIAL ARDUINO #02 E/S DIGITALES: ENCENDER UN LED CON UN PULSADOR

QU APRENDO? CONOCIMIENTOS PREVIOS

Cablear un circuito Seal Digital
Condicional If/else Funcin digitalWrite () y DigitalRead()
Estado de un Pulsador Divisor de voltaje
Leer una entrada digital y escribir Condicional y operadores de comparacin
una salida digital

MATERIALES
Arduino UNO
Led Verde
Pulsador
Resistencia de 1k
Conectores
protoboard
Cable USB

DISEO

CDIGO

// Variables estticas
int pinPulsador = 2; // Declaramos la variable pin del Pulsador
int pinLed = 13; // Declaramos la variable pin del Led

// Variables dinmicas
int estadoPulsador = 0; // Variable para estado del botn

void setup() { // Inicializa el pin del LED como salida:

pinMode(pinLed, OUTPUT); // Inicializa el pin del botn como entrada:
pinMode(pinPulsador, INPUT);

2
}
void loop(){ // Lee el valor del pin del botn y lo almacena en la variable estadoPulsador
estadoPulsador = digitalRead(pinPulsador); // Chequea si el botn est pulsado:
if (estadoPulsador == HIGH) { // Si es as, enciende el LED:
digitalWrite(pinLed, 1);
}
else { // Si no, lo mantiene apagado:
digitalWrite(pinLed, 0);
}
}

EJERCICIO 2
La multinacional francesa Flante experta en maquinaria industrial te ha contratado para que automatices
una mquina cortadora de papel. La condicin principal es que el operario de la mquina cuando vaya a
realizar el corte siempre mantenga las dos manos ocupadas, esta es una regla de seguridad industrial para
evitar accidentes. El operario debe oprimir los dos pulsadores uno con cada mano y la cuchilla cortadora
debe bajar y hacer el corte. El siguiente montaje simula el control de la mquina, los dos pulsadores (S1 y
S2) y el LED rojo simula la cuchilla cortadora.

TUTORIAL ARDUINO #03 LECTURA SERIAL DE UNA ENTRADA DIGITAL

QU APRENDO? CONOCIMIENTOS PREVIOS

Manejar una entrada digital Seal digital
Ver datos por la pantalla del Funcin digitalRead() y Serial.println()
computador. Opcin de Consola serial,
Consola serial
Leer una entrada digital y escribir por
consola seria

MATERIALES
Arduino UNO
3
 Pulsador
Resistencia de 1k
Conectores
Protoboard
Cable USB

DISEO

CDIGO
//Declara puertos de entradas y salidas
int boton=2; //Pin donde se encuentra el pulsador, entrada

//Funcin principal
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(boton, INPUT); //Configurar el botn como una entrada
Serial.begin(9600); //Inicia comunicacin serial
}

//Funcin cclica
void loop() // Esta funcin se mantiene ejecutando cuando este energizado el Arduino
{
int estado = digitalRead(boton); //Guardar en una variable entera el valor del botn 0 1
if (estado==1) //Condicional para saber estado del pulsador
{
// Pulsado
Serial.println("Pulsado"); //Imprime en la consola serial "Pulsado"
}
else
{
// No est pulsado
Serial.println("NO Pulsado"); //Imprime en la consola serial "NO Pulsado"
}
delay(100); //Retardo para la visualizacin de datos en la consola
}
4
 //Fin programa

EJERCICIO 3
Una empresa de gaseosas tiene un sistema con dos sensores, uno de ellos indica si la botella se ha llenado
con el lquido y el otro sensor indica si la botella ya tiene la tapa. Para este caso simularemos los dos
sensores por medio de dos pulsadores (S1 y S2).
La rutina se describe de esta manera: si la botella se llena de manera adecuada (se debe activar S1 y
mostrar por consola Gaseosa llena luego de ello si tiene la tapa colocada (se debe activar S2 y mostrar
por consola Gaseosa tapada, al finalizar el proceso se debe encender un LED que indica que el proceso
termin bien y adems se debe mostrar un mensaje por la consola Gaseosa bien empacada. Recuerda
que primero se debe activar S1 y luego S2 para que le proceso sea vlido.

5
TUTORIAL ARDUINO #04 LECTURA SERIAL DE UNA ENTRADA ANLOGA

QU APRENDO? CONOCIMIENTOS PREVIOS

Manejar una entrada anloga Seal digital
Ver datos por la pantalla del computador Funcin analogRead() y Serial.println()
Mltiples estados de un potencimetro Opcin de Consola serial,
Leer una entrada anloga

MATERIALES
Arduino UNO
Potencimetro
Conectores
Protoboard
Cable USB

DISEO

CDIGO
//Funcin principal
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia comunicacin serial
}

//Funcin cclica
void loop() // Esta funcin se mantiene ejecutando cuando este energizado el Arduino
6
{
int valor= analogRead(A0); //Guardar en una variable entera el valor del potencimetro 0 a 1024
Serial.println(valor); //Imprime en la consola serial el valor de la variable
delay(100); //Retardo para la visualizacin de datos en la consola
}
//Fin programa
TUTORIAL ARDUINO #05 ESCRITURA SERIAL

QU APRENDO? CONOCIMIENTOS PREVIOS

Entrada por consola (teclado) Seal digital
Variables booleanas Funcin digitalWrite() y Serial.read()
Estado de un LED Configuracin de una comunicacin serial .
Escritura serial digital Polaridad de un LED

MATERIALES
Arduino UNO
Led
Cable USB

DISEO

CDIGO
//Declara puertos de entradas y salidas y variables
int led = 13; //Pin donde se encuentra el LED, salida
char leer; //Variable donde se almacena la letra
boolean prendido=false; //Estado LED la primera vez, apagado

//Funcin principal
void setup() { // Se ejecuta cada vez que el Arduino se inicia
Serial.begin(9600); //Inicia comunicacin serial
pinMode(led, OUTPUT); //Configurar el LED como una salida
}

7
//Funcion ciclicla
void loop() // Esta funcin se mantiene ejecutando cuando este energizado el Arduino
{
leer=Serial.read(); //Guardar en una variable el valor de la consola serial
if ( (leer=='a') && (prendido==false) ) // Si es la letra 'a' y adems el LED est apagado
{
digitalWrite(led,HIGH); // Enciende el LED
prendido=true; // Actualiza el estado del LED
}
// Si es la letra 'a' y adems el LED est encendido
else if ( (leer=='a') && (prendido==true) )
{
digitalWrite(led,LOW); // Apaga el LED
prendido=false; // Actualiza el estado del LED
}
}
//Fin programa

EJERCICIO 1: AVISOS LUMINOSOS

Avisos luminosos S.A. te ha contratado para que realices un programa que tiene la caracterstica de recibir
datos, porque la idea es que el aviso de luces se ubique en el piso 130 del Edificio Bulli y tu lo puedas
controlar desde el piso 1, as que por cada letra que le escribas por teclado a la Consola serial el programa
debe hacer determinada rutina con tres LEDs, si le escribes:
Letra A: Prende los tres LED
Letra B: Prende el LED1 por un segundo y lo apaga, luego prende el LED2 por un segundo y lo
apaga y finalmente prende el LED3 por un segundo y lo apaga, y vuelve a comenzar. Esta rutina
genera una sensacin de movimiento
Letra C: Apaga los tres LED

8
//Declara puertos de entradas y salidas y variables
int led1 = 2; //Pin donde se encuentra el LED, salida
int led2 = 3;
int led3 = 4;
char leer; //Variable donde se almacena la letra
boolean prendido=false; //Estado LED la primera vez, apagado

//Funcin principal
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia comunicacin serial
pinMode(led1, OUTPUT); //Configurar el LED como una salida
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
}

//Funcion ciclicla
void loop() // Esta funcin se mantiene ejecutando cuando este energizado el Arduino
{
leer=Serial.read(); //Guardar en una variable el valor de la consola serial
if ( (leer=='a') && (prendido==false) ) // Si es la letra 'a' y adems el LED est apagado
{
digitalWrite(led1,HIGH); // Enciende el LED1
digitalWrite(led2,HIGH); // Enciende el LED2
digitalWrite(led3,HIGH); // Enciende el LED3
prendido=true; // Actualiza el estado del LED
}
// Si es la letra 'b' y adems el LED est encendido

if ( (leer=='b') && (prendido==true) )

{
digitalWrite(led1,HIGH); // Enciende el LED1
delay (1000);
digitalWrite(led1,LOW); // Apaga el LED
delay (1000);
digitalWrite(led2,HIGH); // Apaga el LED
delay (1000);
digitalWrite(led2,LOW); // Apaga el LED
delay (1000);
digitalWrite(led3,HIGH); // Enciende el LED1
delay (1000);
digitalWrite(led3,LOW); // Apaga el LED
delay (1000);

9
 digitalWrite(led1,HIGH); // Enciende el LED1
digitalWrite(led2,HIGH); // Enciende el LED1
digitalWrite(led3,HIGH); // Enciende el LED1

//prendido=true; // Actualiza el estado del LED

}
if ( (leer=='c') && (prendido==true) )
{
digitalWrite(led1,LOW); // Enciende el LED1
digitalWrite(led2,LOW); // Enciende el LED2
digitalWrite(led3,LOW); // Enciende el LED3
prendido=false; // Actualiza el estado del LED
}
}
//Fin programa

EJERCICIO 2: SISTEMA DE RIEGO

Tu abuelito tiene un cultivo de grandes y verdes lechugas, este cultivo tiene 3 aspersores de agua y tu
abuelito quiere prender estos aspersores desde su computador solo escribiendo unos valores por teclado,
los aspersores tienen un estado digital (Valor 0 es apagado y valor 1 es prendido). Debes realizar un
programa que lea una cadena de tres valores, para este ejercicio los aspersores los vamos a simular con
tres LED 1, 2 y 3 por ejemplo:
Si tu abuelito escribe 000 : Todos los aspersores de agua deben estar apagados
Si tu abuelito escribe 101 : El aspersor 1 y 3 se prenden pero el dos debe estar apagado
Si tu abuelito escribe 001 : El aspersor 1 y 2 se apagan pero el tres debe estar prendido

EJEMPLO
int input; // Variable donde se almacenar el dato introducido por teclado
int led1=2; // Variable donde se guardar el nmero de pin al que hemos conectado nuestro led
int led2=3;
void setup(){
Serial.begin(9600); // Se inicia la comunicacin serial
pinMode(led1, OUTPUT); // Se configura el pin como salida
}

void loop(){
if(Serial.available()>0){ // Si existen datos de entrada en la comunicacin serial hacer lo siguiente
input=Serial.read(); // Guardamos el dato introducido
if(input=='1'){ // Si el dato es igual a 1
digitalWrite(led1, HIGH); // Encendemos el led
digitalWrite(led2, HIGH);
Serial.println("Led Encendido");
}

10
 else{ // De lo contrario
digitalWrite(led1, LOW); // Apagamos le led
digitalWrite(led2, LOW);
Serial.println("Led Apagado");
}
}
}
TUTORIAL ARDUINO #06 CONTROL ON/OFF CON POTENCIMETRO

QU APRENDO? CONOCIMIENTOS PREVIOS

Salida digital If/else
Control ON/OFF Funcin digitalWrite() y analogRead()
Comparacin Condicional a partir de un Valor de una entrada a
valor entero de una entrada anlogo

MATERIALES
Arduino UNO
Led
PROTOBOARD
Potencimetro
Resistencia de 220 ohm
Cable USB

DISEO

11
 CDIGO

//Funcin principal
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia comunicacin serial
pinMode(13,OUTPUT); //Configurar el pin 13 como una salida
}

//Funcin cclica
void loop() // Esta funcin se mantiene ejecutando cuando este energizado el Arduino
{
int valor = analogRead(A0); //Guardar en una variable el valor de la lectura anloga
Serial.println(valor); //Imprime el valor por la consola
if (valor >= 500) //Si el valor es mayor o igual a 500
{
digitalWrite(13,HIGH); //Enciende el LED en el pin 13 Si el valor es menor a 500
}
else
{
digitalWrite(13,LOW); //Apaga el LED en el pin 13
}
delay(100); //Retardo de 100ms para ver los datos de la consola
}
//Fin programa

EJERCICIO 6
Un carro de tunnig tiene luces de nen en la parte de abajo, ste es la sensacin de la feria. El piloto
controla las luces (tres LEDs) por medio de un potencimetro al lado de la palanca de cambios, l tiene
tres opciones de luces de acuerdo al valor de lectura del potencimetro que va de 0 a 1023:
12
 0 - 350 Intermitencia de los 3 LED a 100ms
351 - 700 Intermitencia de los 3 LED a 500ms
701 - 1023 Intermitencia de los 3 LED a 1000ms

13
TUTORIAL ARDUINO #07: SENSOR LDR

1. DEFINICIN: El sensor LDR es un componente electrnico pasivo cuyo valor de la resistencia vara en
funcin de la luz que recibe. Cuanta ms luz reciba, el valor de su resistencia ser menor.

Sensor LDR

2. MATERIALES
Placa breadboard
5 Diodos LED
5 resistencias de 220
1 LDR (resistencia dependiente de luz)
1 potencimetro 50k (uno de 10k tambin podra ser til)
1 resistencia de 1k
Cables

3. PROCEDIMIENTO
Se conectarn 5 LED que irn encendindose dependiendo del dicho valor de resistencia, ligado
inversamente con la cantidad de luz, de forma que conforme vaya disminuyendo la cantidad de luz, se irn
encendiendo los LED de forma progresiva. Un ejemplo tpico podra ser la utilizacin en farolas urbanas
que van encendindose conforme va anocheciendo.

4. IMPLEMENTACIN DEL CIRCUITO

El circuito distribuido en la breadboard podra tener esta forma:

14
Primero concretamos los pines que vamos a utilizar para los LED. Por orden, utilizaremos el 12, 11, 10, 9 y
8. Unidos mediante un cable a la breadboard, colocamos las resistencias de 220 puesto que podramos
quemar los diodos por un exceso de calor.

El potencimetro, por otro lado, es una resistencia variable que dispone de tres patillas: entre las dos de
sus extremos existe siempre un valor fijo de resistencia, y entre cualquiera de esos extremos y la patilla
central tenemos una parte de ese valor mximo. Es decir, la resistencia mxima que ofrece el
potencimetro entre sus dos extremos no es ms que la suma de las resistencias entre un extremo y la
patilla central, y entre la patilla central y el otro extremo.
Lo utilizamos para determinar el valor mnimo de la luz que es capaz de detectar el sensor LDR, de forma
que cuando vayamos a ponerlo en marcha debemos regularlo para un correcto funcionamiento. Si
ponemos el valor de la referencia muy baja, empezarn a funcionar los LED con menos luz ambiente que
si ponemos una referencia elevada.
De forma prctica, conectaremos la patilla central al pin AREF (ofrece un voltaje de referencia externo
para poder aumentar la precisin de las entradas analgicas) que luego le diremos al programa que lo
vamos a usar como referencia externa (moverlo manualmente segn el valor mnimo de luz que queramos
detectar). Mientras que cada patilla la conectaremos al nodo y al ctodo (la patilla de la izquierda al
ctodo, y la de la derecha al nodo) de la breadboard para unirlo con el sensor y los LED.

15
Para el sensor, la seal que recibe es una seal analgica que obtenemos del exterior para transformarla
en digital, por lo que colocaremos el cable de entrada en un pin analgico, A0 en nuestro caso. Al colocar
la resistencia de 1k en la parte de arriba del sensor, estamos creando un divisor de tensiones, de manera
que cuanta ms luz haya, ms tensin tendremos a la entrada de nuestra entrada analgica.

Quedando finalmente el montaje de la siguiente manera:

16
Nos queda escribir el cdigo que le pasaremos al arduino (copiar y pegar):

//Aqu almacenamos los datos recogidos del LDR:

int valorLDR = 0;

//Decimos que pines vamos a utilizar para LED

int pinLed1 = 12;
int pinLed2 = 11;
int pinLed3 = 10;
int pinLed4 = 9;
int pinLed5 = 8;

//Y que pin para la LDR

int pinLDR = 0;

void setup()
{
//Establecemos como salida los pines para LED
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);

//Le decimos que vamos a usar una referencia externa

analogReference(EXTERNAL);

void loop()
{
//Guardamos el valor leido en una variable
valorLDR = analogRead(pinLDR);

//Y comenzamos las comparaciones:

if(valorLDR >= 1023)
{
digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 823) & (valorLDR < 1023))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
17
 }
else if((valorLDR >= 623) & (valorLDR < 823))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 423) & (valorLDR < 623))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 223) & (valorLDR < 423))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, LOW);
}
else
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, HIGH);
}

http://elcajondeardu.blogspot.pe/2014/01/tutorial-sensor-ldr.html

18
DISPLAY DE 7 SEGMENTOS (1 DGITO)
Introduccin terica
Un display de segmentos (o visualizador) es un componente electrnico que se utiliza para representar
nmeros. Como su propio nombre indica y, como se puede observar en la imagen siguiente, el display est
compuesto por 7 segmentos, los cuales se encendern y/o apagarn en funcin del nmero a representar.
De forma interna, se asemeja a siete LEDs conectados estratgicamente formando el nmero 8, aunque
externamente dicha semejanza no se observa, de ah su simplicidad.

Cada uno de los segmentos que componen este display se denominan a, b, c, d, e, f y g, tal y como se
muestra a continuacin.

Para mostrar el nmero 0, tendremos que encender a, b, c, d, e y f.

Para el nmero 2, tendramos a, b, g, e y d.
Y de la misma forma para cualquier otro nmero.
El P simboliza el punto decimal.
En cuanto a la clasificacin, existen de dos tipos:

1. Display de segmentos de ctodo comn, en la que todos los ctodos de los LEDs estan internamente
unidos a una patilla comn, la cual est conectada al potencial negativo de la placa.
2. Display de segmentos de nodo comn, en la que todos los nodos se encuentran al positivo.
Para nuestro caso, disponemos de uno de tipo ctodo comn, el LMS5161AS (luz roja, tamao de dgito
0.56'').

19
Conexiones
En lo que se refiere a las conexiones, tenemos que tener en cuenta cada segmento a qu pin lo vamos a
conectar, para poder efectuar una llamada a los pines correcta. En nuestro caso, hemos hecho las
siguientes conexiones (puede variar la designacin segn convenga):

Segmento a - pin 7
Segmento b - pin 8
Segmento c - pin 9
Segmento d - pin 10
Segmento e - pin 11
Segmento f - pin 12
Segmento g - pin 13

Ejemplo

Vamos a realizar un ejemplo en el cual nuestro display ir mostrando de forma ascendente todos los
nmeros con un intervalo de separacin de 1 segundo.
Aqu tenemos el sketch:

int pausa=1000; // Variable que define el intervalo

// de tiempo entre cada digito

void setup()
{
pinMode(7, OUTPUT); // Asignacin de las salidas digitales
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
}

20
void display (int a, int b, int c, int d, int e, int f, int g)
// Funcion del display
{
digitalWrite (7,a); //Se reciben 7 variables y se asignan
digitalWrite (8,b); //a cada una de las salidas
digitalWrite (9,c);
digitalWrite (10,d);
digitalWrite (11,e);
digitalWrite (12,f);
digitalWrite (13,g);
}

void loop() //Funcion principal

// Dependiendo de cada dgito, se enva a la funcin display
// los estados (0 y 1) a cada uno de los segmentos
{
display (1,1,1,1,1,1,0); //escribe 0
delay(pausa);
display (0,1,1,0,0,0,0); //escribe 1
delay(pausa);
display (1,1,0,1,1,0,1); //escribe 2
delay(pausa);
display (1,1,1,1,0,0,1); //escribe 3
delay(pausa);
display (0,1,1,0,0,1,1); //escribe 4
delay(pausa);
display (1,0,1,1,0,1,1); //escribe 5
delay(pausa);
display (1,0,1,1,1,1,1); //escribe 6
delay(pausa);
display (1,1,1,0,0,0,0); //escribe 7
delay(pausa);
display (1,1,1,1,1,1,1); //escribe 8
delay(pausa);
display (1,1,1,0,0,1,1); //escribe 9
delay(pausa);
}

//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);
21
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);

22
TUTORIAL ARDUINO #08: CON FOTORESISTENCIA LDR

1. OBJETIVO: El objetivo de este tutorial es aprender como conectar sensores que varan su resistencia
dependiendo de una magnitud fsica. Un ejemplo de este tipo de sensores es el LDR o fotoresistor,
estudiaremos el funcionamiento de este componente y su conexin con la tarjeta Arduino UNO R3
mediante un divisor resistivo en el resto de este texto.

2. CONCEPTOS BSICOS
Para entender cmo funciona este circuito y el programa que corre en la tarjeta Arduino debemos conocer
3 conceptos clave:
Fotoresistencia LDR: Componente cuya resistencia vara sensiblemente con la cantidad de luz
percibida. La relacin entre la intensidad lumnica y el valor de la resistencia no es lineal. Se utiliza
ampliamente para medir la iluminacin en dispositivos electrnicos que requieren un precio agresivo.
Su comportamiento es el siguiente:
Ms luz = menor resistencia elctrica
Menos luz = mayor resistencia elctrica
Divisor de voltaje: Mediante un par de resistencias en serie, es posible repartir la tensin suministrada
por la fuente entre las terminales de estas, en nuestro caso, el divisor se utiliza con el LDR para obtener

un voltaje variable de acuerdo a la cantidad de luz percibida.

Conversin Analgico-Digital (ADC): Es el proceso mediante el cual se convierte una magnitud fsica
como un voltaje, corriente, temperatura, etc. en un nmero binario (o seal digital) con el propsito
de facilitar su manejo por circuitos digitales como un CPU. El Arduino realiza este proceso para conocer
la cantidad de luz percibida por el LDR y poder procesarla numricamente.
.
3. Materiales necesarios
1 Arduino UNO R3
1 Fotoresistor (LDR)
1 Resistencia de 10 Kohm 1/4 W
3 Resistencias de 220 o 330 ohm 1/4 W
3 Leds 5mm
Cables para protoboard
Protoboard

23
4. DIAGRAMA PARA UTILIZAR ARDUINO CON FOTORESISTENCIA LDR
Debemos armar el circuito como se muestra en el siguiente diagrama pictrico. Recordar que los LED
tienen polaridad y hay que respetarla. El pin ms largo va conectado a la tarjeta arduino, mientras que el
pin ms corto va con una resistencia a tierra, la resistencia tambin puede colocarse sin problema entre el
nodo del led y el arduino (del lado positivo del led):

El circuito armado sobre el protoboard y las conexiones con el arduino quedan de la siguiente manera:

5. CDIGO (SKETCH) PARA ARDUINO CON FOTORESISTENCIA LDR.

La explicacin para el cdigo es la siguiente: Primero se preparan los pines de salida donde estan
conectados los led, el pin de entrada donde se conecta el divisor resistivo y el puerto serie para la
comunicacin. A continuacin se ejecuta un ciclo infinito en el que se lee el valor del voltaje en el pin del
LDR y se accionan los led segn correspondan. Tambin transmitimos el valor ledo por el ADC del
ATMEGA328 a la PC a travs del puerto serie de nuestra tarjeta Arduino. Hemos comentado el cdigo de
manera que sea fcil de entender.
24
1 * Ejemplo de medidor de luz con Arduino utilizando una fotoresistencia LDR y
2 * un grupo de leds para mostrar el resultado de las lecturas. Este sketch puede
3 * servir como base para otros proyectos que requieren medicin de la intensidad
4 * de luz con una fotorresistencia.
5
6
7 // Pin donde se conectan los leds
8 int pinLed1 = 2;
9 int pinLed2 = 3;
10 int pinLed3 = 4;
11 // Pin analogico de entrada para el LDR
12 int pinLDR = 0;
13
14 // Variable donde se almacena el valor del LDR
15 int valorLDR = 0;
16
17 void setup()
18 {
19 // Configuramos como salidas los pines donde se conectan los led
20 pinMode(pinLed1, OUTPUT);
21 pinMode(pinLed2, OUTPUT);
22 pinMode(pinLed3, OUTPUT);
23
24 // Configurar el puerto serial
25 Serial.begin(9600);
26 }
27
28 void loop()
29 {
30 // Apagar todos los leds siempre que se inicia el ciclo
31 digitalWrite(pinLed1, LOW);
32 digitalWrite(pinLed2, LOW);
33 digitalWrite(pinLed3, LOW);
34
35 // Guardamos el valor leido del ADC en una variable
36 // El valor leido por el ADC (voltaje) aumenta de manera directamente proporcional
37 // con respecto a la luz percibida por el LDR
38 valorLDR= analogRead(pinLDR);
39
40 // Devolver el valor leido a nuestro monitor serial en el IDE de Arduino

25
 41 Serial.println(valorLDR);
42
43 // Encender los leds apropiados de acuerdo al valor de ADC
44 if(valorLDR > 256)
45 {
46 digitalWrite(pinLed1, HIGH);
47 }
48 if(valorLDR > 512)
49 {
50 digitalWrite(pinLed2, HIGH);
51 }
52 if(valorLDR > 768)
53 {
54 digitalWrite(pinLed3, HIGH);
55 }
56 // Esperar unos milisegundos antes de actualizar
57 delay(200);
58 }

Para probar nuestro flamante medidor de luz, solamente debemos colocarlo sobre una fuente de luz y
verificar que los led se encienden conforme aumenta la cantidad de luz. En la terminal, tambin podremos
ver cmo va cambiando el valor de la conversin analgico a digital

26
// Pin donde se conectan los leds
int pinLed1 = 2;
int pinLed2 = 3;
int pinLed3 = 4;
int pinLDR = 0; // Pin analogico de entrada para el LDR
int valorLDR = 0; // Variable donde se almacena el valor del LDR

void setup()
{
// Configuramos como salidas los pines donde se conectan los led
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
Serial.begin(9600); // Configurar el puerto serial
}

void loop()
{
// Apagar todos los leds siempre que se inicia el ciclo
digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);

valorLDR= analogRead(pinLDR); // Guardamos el valor ledo del ADC en una variable

Serial.println(valorLDR); // Devolver el valor ledo a nuestro monitor serial en el IDE de Arduino

// Encender los leds apropiados de acuerdo al valor de ADC

if(valorLDR > 256)
{
digitalWrite(pinLed1, HIGH);
}
if(valorLDR > 512)
{
digitalWrite(pinLed2, HIGH);
}
if(valorLDR > 768)
{
digitalWrite(pinLed3, HIGH);
}
delay(200); // Esperar unos milisegundos antes de actualizar

27
}
Lab 3 > Arduino que controla leds con potenciometro
En este laboratorio se realizara el montaje de un arduino que controla led con la actividad recibida por
un potenciometro
Materiales:
Protoboard
Arduino
5 Leds
5 Resistencias (220)
Alambre
1 Potenciometro
Arduino IDE
El esquema de la parte del hardware es el siguiente:

Codigo
int i = 0;
int pinPotenciometro =A0;
int valorPotenciometro = 0;
void setup()
{
pinMode(pinPotenciometro, INPUT);
for (i = 2; i < 7; i++)
pinMode(i, OUTPUT);
Serial.begin(9600);
}
void loop()
{

28
valorPotenciometro = analogRead(pinPotenciometro);
Serial.println(valorPotenciometro, DEC);
delay(100);
if (valorPotenciometro == 0) apagarLeds();
if (valorPotenciometro > 0 && valorPotenciometro < 200) digitalWrite(2, HIGH);
if (valorPotenciometro >= 200 && valorPotenciometro < 400) digitalWrite(3, HIGH);
if (valorPotenciometro >= 400 && valorPotenciometro < 600) digitalWrite(4, HIGH);
if (valorPotenciometro >= 600 && valorPotenciometro < 800) digitalWrite(5, HIGH);
if (valorPotenciometro >= 800) digitalWrite(6, HIGH);
if (valorPotenciometro == 1023) encenderLeds();
}
void apagarLeds()
{
for (i = 2; i < 7; i++)
digitalWrite(i, LOW);
}
void encenderLeds()
{
for (i = 2; i < 7; i++)
digitalWrite(i, HIGH);
}

Para tener en cuenta (Explicacin del Cdigo)

El potencimetro entrega tiene un lmite minimo de 0 y un mximo de 1023
Se inicializa i, pinPotenciometro, valorPotenciometro en 0;
por medio del pinMode definimos que pinPotenciometro sera de entrada de datos y desde el pin
2 hasta el 6, de salida (para enviar HIGH y LOW a los Leds)
Serial.begin(velocidad) inicializa o abre el puerto serie asignndole una velocidad de transmisin
de datos (bits por segundo). Dicha funcin debe ser llamada desde dentro de la estructura o
seccin setup()
Luego en la linea valorPotenciometro = analogRead(pinPotenciometro); estamos diciendo que los
valores enviados por el potenciometro se almacenaran en la variable valorPotenciometro
Serial.println(valorPotenciometro, DEC); es para que si queremos ver los valores que esta enviando
el potenciometro en pantalla, los envie en formato decimal (para ver la consola o monitor, vamos
a Tools>Serial Monitor)
Cada uno de los if que siguen en el codigo, especifican una accion con determinado valor que viene
del potenciometro, cuando es 0, se ejecuta el metodo apagarLeds, lo que pone en low a los leds,
apagandolos, cuando es el maximo, 1023, se activa el metodo encenderLeds, el cual pone el high
los leds, encendindolos todos. Las demas condiciones hace que pasando por determinados
valores, los leds enciendan uno a uno

29