Arduino uno r3
42
Matriz 8x8
-
Upload
wilzon-chambi -
Category
Documents
-
view
84 -
download
3
description
Especificaciones tecnicas del arduino uno R3
Transcript of Arduino uno r3
Matriz 8x8
Este pequeño 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
Código
También pueden ver el código en GitHub
/*
matriz de leds 2288AB-5
matriz pin nro linea columna arduino uno pin
1 5 - 13
2 7 - 12
3 - 2 11
4 - 3 10
5 8 - 16(analogico pin 2)
6 - 5 17(analogico pin 3)
7 6 - 18(analogico pin 4)
8 3 - 19(analogico pin 5)
9 1 - 2
10 - 4 3
11 - 6 4
12 4 - 5
13 - 1 6
14 2 - 7
15 - 7 8
16 - 8 9
*/
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) {
} else if (timeCount < 400) {
drawScreen(e);
} else if (timeCount < 430) {
} else if (timeCount < 600) {
drawScreen(a);
} else if (timeCount < 630) {
} else if (timeCount < 800) {
drawScreen(m);
} else if (timeCount < 830) {
} else if (timeCount < 1000) {
drawScreen(o);
} else if (timeCount < 2830) {
} else if (timeCount < 3000) {
drawScreen(cor2);
} else if (timeCount < 2930) {
} else if (timeCount < 3100) {
drawScreen(cor1);
} else if (timeCount < 3030) {
} else if (timeCount < 3200) {
drawScreen(cor);
} else if (timeCount < 3130) {
} else if (timeCount < 3300) {
drawScreen(cor3);
} else if (timeCount < 3430) {
} else if (timeCount < 3600) {
} 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
# Tutorial Arduino 0004 – Sensor LDR
Bienvenidos a un nuevo tutorial para sacar el máximo partido a vuestro Arduino, comenzamos
a introducir en nuestros proyectos sensores que responderán a situaciones físicas concretas,
empecemos por el LDR!!
Nivel: Básico
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 hipotética compensación lumínica de 5 niveles, es
decir, a través de una resistencia que varia su valor dependiendo de la luz recibida,
aprovecharemos dicha variación para hacer un programa que nos encienda o apague una serie
de LED dependiendo de si hay más luz o menos luz, esto podríamos extrapolarlo a un sistema
de regulación de luz de un jardín con cinco lineas de luz que se vayan encendiendo según va
cayendo la noche compensando progresivamente la deficiencia de luz.
Además le hemos implementado un potenciómetro para ajustar el nivel crítico mínimo 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 Potenciómetro 10kΩ
5 x Diodos LED
5 x Resistencias 220Ω
1 x Resistencia 1KΩ
1 x Juego de Cables
Parte 2: Diseñando el hardware…
En este proyecto lo que queremos conseguir es que, a partir de una resistencia que varía su
valor óhmico en función de que haya más o menos luz, controlar 5 salidas de nuestro Arduino,
a las que podríamos conectar líneas de iluminación para un jardín por ejemplo, de manera que
según va anocheciendo, nuestra iluminación artificial va aumentando.
Además, vamos a colocar un potenciómetro para regular el umbral de luz mínima, 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 tendréis 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 más cantidad de luz reciba, menor será su resistencia, para
que quede claro, si en un potenciómetro variábamos la resistencia deslizando un patín 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 añadimos una resistencia más, podemos utilizar el LDR para hacer el ya conocido
divisor de tensión de donde sacaremos la señal para conectar a nuestra entrada analógica de
Arduino.
Podemos conectarlo de dos maneras diferentes:
Si utilizamos el LDR como resistencia inferior del divisor de tensión, nos dará la tensión
máxima cuando tengamos el LDR en plena oscuridad, ya que estará oponiendo el máximo de
su resistencia al paso de la corriente derivándose esta por Vout al completo, si lo utilizamos
como resistencia superior, el resultado será el inverso, tendremos la tensión máxima cuando
esté completamente iluminado, ya que se comportará prácticamente como un cortocircuito, con
una resistencia de 50Ω o 100Ω.
En este caso lo hemos utilizado como resistencia superior, de manera que cuanta más luz
haya, más tensión tendremos a la entrada de nuestra entrada analógica pudiendo ajustar así,
de una manera muy intuitiva, la tensión de referencia que ahora explicaré.
Como tercera parte del circuito, hemos colocado un potenciómetro configurado como divisor de
tensión para hacer las funciones de regulación del rango de iluminación a partir del cual se
activará nuestro circuito de iluminación.
¿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 difíciles 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 quizás solo vayamos a trabajar en 500 o 600
pasos, desperdiciando mucha resolución.
Para solucionar esto, además de evitar cambiar el programa de Arduino cada vez que lo
cambiemos de entorno, he decido usa una función que nos proporciona Arduino muy
internaste, el pin “Aref”
¿Qué es el pin AREF?
Cuando Arduino toma una señal analógica y la convierte a digital en 1024 cachitos, lo hace por
defecto pensando que la señal 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 resolución mucho mayor.
Debemos tener en cuenta que este pin lleva internamente una resitencia de 32KΩ para evitar
dañar el chip, de manera que si vamos a conectar el pin mediante una resistencia fija, se va a
producir un nuevo divisor de tensión, con lo que habrá que calcular la resistencia adecuada
para la tensión exacta que queremos introducir mediante una sencilla fórmula:
Donde:
Vin = Tensión que introducimos a Vref
Rinterna = Resistencia interna de Arduino de 32KΩ
Rexterna = Resistencia mediante la cual alimentamos Vref
Vrefencia = La tensión sobre que tomará referencia nuestro programa.
De manera que si por ejemplo, estamos introduciendo una tensión de +3v a través de una
resistencia de 5KΩ, la tensión 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 señal de referencia, le estamos diciendo que nos tome 1024 valores entre
0v una determinada tensión máxima, y el reparto de esos valores ya los hemos fijado
equitativamente en nuestro programa para que haga una activación progresiva de las líneas de
iluminación, por tanto, aunque tengamos un rango muy bajo de iluminación con el que jugar, de
1v por ejemplo, nos va a distribuir siempre proporcionalmente la activación de las salidas.
Esa tensión de referencia, será el punto de iluminación a partir del cual, si decrece la luz
ambiente, empezará a decrecer los valores obtenidos en la señal analógica de entrada.
Si ponemos esa referencia muy baja, empezará a funcionar los led con menos luz ambiente
que si ponemos una señal muy alta, recordemos:
Más luz = Menos Resistencia = Mayor Vout
Menos luz = Mayor resistencia = Menor Vout
Veamos el esquema eléctrico del circuito al completo:
Y aquí un a posible distribución del circuito en vuestra protoboard:
Parte 3: Programando…
Este programa es algo más largo que los anteriores, pero desgranándolo poco a poco seguro
que seremos capaces de entenderlo.
Primero veamos el código al completo:
/*
Tutorial # 0004 Arduino Academy - Sensor LDR
Conectamos una foto-resistencia a la entrada
analógica para controlar cinco salidas
en función de la luz ambiente.
Este proyecto es de dominio público.
*/
//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 instrucción que no hemos visto nunca es la siguiente:
analogReference(EXTERNAL);
Con esta instrucción le estamos diciendo a nuestro Arduino, que no use su tensión de
referencia por defecto (+5v) sino la que nosotros introduzcamos por el pin AREF de nuestra
placa, como explicamos en la sección de hardware.
A continuación podemos ver que en el loop, lo primero que hacemos es almacenar la lectura de
la entrada analógica 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 discriminación mediante sentencias if.. if else..
else.. Utilizamos if else para añadir 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:
Podríamos haber acortado alguna línea 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 algún resquicio del proyecto que no acabéis de entender, escribir un comentario con
vuestras dudas.
Hasta pronto!!
# Sensor de temperatura NTC
Bienvenidos a un nuevo tutorial para sacar el máximo partido a vuestro Arduino, seguimos con
los sensores, en este caso exploramos las posibilidades de un sensor de temperatura NTC:
Nivel: Básico
Coste: <30€
Tiempo: 25′
Os recomiendo leer previamente los anteriores tutoriales por si tenéis
dificultades en alguna parte de este proyecto, o bien, para recordar
conceptos de programación 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 podríamos conectar cualquier elemento que
quisiéramos que actuara llegado dicho nivel, podríamos conectar circuitos de ventilación 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.
También vamos a controlar la temperatura vía puerto serie, ya que todavía no hemos hablado
de cómo utilizar los LCD en nuestro Arduino, todo llegará.
De nuevo hemos incorporado un pequeño potenciómetro 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 podría
utilizar el NTC para un sistema en que necesitemos controlar que no descienda la temperatura
a partir de un punto crítico.
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 Potenciómetro 10kΩ
5 x Diodos LED
5 x Resistencias 220Ω
1 x Resistencia 1KΩ
1 x Juego de Cables
Parte 2: Diseñando 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 crítico,
y a partir de ese nivel, irá activando una salida tras otra cada dos grados que aumente la
temperatura.
Veréis en el video que según va aumentando la temperatura, se van incrementado los LED
encendidos, lo he realizado así por que es más visual para la comprensión del funcionamiento,
podréis ver en la sección de programación que es muy sencillo cambiar esto para que solo
active un LED o varios, o lo que necesitéis.
Además vamos a colocar un potenciómetro 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 mínimo de temperatura.
Salidas.
Entrada de temperatura ambiente.
Estamos utilizando una NTC, es decir, una resistencia con coeficiente de temperatura negativo
respecto a la variación de su resistencia, esto es que a más temperatura, aumentará la
concentración 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 tensión
con su salida a una entrada analógica (podéis ver en este ejemplo como funciona una entrada
analógica), en el que nuestra NTC será la resistencia inferior, lo que además nos protegerá de
un problema que tienen estos sensores, cuando la corriente que circula por él es baja, no
tenemos ningún problema, pues la disipación de calor es casi nula (VxI2) pero si la
aumentamos, llegamos a un punto en que esa disipación afecta a la resistencia del sensor, por
lo que deducimos que la respuesta de una NTC no es lineal sino hiperbólica, pero al colocarlo
como un divisor de tensión la variación de tensión Vout va a ser prácticamente lineal.
En cuanto a la otra resistencia que formará el divisor de tensión, utilizaremos una de 1KΩ, esto
es así para aprovechar el rango de muestreo que nos proporciona Arduino con un consumo de
corriente limitado, veamos rápidamente el motivo.
Si recordamos la ecuación del divisor de tensión:
Veremos que si la resistencia máxima de nuestra NTC va a ser 10KΩ, y la fija de 1KΩ,
tendremos una variación de tensión entre 0v y 4,55v. Podéis hacer cuentas vosotros mismos
con otros valores y veréis que si aumentamos la resistencia, disminuye el rango de Vout, y si la
disminuimos, aumentará los consumos de corriente en exceso.
Entrada de ajuste mínimo de temperatura.
Para tener un mando sobre el que ajustar la temperatura mínima, simplemente colocaremos un
potenciómetro dispuesto como divisor de tensión, a una de las entradas analógicas y
utilizaremos su muestreo para mapearlo a nuestro antojo como veremos en la sección de
programación.
Salidas.
Para las salidas utilizaremos la ya conocida configuración de LED más resistencia.
De manera que el esquema eléctrico global nos quedaría así:
Y las conexiones en nuestra protoboard…
Parte 3: Programando…
Veamos primero el código al completo:
/*
Tutorial # 0005 Arduino Academy - Sensor NTC
Conectamos una NTC a una entrada
analógica para controlar cinco salidas
en función de la temperatrura.
Además utilizaremos un ponteciómetro para
controlar la temperatura a partir de la cual
se activarán las salidas
Este proyecto es de dominio público.
*/
//Añadimos la librería 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 analógicas
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] Tensión alimentación del divisor
float Rfija = 1000; // [ohm] Resistencia fija del divisor
float R25 = 2800; // [ohm] Valor de NTC a 25ºC
float Beta = 3900.0; // [K] Parámetro 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 comunicación puerto serie
Serial.begin(9600);
//Declaramos pines de salida
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);
//Y los pines de entrada
pinMode(analogPin1, INPUT);
pinMode(analogPin2, INPUT);
}
void loop()
{
//Primero leemos el pootenciómetro
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(" GRADOS CELSIUS");
Serial.println();
//Ahora las comparaciones para las salidas
if(TempC < tempMin)
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if (((TempC <= (tempMin + escala)) & (TempC > tempMin)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if (((TempC<=(tempMin+(escala*2)))&(TempC>tempMin+escala)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if ((TempC<=(tempMin+(escala*3)))&(TempC>tempMin+(escala*2)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, LOW);
}
else if (TempC > (tempMin + (escala*4)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, HIGH);
}
//Un pequeño delay para no volver loco al puerto serie
delay(500);
}
Empecemos a sacarle brillo!
La primera línea que nos resulta desconocida es:
#include <math.h>
Cuando ponemos #include <librería.h> lo que hacemos es importar las funciones que haya en
esa librería a nuestro programa, en este caso, la librería math.h nos va añadir la posibilidad de
realizar operaciones matemáticas algo más complejas, es como cuando Neo aprendía a hacer
cosas en Matrix en segundos.. (punto friki.. sorry).
En arduino tenemos infinidad de librerías que iremos descubriendo poco a poco, sigamos!
Lo siguiente que nos encontramos es la definición de los pines de entrada y de salida, ya
sabemos de sobra a que nos referimos si habéis 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 analógicas
int analogPin1 = 0;
int analogPin2 = 1;
Pero después 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 20ºC, 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 permitirán, en base a a la
lectura de nuestra entrada analógica conectada al divisor de tensión, calcular la temperatura.
float Vin = 5.0; // [V] Tensión alimentación del divisor
float Rfija = 1000; // [ohm] Resistencia fija del divisor
float R25 = 2800; // [ohm] Valor de NTC a 25ºC
float Beta = 3900.0; // [K] Parámetro 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
Veréis que a la hora de definir el tipo de cada variable, tenemos algo nuevo, la variable de
tipo “float”, esta variable es para los números en coma flotante (número decimal), estas
variables tienen un valor máximo 3.4028235E+38, y como mínimo -3.4028235E+38. Ocupan
4bytes (32bits) con una resolución mucho mayor que los enteros, lo que nos permitirá hacer
cálculos bastante precisos, debemos tener en cuenta no olvidarnos de poner la coma en los
números que utilicemos en la operación como vemos en las líneas de código, de manera que
evitemos errores de interpretación en nuestro programa.
En cuanto a los parámetros necesitaremos conocer 2 datos de nuestra NTC que vendrán
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 más abajo explicaremos en detalle todo esto.
Un vez finalizada la declaración de variables globales, nos toca “configurar” el setup, de nuevo
tenemos una línea nueva!
Serial.begin(9600);
Esta instrucción nos inicializa la comunicación 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
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);
//Y los pines de entrada
pinMode(analogPin1, INPUT);
pinMode(analogPin2, INPUT);
Ahora comenzamos con el bucle, en primer lugar leemos la señal de nuestro potenciómetro
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 analógico 2 y lo almacenamos en tempMin:
tempMin = analogRead(analogPin2);
A continuación tenemos una nueva instrucción:
tempMin = map (tempMin, 0, 1023, -100, 800);
La función map tiene esta estructura:
map(valor, fromLow, fromHigh, toLow, toHigh)
Es decir, como si le dijéramos: Transfórmame “tempMin”, que puede ir de 0 a 1023
en valores escalonados y proporcionados desde -100 has 800.
Con esto adaptamos la lectura del potenciómetro 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 precisión de 0.1º.
A continuación 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(" GRADOS CELSIUS");
Serial.println();
Serial.println("-----------------------------------------------");
Vemos dos instrucciones nuevas:
Serial.println(); //Imprime y salta a Línea Nueva
Serial.print(); //Imprime en la misma línea
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 también 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 líneas de separación
entre la variable que lanzo, para que se lean mejor los datos vía serie.
Y ahora llega lo más complicado del programa, el cálculo de temperatura a partir de la medida
analógica.
Para realizar esto debemos conocer algo de teoría.
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 característica del material
entre 2000K y 4000K) podemos utilizar la ecuación que relaciona la resistencia de la NTC y la
temperatura para calcular esta última, primero veamos la ecuación:
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 ecuación podremos saber cual será la resistencia máxima que nos va a dar nuestra
NTC al calcular su curva característica, en nuestro caso, 10KΩ lo que nos sirve para diseñar el
divisor de tensión.
Observamos que, si calculamos Rt, tendremos todos los datos para hallar la temperatura en un
valor de resistencia determinado despejando T, veamos la ecuación despejada que
utilizaremos en nuestro programa:
Bien, ya tenemos la ecuación para hallar la temperatura, pero nos faltaría saber cual es la
resistencia de la NTC, para esto primero calcularemos cual es la tensión de entrada de nuestra
entrada analógica, es decir, la Vout de nuestro divisor de tensión:
Con esto hallamos cuanto vale cada bit de la conversión analógico-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 analógica, con lo que tenemos la tensión que le está llegando a la
entrada analógica.
Una vez tenemos esto, si recordamos la fórmula del divisor de tensión:
Vemos que tenemos todos los datos a excepción 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 analógica, 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(" GRADOS CELSIUS");
Serial.println();
Para mostrar las salidas podéis ver que el código es muy similar al del proyecto del diodo LED,
si necesitáis 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í decírmelo!!
Hasta pronto!!
Detectando obstáculos con un sensor de ultrasonidos y ArduinoPosted on 19 marzo, 2014
Siempre me ha gustado la robótica y nunca me he atrevido con ello por
lo costoso del proceso de aprendizaje y los componentes, pero hoy en
día gracias a "dispositivos" como Raspberry Pi o Arduino lo tenemos un
poco más 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 robótica.
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 ayudarán a aprender
electrónica y programación de hardware.
En este artículo vamos a ver cómo utilizar un sensor de ultrasonidos para
detectar obstáculos 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
obstáculo, usaremos también una pantalla LCD de 16×2 para mostrar la
distancia en centímetros.
Antes de comenzar mencionar que lo aquí expuesto es una adaptación
del artículo 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 16×2
Adaptador LCM1602 para facilitar la conexión 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)
Lógicamente no todo es necesario, es más, para medir la distancia sólo
necesitaríamos el sensor de ultrasonidos pudiendo mostrar la distancia
por el puerto Serial, pero de esta forma lo haremos mucho más visible y
así de paso, aprenderemos a utilizar varios componentes en un único
"proyecto".
No voy a mostrar cómo se conectan uno a uno los cables y componentes
porque se nos haría muy largo, pero sí que dejo el esquema de cómo se
realizan las conexiones:
¿Qué es un sensor de ultrasonidos?
Según la Wikipedia:
El sensor emite un sonido y mide el tiempo que la señal tarda en
regresar. Estos reflejan en un objeto, el sensor recibe el eco producido y
lo convierte en señales eléctricas, las cuales son elaboradas en el
aparato de valoración. Estos sensores trabajan solamente en el aire, y
pueden detectar objetos con diferentes formas, colores, superficies y de
diferentes materiales. Los materiales pueden ser sólidos, líquidos o
polvorientos, sin embargo han de ser deflectores de sonido. Los sensores
trabajan según el tiempo de transcurso del eco, es decir, se valora la
distancia temporal entre el impulso de emisión y el impulso del eco.
Las conexiones de los componentes son:
Sensor de ultrasonidos:
Vcc: Voltaje (5v), es la conexión 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)
Cátodo: 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 número 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 analógico A4 de Arduino
SCL: Al pin analógico 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 según ésta sea mayor o menor activará una serie de leds
que nos mostrarán visualmente por colores si el objeto está más lejos
(leds verdes) o más cerca (leds rojos), también, según la distancia al
objeto se reproducirá un sonido a través del zumbador, que será
diferente según la distancia a la que se encuentre el obstáculo.
Esto, más allá de nuestro propósito que es más 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
cámara que nos permita ver en tiempo real de quién se trata, "crear una
alarma para despertarnos que sólo se desactive al pasar por cierto
punto, o al alcanzar cierta distancia a un "objeto" o pared y muchísimas
cosas más.
Pues bien, una vez tenemos todo correctamente conectado, tenemos
que cargar el programa a nuestro Arduino. Veamos el programa en
cuestión y luego lo comentamos:
#include <Wire.h>#include <LCD.h>#include <LiquidCrystal_I2C.h> // Pines a los que están conectados el "Trig" y "Echo" del sensor de ultrasonidos#define trigPin 7#define echoPin 6 // Pines a los que están 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 adaptadorLiquidCrystal_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(led3, OUTPUT);pinMode(led4, OUTPUT);pinMode(led5, OUTPUT);pinMode(led6, OUTPUT);pinMode(buzzer, OUTPUT);
// Inicializamos la pantalla LCDlcd.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); // Recogemos la
duración entre los pulsos recibidos por el "echo"distance = (duration/2) / 29.1; // Calculamos la
distancia al obstáculo según la duración entre los pulsos recibidos
// Limpiamos la segunda linea de la pantalla LCDfor(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 según la distancia al obstáculoif (distance <= 100) {
digitalWrite(led, HIGH);sound = 250;
}else{digitalWrite(led,LOW);
}
if (distance < 83) {digitalWrite(led2, HIGH);sound = 260;
}else{
digitalWrite(led2, LOW);}
if (distance < 66) {
digitalWrite(led3, HIGH);sound = 270;
}else{digitalWrite(led3, LOW);
}
if (distance < 49) {digitalWrite(led4, HIGH);sound = 280;
}else{digitalWrite(led4,LOW);
}
if (distance < 32) {digitalWrite(led5, HIGH);sound = 290;
}else{digitalWrite(led5,LOW);
}
if (distance < 15) {digitalWrite(led6, HIGH);sound = 300;
}else{digitalWrite(led6,LOW);
}
// En caso de que la distancia sea mayor que 1 metro (100 cm) o menor que 2 cm, indicamos que "no hay obstáculos"
if (distance > 100 || distance <= 2){Serial.println("Sin obstáculos");
lcd.setCursor(0, 1);lcd.print("Sin obstaculos");
noTone(buzzer);
}else{// En caso de que se encuentre en ese rango mostramos la distancia al
obstáculo en centímetros y reproducimos el zumbido oportunoSerial.print(distance);Serial.println(" cm");
lcd.setCursor(0, 1);lcd.print(int(distance)); lcd.setCursor(2, 1);lcd.print(" cm");
tone(buzzer, sound);
}
delay(200);}
No hay mucho más que explicar del código que lo que se ve en los
comentarios, nada más 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 cuáles son sus estados de inicio. Tras esto, se
ejecuta el "loop" de forma reiterativa comprobando cada vez cuál es la
distancia al obstáculo y ejecutando las sentencias indicadas según las
nuevas mediciones de cada iteración.
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:
