Arduino Uno r3

Matriz 8x8
Este pequeo proyecto es para aquellos que quisieran regalarle un recuerdo a alguien especial, esta
hecho con una matriz de leds de 8x8.
Armado
Para el armado hay varios ejemplos ya hechos en la red y de uno de esos escogimos el siguiente:
1. Arduino UNO
2. Matriz de leds 8x8
3.
para elaborar las conexiones usamos Fritzing
Cdigo
Tambin pueden ver el cdigo en GitHub
/*
matriz de leds 2288AB-5
matriz pin nro
linea
columna
arduino uno pin
13
12
11
10
16(analogico pin 2)
17(analogico pin 3)
18(analogico pin 4)
19(analogico pin 5)
10
11
12
13
14
15
16
*/
const int rownum[8] = {
2,7,19,5,13,18,12,16 };
const int colnum[8] = {
6,11,10,3,17,4,8,9
float timeCount = 0;
};
int t[8][8] = {
{0,1,1,1,1,1,1,0},
{0,0,0,1,1,0,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,1,1,0,0,0}};
int e[8][8] = {
{0,1,1,1,1,1,1,0},
{0,1,0,0,0,0,0,0},
{0,1,0,0,0,0,0,0},
{0,1,1,1,0,0,0,0},
{0,1,1,1,0,0,0,0},
{0,1,0,0,0,0,0,0},
{0,1,0,0,0,0,0,0},
{0,1,1,1,1,1,1,0}};
int a[8][8] = {
{0,0,1,1,1,1,0,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,1,1,1,1,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0}};
int m[8][8] = {
{0,1,1,0,0,1,1,0},
{0,1,0,1,1,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0}};
int o[8][8] = {
{0,0,1,1,1,1,0,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,0,1,1,1,1,0,0}};
int cor[8][8] = {
{0,1,1,0,0,1,1,0},
{1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1},
{1,1,1,1,1,1,1,1},
{0,1,1,1,1,1,1,0},
{0,0,1,1,1,1,0,0},
{0,0,0,1,1,0,0,0}
};
int g[8][8] = {
{0,1,1,1,1,1,1,0},
{0,1,0,0,0,0,0,0},
{0,1,0,0,0,0,0,0},
{0,1,0,0,0,0,0,0},
{0,1,0,1,1,1,1,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,1,1,1,1,1,0}};
int b[8][8] = {
{0,1,1,1,1,1,0,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,1,1,1,1,0,0},
{0,1,1,1,1,1,0,0},
{0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0},
{0,1,1,1,1,1,0,0}};
int I[8][8] = {
{0,0,1,1,1,1,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,1,1,0,0,0},
{0,0,1,1,1,1,0,0}};
int s[8][8] = {
{0,0,1,1,1,1,1,0},
{0,1,0,0,0,0,0,0},
{0,1,0,0,0,0,0,0},
{0,1,0,0,0,0,0,0},
{0,0,1,1,1,1,0,0},
{0,0,0,0,0,0,1,0},
{0,0,0,0,0,0,1,0},
{0,1,1,1,1,1,0,0}};
int blank[8][8] = {
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0}};
int cor1[8][8] = {
{0,0,0,0,0,0,0,0},
{0,1,1,0,0,1,1,0},
{0,1,1,1,1,1,1,0},
{0,1,1,1,1,1,1,0},
{0,1,1,1,1,1,1,0},
{0,0,1,1,1,1,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,0,0,0,0,0}
};
int cor2[8][8] = {
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,1,0,0,1,0,0},
{0,0,1,1,1,1,0,0},
{0,0,1,1,1,1,0,0},
{0,0,0,1,1,0,0,0},
{0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0}
};
int cor3[8][8] = {
{0,1,1,0,0,1,1,0},
{1,0,0,1,1,1,0,1},
{1,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,1},
{0,1,0,0,0,0,1,0},
{0,0,1,0,0,1,0,0},
{0,0,0,1,1,0,0,0}
};
void setup() {
Serial.begin(9600);
for (int thisPin = 0; thisPin < 8; thisPin++) {
pinMode(colnum[thisPin], OUTPUT);
pinMode(rownum[thisPin], OUTPUT);
digitalWrite(colnum[thisPin], HIGH);
}
}
void loop() {
delay(5);
timeCount += 1;
if(timeCount < 200) {
drawScreen(t);
} else if (timeCount < 230) {
drawScreen(e);
drawScreen(a);
drawScreen(m);
drawScreen(o);
drawScreen(cor2);
drawScreen(cor1);
drawScreen(cor);
drawScreen(cor3);
} else {
timeCount = 0;
}
}
int row(int i) {
if(i == 1) {
return 2;
} else if (i == 2) {
return 7;
} else if (i == 3) {
return 19;
} else if (i == 4) {
return 5;
} else if (i == 5) {
return 13;
} else if (i == 6) {
return 18;
} else if (i == 7) {
return 12;
} else if (i == 8) {
return 16;
}
}
int col(int i) {
if(i == 1) {
return 6;
} else if (i == 2) {
return 11;
} else if (i == 3) {
return 10;
} else if (i == 4) {
return 3;
} else if (i == 5) {
return 17;
} else if (i == 6) {
return 4;
} else if (i == 7) {
return 8;
} else if (i == 8) {
return 9;
}
}
void drawScreen(int character[8][8]) {
for(int j = 0; j < 8; j++) {
int rowNumber = j + 1;
digitalWrite(row(rowNumber), HIGH);
for (int k = 0; k < 8; k++) {
int columnNumber = k + 1;
if(character[j][k] == 1) {
digitalWrite(col(columnNumber), LOW);
}
digitalWrite(col(columnNumber), HIGH);
}
digitalWrite(row(rowNumber), LOW);
}
}
Inicio | Open Source | Arduino | Tutorial Arduino # 0004 Sensor LDR
Tutorial Arduino # 0004 Sensor LDR

