En este tutorial de
Arduino vamos a medir
la temperatura ambiente con un sencillo sensor y mostrarla en un display LCD de 16x2, de esta forma podemos familiarizarnos con los principios básicos de programación de esta plataforma.
Material Necesario
El material necesario para la realización de este tutorial viene incluido en cualquiera de los
Kit Arduino que comercializamos y consiste en:
Esquema de Montaje
El esquema de montaje en Fritzing de todos los componentes y las conexiones necesarias es el siguiente:
El esquema es bastante sencillo, en lo que se refiere al
sensor
TMP36 por un pin se le da alimentación, el central se conecta a la entrada analógica A0 del
Arduino y el tercer pin se conecta al GND. En lo que
se refiere al display LCD y a la resistencia variable de 10K necesaria para su funcionamiento:
- Salida 5V del Arduino al positivo de la Breadboard
- GND del Arduino al GND de la Breadboard
- Un pin del potenciometro de 10K Ohm al positivo de la Breadboard
- Pin central del potenciometro de 10K Ohm al GND de la Breadboard
- El tercer pin del potenciometro de 10K Ohm al pin 3 del LCD (V0)
- Pin 15 LCD (BLA) al positivo de la breadboard
- Pin 16 LCD (BLK) al GND de la breadboard
- Pin 1 LCD (VSS) al GND de la Breadboard
- Pin 2 LCD (VDD) al positivo de la Breadboard
- Pin 4 LCD (RS) a la salida 7 del Arduino
- Pin 5 LCD (R/W) al GND de la Breadboard
- Pin 6 LCD (E) a la salida 8 del Arduino
- Pin 11 LCD (DB4) a la salida 9 del Arduino
- Pin 12 LCD (DB5) a la salida 10 del Arduino
- Pin 13 LCD (DB6) a la salida 11 del Arduino
- Pin 14 LCD (DB7) a la salida 12 del Arduino
Este esquema es válido para cualquier display compatible con
Arduino (es decir, compatible con el
driver
Hitachi HD44780 o cualquier clon del mismo), la única variación posible es la posición de determinados
pines, generalmente el 15 y el 16, asociados a la iluminación del fondo del
display LCD.
Cuando se trabaja con este tipo de componentes, en este caso el
sensor
TMP36 y el
display LCD resulta
muy útil consultar los datasheet de los mismos, esto nos permite conocer detalles necesarios sobre la configuración y funcionamiento de los mismos.
-
Datasheet Display LCD 16x2 LMB162HBC
-
Datasheet TMP36
Con respecto al display veremos la configuración de los pines, para poder realizar las conexiones de forma correcta y asegurar que funcione con la librería correspondiente incluida en el
IDE de Arduino. En lo que se refiere al sensor de temperatura TMP36, vemos que se trata de un sensor análogico cuyo rango es de -50ºC a 125ºC y cuya salida saca 10mV por cada ºC de
temperatura (este dato será importante a la hora de programar el sketch de Arduino).
Sketch Arduino
La programación para conseguir el objetivo del tutorial, mostrar la temperatura medida por el sensor en el display, sería este:
#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11 , 12);
const int sensorPin =A0;
void setup(){
Serial.begin(9600);
}
void loop(){
int sensorVal = analogRead(sensorPin);
Serial.print("Sensor Value: ");
Serial.print(sensorVal);
float voltage = (sensorVal/1024.0) * 5.0;
Serial.print(", Voltios: ");
Serial.print(voltage);
Serial.print("; Temp. Grados: ");
int temperature = (voltage - .5) * 100;
Serial.println(temperature);
lcd.begin(16, 2);
lcd.setCursor(0,0);
lcd.write("Temperatura: ");
lcd.setCursor(12,0);
lcd.print(temperature);
lcd.setCursor(14,0);
lcd.write((char)223);
lcd.setCursor(15,0);
lcd.write("C");
delay(2000);
}
La primera parte del sketch no tiene ningún misterio, simplememte "llamamos" a la libreria "LiquidCrystal" , una de las incluidas por defecto en el IDE oficial de Arduino, para poder usar
alguna de sus funcionalidades. Definimos los pines que usamos en el Display de acuerdo al esquema de conexionado que hemos realizado con anterioridad y creamos una constante, sensorPin, para
el sensor TMP36, asignandole el pin A0 al que lo hemos conectado, que usaremos con posterioridad.
En el "setup" usamos una interesante funcionalidad de Arduino, el Monitor Serial, el cual permite comunicarse al PC con la placa y viceversa, es decir, permite enviar instrucciones en tiempo
real al Arduino o recibir en el PC datos del Arduino, también en tiempo real. En este caso solo vamos a recibir datos del Arduino. Iniciamos la comunicación e indicamos la velocidad en
baudios de la conexión, en nuestro caso 9600, con la función:
Serial.begin(9600);
Para ver en el PC los datos que nos envie el Arduino simplemente hay que abrir el Monitor Serial:
En el "Loop", es decir, aquella parte del sketch que queremos que se repita ciclicamente, comenzamos definiendo una variable, sensorVal, como el valor de la lectura obtenida del sensorPin
definido antes (A0), usando la función:
int sensorVal = analogRead(sensorPin);
Luego vamos a definir que información queremos mostrar en Monitor Serial usando la función "Serial.print", esta función solo tiene un argumento, si el mismo lo entrecomillamos, será lo que
directamente queramos que muestre (sin variación posible), generalmente un texto identificativo del campo posterior, sino usaremos la variable cuyo valor queremos que muestre, en nuestro caso
sensorVal:
Serial.print("Sensor Value: ");
Serial.print(sensorVal);
Para entender la siguiente linea del sketch es necesario explicar que la función "analogRead" usada antes tiene un pequeño "truco", si bien el TMP36 emite un voltaje en función de la temperatura
(10mV por grado) el Arduino no nos da un voltaje como valor de la entrada analógica, para dicha lectura utiliza un protocolo llamado ADC (Analog to Digital Converter) que nos da un valor
comprendido entre 0 y 1023 proporcional al voltaje recibido, por lo que si queremos operar con valores de voltajes, es necesario realizar una pequeña operación matemática, dividir el valor de la
lectura entre 1024 (valores posibles) y multiplicar por 5 (las entradas analógicas Arduino solo pueden medir valores entre 0 y 5V), de esta forma:
float voltage = (sensorVal/1024.0) * 5.0;
Con esos voltios, para obtener una temperatura, de nuevo hay que formular, al voltaje obtenido antes hay que restarle 0,5, para registrar las temperaturas negativas dado que el TMP36 puede mediar
hasta -50ºC y multiplicar por 100. Ambas variables, voltaje y temperatura, las mostramos en el Monitor Serial de la misma forma que hicimos con el sensorVal:
Serial.print(", Voltios: ");
Serial.print(voltage);
Serial.print("; Temp. Grados: ");
int temperature = (voltage - .5) * 100;
Serial.println(temperature);
Lo único a mencionar es que la variable Temperatura la hemos definido usando "int" (integer) y no "float" la diferencia es que el primero solo admite números enteros y la segunda admite
decimales, obviamente es más correcto, o al menos más preciso, usar la segunda en vez de la primera. La razón de haberlo hecho así, es que todo lo que mostraremos en el display nos quepa en una
sola linea. Por otra parte si es relevante la precisión es siempre mejor usar sensores digitales como el
DS18B20 y
no analógicos, y si se usan analógicos y existe la posibilidad, como es el caso, alimentarlos a 3.3V y no a 5V para reducir el ruido, lo que cambiaría ligeramente el sketch. Tambien fijaros que
en la comunicación por Serial Monitor si queremos que el siguiente dato lo muestre en una linea diferente, no a continuación de los anteriores, usamos "Serial.println".
Finalmente la última parte del sketch la dedicamos a mostrar los datos que queremos en el display LCD, en nuestro caso un texto con la variable que mostramos (Temperatura) y su valor:
lcd.begin(16, 2);
lcd.setCursor(0,0);
lcd.write("Temperatura: ");
lcd.setCursor(12,0);
lcd.print(temperature);
lcd.setCursor(14,0);
lcd.write((char)223);
lcd.setCursor(15,0);
lcd.write("C");
delay(2000);
}
Primero definimos el tamaño del display usado, 16 caracteres y 2 lineas, situamos el cursor en la primera posición de la primera linea (0,0) y comenzamos a escribir. Lo único relevante es que el
simbolo de los grados (º) hay que definirlo, lo hacemos con (char)223. Por último establecemos un delay de 2 segundos para que actualice el dato en pantalla, al repetir el proceso.
Las librerías son formas de compartir código o funciones de uso común entre diferentes dispositivos y consisten en un conjunto de procedimientos relacionados entre sí. Los sketches depende de las
librerias, en la parte superior de los mismos es frecuente ver el "llamamiento" a estas con esta estructura.
#include <
LiquidCrystal.h>
Lo cual quiere decir que necesitaremos una librería que contenga el archivo "LiquidCrystal" de lo contrario al compilar el sketch obtendremos un bonito error. Una librería es una carpeta con un
conjunto de archivos, con extensión .
cpp (fichero de C++) y
.h (cabecera de C++). Además es frecuente que incluya una carpeta "examples" con sketches ilustrativos del
funcionamiento del dispositivo que se pretende controlar y a los que se podrá acceder desde el IDE pinchando en: Archivo-Ejemplos.
En la plataforma Arduino hay dos tipos de librerías.
Librerias Estandar
El IDE oficial de Arduino incluye un conjunto de librerías con funcionalidades de uso frecuente, que sirven de soporte para todos los ejemplos y sketchs incluidos en el IDE y aportan funciones
básicas de comunicación a hardware habitual en esta plataforma como Servomotores, Display LCD,...etc, además tambien dan soporte a las Shield Oficiales de Arduino como la Arduino Motor Shield,
Arduino Ethernet Shield y un largo etcetera.
Este conjunto de librerias estan incluidas en una carpeta llamada "Libraries" en la propia instalación del Arduino. Es importante saber que cada nueva versión que se instala del IDE trae su
propio conjunto de librerías por ello no es recomendable ni cambiar la localización de esa carpeta, dentro de la propia instalación del IDE, ni instalar librerías propias en la misma.
Librerias del Usuario
A parte de las librerías oficiales, existen multitud de librerías con funcionalidades muy útiles y drivers para dispositivos compatibles con Arduino, shields y sensores fundamentalmente. Estas
librerías se suelen encontrar alojadas en sitios como
Arduino Playground,
Githbu y
Google Code. Es muy importante que al
adquirir un dispositivo con la "etiqueta" de compatible con Arduino se verifique que, si es necesaria, este disponible la librería correspondiente y un tutorial sobre su uso, este hecho es lo que
distingue a los productos de calidad dentro de esta plataforma. Si no están disponibles no quiere decir necesariamente que el dispositivo no sea compatible con Arduino, pero si que el proceso de
instalación y funcionamiento del mismo será cuanto menos bastante engorroso.
Instalacion de una Librería
Generalmente las librerías, al estar compuestas de varios ficheros diferentes, suelen estar comprimidas en formato "zip". Una vez descargada y descomprimida hay que verificar el nombre de la
librería dado que el IDE no reconoce ni espacios ni guiones medios en este tipo de carpetas por lo que muy posiblemente sea necesario el uso de guiones bajos.
En las últimas versiones del IDE de Arduino, en concreto desde la 1.5 la instalación de una librería es muy sencilla, en el IDE pinchamos en Programa - Importar Librería - Añadir Librería, se
abrirá una ventana de búsqueda en la que indicaremos la ruta donde hemos descomprimido la librería anteriormente.
El IDE de Arduino solo escanea en búsqueda de librerías cuando se inicia por lo que será necesario reiniciar el IDE tras la instalación de una nueva librería para que esta este disponible
para su uso.
En este tutorial de
Arduino vamos a medir
la temperatura ambiente y el nivel de humedad relativa con un sensor digital de la familia DHT, en concreto el
DHT22, y
mostrarla en un
display LCD de 16x2, de
esta forma podemos familiarizarnos con el manejo de sensores digitales. El tutorial es válido para cualquier sensor de esta familia. Las ventajas de estos frente a los analógicos son dos: por un
lado el nivel de precisión y rango de medida son superiores en los digitales (dejando a parte los termopares), además los sensores analógicos al enviar una lectura en forma de voltaje, no deben
utilizarse con largas tiradas de cable, sino que deben estar físicamente cerca de la placa que recibe la lectura para evitar perdidas, lo que limita sus aplicaciones practicas. Este inconveniente
no se da en los sensores digitales, por razones obvias.
La familia de sensores ambientales DHT esta formada por tres modelos: DHT11,
DHT21 y DHT22, estos dos últimos se presentan en dos versiones diferentes, la básica, para soldar o pinchar directamente en protoboard y la encapsulada y cableada, mucho más
práctica que es la podéis encontrar en nuestra tienda.
Las características generales de estos sensores son (el
DHT22 es
una evolución del
DHT21 con unas prestaciones muy similares):
La estructura para la conexión de estos sensores es la misma en todos los modelos, un pin para la alimentación, otro para el GND y otro para datos. El cuarto pin es para la función "disconected"
que rara vez se utiliza, de hecho en las versiones encapsuladas (como la que vamos a usar) si bien el pin esta presente no esta cableado, por lo que solo habrá tres cables: el rojo
(alimentación), negro (GND) y amarillo (datos).
Material Necesario
El material necesario para la realización de este tutorial consiste en:
- Salida 5V del Arduino al positivo de la Breadboard
- GND del Arduino al GND de la Breadboard
- Un pin del potenciometro de 10K Ohm al positivo de la Breadboard
- Pin central del potenciometro de 10K Ohm al GND de la Breadboard
- El tercer pin del potenciometro de 10K Ohm al pin 3 del LCD (V0)
- Pin 15 LCD (BLA) al positivo de la breadboard
- Pin 16 LCD (BLK) al GND de la breadboard
- Pin 1 LCD (VSS) al GND de la Breadboard
- Pin 2 LCD (VDD) al positivo de la Breadboard
- Pin 4 LCD (RS) a la salida 7 del Arduino
- Pin 5 LCD (R/W) al GND de la Breadboard
- Pin 6 LCD (E) a la salida 8 del Arduino
- Pin 11 LCD (DB4) a la salida 9 del Arduino
- Pin 12 LCD (DB5) a la salida 10 del Arduino
- Pin 13 LCD (DB6) a la salida 11 del Arduino
- Pin 14 LCD (DB7) a la salida 12 del Arduino
La
resistencia variable de 10K Ohm se utiliza para regular el contraste del display LCD por lo que para ver los datos que enviemos al mismo hay que ajustarlo manualmente mediante un eje o un pequeño
destornillador.
En lo que respecta al sensor DHT22, en nuestra versión encapsulada
y cableada, tenemos tres cables, el rojo para la alimentación, el negro para el GND y el amarillo para datos conectado en nuestro ejemplo al pin 2 de Arduino. La única particularidad es que
montamos una resistencia "pull-up" de 10K Ohm que conecta el voltaje con el pin de datos.
Sketch Arduino
Para el uso de este sensor, como en otros muchos casos, es necesario instalar de forma previa la librería correspondiente, sino
se esta familiarizado con este proceso resultar interesante leer nuestro Tutorial Arduino II: Librerias Arduino.
El sketch para mostrar los datos de temperatura y humedad relativa en el
display LCD es:
#include <LiquidCrystal.h>
//Llamamos a la libreria para controlar el LCD incluida en el IDE de Arduino
LiquidCrystal lcd(7, 8, 9, 10, 11 , 12);
//Definimos los pines asignados al LCD según el esquema de conexión
#include "DHT.h"
//Llamamos a la libreria de los sensores DHT instalada previamente
#define DHTPIN 2
#define DHTTYPE DHT22
//Definimos el pin de Arduino al que conectamos el pin de datos del sensor e indicamos el tipo de sensor (DHT22)
DHT dht(DHTPIN, DHTTYPE);
void setup(){
Serial.begin(9600);
Serial.println("Prueba DHT22");
//Iniciamos la comunicacion Monitor Serial y editamos un texto descriptivo
dht.begin();
//Iniciamos el sensor
}
void loop(){
delay(2000);
//Establecemos un retraso porque el DHT22 solo realiza una lectura cada 2 segundos
float h = dht.readHumidity();
float t = dht.readTemperature();
//Establecemos dos variables, una para la temperatura en ºC y otra para la humedad relativa en %
if (isnan(h) || isnan(t)) {
Serial.println("Error al Leer Sensor DHT¡");
return;
//Con la funcion isnan controlamos que el valor recibido del sensor sea un número, sino dara error
}
Serial.print("Humedad: ");
Serial.print(h);
Serial.print("
%\t");
Serial.print("Temperatura: ");
Serial.print(t);
Serial.println(" *C ");
//Mostramos la información obtenida (temperatura y humedad) en el Monitor Serial
//El \t es equivalente al tabulador (separa los datos)
//El Serial.prinln nos cambia de linea en la siguiente lectura recibida
lcd.begin(16, 2);
//Indicamos el LCD que usamos: 16 caracteres y 2 lineas
lcd.setCursor(0,0);
//Situamos el cursor en la posicion 0 de la primera linea
lcd.write("Temperatura:
");
lcd.setCursor(12,0);
lcd.print(t);
lcd.setCursor(14,0);
lcd.write((char)223);
//Editamos el simbolo de los grados º
lcd.setCursor(15,0);
lcd.write("C");
lcd.setCursor(0,1);
lcd.write("Humedad: ");
lcd.setCursor(9,1);
lcd.print(h);
lcd.setCursor(14,1);
lcd.write("%");
}
Una cosa interesante,
la librería instalada permite manejar dos variables adicionales que no hemos usado, por un lado la temperatura en grados Farenheit y por otro el Heat Index, que es un valor que
pretende relacionar la temperatura y la humedad para dar la temperatura percibida, una especie de "sensación térmica", expresada en grados Farenheit. Se definirían de esta
forma:
float f = dht.readTemperature(true);
float hi = dht.computeHeatIndex(f, h);
Continuamos esta serie de tutoriales sobre el uso de sensores ambientales con la plataforma
Arduino, utilizando un sensor bastante interesante,
el
sensor de temperatura DS18B20. Se trata de un sensor digital que tiene dos cualidades muy útiles, por un lado disponemos de una versión encapsulada y cableada que permite su uso
en exteriores e incluso en contacto con líquidos, de hecho es sumergible, por otro utiliza un protocolo llamado 1-Wire que nos permite utilizar varios sensores de forma simultanea conectandolos a
un mismo pin del
Arduino, siendo capaces
de identificar la lectura de cada uno de ellos de forma independiente. Esto se consigue gracias a que de fabrica, cada sensor sale con un código identificativo de 64 bits, que lo distingue de
forma única de cualquier otro.
Material Necesario
El material necesario para la realización de este tutorial consiste en:
Los datasheet necesarios son:
Esquema de Montaje
Cuando trabajamos con varios
sensores
DS18B20 o en general varios dispositivos que trabajen con el protocolo 1-Wire, podemos dejar que la propia librería utilizada (ahora la veremos) asigne las lecturas a los sensores, sin
embargo, no es muy práctico dado que dicho orden no tiene porque coincidir con el orden de colocación de los sensores respecto a la placa Arduino, en términos prácticos no sabremos que sensor
registra que lectura. Para evitar este inconveniente tenemos que averiguar la dirección del sensor, la cual tiene este formato:
0x28 0x8A 0xB1 0x40 0x04 0x00 0x00 0xC7
Como el tema se va complicando vamos a empezar limitandonos a obtener las direcciones de los dos sensores que vamos a utilizar. Para ello vamos a necesitar dos librerías:
Con respecto al esquema, señalar que hemos puesto la versión estandar del sensor en TO-92, eso se debe a que no esta disponible como objeto en Fritzing la versión cableada que tenemos, la misma
tiene tres cables: uno rojo para el voltaje, otro azul o negro (según la versión) para el GND y uno amarillo para la linea de datos, por ese motivo (el ser una versión cableada) necesitamos las
pinzas de cocodrilo, para poder realizar la conexión de forma rápida y sencilla. Por otra parte veis que usamos una resistencia "pull-up" de 4K7 Ohm y 1/4W entre el voltaje y la linea de datos.
Sketch Arduino
El sketch para averiguar la dirección del sensor sería este:
//Incluimos las librerias que hemos decargado previamente
#include <OneWire.h>
#include <DallasTemperature.h>
//El ejemplo se realiza con Arduino Uno, conectando el pin de datos al Pin 13
#define ONE_WIRE_BUS 13
OneWire oneWire(ONE_WIRE_BUS); // Creamos el objeto oneWire indicando el pin utilizado para
comunicar con cualquier dispositivo OneWire
DallasTemperature sensores(&oneWire); // Asociamos nuestra referencia oneWire a un sensor de
Dallas
DeviceAddress Sensor; // Array donde almacenamos la direccion del sensor
DS18B20
void setup(void)
{
Serial.begin(9600); //Iniciamos la
comunicacion serie
Serial.println("Direccion Sensor
DS18B20:");
sensores.begin(); //Iniciamos los sensores
//Obtenemos la direccion del sensor de temperatura
if (!sensores.getAddress(Sensor, 0))
//Si no es posible determinar la direccion nos da un mensaje de error
Serial.println("Imposible
encontrar direccion del sensor.");
}
//Creamos la funciona Mostrar_Direccion
void Mostrar_Direccion(DeviceAddress direccion)
{
//Definimos la amplitud de la direccion del sensor: 8 bits.
//El sensor envia dos tipos de datos, una lectura de hasta 12 bits y una direccion de 8 bits relevantes
for (uint8_t i = 0; i < 8; i++)
{
//Le indicamos que añada "0x" antes de cada grupo de digitos que forman la direccion.
//Si no usamos esta instruccion luego habrá que añadir "0x" a mano para usarla en el siguiente
sketch.
Serial.print("0x");
if (direccion[i] < 16) Serial.print("0");
Serial.print(direccion[i], HEX);//Usamos formato Hexadecimal
}
}
void loop(void)
{
//Muestra la direccion del sensor
Serial.print("Direccion del sensor:
");
Mostrar_Direccion(Sensor);
Serial.println();
delay(5000);
}
Si abrimos el Monitor Serial veremos la dirección obtenida en un formato que podremos usar en el sketch para obtener las lecturas de los sensores
DS18B20.
:
Esquema de Montaje
El esquema de conexionado en Fritzing para realizar la lectura de dos
sensores
DS18B20 de forma simultanea a través del mismo pin de Arduino sería el siguiente:
Como veréis lo único que se hace es puentear el GND y el VCC de los sensores, así como los respectivos pines de datos.
Sketch Arduino
El sketch completo para obtener los datos de temperatura de ambos sensores así como para establecer la resolución de la misma (viene todo explicado en el propio sketch), es el siguiente:
Sketch Arduino
//La primera parte del sketch is igual al utilizado para averiguar la direccion de los sensores
#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 13
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensores(&oneWire);
//Indicamos las direcciones de los sensores
DeviceAddress S1 = {0x28, 0xF6, 0x15, 0x06, 0x06, 0x00, 0x00, 0xA8}; //Sensor Interior
DeviceAddress S2 = {0x28, 0x1B, 0xCB, 0x05, 0x06, 0x00, 0x00, 0xBF}; //Sensor Exterior
void setup(void)
{
Serial.begin(9600); //Abrimos la comunicación por
serial
sensores.begin(); //Iniciamos los sensores
}
//Creamos una funcion para mostrar la direccion de los sensores
void Mostrar_Direccion(DeviceAddress direccion)
{
for (uint8_t i = 0; i < 8; i++)
{
if (direccion[i] < 16)
Serial.print("0");
Serial.print(direccion[i], HEX);
}
}
//Funcion que muestra la temperatura en grados centigrados del sensor
void Mostrar_Temperatura(DeviceAddress direccion)
{
float tempC = sensores.getTempC(direccion);
Serial.print("Temperatura: ");
Serial.print(tempC);
}
//Funcion que muestra la resolucion del sensor de dicha direccion. Las resoluciones posibles pueden ser:
//Resolucion a 9 bits 0.50 ºC
//Resolucion a 10 bits 0.25 ºC
//Resolucion a 11 bits 0.125 ºC
//Resolucion a 12 bits 0.0625 ºC
void Mostrar_Resolucion(DeviceAddress direccion)
{
Serial.print("Resolucion: ");
Serial.print(sensores.getResolution(direccion));
Serial.println();
}
//Funcion que muestra los datos del sensor de dicha direccion
void Mostrar_Datos(DeviceAddress direccion)
{
Serial.print("Direccion del dispositivo: ");
Mostrar_Direccion(direccion);
Serial.print(" ");
Mostrar_Temperatura(direccion);
Serial.println();
}
void loop(void)
{
Serial.println("Comprobacion Direccion Sensores DS18B20:");
//Podemos ver el numero de dispositivos que estan conectados al bus 1-Wire
Serial.print("El numero de dispositivos es: ");
Serial.println(sensores.getDeviceCount(), DEC);
Serial.print("Direccion Sensor Interior: ");
Mostrar_Direccion(S1);
Serial.println();
Serial.print("Direccion Sensor Exterior: ");
Mostrar_Direccion(S2);
Serial.println();
//Establecemos la resolucion para cada sensor, PRECISION es a 9 bits
sensores.setResolution(S1, 9); //Resolucion a 9 bits 0.50 ºC
sensores.setResolution(S2, 10); //Resolucion a 10 bits 0.25 ºC
//Si queremos mostrar la resolucion que tiene cada sensor:
Serial.print("Resolucion Sensor Interior: ");
Serial.print(sensores.getResolution(S1), DEC);
Serial.println();
Serial.print("Resolucion Sensor Exterior: ");
Serial.print(sensores.getResolution(S2), DEC);
Serial.println();
sensores.requestTemperatures(); //Enviamos el comando para obtener los datos de los sensores
//Mostramos los datos de todos los sensores
//Llamamos a la funcion Mostrar_Datos indicando la direccion del sensor que queremos leer
Serial.print("Sensor Interior --> ");
Mostrar_Datos(S1);
Serial.print("Sensor Exterior --> ");
Mostrar_Datos(S2);
delay(2000); //Retardo de 2 segundo
}
Abriendo el Serial Monitor obtendremos los siguientes datos:
Como ya os habréis dado cuenta las ventajas de este protocolo en general y de este sensor en particular son obvias, usando un solo pin de Arduino, es decir, dejando el resto libre para otras
funcionalidades (pantallas TFT, salidas digitales para controlar reles,...etc) podemos obtener múltiples lecturas cuyo origen puede estar físicamente alejado de la placa, por tratarse de sensores
digitales. Por ello son sensores muy usados en proyectos de domótica, control industrial, ...etc