Proyectos y prácticas con Arduino

 

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.
  1. Datasheet Display LCD 16x2 LMB162HBC
  2. 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:

 

 

  1. Arduino Uno
  2. Breadboard con Puentes de Conexion
  3. Sensor de Temperatura DHT22
  4. Display LCD 16x2 LMB162HBC
  5. Resistencia variable de 10K Ohm
  6. Resistencia 1/4w 10K Ohm
  7. Tira de 40 Pines Macho

Esquema de Montaje

Los datasheet del sensor DHT22 y del Display LCD son:
 
El esquema de montaje en Fritzing de todos los componentes y las conexiones necesarias es el siguiente:

 

 

En lo que se refiere al conexionado del Display LCD es el mismo que usamos en el anterior Tutorial Arduino: Sensor TMP36 y Display LCD, que repetimos:

 

 

 

  • 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.
 
Podéis descargar la librería necesaria aquí: Librería Sensores DHT.
 
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:

 

 


Si no estáis familiarizados con la instalación de librerías tenemos un tutorial al respecto: Tutorial Arduino II: Librerias Arduino.

 

 

 

 

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