Autor: Pablo
Fecha: 27 noviembre, 2011
Compartir en
facebook
twitter
google
pinterest
# 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:
Y aqu un a posible distribucin del circuito en vuestra protoboard:
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);
//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);
}
else if((valorLDR >= 823) & (valorLDR < 1023))
{
digitalWrite(pinLed1, HIGH);
}
{
}
{
}

{
}
else
{
}
}
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!!
# Sensor de temperatura NTC
Bienvenidos a un nuevo tutorial para sacar el mximo partido a vuestro Arduino, seguimos con
los sensores, en este caso exploramos las posibilidades de un sensor de temperatura NTC:
Nivel: Bsico
Coste: <30
Tiempo: 25
Os recomiendo leer previamente los anteriores tutoriales por si tenis

dificultades en alguna parte de este proyecto, o bien, para recordar
conceptos de programacin ya mostrados.
Parte 1: Que vamos a hacer?

En este proyecto vamos a aprender a implementar un sensor de temperatura a nuestros
proyectos Arduino, en este proyecto simularemos cinco estados de aviso de exceso de
temperatura, sobre los cuales los cuales podramos conectar cualquier elemento que
quisiramos que actuara llegado dicho nivel, podramos conectar circuitos de ventilacin de
manera que si no consiguieran mitigar el exceso de calor llegara un punto que desconectara el
sistema que estemos monitorizando, en resumen, en cualquier lugar donde un control de
exceso de temperatura sea necesario.
Tambin vamos a controlar la temperatura va puerto serie, ya que todava no hemos hablado
de cmo utilizar los LCD en nuestro Arduino, todo llegar.
De nuevo hemos incorporado un pequeo potencimetro que nos permitir establecer una
temperatura, a partir de la cual nos vaya dando los avisos (led) en unos intervalos fijados en
nuestro programa.
He elegido realizar un programa de aviso de exceso de temperatura, pero igualmente se podra
utilizar el NTC para un sistema en que necesitemos controlar que no descienda la temperatura
a partir de un punto crtico.
Veamos un video que muestra el resultado final:
Material necesario para este proyecto:
1 x Arduino Uno
1 x Protoboard
1 x NTC
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 nuevo proyecto Arduino tenemos que conseguir, mediante una NTC (Negative
Temperature Coefficient o Coeficiente de Temperatura Negativo) activar 5 salidas de nuestro
Arduino, una de esas salidas nos mostrar que la temperatura est por debajo del nivel crtico,
y a partir de ese nivel, ir activando una salida tras otra cada dos grados que aumente la
temperatura.
Veris en el video que segn va aumentando la temperatura, se van incrementado los LED
encendidos, lo he realizado as por que es ms visual para la comprensin del funcionamiento,
podris ver en la seccin de programacin que es muy sencillo cambiar esto para que solo
active un LED o varios, o lo que necesitis.
Adems vamos a colocar un potencimetro para ajusta la temperatura, a partir de la cual, nos
empezar a lanzar los avisos.
Visto esto, estructuremos el circuito en tres partes:
Entrada de temperatura ambiente.
Entrada de ajuste mnimo de temperatura.
Salidas.
Entrada de temperatura ambiente.

