Uso de una fotoresistencia como sensor de luz

Este es un ejercicio muy sencillo en el que veremos como obtener lecturas

analgicas de un sensor y darles salida por el monitor del puerto serie para verlas.
Necesitaremos una placa Arduino UNO y una resistencia sensible a la luz
o fotoresistencia
Tambin utilizaremos un led para que nos de una salida proporcional a las lecturas
recibidas desde la entrada analgica mediante PWM.

/* Prueba simple del funcionamiento de una fotoresistencia

Conecta la fotoresistencia por una pata al pin 0 y por la
otra a +5V.
Conecta una resistencia de 10K entre el pin 0 y GND.
---------------------------------------------------PhotoR 10K
+5 o---/\/\/--.--/\/\/---o GND
|
Pin 0 o-------'
---------------------------------------------------*/

int lightPin = 0; // Pin para la fotoresistencia

int ledPin=11; // Pin al que se conecta el LED
void setup()
{
Serial.begin(9600); // Inicia la comunicacion serie
pinMode( ledPin, OUTPUT ); // Establece el pin del LED
// como salida
}
void loop()
{
// Primero leemos el valor que nos da la fotoresistecia
// y lo mostramos por el puerto serie
Serial.println(analogRead(lightPin));
// Ahora cogemos la lectura de la fotoresistencia, la
// dividimos por 4 y la mandamos como salida analogica
// al LED
analogWrite(ledPin, analogRead(lightPin)/4);
// Hacemos una pequea pausa para que el baile de
// numeros en el puerto serie no sea mareante
delay(100);
}

Ya podemos subir este cdigo a nuestra placa y probar a ver que pasa.
Muy probablemente el resultado sea decepcionante: el LED brilla poco y cuando
pasamos la mano por encima de la fotoresistencia el brillo del LED baja un poco
ms, pero dependiendo de las condiciones de luz ambiental es probable que no se
note apenas nada.
La solucin es el calibrado del sensor, esto es, hacer una lectura de los valores
que devuelve el sensor en el ambiente en el que va a trabajar y ajustar los valores
de salida a este rango. Para ello emplearemos el comando map().
map(valor, desdeBajo, desdeAlto, hastaBajo, hastaAlto)
valor: el nmero (valor) a mapear.
desdeBajo: el lmite inferior del rango actual del valor.
desdeAlto: el lmite superior del rango actual del valor.
hastaBajo: lmite inferior del rango deseado.
hastaAlto: lmite superior del rango deseado.

El comando map() re-mapea un nmero desde un rango hacia otro. Esto significa
que, un valor contenido en el al rango desdeBajo-desdeAlto ser mapeado al
rango hastaBajo-hastaAlto.
No se limitan los valores dentro del rango, ya que los valores fuera de rango son a
veces objetivos y tiles, as que si le pasamos un valor fuera del rango inicial
calcular una salida dentro del rango de salida. Se puede utilizar el
comando constrain() tanto antes como despus de sta funcin si es
importante respetar los lmites de los rangos.
Ten en cuenta que los lmites inferiores de algn rango pueden ser mayores o
menores que el lmite superior por lo que map() puede utilizarse para revertir una
serie de nmeros, por ejemplo:
y = map(x, 1, 50, 50, 1);
La funcin maneja correctamente tambin los nmeros negativos, por ejemplo:
y = map(x, 1, 50, 50, -100);
tambin es vlido y funciona correctamente.
El comando map() usa matemtica de enteros por lo que no generar nmeros
en coma flotante, es decir, su uso se limita a valores o variables del tipo int.
Trata de aplicar la funcin map() al ejercicio por ti mismo, de modo que el LED
brille al mnimo cuando tapas con la mano la LDR y al mximo cuando la LDR
capta la luz de ambiente. Si te atascas aqu tienes la solucin, aunque te sentirs
ms orgulloso si lo resuelves sin mirar.

int
int
int
int
int

lightPin = 0; //define el pin de la foto-resistencia

ledPin=11;
//define el pin para el LED
valor;
//define una variable en la que haremos los clculos
min = 0;
//valor mnimo que da la foto-resistencia
max = 0;
//valor mximo que da la foto-resistencia

void setup()
{
Serial.begin(9600); //Inicializa la comunicacin serie
pinMode( ledPin, OUTPUT );
}

void loop()
{
valor = analogRead(lightPin);
valor = map(valor, min, max, 0, 255);
analogWrite(ledPin, valor);
Serial.println(valor);
delay(10); //pequeo retardo para darle
// tiempo al LED a responder.
}