Estamos utilizando una NTC, es decir, una resistencia con coeficiente de temperatura negativo
respecto a la variacin de su resistencia, esto es que a ms temperatura, aumentar la
concentracin de portadores, lo que har que su resistencia sea menor.
La manera de conectar este sensor a nuestro circuito va a ser formando un divisor de tensin
con su salida a una entrada analgica (podis ver en este ejemplo como funciona una entrada
analgica), en el que nuestra NTC ser la resistencia inferior, lo que adems nos proteger de
un problema que tienen estos sensores, cuando la corriente que circula por l es baja, no
tenemos ningn problema, pues la disipacin de calor es casi nula (VxI 2) pero si la
aumentamos, llegamos a un punto en que esa disipacin afecta a la resistencia del sensor, por
lo que deducimos que la respuesta de una NTC no es lineal sino hiperblica, pero al colocarlo
como un divisor de tensin la variacin de tensin Vout va a ser prcticamente lineal.
En cuanto a la otra resistencia que formar el divisor de tensin, utilizaremos una de 1K, esto
es as para aprovechar el rango de muestreo que nos proporciona Arduino con un consumo de
corriente limitado, veamos rpidamente el motivo.
Si recordamos la ecuacin del divisor de tensin:
Veremos que si la resistencia mxima de nuestra NTC va a ser 10K, y la fija de 1K,
tendremos una variacin de tensin entre 0v y 4,55v. Podis hacer cuentas vosotros mismos
con otros valores y veris que si aumentamos la resistencia, disminuye el rango de Vout, y si la
disminuimos, aumentar los consumos de corriente en exceso.
Entrada de ajuste mnimo de temperatura.
Para tener un mando sobre el que ajustar la temperatura mnima, simplemente colocaremos un
potencimetro dispuesto como divisor de tensin, a una de las entradas analgicas y
utilizaremos su muestreo para mapearlo a nuestro antojo como veremos en la seccin de
programacin.
Salidas.
Para las salidas utilizaremos la ya conocida configuracin de LED ms resistencia.
De manera que el esquema elctrico global nos quedara as:
Y las conexiones en nuestra protoboard
Parte 3: Programando
Veamos primero el cdigo al completo:
/*
Tutorial # 0005 Arduino Academy - Sensor NTC
Conectamos una NTC a una entrada

analgica para controlar cinco salidas
en funcin de la temperatrura.
Adems utilizaremos un pontecimetro para

controlar la temperatura a partir de la cual
se activarn las salidas
Este proyecto es de dominio pblico.

*/
//Aadimos la librera math.h

#include <math.h>
//Pines para los LED

int pinLed1 = 8;
int pinLed2 = 9;
int pinLed3 = 10;
int pinLed4 = 11;
int pinLed5 = 12;
//Pines para las entradas analgicas

int analogPin1 = 0;
int analogPin2 = 1;
//Escala de Avisos
int escala = 2;
//Variable para la temperatura de disparo

double tempMin = 0.0;
//Datos para las ecuaciones
float Vin = 5.0;
// [V]
Tensin alimentacin del divisor
float Rfija = 1000; // [ohm]

float R25 = 2800;
// [ohm]
Resistencia fija del divisor

Valor de NTC a 25C
float Beta = 3900.0; // [K]
Parmetro Beta de NTC
float T0 = 293.15; // [K]
Temperatura de referencia en Kelvin
float Vout = 0.0;
// [V]
Variable para almacenar Vout
float Rntc = 0.0;
// [ohm]
Variable para NTC en ohmnios
float TempK = 0.0; // [K]
Temperatura salida en Kelvin
float TempC = 0.0; // [C]
Temperatura salida en Celsius
void setup() {
//Comenzamos la comunicacin puerto serie

Serial.begin(9600);
//Declaramos pines de salida

//Y los pines de entrada

pinMode(analogPin1, INPUT);
void loop()
{
//Primero leemos el pootencimetro
tempMin = analogRead(analogPin2);
//Lo mapeamos a valores de -100 a 800
tempMin = map (tempMin, 0, 1023, -100, 800);
//Y lo dividimos entre 10 para darle un decimal
tempMin = tempMin/10;
//Y lanzamos el ajuste establecido via serie
Serial.println("-----------------------------------------------");
Serial.println();
Serial.print("AJUSTE DE TEMPERATURA MINIMA A ");
Serial.print(tempMin);
Serial.println(" GRADOS CELSIUS");
Serial.println();
Serial.println("-----------------------------------------------");
//Y ahora calculamos la Temperatura
//Primero la Vout del divisor

Vout=(Vin/1024)*(analogRead(analogPin1));
//Ahora la resistencia de la NTC

Rntc=(Vout*Rfija)/(Vin-Vout);
//Y por ltimo la temperatura en Kelvin

TempK = Beta/(log(Rntc/R25)+(Beta/T0));
//Y ahora la pasamos a celsius

TempC = TempK-273.15;
//Y lo mostramos por puerto serie

Serial.println();
Serial.print("LA TEMPERATURA DE LA NTC ES DE ");
Serial.print(TempC);
Serial.println();
//Ahora las comparaciones para las salidas

if(TempC < tempMin)
{
}
else if (((TempC <= (tempMin + escala)) & (TempC > tempMin)))
{
}
else if (((TempC<=(tempMin+(escala*2)))&(TempC>tempMin+escala)))
{
}
else if ((TempC<=(tempMin+(escala*3)))&(TempC>tempMin+(escala*2)))
{
}
else if (TempC > (tempMin + (escala*4)))
{
}
//Un pequeo delay para no volver loco al puerto serie

delay(500);
}
Empecemos a sacarle brillo!
La primera lnea que nos resulta desconocida es:
#include <math.h>
Cuando ponemos #include <librera.h> lo que hacemos es importar las funciones que haya en
esa librera a nuestro programa, en este caso, la librera math.h nos va aadir la posibilidad de
realizar operaciones matemticas algo ms complejas, es como cuando Neo aprenda a hacer
cosas en Matrix en segundos.. (punto friki.. sorry).
En arduino tenemos infinidad de libreras que iremos descubriendo poco a poco, sigamos!
Lo siguiente que nos encontramos es la definicin de los pines de entrada y de salida, ya
sabemos de sobra a que nos referimos si habis seguido los anteriores tutoriales.
//Pines para los LED
int pinLed1 = 8;
int pinLed2 = 9;
int pinLed3 = 10;
int pinLed4 = 11;
int pinLed5 = 12;
//Pines para las entradas analgicas

int analogPin1 = 0;
int analogPin2 = 1;
Pero despus de esto declaramos la variable escala como entero:
int escala = 2;
Esta variable la utilizaremos para establecer el intervalo que queremos que haya entre alarmas,
es decir, si yo pongo una temperatura de disparo de 20C, con una escala de 2 la primera
alarma ser a 20, la segunda a 22, la tercera a 24, etc
Ahora introduciremos los datos para hacer las ecuaciones que nos permitirn, en base a a la
lectura de nuestra entrada analgica conectada al divisor de tensin, calcular la temperatura.
float Vin = 5.0;
// [V]
Tensin alimentacin del divisor
float Rfija = 1000; // [ohm]

float R25 = 2800;
Resistencia fija del divisor
// [ohm]
Valor de NTC a 25C
float Beta = 3900.0; // [K]
Parmetro Beta de NTC
float T0 = 293.15; // [K]
float Vout = 0.0;
// [V]
float Rntc = 0.0;
// [ohm]
Temperatura de referencia en Kelvin
Variable para almacenar Vout

Variable para NTC en ohmnios
float TempK = 0.0; // [K]
Temperatura salida en Kelvin
float TempC = 0.0; // [C]
Temperatura salida en Celsius
Veris que a la hora de definir el tipo de cada variable, tenemos algo nuevo, la variable de
tipo float, esta variable es para los nmeros en coma flotante (nmero decimal), estas
variables tienen un valor mximo 3.4028235E+38, y como mnimo -3.4028235E+38. Ocupan
4bytes (32bits) con una resolucin mucho mayor que los enteros, lo que nos permitir hacer
clculos bastante precisos, debemos tener en cuenta no olvidarnos de poner la coma en los
nmeros que utilicemos en la operacin como vemos en las lneas de cdigo, de manera que
evitemos errores de interpretacin en nuestro programa.
En cuanto a los parmetros necesitaremos conocer 2 datos de nuestra NTC que vendrn
dispuestos en el datasheet, una resistencia de referencia a una temperatura determinada, en
nuestro caso 2800 a 25 y la Beta de nuestra NTC en Kelvin, para nosotros 3950 K.
Un poco ms abajo explicaremos en detalle todo esto.
Un vez finalizada la declaracin de variables globales, nos toca configurar el setup, de nuevo
tenemos una lnea nueva!
Serial.begin(9600);
Esta instruccin nos inicializa la comunicacin puerto serie desde Arduino al PC a una
velocidad de 9600 baudios (bits por segundo), con esto, cualquier cosa que enviemos lo
podremos visualizar en el monitor de puerto serie de nuestro software de Arduino o cualquier
otro.
Luego, como siempre, declaramos que pines van a ser entradas y cuales van a ser salidas.
//Declaramos pines de salida
//Y los pines de entrada

Ahora comenzamos con el bucle, en primer lugar leemos la seal de nuestro potencimetro
para establecer una temperatura de referencia sobre la que comparar la temperatura de la NTC
y disparar los avisos.
Primero leemos el valor del pin analgico 2 y lo almacenamos en tempMin:
tempMin = analogRead(analogPin2);
A continuacin tenemos una nueva instruccin:
tempMin = map (tempMin, 0, 1023, -100, 800);
La funcin map tiene esta estructura:
map(valor, fromLow, fromHigh, toLow, toHigh)
Es decir, como si le dijramos: Transfrmame tempMin, que puede ir de 0 a 1023
en valores escalonados y proporcionados desde -100 has 800.
Con esto adaptamos la lectura del potencimetro a un rango de -100 a 800, esto lo
hemos hecho as para que al dividir entre 10 el valor:
tempMin = tempMin/10;
Nos devuelva una temperatura de referencia entre -10.0 y +80.0, con esto podremos ajustar
la temperatura de disparo con una precisin de 0.1.
A continuacin lo que hacemos es mandar por el puerto serie el dato prefijado para tener una
referencia visual del mismo.
Serial.println("-----------------------------------------------");
Serial.println();
Serial.print("AJUSTE DE TEMPERATURA MINIMA A ");
Serial.print(tempMin);
Serial.println();
Serial.println("-----------------------------------------------");
Vemos dos instrucciones nuevas:
Serial.println(); //Imprime y salta a Lnea Nueva

Serial.print(); //Imprime en la misma lnea
Esto nos enviar por puerto serie cualquier cosa que incluyamos dentro de ( ), si es una
variable, con poner el nombre de la variable es suficiente, como se puede ver con tempMin,
pero tambin podemos mandar cualquier texto que queramos, siempre que lo incluyamos entre
comillas, como se puede ver, yo lo nico que he hecho es crear unas lneas de separacin
entre la variable que lanzo, para que se lean mejor los datos va serie.
Y ahora llega lo ms complicado del programa, el clculo de temperatura a partir de la medida
analgica.
Para realizar esto debemos conocer algo de teora.
Teniendo en cuenta que el fabricante nos da el valor resistivo para una temperatura en concreto
(en nuestro caso 2800 para 25) y la Beta (Temperatura caracterstica del material entre
2000K y 4000K) podemos utilizar la ecuacin que relaciona la resistencia de la NTC y la
temperatura para calcular esta ltima, primero veamos la ecuacin:
Siendo:
Rt = Resistencia a temperatura T en grados Kelvin (k = C + 273,15)

Ro = Resistencia de referencia a una temperatura To en Kelvin.
B = Valor Beta de nuestra NTC.
To = Temperatura de referencia en Kelvin.

T = Temperatura a medir.
Con esta ecuacin podremos saber cual ser la resistencia mxima que nos va a dar nuestra
NTC al calcular su curva caracterstica, en nuestro caso, 10K lo que nos sirve para disear el
divisor de tensin.
Observamos que, si calculamos Rt, tendremos todos los datos para hallar la temperatura en un
valor de resistencia determinado despejando T, veamos la ecuacin despejada que utilizaremos
en nuestro programa:
Bien, ya tenemos la ecuacin para hallar la temperatura, pero nos faltara saber cual es la
resistencia de la NTC, para esto primero calcularemos cual es la tensin de entrada de nuestra
entrada analgica, es decir, la Vout de nuestro divisor de tensin:
Con esto hallamos cuanto vale cada bit de la conversin analgico-digital (recordemos que
nuestro conversor divide los 5 voltios entre 1024 cachitos) y lo multiplicamos por la cantidad de
bit que nos lee la entrada analgica, con lo que tenemos la tensin que le est llegando a la
entrada analgica.
Una vez tenemos esto, si recordamos la frmula del divisor de tensin:
Vemos que tenemos todos los datos a excepcin de Rinferior, que es justo la resistencia de la
NTC que necesitamos para calcular la temperatura, por lo que despejando nos queda:
Con esto ya tenemos todos los datos para calcular nuestra temperatura a partir de las lecturas
de la entrada analgica, de manera que nos quedar de la siguiente manera al plasmarlo en
nuestro programa.
//Primero la Vout del divisor
Vout=(Vin/1024)*(analogRead(analogPin1));
//Ahora la resistencia de la NTC

Rntc=(Vout*Rfija)/(Vin-Vout);
//Y por ltimo la temperatura en Kelvin

TempK = Beta/(log(Rntc/R25)+(Beta/T0));
//Ahora la pasamos a celsius

TempC = TempK-273.15;
Ahora lo nico que hacemos es enviarlo como antes he explicado por el puerto serie:
Serial.println();
Serial.print("LA TEMPERATURA DE LA NTC ES DE ");
Serial.print(TempC);
Serial.println();
Para mostrar las salidas podis ver que el cdigo es muy similar al del proyecto del diodo LED,
si necesitis que lo explique no tengo inconveniente, pero no quiero repetir demasiadas cosas
en los post, creo que se entienden muy bien las comparaciones.
El delay que hemos puesto al final es para que los mande la temperatura cada medio segundo
por el puerto serie.
Y esto es todo!!
Como veis vamos aumentando el nivel progresivamente, espero que no sean demasiado
bruscos los cambios, si es as decrmelo!!
Hasta pronto!!
Detectando obstculos con

un sensor de ultrasonidos y
Arduino
Posted on 19 marzo, 2014
Siempre me ha gustado la robtica y nunca me he atrevido con ello por

lo costoso del proceso de aprendizaje y los componentes, pero hoy en
da gracias a "dispositivos" como Raspberry Pi o Arduino lo tenemos un
poco ms a mano. Por ello hace no mucho tiempo me compr un Starter
Kit de Arduino para empezar a ir viendo como son las cosas en robtica.
Siendo conscientes que de ah a "construir un robot" hay un largo
camino podemos decir que gracias a ellos poco a poco se pueden ir
adquiriendo conocimientos relacionados que nos ayudarn a aprender
electrnica y programacin de hardware.
En este artculo vamos a ver cmo utilizar un sensor de ultrasonidos para
detectar obstculos a cierta distancia y actuar en consecuencia.
Mediante un sensor de ultrasonidos activaremos unos LED y un
zumbador (buzzer) dependiendo de la distancia a la que se encuentre un
obstculo, usaremos tambin una pantalla LCD de 162 para mostrar la
distancia en centmetros.
Antes de comenzar mencionar que lo aqu expuesto es una adaptacin
del artculo deInstructables
Componentes necesarios:
Arduino (UNO en este caso) y su cable USB
Protoboard o breadboard
6 LED (2 verdes, 2 amarillo y 2 rojos)
7 resistencias de 220 de 330 ohmios
Sensor de ultrasonidos (HC-SR04)
Pantalla LCD de 162
Adaptador LCM1602 para facilitar la conexin de la pantalla al
Arduino
Un zumbador (buzzer)
Cables para realizar conexiones:
20 macho a macho
4 hembra a hembra (Opcional, se puede conectar

directamente a la breadboard)
Lgicamente no todo es necesario, es ms, para medir la distancia slo

necesitaramos el sensor de ultrasonidos pudiendo mostrar la distancia
por el puerto Serial, pero de esta forma lo haremos mucho ms visible y
as de paso, aprenderemos a utilizar varios componentes en un nico
"proyecto".
No voy a mostrar cmo se conectan uno a uno los cables y componentes
porque se nos hara muy largo, pero s que dejo el esquema de cmo se
realizan las conexiones:
Qu es un sensor de ultrasonidos?
Segn la Wikipedia:
El sensor emite un sonido y mide el tiempo que la seal tarda en
regresar. Estos reflejan en un objeto, el sensor recibe el eco producido y
lo convierte en seales elctricas, las cuales son elaboradas en el
aparato de valoracin. Estos sensores trabajan solamente en el aire, y
pueden detectar objetos con diferentes formas, colores, superficies y de
diferentes materiales. Los materiales pueden ser slidos, lquidos o
polvorientos, sin embargo han de ser deflectores de sonido. Los
sensores trabajan segn el tiempo de transcurso del eco, es decir, se
valora la distancia temporal entre el impulso de emisin y el impulso del
eco.
Las conexiones de los componentes son:
Sensor de ultrasonidos:
Vcc: Voltaje (5v), es la conexin que da corriente al sensor
GND: A masa (GND)
Trig: Al pin digital 7 del Arduino
Echo: Al pin digital 6 de Arduino
Leds:
nodo: (patilla larga) Van a los pines digitales 8, 9, 10, 11,

12 y 13 del Arduino, de izquierda a derecha (primer rojo al
ltimo verde)
Ctodo: Mediante una resistencia de 220 ohmios cada uno a
masa (GND)
Zumbador (buzzer):
Terminal positiva (cable rojo en el esquema): Mediante una

resistencia de 220 ohmios a un cable que lo conecta con el Pin
digital nmero 3 (PWM) del Arduino
Terminal negativa: A masa (GND)
Pantalla LCD, mediante el adaptador LCM1602 de cuatro pines va

conectado a:
Vcc: Voltaje (5v)
GND: A masa (GND)
SDA: Al pin analgico A4 de Arduino
SCL: Al pin analgico A5 de Arduino
Del Arduino a la breadboard:
GND: A una de las dos fases de color azul
5v: Voltaje, a una de las dos fases de color rojo
Sabiendo esto lo que haremos ser calcular la distancia a un objeto

mediante el sensor de ultrasonidos, distancia que ser mostrada en la
pantalla LCD y segn sta sea mayor o menor activar una serie de leds
que nos mostrarn visualmente por colores si el objeto est ms lejos
(leds verdes) o ms cerca (leds rojos), tambin, segn la distancia al
objeto se reproducir un sonido a travs del zumbador, que ser
diferente segn la distancia a la que se encuentre el obstculo.
Esto, ms all de nuestro propsito que es ms que nada el aprendizaje,
tiene multitud de utilidades como por ejemplo detectar si alguien se
aproxima a una puerta y en caso de que se acerque mucho activar una
cmara que nos permita ver en tiempo real de quin se trata, "crear una
alarma para despertarnos que slo se desactive al pasar por cierto
punto, o al alcanzar cierta distancia a un "objeto" o pared y muchsimas
cosas ms.
Pues bien, una vez tenemos todo correctamente conectado, tenemos
que cargar el programa a nuestro Arduino. Veamos el programa en
cuestin y luego lo comentamos:
#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
// Pines a los que estn conectados el "Trig" y "Echo" del sensor de ultrasonidos
#define trigPin 7
#define echoPin 6
// Pines a los que estn conectados los LED
#define led 13
#define led2 12
#define led3 11
#define led4 10
#define led5 9
#define led6 8
// Pin al que conectamos el buzzer

#define buzzer 3
// Conexiones de la pantalla LCD al adaptador
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Addr, En, Rw, Rs, d4, d5, d6, d7,
backlighpin, polarity
int sound = 250;
void setup() {
// Inicialimos el Serial, sensor de ultrasonidos, leds y buzzer (zumbador)
Serial.begin (9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(led, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(buzzer, OUTPUT);
//
// Inicializamos la pantalla LCD

lcd.begin(16,2);
lcd.noBacklight();
// Situamos el cursor en la primera casilla de la primera fila y escribimos un texto
lcd.setCursor(0, 0);
lcd.print("tecnogame.org");
}
void loop() {
long duration, distance;
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
los pulsos recibidos por el "echo"
distance = (duration/2) / 29.1;
obstculo segn la duracin entre los pulsos recibidos
// Recogemos la duracin entre

// Calculamos la distancia al
// Limpiamos la segunda linea de la pantalla LCD

for(int i = 0; i < 16; i++){
lcd.setCursor(i, 1);
lcd.print(" ");
}
// Esta serie de ifs sirven para encender unos led y establecer unos tonos para el
zumbador segn la distancia al obstculo
if (distance <= 100) {
digitalWrite(led, HIGH);
sound = 250;
}else{
digitalWrite(led,LOW);
}
if (distance < 83) {
digitalWrite(led2, HIGH);
sound = 260;
}else{
digitalWrite(led2, LOW);
}

sound = 270;
}else{
digitalWrite(led3, LOW);
}
sound = 280;
}else{
digitalWrite(led4,LOW);
}
sound = 290;
}else{
}
sound = 300;
}else{
}
// En caso de que la distancia sea mayor que 1 metro (100 cm) o menor que 2 cm,
indicamos que "no hay obstculos"
if (distance > 100 || distance <= 2){
Serial.println("Sin obstculos");
lcd.print("Sin obstaculos");
noTone(buzzer);
}else{
// En caso de que se encuentre en ese rango mostramos la distancia al obstculo
en centmetros y reproducimos el zumbido oportuno
Serial.print(distance);
Serial.println(" cm");
lcd.print(int(distance));
lcd.print(" cm");
tone(buzzer, sound);
}
delay(200);
}
No hay mucho ms que explicar del cdigo que lo que se ve en los