# Tutorial Arduino 0004 Sensor LDR

Bienvenidos a un nuevo tutorial para sacar el mximo partido a vuestro Arduino, comenzamos a
introducir en nuestros proyectos sensores que respondern a situaciones fsicas concretas,
empecemos por el LDR!!

Nivel: Bsico

Coste: < 30

Tiempo: 25

Parte 1: Qu vamos a hacer?

En este proyecto, vamos a utilizar un LDR (Light Dependent Resistor o resistencia dependiente
de la luz) para simular una hipottica compensacin lumnica de 5 niveles, es decir, a travs de
una resistencia que varia su valor dependiendo de la luz recibida, aprovecharemos dicha
variacin para hacer un programa que nos encienda o apague una serie de LED dependiendo
de si hay ms luz o menos luz, esto podramos extrapolarlo a un sistema de regulacin de luz
de un jardn con cinco lineas de luz que se vayan encendiendo segn va cayendo la noche
compensando progresivamente la deficiencia de luz.

Adems le hemos implementado un potencimetro para ajustar el nivel crtico mnimo de luz
que queremos soportar, a partir del cual se activar nuestro circuito y empezar a aumentar la
luz del lugar progresivamente.
Veamos un video con el resultado final!
Material necesario para este proyecto:

1 x Arduino Uno
1 x Protoboard
1 x LDR
1 x Potencimetro 10k
5 x Diodos LED
5 x Resistencias 220
1 x Resistencia 1K
1 x Juego de Cables

Parte 2: Diseando el hardware

En este proyecto lo que queremos conseguir es que, a partir de una resistencia que vara su
valor hmico en funcin de que haya ms o menos luz, controlar 5 salidas de nuestro Arduino,
a las que podramos conectar lneas de iluminacin para un jardn por ejemplo, de manera que
segn va anocheciendo, nuestra iluminacin artificial va aumentando.
Adems, vamos a colocar un potencimetro para regular el umbral de luz mnima, a partir del
cual, comenzar a funcionar nuestro circuito de luz artificial para que sea adaptable a cualquier
entorno.
Dividamos el circuito en tres partes:

Salidas

LDR

Regulador

Para las salidas, ya hemos aprendido en otros tutoriales como conectar unos diodos LED y
como calcular su resistencia ptima.
En cuanto al LDR, es nuevo para nosotros, en breve tendris disponible un tutorial sobre este
componente, as que de momento nos vamos a quedar en que funciona como una resistencia
variable de manera que, cuanta ms cantidad de luz reciba, menor ser su resistencia, para
que quede claro, si en un potencimetro varibamos la resistencia deslizando un patn por la
pista de material resistivo, aqu lo har la cantidad de luz que reciba la foto-resistencia.
Qu podemos deducir con esto?

Que si aadimos una resistencia ms, podemos utilizar el LDR para hacer el ya conocido
divisor de tensin de donde sacaremos la seal para conectar a nuestra entrada analgica de
Arduino.
Podemos conectarlo de dos maneras diferentes:

Si utilizamos el LDR como resistencia inferior del divisor de tensin, nos dar la tensin
mxima cuando tengamos el LDR en plena oscuridad, ya que estar oponiendo el mximo de
su resistencia al paso de la corriente derivndose esta por Vout al completo, si lo utilizamos
como resistencia superior, el resultado ser el inverso, tendremos la tensin mxima cuando
est completamente iluminado, ya que se comportar prcticamente como un cortocircuito, con
una resistencia de 50 o 100.
En este caso lo hemos utilizado como resistencia superior, de manera que cuanta ms luz
haya, ms tensin tendremos a la entrada de nuestra entrada analgica pudiendo ajustar as,
de una manera muy intuitiva, la tensin de referencia que ahora explicar.
Como tercera parte del circuito, hemos colocado un potencimetro configurado como divisor de
tensin para hacer las funciones de regulacin del rango de iluminacin a partir del cual se
activar nuestro circuito de iluminacin.
Como hemos conseguido esto?
Primero hay que pensar un par de cosas, nuestra foto-resistencia configurada como divisor
resistivo, nos va a dar 0v cuando este COMPLETAMENTE a oscuras, y +5v cuando est

COMPLETAMENTE iluminada, situaciones que pueden ser difciles de conseguir dependiendo