comentarios, nada ms encender el Arduino con el programa se ejecuta
el "setup" que se encarga de inicializar los componentes e indicar en qu
"puertos" se encuentran y cules son sus estados de inicio. Tras esto, se
ejecuta el "loop" de forma reiterativa comprobando cada vez cul es la
distancia al obstculo y ejecutando las sentencias indicadas segn las

nuevas mediciones de cada iteracin.
Como vemos algo muy sencillo, pero que nos permite conocer las
peculiaridades de ciertos componentes que pueden ser utilizados en
muchos proyectos con Arduino.
Si quieres puedes ver el resultado del proyecto en el siguiente video:

Arduino Uno r3

Uploaded by

Document Information

Original Title

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

Arduino Uno r3

Uploaded by

Copyright:

Available Formats

Matriz 8x8

para elaborar las conexiones usamos Fritzing

Tambin pueden ver el cdigo en GitHub

arduino uno pin

Inicio | Open Source | Arduino | Tutorial Arduino # 0004 Sensor LDR

Tutorial Arduino # 0004 Sensor LDR

Fecha: 27 noviembre, 2011

# Tutorial Arduino 0004 Sensor LDR

Parte 1: Qu vamos a hacer?

LDR (Light Dependent Resistor o resistencia

dependiente de la luz) para simular una hipottica compensacin lumnica de 5 niveles, es