del entorno en el que trabajemos, y por otra parte, ese rango de 0v a 5v habr que dividirlo en
1024 pasos que va a leer nuestro Arduino, pero quizs solo vayamos a trabajar en 500 o 600
pasos, desperdiciando mucha resolucin.
Para solucionar esto, adems de evitar cambiar el programa de Arduino cada vez que lo
cambiemos de entorno, he decido usa una funcin que nos proporciona Arduino muy
internaste, el pin Aref
Qu es el pin AREF?
Cuando Arduino toma una seal analgica y la convierte a digital en 1024 cachitos, lo hace por
defecto pensando que la seal que va a recibir puede variar entre 0v y 5v lo que nos da
aproximadamente un valor por cada 4,88 mV, pero nosotros podemos decirle que no, que
realmente va a trabajar entre 0v y 3v, obteniendo as 1024 cachitos distribuidos entre 0v y 3v, lo
que nos da un valor por cada 2,9 mV, es decir una resolucin mucho mayor.
Debemos tener en cuenta que este pin lleva internamente una resitencia de 32K para evitar
daar el chip, de manera que si vamos a conectar el pin mediante una resistencia fija, se va a
producir un nuevo divisor de tensin, con lo que habr que calcular la resistencia adecuada
para la tensin exacta que queremos introducir mediante una sencilla frmula:

Donde:

Vin = Tensin que introducimos a Vref

Rinterna = Resistencia interna de Arduino de 32K

Rexterna = Resistencia mediante la cual alimentamos Vref

Vrefencia = La tensin sobre que tomar referencia nuestro programa.

De manera que si por ejemplo, estamos introduciendo una tensin de +3v a travs de una
resistencia de 5K, la tensin real de referencia en nuestro Arduino ser de:
(32000/(32000+5000)) x 3 = 2,59v
Porqu evita cambiar el programa continuamente?
Por que variando la seal de referencia, le estamos diciendo que nos tome 1024 valores entre
0v una determinada tensin mxima, y el reparto de esos valores ya los hemos fijado
equitativamente en nuestro programa para que haga una activacin progresiva de las lneas de
iluminacin, por tanto, aunque tengamos un rango muy bajo de iluminacin con el que jugar, de
1v por ejemplo, nos va a distribuir siempre proporcionalmente la activacin de las salidas.

Esa tensin de referencia, ser el punto de iluminacin a partir del cual, si decrece la luz
ambiente, empezar a decrecer los valores obtenidos en la seal analgica de entrada.
Si ponemos esa referencia muy baja, empezar a funcionar los led con menos luz ambiente
que si ponemos una seal muy alta, recordemos:

Ms luz = Menos Resistencia = Mayor Vout

Menos luz = Mayor resistencia = Menor Vout

Veamos el esquema elctrico del circuito al completo:

Parte 3: Programando
Este programa es algo ms largo que los anteriores, pero desgranndolo poco a poco seguro
que seremos capaces de entenderlo.
Primero veamos el cdigo al completo:
/*
Tutorial # 0004 Arduino Academy - Sensor LDR

Conectamos una foto-resistencia a la entrada

analgica para controlar cinco salidas
en funcin de la luz ambiente.

Este proyecto es de dominio pblico.

*/

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

}
En este programa os tiene que resultar casi todo conocido de los anteriores proyectos, si no, os
recomiendo echar un vistazo alos anteriores tutoriales Arduino que tenemos en la despensa.
La instruccin que no hemos visto nunca es la siguiente:
analogReference(EXTERNAL);
Con esta instruccin le estamos diciendo a nuestro Arduino, que no use su tensin de
referencia por defecto (+5v) sino la que nosotros introduzcamos por el pin AREF de nuestra
placa, como explicamos en la seccin de hardware.
A continuacin podemos ver que en el loop, lo primero que hacemos es almacenar la lectura de
la entrada analgica en una variable para luego, dependiendo de los datos obtenidos, hacer
una cosa u otra.
valorLDR = analogRead(pinLDR);
Y una vez obtenida la lectura empezamos la discriminacin mediante sentencias if.. if else..
else.. Utilizamos if else para aadir varias condiciones seguidas, y un ltimo else para cerrar
las condiciones.
En el siguiente diagrama de flujo de programa podemos ver como actuar Arduino a nuestras
comparaciones:

Podramos haber acortado alguna lnea de programa con un par de cambios, pero creo que de
esta manera se entiende mejor dado que estamos empezando, ya habr tiempo de complicar el
tema!

Y eso es todo por hoy!

Y si hay algn resquicio del proyecto que no acabis de entender, escribir un comentario con
vuestras dudas.
Hasta pronto!!