Veamos un video con el resultado final!

Material necesario para este proyecto:

Parte 2: Diseando el hardware

Qu podemos deducir con esto?

Como hemos conseguido esto?

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.

Ms luz = Menos Resistencia = Mayor Vout

Menos luz = Mayor resistencia = Menor Vout

Veamos el esquema elctrico del circuito al completo:

Y aqu un a posible distribucin del circuito en vuestra protoboard:

Conectamos una foto-resistencia a la entrada

Este proyecto es de dominio pblico.

//Aqu almacenamos los datos recogidos del LDR:

//Decimos que pines vamos a utilizar para LED

//Y que pin para la LDR

//Le decimos que vamos a usar una referencia externa

//Y comenzamos las comparaciones:

else if((valorLDR >= 223) & (valorLDR < 423))

Os recomiendo leer previamente los anteriores tutoriales por si tenis

Parte 1: Que vamos a hacer?

Material necesario para este proyecto:

Parte 2: Diseando el hardware

Entrada de temperatura ambiente.

Entrada de ajuste mnimo de temperatura.

Entrada de temperatura ambiente.

Y las conexiones en nuestra protoboard

Conectamos una NTC a una entrada

Adems utilizaremos un pontecimetro para

Este proyecto es de dominio pblico.

//Aadimos la librera math.h

//Pines para los LED

//Pines para las entradas analgicas

//Variable para la temperatura de disparo

//Datos para las ecuaciones

float Vin = 5.0;

Tensin alimentacin del divisor

float Rfija = 1000; // [ohm]

Resistencia fija del divisor

float Beta = 3900.0; // [K]

Parmetro Beta de NTC

float T0 = 293.15; // [K]

Temperatura de referencia en Kelvin

float Vout = 0.0;

Variable para almacenar Vout

float Rntc = 0.0;

Variable para NTC en ohmnios

float TempK = 0.0; // [K]

Temperatura salida en Kelvin

float TempC = 0.0; // [C]